Matte23/Laboratori-MIPS
1
0
Fork 0
Code Activity

feat: Initial commit

Browse Source
This commit is contained in:
Matteo Schiff
2024-03-22 13:53:19 +01:00
parent 44aa2938a2
commit 2a54d9dbc2
34 changed files with 1475 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
LICENSE Normal file
View File

@@ -0,0 +1,9 @@
MIT License
Copyright (c) 2024 Matte23
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

16
Laboratorio2/Esercizio1.asm Normal file
View File

@@ -0,0 +1,16 @@
.data
n1: .byte 10
n2: .byte 0x10
n3: .byte '1'
res: .space 1
.text
.globl main
.ent main
main:
lb $t1, n1
lb $t2, n2
lb $t3, n3
sub $t4, $t1, $t2
add $t4, $t4, $t3
sb $t4, res

34
Laboratorio2/Esercizio2.asm Normal file
View File

@@ -0,0 +1,34 @@
.data
var1: .byte 'm'
var2: .byte 'i'
var3: .byte 'p'
var4: .byte 's'
var5: .byte 0
.text
.globl main
.ent main
main:
lb $t1, var1
sub $t1, $t1, 32
sb $t1, var1
lb $t1, var2
sub $t1, $t1, 32
sb $t1, var2
lb $t1, var3
sub $t1, $t1, 32
sb $t1, var3
lb $t1, var4
sub $t1, $t1, 32
sb $t1, var4
la $a0, var1
li $v0, 4
syscall
li $v0, 10
syscall
.end main

18
Laboratorio2/Esercizio3.asm Normal file
View File

@@ -0,0 +1,18 @@
.data
op1: .byte 150
op2: .byte 100
.text
.globl main
.ent main
main:
lb $t1, op1
lb $t2, op2
add $t1, $t1, $t2
move $a0, $t1
li $v0, 1
syscall
li $v0, 10
syscall
.end main

19
Laboratorio2/Esercizio4.asm Normal file
View File

@@ -0,0 +1,19 @@
.text
.globl main
.ent main
main:
li $v0, 5
syscall
move $t1, $v0
li $v0, 5
syscall
move $t2, $v0
add $t1, $t1, $t2
sub $t2, $t1, $t2
sub $t1, $t1, $t2
li $v0, 10
syscall
.end main

58
Laboratorio2/Esercizio5.asm Normal file
View File

@@ -0,0 +1,58 @@
.data
formula: .asciiz "Calcolo f = (g+h)-(i+j)\n"
insert_g: .asciiz "Inserire g = "
insert_h: .asciiz "\nInserire h = "
insert_i: .asciiz "\nInserire i = "
insert_j: .asciiz "\nInserire j = "
acq_term: .asciiz "\nAcquisizione terminata. f = "
res: .word 1
.text
.globl main
.ent main
main:
la $a0, formula
li $v0, 4
syscall
la $a0, insert_g
li $v0, 4
syscall
li $v0, 5
syscall
move $t1, $v0
la $a0, insert_h
li $v0, 4
syscall
li $v0, 5
syscall
add $t1, $t1, $v0
la $a0, insert_i
li $v0, 4
syscall
li $v0, 5
syscall
sub $t1, $t1, $v0
la $a0, insert_j
li $v0, 4
syscall
li $v0, 5
syscall
sub $t1, $t1, $v0
la $a0, acq_term
li $v0, 4
syscall
move $a0, $t1
li $v0, 1
syscall
sw $t1, res
li $v0, 10
syscall
.end main

23
Laboratorio3/Esercizio1.asm Normal file
View File

@@ -0,0 +1,23 @@
.data
var: .word 0x3FFFFFF0
.text
.globl main
.ent main
main:
lw $t1, var
add $t1, $t1, $t1
move $a0, $t1
li $v0, 1
syscall
addi $t2, $t1, 40
move $a0, $t2
li $v0, 1
syscall
li $t2, 40
add $t2, $t1, $t1
move $a0, $t2
li $v0, 1
syscall
li $v0, 10
syscall

28
Laboratorio3/Esercizio2.asm Normal file
View File

@@ -0,0 +1,28 @@
.data
formula: .asciiz "Overflow\n"
res: .word 1
.text
.globl main
.ent main
main:
li $v0, 5
syscall
move $t1, $v0
li $v0, 5
syscall
move $t2, $v0
addu $t1, $t1, $t2
slt $t2, $t1, 0
beq $t2, $0, fine
la $a0, formula
li $v0, 4
syscall
fine:
li $v0, 10
syscall
.end main

64
Laboratorio3/Esercizio5.asm Normal file
View File

