├── .github ├── FUNDING.yml ├── ISSUE_TEMPLATE │ └── bug_report.md └── auto_assign.yml ├── LICENSE ├── README.md ├── homeworks ├── README.md └── homework01-17.asm └── snippets ├── MCD.asm ├── MCDRICORSIVO.asm ├── PaLiNdRoMo.asm ├── PaLiNdRoMoRICORSIVO.asm ├── bubbleSort.asm ├── bubbleSortRICORSIVO.asm ├── cercaSottoStringa.asm ├── cercaSottoStringaRICORSIVA.asm ├── cicloFor.asm ├── confrontaStringhe.asm ├── confrontaStringheRICORSIVA.asm ├── contaBitDiversi.asm ├── contaBitUgualiRICORSIVA.asm ├── contaElementiInVettore.asm ├── contaLettere.asm ├── contaLettereRICORSIVO.asm ├── contaNove.asm ├── contaOccorrenzeVettoreRICORSIVO.asm ├── contaPariInLista.asm ├── contaPariInListaRICORSIVA.asm ├── ifThenElse.asm ├── insertionSort.asm ├── insertionSortRICORSIVO.asm ├── isPalindroma.asm ├── letturaInputEStampaMax.asm ├── listaInserisciValoreESomma.asm ├── log2RICORSIVA.asm ├── lunghezzaListaRICORSIVO.asm ├── matriceContenenteCubiDiAltraMatrice.asm ├── matriceRisultanteColonnaxRiga.asm ├── mergesort.asm ├── printListReverseRICORSIVO.asm ├── raggruppaLettere.asm ├── raggruppaLettereRICORSIVO.asm ├── ricercaBinariaInputEStampaRICORSIVO.asm ├── ricercaBinariaMatriceRICORSIVO.asm ├── ricercaBinariaRICORSIVA.asm ├── ruotaVettoreSenzaAppoggioRICORSIVO.asm ├── ruotaVettoresenzaAppoggio.asm ├── selectionSort.asm ├── selectionSortRICORSIVO.asm ├── sommaColonneMatrice.asm ├── sommaDiagonaleMatrice( con funzioni).asm ├── sommaDiagonaleMatrice.asm ├── sommaEntrambeDiagonaliMatrice.asm ├── sommaNumeriInVettore(con indice).asm ├── sommaNumeriInVettore(con puntatori).asm ├── sommaVettore.asm ├── stampaNumeriOrdineDecrescente.asm ├── stampaReverseStringa.asm ├── stringa.asm ├── structListaVisita.asm ├── switchCase.asm ├── trovaMaxInVettore.asm ├── trovaModaVettoreRICORSIVO.asm ├── trovaNumero.asm ├── verificaLatiTriangolo.asm └── whileDo.asm /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | github: edoardottt 2 | liberapay: edoardottt 3 | patreon: edoardottt 4 | ko_fi: edoardottt 5 | open_collective: edoardottt 6 | custom: "https://www.paypal.me/edoardottt" 7 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/bug_report.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Bug report 3 | about: Create a report to help us improve 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Describe the bug** 11 | A clear and concise description of what the bug is. 12 | 13 | **To Reproduce** 14 | Steps to reproduce the behavior: 15 | 1. Go to '...' 16 | 2. Click on '....' 17 | 3. Scroll down to '....' 18 | 4. See error 19 | 20 | **Expected behavior** 21 | A clear and concise description of what you expected to happen. 22 | 23 | **Screenshots** 24 | If applicable, add screenshots to help explain your problem. 25 | 26 | **Desktop (please complete the following information):** 27 | - OS: [e.g. iOS] 28 | - Browser [e.g. chrome, safari] 29 | - Version [e.g. 22] 30 | 31 | **Smartphone (please complete the following information):** 32 | - Device: [e.g. iPhone6] 33 | - OS: [e.g. iOS8.1] 34 | - Browser [e.g. stock browser, safari] 35 | - Version [e.g. 22] 36 | 37 | **Additional context** 38 | Add any other context about the problem here. 39 | -------------------------------------------------------------------------------- /.github/auto_assign.yml: -------------------------------------------------------------------------------- 1 | # Set to true to add reviewers to pull requests 2 | addReviewers: true 3 | 4 | # A list of reviewers to be added to pull requests (GitHub user name) 5 | reviewers: 6 | - edoardottt 7 | 8 | # A list of keywords to be skipped the process that add reviewers if pull requests include it 9 | skipKeywords: 10 | - wip 11 | 12 | # A number of reviewers added to the pull request 13 | # Set 0 to add all the reviewers (default: 0) 14 | numberOfReviewers: 0 15 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | This is free and unencumbered software released into the public domain. 2 | 3 | Anyone is free to copy, modify, publish, use, compile, sell, or 4 | distribute this software, either in source code form or as a compiled 5 | binary, for any purpose, commercial or non-commercial, and by any 6 | means. 7 | 8 | In jurisdictions that recognize copyright laws, the author or authors 9 | of this software dedicate any and all copyright interest in the 10 | software to the public domain. We make this dedication for the benefit 11 | of the public at large and to the detriment of our heirs and 12 | successors. We intend this dedication to be an overt act of 13 | relinquishment in perpetuity of all present and future rights to this 14 | software under copyright law. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 | OTHER DEALINGS IN THE SOFTWARE. 23 | 24 | For more information, please refer to 25 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | MIPS Architecture 💾 2 | ------- 3 | 4 | ![cpuwithcompletepipeline](https://github.com/edoardottt/images/blob/main/asm-snippets/mips.png) 5 | Ref: 6 | 7 | I wrote these files while I was attending the *Computer's Architecture* course held by Professor Sterbini in Sapienza University of Rome. 8 | 9 | Course syllabus: 10 | 11 | - Computer Abstractions and Technology 12 | - Operations of the Computer Hardware 13 | - Operands of the Computer Hardware 14 | - Logical Operations 15 | - Parallelism and Instructions: Synchronization 16 | - Arithmetic for Computers 17 | - Parallelism and Computer Arithmetic 18 | - The Processor Logic Design 19 | - Pipelining 20 | - Data Hazards: Forwarding vs. Stalling 21 | - Control Hazards 22 | - Exceptions 23 | - Memory Hierarchy 24 | - Caches 25 | - Measuring and Improving Cache Performance 26 | - Virtual Memory 27 | - Cache Coherence 28 | - Storage and Other I/O Topics 29 | - Disk Storage 30 | - Flash Storage 31 | - Connecting Processors, Memory, and I/O Devices 32 | - Interfacing I/O Devices to the Processor, Memory, and Operating System 33 | 34 | Download ⬇️ 35 | ------- 36 | 37 | ```console 38 | git clone https://github.com/edoardottt/asm-snippets 39 | ``` 40 | 41 | Contributing 🤝 42 | ------ 43 | 44 | If you spot an error just open an [issue](https://github.com/edoardottt/asm-snippets/issues). 45 | 46 | License 📝 47 | ------- 48 | 49 | This repository is [unlicensed](https://github.com/edoardottt/asm-snippets/blob/master/LICENSE). 50 | [edoardottt.com](https://edoardottt.com/) to contact me. 51 | -------------------------------------------------------------------------------- /homeworks/README.md: -------------------------------------------------------------------------------- 1 | #### 1st Homework - January 2017 2 | 3 | - Prendi in input due stringhe. 4 | - Se sono identiche stampa "anagramma" 5 | - Se differiscono di uno o due caratteri stampa "simili" 6 | - Se differiscono di tre o più caratteri stampa "diversi" 7 | -------------------------------------------------------------------------------- /homeworks/homework01-17.asm: -------------------------------------------------------------------------------- 1 | .data 2 | testo1: .space 101 3 | testo2: .space 101 4 | vettoreascii: .byte '[','/',']','^','_','`','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','{','|','}','~','!','"','#','$','%','&','(',')','*','+',',','-','.','/','0','1','2','3','4','5','6','7','8','9',':',';','<','=','>','?','@','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',' ', 5 | anagramma: .asciiz "ANAGRAMMA" 6 | simili: .asciiz "SIMILI" 7 | diversi: .asciiz "DIVERSI" 8 | .text 9 | .globl main 10 | main: 11 | li $v0, 8 #leggo il testo1 in input 12 | la $a0, testo1 13 | la $a1, 101 14 | syscall 15 | li $v0, 8 #leggo il testo2 in input 16 | la $a0, testo2 17 | la $a1, 101 18 | syscall 19 | la $t0, testo1 #carico in $t0 il testo1 20 | la $t1, testo2 #carico in $t1 il testo2 21 | la $t6, vettoreascii #carico in $t6 il vettoreascii 22 | scorrivettore: 23 | lb $t3,0($t6) #carico in $t3 l'indirizzo dell'i-esimo valore di vettoreascii 24 | beq $t3,'\0',stampa #se il vettore � finito stampo 25 | contaoccorrenzetesto1: 26 | lb $t2,0($t0) #carico in $t2 l'i-esimo valore di testo1 27 | beq $t2,'\0',contaocctesto2 #se la stringa � finita vado a contaocctesto2 28 | beq $t2,$t3,aggiungioccparziale1 #se $t2 e $t3 sono uguali aggiungo un'occorrenza parziale 29 | addi $t0,$t0,1 #passo al valore successivo 30 | j contaoccorrenzetesto1 31 | 32 | aggiungioccparziale1: 33 | addi $s4,$s4,1 #aggiungo un'occorrenza 34 | addi $t0,$t0,1 #passo al valore successivo 35 | j contaoccorrenzetesto1 36 | 37 | contaocctesto2: 38 | lb $t7,0($t1) #carico in $t7 l'i-esimo valore di testo2 39 | beq $t7,'\0',aggiornacontfinale #se testo2 � finito aggiorno il contatore finale 40 | beq $t7,$t3,aggiungioccparziale2 #se $t7 e $t3 sono uguali aggiungo un'occorrenza parziale 41 | addi $t1,$t1,1 #passo al valore successivo 42 | j contaocctesto2 43 | aggiungioccparziale2: 44 | add $s5,$s5,1 #aggiungo un'occorrenza 45 | addi $t1,$t1,1 #passo al valore successivo 46 | j contaocctesto2 47 | 48 | 49 | aggiornacontfinale: 50 | sub $s3, $s4, $s5 #calcolo la differenza parziale 51 | abs $s3,$s3 #setto ad assoluto il valore di $t3 52 | add $t5,$t5,$s3 #la aggiungo al contatore finale 53 | li $s4,0 54 | li $s5,0 55 | addi $t6,$t6,1 #passo al valore del vettoreascii successivo 56 | la $t0,testo1 57 | la $t1,testo2 58 | j scorrivettore 59 | 60 | stampa: 61 | beq $t5,0, anag #se la differenza � 0 stampa ANAGRAMMA 62 | beq $t5,1,simil #se la differenza � 1 o 2 stampa SIMILI 63 | beq $t5,2,simil 64 | bge $t5,3,diver #se la differenza � >= 3 stampa DIVERSI 65 | 66 | anag: 67 | li $v0,4 68 | la $a0,anagramma 69 | syscall 70 | j termina 71 | 72 | simil: 73 | li $v0,4 74 | la $a0,simili 75 | syscall 76 | j termina 77 | diver: 78 | li $v0,4 79 | la $a0,diversi 80 | syscall 81 | j termina 82 | 83 | termina: 84 | li $v0,10 85 | syscall 86 | -------------------------------------------------------------------------------- /snippets/MCD.asm: -------------------------------------------------------------------------------- 1 | # MASSIMO COMUN DIVISORE TRA DUE INTERI POSITIVI 2 | .data 3 | richiesta: .asciiz "inserire due valori x ed y interi positivi\n" 4 | 5 | .text 6 | li $v0,4 7 | la $a0,richiesta 8 | syscall 9 | 10 | li $v0,5 11 | syscall 12 | move $s0,$v0 #X 13 | li $v0,5 14 | syscall 15 | move $s1,$v0 #Y 16 | 17 | loop: 18 | beq $s0,$s1,uguali 19 | bgt $s0,$s1,secondoCaso 20 | blt $s0,$s1,terzoCaso 21 | uguali: 22 | li $v0,1 23 | move $a0,$s0 24 | syscall 25 | li $v0,10 26 | syscall 27 | secondoCaso: 28 | move $s2,$s1 29 | move $s1,$s0 30 | move $s0,$s2 31 | j loop 32 | terzoCaso: 33 | sub $s1,$s1,$s0 34 | j loop -------------------------------------------------------------------------------- /snippets/MCDRICORSIVO.asm: -------------------------------------------------------------------------------- 1 | # MCD TRA DUE INTERI POSITIVI RICORSIVO 2 | .data 3 | richiesta: .asciiz "inserire due valori x ed y interi positivi\n" 4 | 5 | .text 6 | li $v0,4 7 | la $a0,richiesta 8 | syscall 9 | 10 | li $v0,5 11 | syscall 12 | move $s0,$v0 #X 13 | li $v0,5 14 | syscall 15 | move $s1,$v0 #Y 16 | jal mcd 17 | li $v0,1 18 | syscall 19 | li $v0,10 20 | syscall 21 | mcd: 22 | subi $sp,$sp,12 23 | sw $ra,0($sp) 24 | sw $s0,4($sp) 25 | sw $s1,8($sp) 26 | 27 | beq $s0,$s1,caso_base 28 | jal verifica 29 | jal mcd 30 | lw $ra,0($sp) 31 | lw $s0,4($sp) 32 | lw $s1,8($sp) 33 | addi $sp,$sp,12 34 | jr $ra 35 | caso_base: 36 | move $a0,$s0 37 | 38 | lw $ra,0($sp) 39 | lw $s0,4($sp) 40 | lw $s1,8($sp) 41 | addi $sp,$sp,12 42 | jr $ra 43 | verifica: 44 | sgt $t0,$s0,$s1 45 | beq $t0,1,cambia 46 | sub $s1,$s1,$s0 47 | jr $ra 48 | cambia: 49 | move $s2,$s1 50 | move $s1,$s0 51 | move $s0,$s2 52 | jr $ra 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | -------------------------------------------------------------------------------- /snippets/PaLiNdRoMo.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/PaLiNdRoMo.asm -------------------------------------------------------------------------------- /snippets/PaLiNdRoMoRICORSIVO.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/PaLiNdRoMoRICORSIVO.asm -------------------------------------------------------------------------------- /snippets/bubbleSort.asm: -------------------------------------------------------------------------------- 1 | # BUBBLE SORT 2 | .data 3 | richiesta: .asciiz "inserire la lunghezza del vettore,poi i valori numerici\n" 4 | vettore: .word 0:100 5 | len: .word 0 6 | .text 7 | li $v0,4 8 | la $a0,richiesta 9 | syscall 10 | li $v0,5 11 | syscall 12 | sw $v0,len 13 | lw $s1,len 14 | li $a0,0 15 | riempi: 16 | beq $s0,$s1,main 17 | li $v0,5 18 | syscall 19 | sw $v0,vettore($a0) 20 | addi $a0,$a0,4 21 | addi $s0,$s0,1 22 | j riempi 23 | main: 24 | subi $s2,$s1,1 25 | jal bubblesort 26 | stampa: 27 | bge $a3,$s1,fine 28 | lw $a2,vettore($a1) 29 | li $v0,1 30 | move $a0,$a2 31 | syscall 32 | addi $a1,$a1,4 33 | addi $a3,$a3,1 34 | li $v0,11 35 | li $a0,' ' 36 | syscall 37 | j stampa 38 | fine: 39 | li $v0,10 40 | syscall 41 | 42 | bubblesort: 43 | beq $t0,$s1,JR 44 | for: 45 | beq $t2,$s2,endFor 46 | sll $t3,$t2,2 47 | addi $t4,$t2,1 48 | sll $t5,$t4,2 49 | lw $t6,vettore($t3) 50 | lw $t7,vettore($t5) 51 | bgt $t6,$t7,cambio 52 | addi $t2,$t2,1 53 | j for 54 | cambio: 55 | move $t8,$t6 56 | sw $t7,vettore($t3) 57 | sw $t8,vettore($t5) 58 | addi $t2,$t2,1 59 | j for 60 | endFor: 61 | li $t2,0 62 | addi $t0,$t0,1 63 | j bubblesort 64 | JR: 65 | jr $ra 66 | -------------------------------------------------------------------------------- /snippets/bubbleSortRICORSIVO.asm: -------------------------------------------------------------------------------- 1 | # BUBBLE SORT RICORSIVO 2 | .data 3 | richiesta: .asciiz "inserire la lunghezza del vettore,poi i valori numerici\n" 4 | vettore: .word 0:100 5 | len: .word 0 6 | .text 7 | li $v0,4 8 | la $a0,richiesta 9 | syscall 10 | li $v0,5 11 | syscall 12 | sw $v0,len 13 | lw $s1,len 14 | li $a0,0 15 | riempi: 16 | beq $s0,$s1,main 17 | li $v0,5 18 | syscall 19 | sw $v0,vettore($a0) 20 | addi $a0,$a0,4 21 | addi $s0,$s0,1 22 | j riempi 23 | main: 24 | subi $s2,$s1,1 25 | jal bubblesort 26 | stampa: 27 | bge $a3,$s1,fine 28 | lw $a2,vettore($a1) 29 | li $v0,1 30 | move $a0,$a2 31 | syscall 32 | addi $a1,$a1,4 33 | addi $a3,$a3,1 34 | li $v0,11 35 | li $a0,' ' 36 | syscall 37 | j stampa 38 | fine: 39 | li $v0,10 40 | syscall 41 | bubblesort: 42 | subi $sp,$sp,8 43 | sw $ra,0($sp) 44 | sw $t0,4($sp) 45 | 46 | beq $t0,$s1,casobase 47 | for: 48 | beq $t2,$s2,endFor 49 | sll $t3,$t2,2 50 | addi $t4,$t2,1 51 | sll $t5,$t4,2 52 | lw $t6,vettore($t3) 53 | lw $t7,vettore($t5) 54 | bgt $t6,$t7,cambio 55 | addi $t2,$t2,1 56 | j for 57 | cambio: 58 | move $t8,$t6 59 | sw $t7,vettore($t3) 60 | sw $t8,vettore($t5) 61 | addi $t2,$t2,1 62 | j for 63 | endFor: 64 | li $t2,0 65 | addi $t0,$t0,1 66 | jal bubblesort 67 | lw $ra,0($sp) 68 | lw $t0,4($sp) 69 | addi $sp,$sp,8 70 | jr $ra 71 | casobase: 72 | lw $ra,0($sp) 73 | lw $t0,4($sp) 74 | addi $sp,$sp,8 75 | jr $ra -------------------------------------------------------------------------------- /snippets/cercaSottoStringa.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/cercaSottoStringa.asm -------------------------------------------------------------------------------- /snippets/cercaSottoStringaRICORSIVA.asm: -------------------------------------------------------------------------------- 1 | .data 2 | testo: .space 100 3 | query: .space 100 4 | .text 5 | .globl main 6 | main: 7 | #leggo testo in input 8 | li $v0,8 9 | la $a0,testo 10 | li $a1,100 11 | syscall 12 | 13 | #leggo query in input 14 | li $v0,8 15 | la $a0,query 16 | li $a1,10 17 | syscall 18 | 19 | la $t0,testo 20 | la $t1,query 21 | 22 | #preparo offset 23 | addi $s0,$s0,0 #N 24 | addi $s1,$s1,0 #M 25 | 26 | jal cerca 27 | 28 | #stampa 29 | stampa: 30 | li $v0,1 31 | move $a0,$t5 32 | syscall 33 | li $v0,10 34 | syscall 35 | 36 | cerca: 37 | lb $t2,0($t0) 38 | lb $t3,0($t1) 39 | beq $t3,'\0',tornoN 40 | beq $t3,'\n',tornoN 41 | beq $t2,'\0',tornoMenoUno 42 | beq $t2,'\n',tornoMenoUno 43 | sub $sp,$sp,4 44 | sw $ra,0($sp) 45 | bne $t2,$t3,incremento 46 | beq $t2,$t3,secondaLettera 47 | jal cerca 48 | 49 | incremento: 50 | addi $t5,$t5,1 51 | addi $t0,$t0,1 52 | addi $s1,$zero,0 53 | add $t1,$t1,$s1 54 | jal cerca 55 | 56 | secondaLettera: 57 | addi $t0,$t0,1 58 | addi $t1,$t1,1 59 | jal cerca 60 | 61 | tornoN: 62 | move $s0,$t5 63 | lw $ra,0($sp) 64 | add $sp,$sp,4 65 | jr $ra 66 | 67 | tornoMenoUno: 68 | addi $t5,$zero,-1 69 | lw $ra,0($sp) 70 | add $sp,$sp,4 71 | jr $ra 72 | 73 | 74 | -------------------------------------------------------------------------------- /snippets/cicloFor.asm: -------------------------------------------------------------------------------- 1 | .text 2 | #ESEMPIO CICLO FOR 3 | xor $t0,$t0,$t0 #inizializzazione registro (indice) a zero. 4 | for: 5 | beq $t0,60,endFor #condizione di uscita dal ciclo 6 | addi $t1,$t1,1 #aggiornamento variabile 7 | addi $t0,$t0,1 #aggiornamento indice 8 | j for #salto incondizionato 9 | endFor: 10 | li $v0,1 #stampa valore finale 11 | move $a0,$t1 12 | syscall 13 | 14 | -------------------------------------------------------------------------------- /snippets/confrontaStringhe.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/confrontaStringhe.asm -------------------------------------------------------------------------------- /snippets/confrontaStringheRICORSIVA.asm: -------------------------------------------------------------------------------- 1 | .data 2 | stringa1: .space 101 3 | stringa2: .space 101 4 | prima: .asciiz "prima" 5 | seconda :.asciiz "seconda" 6 | uguali : .asciiz "uguali" 7 | .text 8 | .globl main 9 | main: 10 | #lettura stringhe in input 11 | li $v0,8 12 | la $a0,stringa1 13 | li $a1,100 14 | syscall 15 | li $v0,8 16 | la $a0,stringa2 17 | la $a1,100 18 | syscall 19 | la $t0,stringa1 20 | la $t1,stringa2 21 | 22 | jal conta 23 | 24 | #stampa 25 | beq $t4,1,stampaPrima 26 | beq $t4,0,stampaUguali 27 | beq $t4,-1,stampaSeconda 28 | 29 | stampaPrima: 30 | li $v0,4 31 | la $a0,prima 32 | syscall 33 | li $v0,10 34 | syscall 35 | stampaUguali: 36 | li $v0,4 37 | la $a0,uguali 38 | syscall 39 | li $v0,10 40 | syscall 41 | stampaSeconda: 42 | li $v0,4 43 | la $a0,seconda 44 | syscall 45 | li $v0,10 46 | syscall 47 | 48 | 49 | conta: 50 | sub $sp,$sp,4 51 | sw $ra,0($sp) 52 | lb $t2,0($t0) 53 | lb $t3,0($t1) 54 | beq $t2,0,controlloY 55 | beq $t2,'\n',controlloY 56 | beq $t3,0,controlloX 57 | beq $t3,'\n',controlloX 58 | blt $t2,$t3,primaMinoreSeconda 59 | bgt $t2,$t3,primaMaggioreSeconda 60 | beq $t2,$t3,continua 61 | jal conta 62 | 63 | 64 | controlloY: 65 | beq $t3,0,ugualii 66 | beq $t3,'\n',ugualii 67 | li $t4,-1 68 | j fine 69 | 70 | controlloX: 71 | beq $t2,0,uguali 72 | beq $t2,'\n',ugualii 73 | li $t4,1 74 | j fine 75 | 76 | ugualii: 77 | li $t4,0 78 | j fine 79 | 80 | primaMinoreSeconda: 81 | li $t4,-1 82 | j fine 83 | 84 | primaMaggioreSeconda: 85 | li $t4,1 86 | j fine 87 | continua: 88 | addi $t0,$t0,1 89 | addi $t1,$t1,1 90 | jal conta 91 | fine: 92 | lw $ra,0($sp) 93 | add $sp,$sp,4 94 | jr $ra 95 | 96 | -------------------------------------------------------------------------------- /snippets/contaBitDiversi.asm: -------------------------------------------------------------------------------- 1 | .data 2 | .text 3 | .globl main 4 | main: 5 | #lettura X in input 6 | li $v0,5 7 | syscall 8 | move $t0,$v0 9 | 10 | #lettura Y in input 11 | li $v0,5 12 | syscall 13 | move $t1,$v0 14 | 15 | li $t6,2 #per la divisione 16 | 17 | jal conta 18 | 19 | #stampa 20 | li $v0,1 21 | move $a0,$t5 22 | syscall 23 | li $v0,10 24 | syscall 25 | 26 | conta: 27 | #caso base 28 | beq $t0,0,controlloy 29 | 30 | #salvo valori su stack 31 | sub $sp,$sp,4 32 | sw $ra,0($sp) 33 | 34 | andi $s0,$t0,1 35 | andi $s1,$t1,1 36 | xor $t3,$s0,$s1 37 | add $t5,$t5,$t3 38 | div $t0,$t0,$t6 39 | div $t1,$t1,$t6 40 | 41 | jal conta 42 | 43 | controlloy: 44 | beq $t1,0,fine 45 | jr $ra 46 | 47 | fine: 48 | #carico valori da stack 49 | lw $ra,0($sp) 50 | addi $sp,$sp,4 51 | jr $ra 52 | 53 | 54 | 55 | 56 | 57 | -------------------------------------------------------------------------------- /snippets/contaBitUgualiRICORSIVA.asm: -------------------------------------------------------------------------------- 1 | .data 2 | .text 3 | .globl main 4 | main: 5 | #lettura X in input 6 | li $v0,5 7 | syscall 8 | move $t0,$v0 9 | 10 | addi $v0,$zero,0 #azzero $v0 11 | 12 | #lettura Y in input 13 | li $v0,5 14 | syscall 15 | move $t1,$v0 16 | 17 | jal conta 18 | 19 | #stampa 20 | li $v0,1 21 | move $a0,$t3 22 | syscall 23 | li $v0,10 24 | syscall 25 | 26 | conta: 27 | beq $t0,0,fine 28 | beq $t1,0,fine 29 | subi $sp,$sp,4 30 | sw $ra,0($sp) 31 | andi $t4,$t0,1 32 | andi $t5,$t1,1 33 | beq $t4,$t5,lsbUguali 34 | bne $t4,$t5,lsbDiversi 35 | jal conta 36 | 37 | lsbUguali: 38 | div $t0,$t0,2 39 | div $t1,$t1,2 40 | addi $t3,$t3,1 41 | jal conta 42 | 43 | lsbDiversi: 44 | div $t0,$t0,2 45 | div $t1,$t1,2 46 | jal conta 47 | 48 | fine: 49 | lw $ra,0($sp) 50 | add $sp,$sp,4 51 | jr $ra 52 | 53 | -------------------------------------------------------------------------------- /snippets/contaElementiInVettore.asm: -------------------------------------------------------------------------------- 1 | # CONTA ELEMENTI IN VETTORE ( ENTRAMBI DATI IN INPUT ) 2 | # con funzioni e salvataggio su stack pointer 3 | 4 | .data 5 | vettore: .space 100 6 | 7 | .text 8 | li $t1,0 9 | riempi: 10 | li $v0,5 11 | syscall 12 | beq $v0,$t1,elemento 13 | sw $v0,vettore($t0) 14 | addi $t0,$t0,4 15 | j riempi 16 | elemento: 17 | la $a0,vettore 18 | lw $a1,vettore($t1) 19 | li $v0,5 20 | syscall 21 | move $t3,$v0 22 | scandisci: 23 | beq $a1,$t1,stampa 24 | lw $a1,0($a0) 25 | jal verifica 26 | addi $a0,$a0,4 27 | j scandisci 28 | verifica: 29 | subi $sp,$sp,8 30 | sw $ra,0($sp) 31 | sw $a1,4($sp) 32 | 33 | beq $a1,$t3,aggiungi 34 | 35 | lw $ra,0($sp) 36 | lw $a1,4($sp) 37 | addi $sp,$sp,8 38 | jr $ra 39 | aggiungi: 40 | addi $s2,$s2,1 41 | 42 | lw $ra,0($sp) 43 | lw $a1,4($sp) 44 | addi $sp,$sp,8 45 | jr $ra 46 | stampa: 47 | li $v0,1 48 | move $a0,$s2 49 | syscall 50 | li $v0,10 51 | syscall 52 | 53 | 54 | 55 | 56 | 57 | 58 | -------------------------------------------------------------------------------- /snippets/contaLettere.asm: -------------------------------------------------------------------------------- 1 | # CONTA I CARATTERI DI UNA STRINGA DATA IN INPUT E STAMPA LA TERNA <#LETTERE,#NUMERI,#ALTRO> 2 | .data 3 | richiesta: .asciiz "inserire una stringa (max 100 caratteri)\n" 4 | stringa: .space 101 5 | .text 6 | li $v0,4 7 | la $a0,richiesta 8 | syscall 9 | li $v0,8 10 | la $a0,stringa 11 | li $a1,100 12 | syscall 13 | len: 14 | lb $s0,stringa($s1) 15 | beq $s0,10,main 16 | addi $s2,$s2,1 17 | addi $s1,$s1,1 18 | j len 19 | main: 20 | li $a1,0 21 | subi $s2,$s2,1 22 | li $t0,0 23 | jal conta 24 | li $v0,1 25 | move $a0,$a1 26 | syscall 27 | li $v0,11 28 | li $a0,'\t' 29 | syscall 30 | li $v0,1 31 | move $a0,$a2 32 | syscall 33 | li $v0,11 34 | li $a0,'\t' 35 | syscall 36 | li $v0,1 37 | move $a0,$a3 38 | syscall 39 | li $v0,11 40 | li $a0,'\t' 41 | syscall 42 | li $v0,10 43 | syscall 44 | conta: 45 | bgt $t0,$s2,JR 46 | lb $t1,stringa($t0) 47 | #controllo lettera 48 | sle $s3,$t1,'z' 49 | sge $s4,$t1,'a' 50 | and $s5,$s3,$s4 51 | sle $s3,$t1,'Z' 52 | sge $s4,$t1,'A' 53 | and $s6,$s3,$s4 54 | or $s6,$s5,$s6 55 | beq $s6,1,lettere 56 | # controllo numeri 57 | sge $s3,$t1,'0' 58 | sle $s4,$t1,'9' 59 | and $s7,$s3,$s4 60 | beq $s7,1,numeri 61 | addi $t0,$t0,1 62 | addi $a3,$a3,1 63 | j conta 64 | JR: 65 | jr $ra 66 | numeri: 67 | addi $a2,$a2,1 68 | addi $t0,$t0,1 69 | j conta 70 | 71 | lettere: 72 | addi $a1,$a1,1 73 | addi $t0,$t0,1 74 | j conta -------------------------------------------------------------------------------- /snippets/contaLettereRICORSIVO.asm: -------------------------------------------------------------------------------- 1 | # CONTA I CARATTERI DI UNA STRINGA DATA IN INPUT RICORSIVAMENTE E STAMPA LA TERNA <#LETTERE,#NUMERI,#ALTRO> 2 | .data 3 | richiesta: .asciiz "inserire una stringa (max 100 caratteri)\n" 4 | stringa: .space 101 5 | .text 6 | li $v0,4 7 | la $a0,richiesta 8 | syscall 9 | li $v0,8 10 | la $a0,stringa 11 | li $a1,100 12 | syscall 13 | len: 14 | lb $s0,stringa($s1) 15 | beq $s0,10,main 16 | addi $s2,$s2,1 17 | addi $s1,$s1,1 18 | j len 19 | main: 20 | li $a1,0 21 | subi $s2,$s2,1 22 | li $t0,0 23 | jal conta 24 | li $v0,1 25 | move $a0,$a1 26 | syscall 27 | li $v0,11 28 | li $a0,'\t' 29 | syscall 30 | li $v0,1 31 | move $a0,$a2 32 | syscall 33 | li $v0,11 34 | li $a0,'\t' 35 | syscall 36 | li $v0,1 37 | move $a0,$a3 38 | syscall 39 | li $v0,11 40 | li $a0,'\t' 41 | syscall 42 | li $v0,10 43 | syscall 44 | conta: 45 | subi $sp,$sp,8 46 | sw $ra,0($sp) 47 | sw $t0,4($sp) 48 | 49 | bgt $t0,$s2,casobase 50 | lb $t1,stringa($t0) 51 | #controllo lettera 52 | sle $s3,$t1,'z' 53 | sge $s4,$t1,'a' 54 | and $s5,$s3,$s4 55 | sle $s3,$t1,'Z' 56 | sge $s4,$t1,'A' 57 | and $s6,$s3,$s4 58 | or $s6,$s5,$s6 59 | # controllo numeri 60 | sge $s3,$t1,'0' 61 | sle $s4,$t1,'9' 62 | and $s7,$s3,$s4 63 | jal verifica 64 | addi $t0,$t0,1 65 | jal conta 66 | 67 | lw $ra,0($sp) 68 | lw $t0,4($sp) 69 | addi $sp,$sp,8 70 | jr $ra 71 | verifica: 72 | beq $s6,1,lettere 73 | beq $s7,1,numeri 74 | addi $a3,$a3,1 75 | jr $ra 76 | numeri: 77 | addi $a2,$a2,1 78 | jr $ra 79 | lettere: 80 | addi $a1,$a1,1 81 | jr $ra 82 | casobase: 83 | lw $ra,0($sp) 84 | lw $t0,4($sp) 85 | addi $sp,$sp,8 86 | jr $ra -------------------------------------------------------------------------------- /snippets/contaNove.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/contaNove.asm -------------------------------------------------------------------------------- /snippets/contaOccorrenzeVettoreRICORSIVO.asm: -------------------------------------------------------------------------------- 1 | # CONTA OCCORRENZE DI X IN UN VETTORE RICORSIVAMENTE 2 | .data 3 | richiesta: .asciiz " inserire un numero da cercare nel vettore\n" 4 | vettore: .word 1,2,2,3,3,3,4,4,4,4,5,5,5,5,5,6,6,6,6,6,6,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,9 5 | elem: .word 45 6 | .text 7 | li $v0,4 8 | la $a0,richiesta 9 | syscall 10 | li $v0,5 11 | syscall 12 | move $a0,$v0 13 | li $t1,45 # j (indice fine) 14 | jal conta # chiamata ricorsiva 15 | stampa: 16 | li $v0,1 17 | move $a0,$t5 18 | syscall 19 | li $v0,10 20 | syscall 21 | 22 | conta: 23 | subi $sp,$sp,12 #allocazione stack 24 | sw $ra,0($sp) 25 | sw $t0,4($sp) 26 | sw $t1,8($sp) 27 | 28 | beq $t1,$t0,caso_base # caso base 29 | subi $t1,$t1,1 # aggiornamento parametri 30 | jal conta # chiamata ricorsiva 31 | sll $t3,$t1,2 # offset 32 | lw $t4,vettore($t3) # elemento corrente 33 | beq $t4,$a0,aggiornaCont # occorrenze++ 34 | lw $ra,0($sp) # ripristino stack 35 | lw $t0,4($sp) 36 | lw $t1,8($sp) 37 | addi $sp,$sp,12 38 | jr $ra 39 | 40 | caso_base: 41 | lw $ra,0($sp) # ripristino stack 42 | lw $t0,4($sp) 43 | lw $t1,8($sp) 44 | addi $sp,$sp,12 45 | jr $ra 46 | aggiornaCont: 47 | addi $t5,$t5,1 48 | lw $ra,0($sp) 49 | lw $t0,4($sp) 50 | lw $t1,8($sp) 51 | addi $sp,$sp,12 52 | jr $ra 53 | -------------------------------------------------------------------------------- /snippets/contaPariInLista.asm: -------------------------------------------------------------------------------- 1 | # CONTA QUANTI VALORI CON INDICI PARI CI SONO NELLA LISTA 2 | .data 3 | richiesta: .asciiz "inserire la lunghezza del vettore ed inserire i valori(max 20)\n" 4 | vettore: .space 21 5 | N: .word 0 6 | .text 7 | li $v0,4 8 | la $a0,richiesta 9 | syscall 10 | li $v0,5 11 | syscall 12 | sw $v0,N 13 | move $t0,$v0 14 | addi $t9,$t9,1 15 | riempi: 16 | li $v0,5 17 | syscall 18 | beq $t9,$t0,main 19 | sw $v0,vettore($s0) 20 | addi $t9,$t9,1 21 | addi $s0,$s0,4 22 | j riempi 23 | main: 24 | li $t1,0 25 | jal contaPari 26 | li $v0,1 27 | move $a0,$s1 28 | syscall 29 | li $v0,10 30 | syscall 31 | contaPari: 32 | lw $t2,vettore($t1) 33 | beq $t2,-1,JR 34 | div $t1,$t1,4 35 | div $t3,$t1,2 36 | mfhi $t3 37 | beq $t3,0,pari 38 | sll $t1,$t2,2 39 | j contaPari 40 | pari: 41 | addi $s1,$s1,1 42 | sll $t1,$t2,2 43 | j contaPari 44 | JR: 45 | jr $ra 46 | -------------------------------------------------------------------------------- /snippets/contaPariInListaRICORSIVA.asm: -------------------------------------------------------------------------------- 1 | # CONTA QUANTI VALORI CON INDICI PARI CI SONO NELLA LISTA RICORSIVAMENTE 2 | .data 3 | richiesta: .asciiz "inserire la lunghezza del vettore ed inserire i valori(max 20)\n" 4 | vettore: .space 21 5 | N: .word 0 6 | .text 7 | li $v0,4 8 | la $a0,richiesta 9 | syscall 10 | li $v0,5 11 | syscall 12 | sw $v0,N 13 | move $t0,$v0 14 | addi $t9,$t9,1 15 | riempi: 16 | li $v0,5 17 | syscall 18 | beq $t9,$t0,main 19 | sw $v0,vettore($s0) 20 | addi $t9,$t9,1 21 | addi $s0,$s0,4 22 | j riempi 23 | main: 24 | li $t1,0 25 | jal contaPari 26 | li $v0,1 27 | move $a0,$s1 28 | syscall 29 | li $v0,10 30 | syscall 31 | contaPari: 32 | subi $sp,$sp,8 33 | sw $ra,0($sp) 34 | sw $t1,4($sp) 35 | 36 | lw $t2,vettore($t1) 37 | beq $t2,-1,casobase 38 | div $t1,$t1,4 39 | div $t3,$t1,2 40 | mfhi $t3 41 | jal conta 42 | sll $t1,$t2,2 43 | jal contaPari 44 | 45 | lw $ra,0($sp) 46 | lw $t1,4($sp) 47 | addi $sp,$sp,8 48 | jr $ra 49 | conta: 50 | beq $t3,0,pari 51 | jr $ra 52 | pari: 53 | addi $s1,$s1,1 54 | jr $ra 55 | casobase: 56 | lw $ra,0($sp) 57 | lw $t1,4($sp) 58 | addi $sp,$sp,8 59 | jr $ra -------------------------------------------------------------------------------- /snippets/ifThenElse.asm: -------------------------------------------------------------------------------- 1 | .text 2 | # ESEMPIO IF THEN ELSE 3 | subi $t0,$t0,4 4 | blez $t0,else 5 | addi $t1,$t1,1 #$t0>0 6 | j codicePost 7 | else: 8 | #$t0<0 9 | 10 | codicePost:#se $t0>0,stampa 1 11 | li $v0,1 12 | move $a0,$t0 13 | syscall 14 | -------------------------------------------------------------------------------- /snippets/insertionSort.asm: -------------------------------------------------------------------------------- 1 | # INSERTION SORT 2 | .data 3 | richiesta: .asciiz "inserire la lunghezza del vettore,poi i valori numerici\n" 4 | vettore: .word 0:100 5 | len: .word 0 6 | .text 7 | li $v0,4 8 | la $a0,richiesta 9 | syscall 10 | li $v0,5 11 | syscall 12 | sw $v0,len 13 | lw $s1,len 14 | li $a0,0 15 | riempi: 16 | beq $s0,$s1,main 17 | li $v0,5 18 | syscall 19 | sw $v0,vettore($a0) 20 | addi $a0,$a0,4 21 | addi $s0,$s0,1 22 | j riempi 23 | main: 24 | li $t0,1 25 | jal insertionSort 26 | stampa: 27 | bge $a3,$s1,fine 28 | lw $a2,vettore($a1) 29 | li $v0,1 30 | move $a0,$a2 31 | syscall 32 | addi $a1,$a1,4 33 | addi $a3,$a3,1 34 | j stampa 35 | fine: 36 | li $v0,10 37 | syscall 38 | 39 | insertionSort: 40 | beq $t0,$s1,JR 41 | sll $t3,$t0,2 42 | lw $t2,vettore($t3) 43 | move $t4,$t2 44 | subi $t1,$t0,1 45 | while: 46 | slt $s6,$t1,$k0 47 | sll $t5,$t1,2 48 | lw $s5,vettore($t5) 49 | sle $s7,$s5,$t4 50 | or $s4,$s6,$s7 51 | beq $s4,1,exit 52 | addi $t9,$t1,1 53 | sll $t9,$t9,2 54 | sw $s5,vettore($t9) 55 | subi $t1,$t1,1 56 | addi $t8,$t1,1 57 | sll $t8,$t8,2 58 | sw $t4,vettore($t8) 59 | j while 60 | exit: 61 | addi $t0,$t0,1 62 | j insertionSort 63 | JR: 64 | jr $ra 65 | -------------------------------------------------------------------------------- /snippets/insertionSortRICORSIVO.asm: -------------------------------------------------------------------------------- 1 | # INSERTION SORT RICORSIVO 2 | .data 3 | richiesta: .asciiz "inserire la lunghezza del vettore,poi i valori numerici\n" 4 | vettore: .word 0:100 5 | len: .word 0 6 | .text 7 | li $v0,4 8 | la $a0,richiesta 9 | syscall 10 | li $v0,5 11 | syscall 12 | sw $v0,len 13 | lw $s1,len 14 | li $a0,0 15 | riempi: 16 | beq $s0,$s1,main 17 | li $v0,5 18 | syscall 19 | sw $v0,vettore($a0) 20 | addi $a0,$a0,4 21 | addi $s0,$s0,1 22 | j riempi 23 | main: 24 | addi $s1,$s1,1 25 | li $k0,0 26 | jal insertionSort 27 | subi $s1,$s1,1 28 | stampa: 29 | bge $a3,$s1,fine 30 | lw $a2,vettore($a1) 31 | li $v0,1 32 | move $a0,$a2 33 | syscall 34 | addi $a1,$a1,4 35 | addi $a3,$a3,1 36 | j stampa 37 | fine: 38 | li $v0,10 39 | syscall 40 | 41 | insertionSort: 42 | subi $sp,$sp,8 43 | sw $ra,0($sp) 44 | sw $s1,4($sp) 45 | 46 | ble $s1,2,casobase 47 | subi $s1,$s1,1 48 | jal insertionSort 49 | subi $s2,$s1,1 50 | sll $k1,$s2,2 51 | lw $s3,vettore($k1) 52 | move $s4,$s3 53 | subi $t0,$s2,1 54 | jal while 55 | 56 | lw $ra,0($sp) 57 | lw $s1,4($sp) 58 | addi $sp,$sp,8 59 | jr $ra 60 | while: 61 | slt $s5,$t0,$k0 62 | sll $t9,$t0,2 63 | lw $s6,vettore($t9) 64 | sle $s7,$s6,$s4 65 | or $s7,$s5,$s7 66 | beq $s7,1,endWhile 67 | addi $t7,$t0,1 68 | sll $t7,$t7,2 69 | sw $s6,vettore($t7) 70 | subi $t0,$t0,1 71 | addi $t5,$t0,1 72 | sll $t5,$t5,2 73 | sw $s4,vettore($t5) 74 | j while 75 | endWhile: 76 | jr $ra 77 | casobase: 78 | lw $ra,0($sp) 79 | lw $s1,4($sp) 80 | addi $sp,$sp,8 81 | jr $ra 82 | 83 | -------------------------------------------------------------------------------- /snippets/isPalindroma.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/isPalindroma.asm -------------------------------------------------------------------------------- /snippets/letturaInputEStampaMax.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/letturaInputEStampaMax.asm -------------------------------------------------------------------------------- /snippets/listaInserisciValoreESomma.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/listaInserisciValoreESomma.asm -------------------------------------------------------------------------------- /snippets/log2RICORSIVA.asm: -------------------------------------------------------------------------------- 1 | .data 2 | x: .word 3 | y:.word 4 | .text 5 | .globl main 6 | main: 7 | #x in input 8 | li $v0,5 9 | la $a0,x 10 | syscall 11 | sw $v0,x 12 | lw $t0,x 13 | 14 | addi $v0,$zero,0 #resetto $v0 15 | 16 | #y in input 17 | li $v0,5 18 | la $a0,y 19 | syscall 20 | sw $v0,y 21 | lw $t1,y 22 | 23 | li $t2,2 #salvo valore due per la divisione 24 | 25 | jal log #chiamata ricorsiva 26 | 27 | stampa: 28 | li $v0,1 29 | move $a0,$t3 30 | syscall 31 | li $v0,10 32 | syscall 33 | 34 | log: 35 | 36 | beq $t0,1,controlloy 37 | 38 | #salvo valori sullto stack 39 | sub $sp,$sp,4 40 | sw $ra,0($sp) 41 | 42 | beq $t1,1,controllox 43 | div $t0,$t0,$t2 44 | addi $t3,$t3,1 45 | jal log 46 | 47 | 48 | controllox: 49 | beq $t0,1,fine 50 | bgt $t0,1,xmezzi 51 | xmezzi: 52 | div $t0,$t0,$t2 53 | addi $t3,$t3,1 54 | jal log 55 | controlloy: 56 | beq $t1,1,fine 57 | bgt $t1,1,ymezzi 58 | 59 | ymezzi: 60 | div $t1,$t1,$t2 61 | addi $t3,$t3,1 62 | jal log 63 | fine: 64 | #carico valori dallo stack 65 | lw $ra,0($sp) 66 | add $sp,$sp,4 67 | jr $ra 68 | -------------------------------------------------------------------------------- /snippets/lunghezzaListaRICORSIVO.asm: -------------------------------------------------------------------------------- 1 | # DATA UNA STRUCT LISTA STAMPARE RICORSIVAMENTE LE VISITE E INFINE LA SUA LUNGHEZZA 2 | .data 3 | richiesta: .asciiz "inserire il numero dei valori e successivamente la lista(max 100 valori)\n" 4 | lista: .word 0:100 5 | N: .word 0 6 | .text 7 | li $v0,4 8 | la $a0,richiesta 9 | syscall 10 | li $v0,5 11 | syscall 12 | sw $v0,N 13 | move $t0,$v0 14 | li $a0,0 15 | riempi: 16 | beq $t1,$t0,main 17 | li $v0,5 18 | syscall 19 | sw $v0,lista($a0) 20 | addi $a0,$a0,4 21 | addi $t1,$t1,1 22 | j riempi 23 | main: 24 | li $s0,0 25 | jal LEN 26 | li $v0,11 27 | li $a0,'\n' 28 | syscall 29 | li $v0,1 30 | move $a0,$s3 31 | syscall 32 | li $v0,10 33 | syscall 34 | 35 | LEN: 36 | subi $sp,$sp,8 37 | sw $ra,0($sp) 38 | sw $s0,4($sp) 39 | 40 | sll $s1,$s0,2 41 | lw $s2,lista($s1) 42 | li $v0,1 43 | move $a0,$s0 44 | syscall 45 | li $v0,11 46 | li $a0,'\r' 47 | syscall 48 | addi $s3,$s3,1 49 | beq $s2,-1,casoBase 50 | move $s0,$s2 51 | jal LEN 52 | 53 | lw $ra,0($sp) 54 | lw $s0,4($sp) 55 | addi $sp,$sp,8 56 | jr $ra 57 | casoBase: 58 | lw $ra,0($sp) 59 | lw $s0,4($sp) 60 | addi $sp,$sp,8 61 | jr $ra 62 | -------------------------------------------------------------------------------- /snippets/matriceContenenteCubiDiAltraMatrice.asm: -------------------------------------------------------------------------------- 1 | # CALCOLO DI UNA MATRICE CONTENENTE I CUBI (x^3) DI INTERI DI UN'ALTRA MATRICE 2 | .data 3 | matrice: .word 1,2,3,4,5 4 | 5,4,3,2,1 5 | 6,7,8,9,0 6 | righe: .word 3 7 | colonne: .word 5 8 | matriceCubi: .word 0:15 9 | a_capo: .asciiz "\r\n" 10 | space: .byte 32 11 | .text 12 | la $a0,matrice 13 | li $a1,0 14 | lw $t0,righe 15 | lw $t1,colonne 16 | mul $a2,$t0,$t1 17 | la $s0,matriceCubi 18 | ciclo: 19 | beq $a1,$a2,stampaP 20 | lw $a3,0($a0) 21 | mul $s5,$a3,$a3 22 | mul $a3,$a3,$s5 23 | sw $a3,0($s0) 24 | addi $s0,$s0,4 25 | addi $a0,$a0,4 26 | addi $a1,$a1,1 27 | j ciclo 28 | stampaP: 29 | li $t6,0 30 | li $t2,0 31 | la $s0,matriceCubi 32 | la $a3,space 33 | stampa: 34 | beq $t2,15,esci 35 | lw $t3,0($s0) 36 | li $v0,1 37 | move $a0,$t3 38 | syscall 39 | li $v0,4 40 | move $a0,$a3 41 | syscall 42 | addi $s0,$s0,4 43 | addi $t2,$t2,1 44 | addi $t6,$t6,1 45 | beq $t6,5,nextLine 46 | beq $t6,10,nextLine 47 | j stampa 48 | nextLine: 49 | li $v0,4 50 | la $a0,a_capo 51 | syscall 52 | j stampa 53 | esci: 54 | li $v0,10 55 | syscall -------------------------------------------------------------------------------- /snippets/matriceRisultanteColonnaxRiga.asm: -------------------------------------------------------------------------------- 1 | # MATRICE RISULTANTE IL PRODOTTO VETTORE COLONNA X VETTORE RIGA 2 | .data 3 | riga: .word 1,2,3,4 4 | colonna: .word 2,3,4 5 | matrice: .word 0:12 6 | .text 7 | li $t0,0 8 | li $t1,0 9 | li $t2,0 10 | li $t9,0 11 | scorri: 12 | beq $t2,12,stampa 13 | sll $t3,$t0,2 14 | lw $t6,riga($t3) 15 | sll $t4,$t1,2 16 | lw $t7,colonna($t4) 17 | mul $t8,$t6,$t7 18 | sll $t5,$t2,2 19 | sw $t8,matrice($t5) 20 | addi $t0,$t0,1 21 | addi $t2,$t2,1 22 | beq $t0,4,colonnaSucc 23 | j scorri 24 | 25 | colonnaSucc: 26 | li $t0,0 27 | addi $t1,$t1,1 28 | j scorri 29 | stampa: 30 | 31 | beq $t9,12,fine 32 | sll $s1,$t9,2 33 | lw $s0,matrice($s1) 34 | li $v0,1 35 | move $a0,$s0 36 | syscall 37 | addi $t9,$t9,1 38 | j stampa 39 | 40 | fine: 41 | li $v0,10 42 | syscall 43 | 44 | -------------------------------------------------------------------------------- /snippets/mergesort.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/mergesort.asm -------------------------------------------------------------------------------- /snippets/printListReverseRICORSIVO.asm: -------------------------------------------------------------------------------- 1 | # STAMPA INVERSA DI UNA STRUCT LISTA 2 | .data 3 | lista: .word 4 | 4,4, 5 | 2,-1, 6 | 1,3, 7 | 3,1, 8 | 5,2 9 | .text 10 | li $t0,0 11 | li $t1,0 12 | jal PR # chiamata ricorsiva 13 | li $v0,10 14 | syscall 15 | 16 | PR: 17 | subi $sp,$sp,12 # allocazione stack 18 | sw $ra,0($sp) 19 | sw $t0,4($sp) 20 | sw $t4,8($sp) 21 | 22 | addi $t1,$t0,1 # i++ 23 | sll $t2,$t0,2 # offset i 24 | sll $t3,$t1,2 # offset i++ 25 | lw $t4,lista($t2) # elemento i 26 | lw $t5,lista($t3) # elemento i++(prossimo indice) 27 | beq $t5,-1,casobase #se i++==-1 lista finita 28 | mul $t0,$t5,2 # i++*2 29 | jal PR # chiamata ricorsiva 30 | li $v0,1 # stampa alla chiusura delle chiamate ricorsive 31 | move $a0,$t4 32 | syscall 33 | li $v0,11 # stampa tab 34 | li $a0,'\t' 35 | syscall 36 | lw $ra,0($sp) 37 | lw $t0,4($sp) # ripristino stack 38 | lw $t4,8($sp) 39 | addi $sp,$sp,12 40 | jr $ra 41 | casobase: # caso base 42 | li $v0,1 43 | move $a0,$t4 44 | syscall 45 | li $v0,11 46 | li $a0,'\t' 47 | syscall 48 | lw $ra,0($sp) 49 | lw $t0,4($sp) 50 | lw $t4,8($sp) 51 | addi $sp,$sp,12 52 | jr $ra 53 | -------------------------------------------------------------------------------- /snippets/raggruppaLettere.asm: -------------------------------------------------------------------------------- 1 | # RAGGRUPPA TUTTE LE LETTERE ALL'INIZIO E GLI ALTRI CARATTERI ALLA FINE 2 | .data 3 | richiesta: .asciiz "inserire una stringa (max 100 caratteri)\n" 4 | stringa: .space 31 5 | 6 | .text 7 | li $v0,4 8 | la $a0,richiesta 9 | syscall 10 | li $v0,8 11 | la $a0,stringa 12 | la $a1,30 13 | syscall 14 | len: 15 | lb $s0,stringa($s1) 16 | beq $s0,10,main 17 | addi $s1,$s1,1 18 | addi $s2,$s2,1 19 | j len 20 | main: 21 | subi $s2,$s2,1 22 | jal raggruppa 23 | li $v0,4 24 | la $a0,stringa 25 | syscall 26 | li $v0,10 27 | syscall 28 | raggruppa: 29 | bge $t0,$s2,JR 30 | lb $t1,stringa($t0) 31 | j verifica 32 | 33 | scambia: 34 | lb $t8,stringa($s2) 35 | sb $t1,stringa($s2) 36 | sb $t8,stringa($t0) 37 | subi $s2,$s2,1 38 | j raggruppa 39 | verifica: 40 | sle $t2,$t1,'Z' 41 | sge $t3,$t1,'A' 42 | and $t4,$t2,$t3 43 | sle $t2,$t1,'z' 44 | sge $t3,$t1,'a' 45 | and $t5,$t2,$t3 46 | or $t6,$t4,$t5 47 | beq $t6,0,scambia 48 | addi $t0,$t0,1 49 | j raggruppa 50 | JR: 51 | jr $ra 52 | -------------------------------------------------------------------------------- /snippets/raggruppaLettereRICORSIVO.asm: -------------------------------------------------------------------------------- 1 | # RAGGRUPPA TUTTE LE LETTERE ALL'INIZIO E GLI ALTRI CARATTERI ALLA FINE RICORSIVAMENTE 2 | .data 3 | richiesta: .asciiz "inserire una stringa (max 100 caratteri)\n" 4 | stringa: .space 101 5 | 6 | .text 7 | li $v0,4 8 | la $a0,richiesta 9 | syscall 10 | li $v0,8 11 | la $a0,stringa 12 | la $a1,100 13 | syscall 14 | len: 15 | lb $s0,stringa($s1) 16 | beq $s0,10,main 17 | addi $s1,$s1,1 18 | addi $s2,$s2,1 19 | j len 20 | main: 21 | subi $s2,$s2,1 22 | jal raggruppa 23 | li $v0,4 24 | la $a0,stringa 25 | syscall 26 | li $v0,10 27 | syscall 28 | raggruppa: 29 | subi $sp,$sp,12 30 | sw $ra,0($sp) 31 | sw $t0,4($sp) 32 | sw $s2,8($sp) 33 | 34 | bge $t0,$s2,casobase 35 | lb $t1,stringa($t0) 36 | sle $t2,$t1,'Z' 37 | sge $t3,$t1,'A' 38 | and $t4,$t2,$t3 39 | sle $t2,$t1,'z' 40 | sge $t3,$t1,'a' 41 | and $t5,$t2,$t3 42 | or $t6,$t4,$t5 43 | jal scambia 44 | jal raggruppa 45 | lw $ra,0($sp) 46 | lw $ra,0($sp) 47 | lw $t0,4($sp) 48 | lw $s2,8($sp) 49 | addi $sp,$sp,12 50 | jr $ra 51 | casobase: 52 | lw $ra,0($sp) 53 | lw $t0,4($sp) 54 | lw $s2,8($sp) 55 | addi $sp,$sp,12 56 | jr $ra 57 | scambia: 58 | beq $t6,1,JR 59 | lb $t8,stringa($s2) 60 | sb $t1,stringa($s2) 61 | sb $t8,stringa($t0) 62 | subi $s2,$s2,1 63 | jr $ra 64 | JR: 65 | addi $t0,$t0,1 66 | jr $ra -------------------------------------------------------------------------------- /snippets/ricercaBinariaInputEStampaRICORSIVO.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/ricercaBinariaInputEStampaRICORSIVO.asm -------------------------------------------------------------------------------- /snippets/ricercaBinariaMatriceRICORSIVO.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/ricercaBinariaMatriceRICORSIVO.asm -------------------------------------------------------------------------------- /snippets/ricercaBinariaRICORSIVA.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/ricercaBinariaRICORSIVA.asm -------------------------------------------------------------------------------- /snippets/ruotaVettoreSenzaAppoggioRICORSIVO.asm: -------------------------------------------------------------------------------- 1 | # STAMPARE UN VETTORE IN INPUT AL CONTRARIO RICORSIVAMENTE SENZA VETTORE DI APPOGGIO 2 | # DA TROVARE ERRORE: LE CHIAMATE RICORSIVE SONO GIUSTE, MA ESCE PRIMA DI CHIUDERE L'ULTIMA 3 | # ESEMPIO: VETTORE= 1,2,3,4,5===STAMPA====> 1,4,3,2,5 4 | .data 5 | vettore: .word 50:1 6 | richiesta: .asciiz "inserire interi positivi da salvare sul vettore (max 100), -1 per terminare\n" 7 | vettVuoto: .asciiz "vettore vuoto\n" 8 | space: .byte 32 9 | 10 | .text 11 | li $t8,-1 12 | li $v0,4 13 | la $a0,richiesta 14 | syscall 15 | la $a0,vettore 16 | addi $s7,$a0,200 17 | riempi: 18 | li $v0,5 19 | syscall # riempimento vettore 20 | beq $v0,-1,menoUno 21 | sw $v0,0($a0) 22 | addi $a0,$a0,4 23 | j riempi 24 | menoUno: 25 | sw $t8,0($a0) # tutti gli altri valori settati a -1 26 | beq $a0,$s7,len 27 | addi $a0,$a0,4 28 | j menoUno 29 | len: 30 | la $a0,vettore 31 | li $a1,0 32 | cLen: 33 | lw $v0,0($a0) 34 | beq $v0,-1,comincia # calcolo lunghezza vettore 35 | addi $a1,$a1,1 36 | addi $a0,$a0,4 37 | j cLen 38 | comincia: 39 | beq $a1,0,vettVuot # se len==0: vettore vuoto 40 | div $t0,$a1,2 41 | li $t1,0 42 | subi $t2,$a1,1 43 | move $t8,$t2 44 | li $t9,0 45 | la $s6,vettore 46 | jal reverse 47 | stampa: 48 | beq $t9,$a1,fine 49 | lw $s7,0($s6) 50 | li $v0,1 51 | move $a0,$s7 52 | syscall 53 | addi $t9,$t9,1 54 | addi $s6,$s6,4 55 | j stampa 56 | 57 | vettVuot: 58 | li $v0,4 59 | la $a0,vettVuoto 60 | syscall 61 | j fine 62 | reverse: 63 | subi $sp,$sp,12 64 | sw $ra,0($sp) 65 | sw $t1,4($sp) 66 | sw $t2,8($sp) 67 | addi $t1,$t1,1 68 | subi $t2,$t2,1 69 | bgt $t1,$t0,caso_base 70 | jal reverse 71 | 72 | sll $t3,$t1,2 73 | sll $t4,$t2,2 74 | lw $t5,vettore($t3) 75 | lw $t6,vettore($t4) 76 | sw $t6,vettore($t3) 77 | sw $t5,vettore($t4) 78 | 79 | 80 | lw $ra,0($sp) 81 | lw $t1,4($sp) 82 | lw $t2,8($sp) 83 | addi $sp,$sp,12 84 | jr $ra 85 | 86 | caso_base: 87 | lw $ra,0($sp) 88 | lw $t1,4($sp) 89 | lw $t2,8($sp) 90 | addi $sp,$sp,12 91 | jr $ra 92 | fine: 93 | li $v0,10 94 | syscall 95 | 96 | 97 | -------------------------------------------------------------------------------- /snippets/ruotaVettoresenzaAppoggio.asm: -------------------------------------------------------------------------------- 1 | # RUOTARE UN VETTORE SENZA STRUTTURA DI APPOGGIO 2 | .data 3 | vettore: .word 100:1 4 | richiesta: .asciiz "inserire interi positivi da salvare sul vettore (max 100), -1 per terminare\n" 5 | vettVuoto: .asciiz "vettore vuoto\n" 6 | 7 | .text 8 | li $t8,-1 9 | li $v0,4 10 | la $a0,richiesta 11 | syscall 12 | la $a0,vettore 13 | addi $s7,$a0,400 14 | riempi: 15 | li $v0,5 16 | syscall # riempimento vettore 17 | beq $v0,-1,menoUno 18 | sw $v0,0($a0) 19 | addi $a0,$a0,4 20 | j riempi 21 | menoUno: 22 | sw $t8,0($a0) # tutti gli altri valori settati a -1 23 | beq $a0,$s7,len 24 | addi $a0,$a0,4 25 | j menoUno 26 | len: 27 | la $a0,vettore 28 | li $a1,0 29 | cLen: 30 | lw $v0,0($a0) 31 | beq $v0,-1,comincia # calcolo lunghezza vettore 32 | addi $a1,$a1,1 33 | addi $a0,$a0,4 34 | j cLen 35 | comincia: 36 | beq $a1,0,vettVuot # se len==0: vettore vuoto 37 | div $t0,$a1,2 38 | li $t1,0 39 | subi $t2,$a1,1 40 | scorri: 41 | bge $t1,$t0,stampaReverse # se ho finito stampo il vettore 42 | sll $t3,$t1,2 43 | sll $t4,$t2,2 44 | lw $t5,vettore($t3) # v[i] inizio 45 | lw $t6,vettore($t4) # v[j] fine 46 | sw $t6,vettore($t3) # li scambio 47 | sw $t5,vettore($t4) 48 | addi $t1,$t1,1 # i++ 49 | subi $t2,$t2,1 #j-- 50 | j scorri 51 | 52 | stampaReverse: 53 | la $s0,vettore 54 | sll $a3,$a1,2 55 | add $s1,$s0,$a3 56 | stampa: # ciclo che stampa i valori del nuovo vettore 57 | bge $s0,$s1,fine 58 | lw $s2,0($s0) 59 | li $v0,1 60 | move $a0,$s2 61 | syscall 62 | addi $s0,$s0,4 63 | j stampa 64 | fine: 65 | li $v0,10 66 | syscall 67 | 68 | vettVuot: 69 | li $v0,4 70 | la $a0,vettVuoto 71 | syscall 72 | li $v0,10 73 | syscall 74 | 75 | 76 | 77 | 78 | 79 | -------------------------------------------------------------------------------- /snippets/selectionSort.asm: -------------------------------------------------------------------------------- 1 | #SELECTION SORT 2 | .data 3 | richiesta: .asciiz "inserire la lunghezza del vettore e poi i valori(max 100)\n" 4 | vettore: .word 0:100 5 | len: .word 0 6 | .text 7 | li $v0,4 8 | la $a0,richiesta 9 | syscall 10 | li $v0,5 11 | syscall 12 | sw $v0,len 13 | move $s0,$v0 14 | li $a0,0 15 | riempi: 16 | beq $s1,$s0,main 17 | li $v0,5 18 | syscall 19 | sw $v0,vettore($a0) 20 | addi $s1,$s1,1 21 | addi $a0,$a0,4 22 | j riempi 23 | main: 24 | li $t0,0 25 | subi $s2,$s0,1 26 | jal selectionSort 27 | stampa: 28 | beq $k0,$s0,fine 29 | sll $a3,$k0,2 30 | lw $k1,vettore($a3) 31 | li $v0,1 32 | move $a0,$k1 33 | syscall 34 | addi $k0,$k0,1 35 | li $v0,11 36 | li $a0,' ' 37 | syscall 38 | j stampa 39 | fine: 40 | li $v0,10 41 | syscall 42 | 43 | selectionSort: 44 | bge $t0,$s2,JR 45 | move $t1,$t0 46 | addi $t2,$t0,1 47 | for: 48 | bge $t2,$s0,esci 49 | sll $t4,$t2,2 50 | lw $t3,vettore($t4) 51 | sll $t6,$t1,2 52 | lw $t5,vettore($t6) 53 | blt $t3,$t5,cambio 54 | addi $t2,$t2,1 55 | j for 56 | cambio: 57 | move $t1,$t2 58 | addi $t2,$t2,1 59 | j for 60 | esci: 61 | bne $t1,$t0,cambia 62 | addi $t0,$t0,1 63 | j selectionSort 64 | cambia: 65 | sll $s3,$t0,2 66 | lw $s4,vettore($s3) 67 | move $s5,$s4 68 | sll $s6,$t1,2 69 | lw $s7,vettore($s6) 70 | sw $s7,vettore($s3) 71 | sw $s5,vettore($s6) 72 | addi $t0,$t0,1 73 | j selectionSort 74 | JR: 75 | jr $ra 76 | -------------------------------------------------------------------------------- /snippets/selectionSortRICORSIVO.asm: -------------------------------------------------------------------------------- 1 | #SELECTION SORT RICORSIVO 2 | .data 3 | richiesta: .asciiz "inserire la lunghezza del vettore e poi i valori(max 100)\n" 4 | vettore: .word 0:100 5 | len: .word 0 6 | .text 7 | li $v0,4 8 | la $a0,richiesta 9 | syscall 10 | li $v0,5 11 | syscall 12 | sw $v0,len 13 | move $s0,$v0 14 | li $a0,0 15 | riempi: 16 | beq $s1,$s0,main 17 | li $v0,5 18 | syscall 19 | sw $v0,vettore($a0) 20 | addi $s1,$s1,1 21 | addi $a0,$a0,4 22 | j riempi 23 | main: 24 | li $t0,0 25 | subi $s2,$s0,1 26 | jal selectionSort 27 | stampa: 28 | beq $k0,$s0,fine 29 | sll $a3,$k0,2 30 | lw $k1,vettore($a3) 31 | li $v0,1 32 | move $a0,$k1 33 | syscall 34 | addi $k0,$k0,1 35 | li $v0,11 36 | li $a0,' ' 37 | syscall 38 | j stampa 39 | fine: 40 | li $v0,10 41 | syscall 42 | 43 | selectionSort: 44 | subi $sp,$sp,12 45 | sw $ra,0($sp) 46 | sw $t0,4($sp) 47 | sw $t1,8($sp) 48 | 49 | bge $t0,$s2,casobase 50 | move $t1,$t0 51 | addi $t2,$t0,1 52 | for: 53 | bge $t2,$s0,esci 54 | sll $t4,$t2,2 55 | lw $t3,vettore($t4) 56 | sll $t6,$t1,2 57 | lw $t5,vettore($t6) 58 | blt $t3,$t5,cambio 59 | addi $t2,$t2,1 60 | j for 61 | cambio: 62 | move $t1,$t2 63 | addi $t2,$t2,1 64 | j for 65 | esci: 66 | bne $t1,$t0,cambia 67 | addi $t0,$t0,1 68 | j sel 69 | cambia: 70 | sll $s3,$t0,2 71 | lw $s4,vettore($s3) 72 | move $s5,$s4 73 | sll $s6,$t1,2 74 | lw $s7,vettore($s6) 75 | sw $s7,vettore($s3) 76 | sw $s5,vettore($s6) 77 | addi $t0,$t0,1 78 | j sel 79 | sel: 80 | jal selectionSort 81 | lw $ra,0($sp) 82 | lw $t0,4($sp) 83 | lw $t1,8($sp) 84 | addi $sp,$sp,12 85 | jr $ra 86 | 87 | casobase: 88 | lw $ra,0($sp) 89 | lw $t0,4($sp) 90 | lw $t1,8($sp) 91 | addi $sp,$sp,12 92 | jr $ra 93 | 94 | 95 | 96 | -------------------------------------------------------------------------------- /snippets/sommaColonneMatrice.asm: -------------------------------------------------------------------------------- 1 | # SOMMA PER COLONNE DI UNA MATRICE NxM ( QUALSIASI COLONNA SI SCEGLIE RISUKTA SEMPRE LO STESSO RISULTATO) 2 | .data 3 | matrice: .word 91:1 4 | richiesta: .asciiz "inserire un 0 SALVARE IN UN VETTORE E STAMPARE IL RISULTATO DELLA VISITA DI ESSA. 2 | .data 3 | lista: .word 1,1,2,3,3,5,4,2,5,-1,6,4 4 | visita: .word 0:6 5 | .text 6 | li $t0,0 7 | li $t6,0 8 | li $t7,0 9 | scorri: 10 | ble $t5,-1,stampa 11 | sll $t1,$t0,2 12 | lw $t2,lista($t1) 13 | sw $t2,visita($t6) 14 | addi $t6,$t6,4 15 | addi $t3,$t0,1 16 | sll $t4,$t3,2 17 | lw $t5,lista($t4) 18 | mul $t5,$t5,2 19 | move $t0,$t5 20 | j scorri 21 | stampa: 22 | beq $t7,24,fine 23 | lw $t8,visita($t7) 24 | addi $t7,$t7,4 25 | li $v0,1 26 | move $a0,$t8 27 | syscall 28 | j stampa 29 | fine: 30 | li $v0,10 31 | syscall -------------------------------------------------------------------------------- /snippets/switchCase.asm: -------------------------------------------------------------------------------- 1 | #ESEMPIO SWITCH CASE 2 | .data 3 | dest: .word caso0,caso1,caso2,caso3 #label if 4 | 5 | .text 6 | addi $t0,$t0,3 #valore indice (i) 7 | sll $t0,$t0,2 #i*4 8 | lw $t1,dest($t0) #carico in $t1 l'indirizzo della label che mi interessa 9 | jr $t1 #salto inc. alla label 10 | 11 | caso0: #VARI CASI 12 | xor $t2,$t2,$t2 13 | j end 14 | caso1: 15 | addi $t2,$t2,111 16 | j end 17 | caso2: 18 | addi $t2,$t2,222 19 | j end 20 | caso3: 21 | addi $t2,$t2,333 22 | j end 23 | 24 | end: 25 | li $v0,1 # stampa a seconda dell'input di i 26 | move $a0,$t2 27 | syscall -------------------------------------------------------------------------------- /snippets/trovaMaxInVettore.asm: -------------------------------------------------------------------------------- 1 | .data 2 | vettore: .word 1,7,23,90,26,74,654,98,34,65,78,6,84,5,9,9 #vettore da scorrere 3 | dim: .word 16 #dim vettore 4 | .text 5 | lw $t3,dim($zero) 6 | lw $t1,vettore($t0) 7 | move $t2,$t1 #imposto vettore[0] come primo massimo 8 | mul $t3,$t3,4 #salvo in $t3 l'offset dell'ultimo elemento del vettore 9 | for: 10 | bge $t0,$t3,end #condizione di uscita 11 | lw $t1,vettore($t0) #vettore[i] 12 | bgt $t1,$t2,aggiornamentoMax 13 | addi $t0,$t0,4 #aggiorno indice 14 | j for #salto inc. 15 | 16 | aggiornamentoMax: 17 | move $t2,$t1 #aggiornamento max 18 | addi $t0,$t0,4 #aggiorno indice 19 | j for 20 | 21 | end: #stampa max 22 | li $v0,1 23 | move $a0,$t2 24 | syscall -------------------------------------------------------------------------------- /snippets/trovaModaVettoreRICORSIVO.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/trovaModaVettoreRICORSIVO.asm -------------------------------------------------------------------------------- /snippets/trovaNumero.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/trovaNumero.asm -------------------------------------------------------------------------------- /snippets/verificaLatiTriangolo.asm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/edoardottt/asm-snippets/95a42da45183a2b14508e934a13196033b1c4db9/snippets/verificaLatiTriangolo.asm -------------------------------------------------------------------------------- /snippets/whileDo.asm: -------------------------------------------------------------------------------- 1 | .text 2 | # ESEMPIO WHILE DO 3 | addi $t0,$t0,100 #valore iniziale $t0 4 | while: 5 | beqz $t0,endWhile #condizione per uscire dal ciclo 6 | subi $t0,$t0,1 #aggiorno valore 7 | j while #salto incondizionato 8 | endWhile: 9 | li $v0,1 10 | move $a0,$t0 #stampa il valore (0) 11 | syscall 12 | --------------------------------------------------------------------------------