@@ -0,0 +1,64 @@
.data
wVet: .space 50
wRes: .space 1
charact: .byte 'a'
mex_prompt: .asciiz "Inserire caratteri\n"
mex_occ: .asciiz "Occorrenze: "
.text
.globl main
.ent main
main:
la $t0, wVet # punta a inizio vettore
li $t1, 0 # inizializzo contatore
# stampo primo messaggi
la $a0, mex_prompt
li $v0, 4 # id della syscall print_str
syscall
# lettura stringa. a quanto pare posso solo fare una read_chr
ciclo_read:
# syscall read
li $v0, 12
syscall # il risultato è in v0
sb $v0, ($t0)
add $t0, $t0, 1 # incremento puntatore
beq $v0, '\n', fine_lettura # smetto di saltare quando ho raggiunto un newline
add $t1, $t1, 1 # incremento contatore (sapendo che non è un \n)
beq $t1, 50, fine_lettura # controllo di non uscire dal buffer
b ciclo_read
fine_lettura:
move $t5, $t1 # salvo in $t5 la lunghezza della stringa
# resetto puntatore
la $t0, wVet # punta a inizio vettore
add $t1, $t0, $t5 # indirizzo finale
lb $t2, charact
move $t4, $0
conta_occorrenze:
lb $t3, ($t0)
bne $t3, $t2, prox_chr # salto se non è un minimo
addi $t4, $t4, 1 # memorizzo il nuovo minimo
prox_chr:
add $t0, $t0, 1 # incremento puntatore
bne $t0, $t1, conta_occorrenze # smetto di saltare quando ho iterato su tutti i caratteri
# stampo ultimo messaggio
la $a0, mex_occ
li $v0, 4 # id della syscall print_str
syscall
move $a0, $t4
li $v0, 1
syscall
fine:
li $v0, 10
syscall
.end main

25
Laboratorio4/Esercizio1.asm Normal file
View File

@@ -0,0 +1,25 @@
.data
mpari: .asciiz "Il numero è pari\n"
mdispari: .asciiz "Il numero è dispari\n"
.text
.globl main
.ent main
main:
li $v0, 5
syscall
move $t0, $v0
andi $t0, t0, 0x1
beq .dispari %t0, 0x1
la $a0, mpari
j fine
dispari:
la $a0, mdispari
fine:
li $v0, 4
syscall
li $v0, 10
syscall

45
Laboratorio4/Esercizio3.asm Normal file
View File

@@ -0,0 +1,45 @@
.data
var1: .word 14
var2: .word 13
var3: .word 12
.text
.globl main
.ent main
main:
lw $t1, var1
lw $t2, var2
lw $t3, var3
blt $t1, $t2 stepa
move $t0, $t2
move $t2, $t1
move $t1, $t0
stepa:
blt $t1, $t3 stepb
move $t0, $t3
move $t3, $t1
move $t1, $t0
stepb:
blt $t2, $t3 stepc
move $t0, $t3
move $t3, $t2
move $t2, $t0
stepc:
move $a0, $t1
li $v0, 1
syscall
move $a0, $t2
li $v0, 1
syscall
move $a0, $t3
li $v0, 1
syscall
li $v0, 10
syscall

29
Laboratorio4/Esercizio4.asm Normal file
View File

@@ -0,0 +1,29 @@
.data
var1: .word 14
.text
.globl main
.ent main
main:
lw $t1, var1
move $t0, $0
move $t3, $0
addi $t5, $t0, 1
loop:
sllv $t4, $t5, $t3
and $t2, $t1,$t4
srlv $t2, $t2, $t3
beq $t2, 0, is_zero
addi $t0, $t0, 1
is_zero:
addi $t3, $t3, 1
bne $t3, 8, loop
move $a0, $t0
li $v0, 1
syscall
li $v0, 10
syscall

31
Laboratorio5/Esercizio1.asm Normal file
View File

@@ -0,0 +1,31 @@
.data
mpari: .asciiz "Il numero è pari\n"
mdispari: .asciiz "Il numero è dispari\n"
.text
.globl main
.ent main
main:
move $t0, $0
addi $t2, $0, 10
read_num:
li $v0, 12
syscall
beq $v0, '\n', fine # smetto di saltare quando ho raggiunto un newline
addi $t1, $v0, -48 # $t0 = $v0 - '0'
mult $t0, $t2
mflo $t0
add $t0, $t0, $t1
j read_num
fine:
move $a0, $t0
li $v0, 1
syscall
li $v0, 10
syscall

33
Laboratorio6/Esercizio1.asm Normal file
View File

@@ -0,0 +1,33 @@
.data
wVet: .space 20
wDim: .byte 20
.text
.globl main
.ent main
main:
la $t0, wVet # punta a inizio vettore
lb $t1, wDim
add $t1, $t1, $t0
addi $t4, $0, 1
sb $t4, ($t0)
addi $t0, $t0, 1
sb $t4, ($t0)
# lettura stringa. a quanto pare posso solo fare una read_chr
ciclo_fibonacci:
# syscall read
addi $t2, $t0, -1
lb $t4, ($t2)
addi $t2, $t2, -1
lb $t5, ($t2)
add $t4, $t4, $t5
sb $t4, ($t0)
addi $t0, $t0, 1
bne $t0, $t1, ciclo_fibonacci
li $v0, 10
syscall
.end main

34
Laboratorio6/Esercizio4.asm Normal file
View File

@@ -0,0 +1,34 @@
.data
wVet: .space 100
wDim: .byte 10
.text
.globl main
.ent main
main:
la $t0, wVet # punta a inizio vettore
lb $t1, wDim
addi $t2, $0, 1
# lettura stringa. a quanto pare posso solo fare una read_chr
ciclo_riga:
addi $t3, $0, 1
ciclo_colonna:
mult $t2, $t3
mflo $t4
sb $t4, ($t0)
addi $t0, $t0, 1
addi $t3, $t3, 1
bne $t3, $t1, ciclo_colonna
addi $t0, $t0, 10
addi $t2, $t2, 1
bne $t2, $t1, ciclo_riga
li $v0, 10
syscall
.end main

40
Laboratorio6/Esercizio5.asm Normal file
View File

@@ -0,0 +1,40 @@
.data
wVet: .word 154, 123, 109, 86, 4, 0
.word 412, -23, -231, 9, 50, 0
.word 123, -24, 12, 55, -45, 0
.word 0, 0, 0, 0, 0, 0
wDimX: .byte 5
wDimY: .byte 3
.text
.globl main
.ent main
main:
la $t0, wVet # punta a inizio vettore
lb $t1, wDimX
lb $t6, wDimY
addi $t2, $0, 1
ciclo_riga:
addi $t3, $0, 1
addi $t4, $0, 0
ciclo_colonna:
lw $t5, ($t0)
add $t4, $t4, $t5
addi $t0, $t0, 1
addi $t3, $t3, 1
bne $t3, $t1, ciclo_colonna
addi $t0, $t0, 1
sw $t4, ($t0)
addi $t0, $t0, 10
addi $t2, $t2, 1
bne $t2, $t6, ciclo_riga
li $v0, 10
syscall
.end main

30
Laboratorio7/Esercizio1.asm Normal file
View File

@@ -0,0 +1,30 @@
.data
num: .word 3141592653
.text
.globl main
.ent main
main:
lw $t0, num
addi $t2, $0, 10
move $t3, $sp
seq_divide:
divu $t0, $t2
mfhi $t1 # remainder to $a2
mflo $t0
addi $sp, $sp, -4
sw $t1, 0($sp)
bne $t1, $0, seq_divide
print:
addi $sp, $sp, 4
lw $t0, 0($sp)
addi $a0, $t0, 48 # $t0 = $v0 - '0'
li $v0, 11
syscall
bne $sp, $t3, print
li $v0, 10
syscall
.end main

46
Laboratorio7/Esercizio2.asm Normal file
View File

@@ -0,0 +1,46 @@
.data
num: .word 3141592653
p: .asciiz "Il numero è palindromo"
np: .asciiz "Il numero non è palindromo"
.text
.globl main
.ent main
main:
move $t0, $sp
addi $t0, $t0, -4
read_str:
li $v0, 12
syscall
beq $v0, '\n', fine # smetto di saltare quando ho raggiunto un newline
addi $sp, $sp, -4
sw $v0, 0($sp)
j read_str
fine:
print:
lw $t1, 0($sp)
lw $t2, 0($t0)
bne $t1, $t2, non_p
addi $sp, $sp, 4
addi $t0, $t0, -4
bgt $t0, $sp, print
la $a0, p
li $v0, 4
syscall
j f
non_p:
la $a0, np
li $v0, 4
syscall
f:
li $v0, 10
syscall
.end main

0
Laboratorio7/Esercizio4.asm Normal file
View File

27
Laboratorio8/Esercizio4.asm Normal file
View File

@@ -0,0 +1,27 @@
.data
p: .asciiz "Il numero è palindromo"
.text
.globl main
.ent main
main:
addiu $sp, $sp, -4
sw $ra, ($sp)
li $a0, 4
li $a1, 3
li $a2, 2
li $a3, 1
jal determinante2x2
lw $ra, ($sp)
jr $ra
.end main
.ent determinante2x2
determinante2x2:
mul $t0, $a0, $a3
mul $t1, $a1, $a2
sub $v0, $t0, $t1
jr $ra
.end determinante2x2

87
Laboratorio8/Esercizio5.asm Normal file
View File

@@ -0,0 +1,87 @@
.data
p: .asciiz "Il numero è palindromo"
.text
.globl main
.ent main
main:
addiu $sp, $sp, -4
sw $ra, ($sp)
li $a0, 4
li $a1, 3
li $a2, 2
li $a3, 1
jal determinante2x2
lw $ra, ($sp)
jr $ra
.end main
.ent determinante3x3
determinante3x3
# crea frame
sub $sp, $sp, 4
sw $fp, ($sp)
move $fp, $sp
# salva i registri
sub $sp, $sp, 24
sw $s0, ($sp)
sw $s1, 4($sp)
sw $s2, 8($sp)
sw $s3, 12($sp)
sw $s4, 16($sp)
sw $ra, 20($sp)
move $s0, $a0
move $s1, $a1
move $s2, $a2
move $s3, $a3
# calcolo step 1
lw $a0, 20($fp)
lw $a1, 16($fp)
lw $a2, 8($fp)
lw $a3, 4($fp)
jal determinante2x2
mul $s4, $v0, $s0
# calcolo step 2
move $a0, $s3
lw $a1, 16($fp)
lw $a2, 12($fp)
lw $a3, 4($fp)
jal determinante2x2
mul $t0, $v0, $s1
addu $s4, $s4, $t0
# calcolo step 3
move $a0, $s3
lw $a1, 20($fp)
lw $a2, 12($fp)
lw $a3, 8($fp)
jal determinante2x2
mul $t0, $v0, $s2
addu $v0, $s4, $t0
# ripristina i registri
lw $s0, ($sp)
lw $s1, 4($sp)
lw $s2, 8($sp)
lw $s3, 12($sp)
lw $s4, 16($sp)
lw $ra, 20($sp)
lw $fp, 24($sp)
addi $sp, $sp, 28
jr $ra
.end determinante3x3
.ent determinante2x2
determinante2x2:
mul $t0, $a0, $a3
mul $t1, $a1, $a2
sub $v0, $t0, $t1
jr $ra
.end determinante2x2

70
Laboratorio9/bisestile.asm Normal file
View File

@@ -0,0 +1,70 @@
LUNG =, 6
.data
anni: .word 1945, 2008, 1800, 2006, 1748, 1600
ris: .space LUNG
.text
.globl main
.ent main
main:
la $a0, anni
la $a1, ris
li $a2, LUNG
jal bisestile
li $v0, 10 # codice per uscita dal programma
syscall # fine
.end main
.ent bisestile
bisestile:
addi $sp, $sp, -4
sw $ra, ($sp)
li $s0, 0
sll $a2, $a2, 2
addu $s1, $a0, $a2
move $s2, $a0
move $s3, $a1
loop:
lw $a0, ($s2)
jal bisestileS
beq $v0, $0, skip
addiu $s0, $s0, 1
skip:
sb $v0, ($s3)
addiu $s2, $s2, 4
addiu $s3, $s3, 1
bne $s2, $s1, loop
move $v0, $s0
lw $ra, ($sp)
addi $sp, $sp, 4
jr $ra
.end bisestile
.ent bisestileS
bisestileS:
# anno in $a0
li $t0, 400
div $a0, $t0
mfhi $t0
beq $t0, 0, bis
li $t0, 100
div $a0, $t0
mfhi $t0
beq $t0, 0, nbis
li $t0, 4
div $a0, $t0
mfhi $t0
beq $t0, 0, bis
nbis:
li $v0, 0
jr $ra
bis:
li $v0, 1
jr $ra
.end bisestileS

46
Laboratorio9/costoparcheggio.asm Normal file
View File

@@ -0,0 +1,46 @@
.data
ora_in: .byte 12, 47
ora_out: .byte 18, 14
X: .byte 1
Y: .byte 40
.text
.globl main
.ent main
main:
la $a0, ora_in # indirizzo di ora_in
la $a1, ora_out # indirizzo di ora_out
lbu $a2, X
lbu $a3, Y
jal costoParcheggio
li $v0, 10 # codice per uscita dal programma
syscall # fine
.end main
.ent costoParcheggio
costoParcheggio:
# Calcolo minuti nel parcheggio in $t0
li $t0, 60
lbu $t1, ($a0)
lbu $t2, ($a1)
subu $t1, $t2, $t1
multu $t0, $t1
mflo $t0
lb $t1, 1($a0)
lb $t2, 1($a1)
addu $t0, $t0, $t2
sub $t0, $t0, $t1
divu $t0, $a3
mflo $t0
mfhi $t1
beq $t1, $0, compl
addiu $t0, $t0, 1
compl:
multu $t0, $a2
mflo $v0
jr $ra
.end costoParcheggio

47
Laboratorio9/hamming.asm Normal file
View File

@@ -0,0 +1,47 @@
DIM =, 5
.data
vet1: .word 56, 12, 98, 129, 58
vet2: .word 1, 0, 245, 129, 12
risultato: .space DIM
.text
.globl main
.ent main
main:
la $a0, vet1
la $a1, vet2
la $a2, risultato
li $a3, DIM
jal CalcolaDistanzaH
li $v0, 10 # codice per uscita dal programma
syscall
.end main
.ent CalcolaDistanzaH
CalcolaDistanzaH:
sll $a3, $a3, 2
addu $t0, $a0, $a3
loop:
lw $t1, ($a0)
lw $t2, ($a1)
xor $t1, $t1, $t2
li $t2, 0
li $t3, 0
iloop:
andi $t4, $t1, 0x0001
addu $t2, $t2, $t4
srl $t1, $t1, 1
addiu $t3, $t3, 1
bne $t3,8, iloop
sw $t2, ($a2)
# incremento
addiu $a0, $a0, 4
addiu $a1, $a1, 4
addiu $a2, $a2, 4
bne $a0, $t0, loop
jr $ra
.end CalcolaDistanzaH

62
Laboratorio9/sconto.asm Normal file
View File

@@ -0,0 +1,62 @@
NUM =, 5
DIM =, NUM, *, 4
SCONTO =, 30
ARROTONDA=1
.data
prezzi: .word 39, 1880, 2394, 1000, 1590
scontati: .space DIM
.text
.globl main
.ent main
main:
la $a0, prezzi
la $a1, scontati
li $a2, NUM
li $a3, SCONTO
li $t0, ARROTONDA
subu $sp, 4
sw $t0, ($sp)
jal calcola_sconto
li $v0, 10 # codice per uscita dal programma
syscall # fine
.end main
.ent calcola_sconto
calcola_sconto:
addiu $sp, $sp, -4 # crea spazio per lo stack
sw $fp, ($sp) # memorizza frame pointer
move $fp, $sp # il nuovo frame pointer è lo stack pointer precedente
move $t0, $a0 # pointer prezzi
move $t1, $a1 # pointer scontati
sll $t2, $a2, 2 # moltiplica per 4 (stiamo lavorando con delle
addu $t2, $t0, $t2 # pointer fine prezzi
li $t5, 100 # fattore per dividere
sub $t3, $t5, $a3 # fattore moltiplicativo
lw $t4, 4($fp) # flag approssima
move $v0, $0 # totale scontato
loop:
lw $t8, ($t0) # carica prezzo dalla memoria
mul $t6, $t8, $t3 # moltiplica per fattore
divu $t6, $t5 # dividi
mflo $t6 # carica quoto
beqz $t4, salva # salta al salvataggio se la flag arrotonda è zero
mfhi $t7 # carica resto
blt $t7, 50, salva # salta al salvataggio se il resto è minore di 50
addiu $t6, $t6, 1 # arrotonda per eccesso
salva:
sw $t6, ($t1) # salva in memoria
subu $t6, $t8, $t6
addu $v0, $v0, $t6 # aggiorna totale
addiu $t0, $t0, 4 # incrementa pointer prezzi
addiu $t1, $t1, 4 # incrementa pointer scontati
bne $t0, $t2, loop
lw $fp, ($sp) # carica lo stack pointer salvato
move $sp, $fp # ripristinalo
addiu $sp, $sp, 4 # pop stack
jr $ra
.end calcola_sconto

52
Temi esame/cambio.asm Normal file
View File

@@ -0,0 +1,52 @@
DIM =, 6
.data
vetB: .byte 2, 14, 119, 54, 10, 41
vetN: .space DIM
.text
.globl main
.ent main
main:
la $a0, vetB
la $a1, vetN
li $a2, DIM
jal Cambio
li $v0, 10 # codice per uscita dal programma
syscall # fine
.end main
.ent Cambio
Cambio:
li $t0, 0 # contatore di riga
loop:
li $t1, 0 # numero di cambi
addu $t2, $t0, $a0
lb $t2, ($t2) # carico la parola
li $t3, 0 # contatore bit
# inizializzo last val
andi $t4, $t2, 0x00000001
rileva_cambi:
srl $t2, $t2, 1
andi $t5, $t2, 0x00000001
beq $t4, $t5, cont
addiu $t1, $t1, 1
cont:
move $t4, $t5
addiu $t3, $t3, 1
bne $t3, 7, rileva_cambi
addu $t2, $t0, $a1
sb $t1, ($t2) # salvo il risultato in vetN
addiu $t0, $t0, 1
bne $t0, $a2, loop
jr $ra
.end Cambio

92
Temi esame/codF.asm Normal file
View File

@@ -0,0 +1,92 @@
.data
cognome:.asciiz "ROSSI"
nome:.asciiz "GENNARO"
data:.asciiz "120892"
CF:.space 12
.text
.globl main
.ent main
main:
subu $sp, $sp, 4
sw $ra, ($sp)
la $a0, cognome
la $a1, nome
la $a2, data
la $a3, CF
jal CalcoloCF
lw $ra, ($sp)
addiu $sp, $sp, 4
jr $ra
.end main
.ent CalcoloCF
CalcoloCF:
# Calcolo cognome
li $t0, 0
move $t2, $a0
genC:
# salto delle vocali
lb $t3, 0($t2)
beq $t3 'A', next
beq $t3 'E', next
beq $t3 'I', next
beq $t3 'O', next
beq $t3 'U', next
# aggiungo carattere
sb $t3, 0($a3)
addiu $a3,$a3,1
addiu $t0,$t0,1
next:
addiu $t2,$t2,1
bne $t0, 3, genC
# Calcolo nome
li $t0, 0
move $t2, $a1
genC1:
# salto delle vocali
lb $t3, ($t2)
beq $t3 'A', next1
beq $t3 'B', next1
beq $t3 'C', next1
beq $t3 'D', next1
beq $t3 'E', next1
# aggiungo carattere
sb $t3, ($a3)
addiu $a3,$a3,1
addiu $t0,$t0,1
next1:
addiu $t2,$t2,1
bne $t0, 3, genC1
# Copio data
move $t0, $a2
lb $t1, ($t0)
sb $t1, ($a3)
lb $t1, 1($t0)
sb $t1, 1($a3)
addiu $t0,$t0,4
addiu $a3,$a3,4
lb $t1, ($t0)
sb $t1, ($a3)
lb $t1, 1($t0)
sb $t1, 1($a3)
jr $ra
.end CalcoloCF
.ent MonthToChar
MonthToChar:
# Parametro in ingresso $a0 = 2 CARATTERI ESTRATTI DALLA DATA
# (esempio: "01" per Gennaio)
# Parametro in uscita $v0 = "A" per l'esempio di Gennaio
# codice della procedura da non sviluppare
li $v0, 'X'
jr $ra
.end MonthToChar

102
Temi esame/codFmeglio.asm Normal file
View File

@@ -0,0 +1,102 @@
.data
cognome:.asciiz "ROSSI"
nome:.asciiz "GENNARO"
data:.asciiz "120892"
CF:.space 12
.text
.globl main
.ent main
main:
subu $sp, $sp, 4
sw $ra, ($sp)
la $a0, cognome
la $a1, nome
la $a2, data
la $a3, CF
jal CalcoloCF
lw $ra, ($sp)
addiu $sp, $sp, 4
jr $ra
.end main
.ent CalcoloCF
CalcoloCF:
subu $sp, $sp, 4
sw $ra, ($sp)
# Calcolo cognome e nome
move $t0, $a3 # destinazione
addiu $t1, $t0, 6 # puntatore termine
addiu $t2, $t0, 3 # puntatore swap
move $t3, $a0 # parola
loop_lettere:
# salto delle vocali
lb $t4, 0($t3)
beq $t4, 'A', next
beq $t4, 'E', next
beq $t4, 'I', next
beq $t4, 'O', next
beq $t4, 'U', next
# aggiungo carattere
sb $t4, 0($t0)
addiu $t0, $t0, 1
next:
bne $t0, $t2, incr
# cambio source al nome
move $t3, $a1
j en
incr:
addiu $t3, $t3, 1
en:
bne $t0, $t1, loop_lettere
# Copio la data
move $t1, $a2
lb $t2, ($t1)
sb $t2, ($t0)
lb $t2, 1($t1)
sb $t2, 1($t0)
# Inserisco mese
addiu $t0, $t0, 2
addiu $t1, $t1, 2
lw $a0, ($t1)
andi $a0, $a0, 0x0000FFFF
jal MonthToChar
sb $v0, ($t0)
lb $t2, 2($t1)
sb $t2, 1($t0)
lb $t2, 3($t1)
sb $t2, 2($t0)
# calcolo parity bit
move $t0, $a3 # iteratore codice
addiu $t1, $t0, 12 # puntatore termine
li $t2, 0
parity:
lb $t3, ($t0)
xor $t2, $t2, $t3
addiu $t0, $t0, 1
bne $t0, $t1, parity
sb $t2, ($t0)
lw $ra, ($sp) # ripristina $ra
addu $sp, 4 # ripristina $sp
jr $ra
.end CalcoloCF
.ent MonthToChar
MonthToChar:
# Parametro in ingresso $a0 = 2 CARATTERI ESTRATTI DALLA DATA
# (esempio: "01" per Gennaio)
# Parametro in uscita $v0 = "A" per l'esempio di Gennaio
# codice della procedura da non sviluppare
li $v0, 'H'
jr $ra
.end MonthToChar

57
Temi esame/minintrig.asm Normal file
View File

@@ -0,0 +1,57 @@
DIM = 8
.data
matrice:
.byte 3, 1, 41, 5, 9, 26, 5, 35
.byte 89, 79, 32, 3, 8, 46, 26, 4
.byte 33, 8, 32, 79, 50, 28, 8, 4
.byte 19, 71, 69, 39, 9, 37, 5, 10
.byte 58, 20, 9, 74, 9, 44, 59, 2
.byte 30, 7, 8, 16, 40, 6, 28, 6
.byte 20, 8, 9, 98, 62, 80, 3, 48
.byte 25, 34, 21, 1, 70, 6, 7, 9
.text
.globl main
.ent main
main:
subu $sp, $sp, 4
sw $ra, ($sp)
la $a0, matrice
li $a1, 1
li $a2, DIM
jal maxInTriangolo
# lettura del risultato calcolato dalla procedura
lw $ra, ($sp)
addiu $sp, $sp, 4
jr $ra
.end main
.ent maxInTriangolo
maxInTriangolo:
# ricerca max in riga
li $v0, 0
mul $t0, $a1, $a2
add $t0, $t0, $a0
add $t1, $t0, $a2
loop_riga:
lw $t2, ($t0)
blt $t2, $v0, cont_riga
move $v0, $t2
cont_riga:
addiu $t0, $t0, 1
bne $t0,$t1, loop_riga
add $t0, $a0, $a2
mul $t1, $a1, $a2
add $t1, $t1, $t0
loop_colonna:
lw $t2, ($t0)
blt $t2, $v0, cont_colonna
move $v0, $t2
cont_colonna:
addu $t0, $t0, $a2
bne $t0,$t1, loop_colonna
.end maxInTriangolo

33
Temi esame/ortofrutta.asm Normal file
View File

@@ -0,0 +1,33 @@
#a0 matrice
#a1 num
#a2 SAC
.ent calcolaCosto
calcolaCosto:
li $t0, 0
move $t1, a0
li $t2,0
li $t3,0
ciclo:
lw $t4, 0($t1)
addiu $t1,$t1,1
addu $t2,$t2,$t1
lw $t4, 0($t1)
addiu $t1,$t1,1
addu $t3,$t3,$t1
lw $t4, 0($t1)
addiu $t1,$t1,1
beq $t4, 0, calc_rem # if $t4 =101 calc_rem goto target
addu $t3, $t3, $a2
calc_rem:
blt $t3, 99, incr # if $t0 < $t1 then goto target
sub $t3,$t3,100
addiu $t2,$t2,1
incr:
addiu $t0, $t0, 1
bne $t0, $a1, ciclo
.end calcolaCosto

87
Temi esame/unamatrice.asm Normal file
View File

@@ -0,0 +1,87 @@
N =, 3
M =, 4
.data
matriceA:
.word 0xAB317811, 0xCD514229, 0xEF832040, 0xA1346269
.word 0xB2178309, 0xC3524578, 0x65702887, 0x59227465
.word 0x14930352, 0x24157817, 0x39088169, 0x63245986
matriceB:
.word 0x39916800, 0x47900160, 0x62270208, 0x87178291
.word 0xA7674368, 0xB2092278, 0xC3556874, 0xD6402373
.word 0xE1216451, 0x24329020, 0x51090942, 0x11240007
matriceC:
.space N * M * 4
.text
.globl main
.ent main
main:
subu $sp, $sp, 4
sw $ra, ($sp)
la $a0, matriceA
la $a1, matriceB
la $a2, matriceC
li $a3, N
li $t0, M
subu $sp, $sp, 4
sw $t0, ($sp)
jal MediaMatrice
addiu $sp, $sp, 4
lw $ra, ($sp)
addiu $sp, $sp, 4
jr $ra
.end main
.ent MediaMatrice
MediaMatrice:
mult $a3, $t0
mflo $a3
li $t1, 0
loop_colonna:
li $t2, 0
loop_riga:
addu $t3, $t1, $t2
sll $t3, $t3, 2
addu $t3, $t3, $a0
lw $t3, ($t3)
addu $t4, $t1, $t2
sll $t4, $t4, 2
addu $t4, $t4, $a1
lw $t4, ($t4)
slt $t5, $t3, $0
slt $t6, $t3, $0
xor $t5, $t5, $t6
bne $t5, $0, opposto
addu $t4, $t3, $t4
srl $t4, $t4, 1
li $t5, 0x80000000
and $t3, $t3, $t5
or $t4, $t4, $t3
j salva_media
opposto:
add $t4, $t3, $t4
sra $t4, $t4, 1
salva_media:
addu $t3, $t1, $t2
sll $t3, $t3, 2
addu $t3, $t3, $a2
sw $t4, ($t3)
addiu $t2, $t2, 1
bne $t2, $t0, loop_riga
addu $t1, $t1, $t0
bne $t1, $a3, loop_colonna
jr $ra
.end MediaMatrice

64
ricercaMin.asm Normal file
View File

@@ -0,0 +1,64 @@
.data
wVet: .space 50
wRes: .space 1
mex_prompt: .asciiz "Inserire caratteri\n"
mex_result: .asciiz "\nValore minimo: "
.text
.globl main
.ent main
main:
la $t0, wVet # punta a inizio vettore
li $t1, 0 # inizializzo contatore
# stampo primo messaggi
la $a0, mex_prompt
li $v0, 4 # id della syscall print_str
syscall
# lettura stringa. a quanto pare posso solo fare una read_chr
ciclo_read:
# syscall read
li $v0, 12
syscall # il risultato è in v0
sb $v0, ($t0)
add $t0, $t0, 1 # incremento puntatore
beq $v0, '\n', fine_lettura # smetto di saltare quando ho raggiunto un newline
add $t1, $t1, 1 # incremento contatore (sapendo che non è un \n)
beq $t1, 50, fine_lettura # controllo di non uscire dal buffer
b ciclo_read
fine_lettura:
move $t5, $t1 # salvo in $t5 la lunghezza della stringa
# resetto contatore e puntatore
la $t0, wVet # punta a inizio vettore
li $t1, 0 # inizializzo contatore
lb $t2, ($t0) # memorizzo il valore minimo dentro t2, e inizializzo con primo carattere
cerca_min:
lb $t3, ($t0)
ble $t3, 0x20, prox_chr # salto se è un carattere speciale
bgt $t3, $t2, prox_chr # salto se non è un minimo
move $t2, $t3 # memorizzo il nuovo minimo
prox_chr:
add $t0, $t0, 1 # incremento puntatore
add $t1, $t1, 1 # incremento contatore
bne $t1, $t5, cerca_min # smetto di saltare quando ho iterato su tutti i caratteri
# stampo messaggio
la $a0, mex_result
li $v0, 4 # id della syscall mex_result
syscall
# stampo carattere minimo
move $a0, $t2
li $v0, 11
syscall
# termino programma
li $v0, 10
syscall
.end main

16
test.asm Normal file
View File

@@ -0,0 +1,16 @@
.data # dichiarazione dati
op1: .byte 3
op2: .byte 2
res: .space 1 # allocazione spazio in memoria per risultato
.text
.globl main
.ent main
main:
lb $t1, op1 # caricamento dati
lb $t2, op2
add $t1, $t1, $t2 # esecuzione somma
sb $t1, res # salvataggio del risultato in memoria
li $v0, 10 # codice per uscita dal programma
syscall # fine
.end main

51
vigenere.asm Normal file
View File

@@ -0,0 +1,51 @@
la $s0, plaintext
la $s1, key
la $s2, len
la $s3, chipertext
.ent cifrarioVigenere
cifrarioVigenere:
li $t0, 0 # counter current char
li $t1, 0 # counter modulo char
li $v0, 0 # current encoded chars
# i registri da $t3 in poi in poi possono essere usati liberamente nel loop
loop:
addu $t3, $s0, $t0
lb $t3, 0($t3)
bne $t3, 0, end # termina se null byte
# controllo se lettera è minuscola
blt $t3, 'z', copy # se maggiore di
bgt $t3, 'a', copy # se minore di
addu $4, $s1, $t1 # risolvo indirizzo carattere chiave
lw $t4, 0($t4) # carico in memoria
sub $t4, $t4, 'a'
addu $t3, $t3, $t4 # eseguo la codifica
ble $t3, 'z', copy
sub $t1, $t1, 'z', +,1
add $t1, $t1, 'a'
copy:
addu $t4, $s3, $t0
sw $t3, 0($t4) # salvo nel chipertext
bne $t1, $s2, increment_modulo
addiu $t1, $0, 0 # resetto contatore modulo
j cont
increment_modulo:
addiu $t1, $t1, 1 # incremento contatore modulo
cont:
addi $t0, $t0, 1 # incremento contatore carattere
j loop # jump to loop
end:
jr $ra
.end cifrarioVigenere