Assembly (del MIPS): piccolo prontuario

Transcript

1 Università degli Studi dell Insubria Dipartimento di Scienze Teoriche e Applicate Architetture degli elaboratori: Assembly (del MIPS): piccolo prontuario Marco Tarini Dipartimento di Scienze Teoriche e Applicate marco.tarini@uninsubria.it Linguaggio Assembly Linguaggio molto aderente ad un Instruction Set, Specifico per un Instruction Set Rapporto (quasi) 1:1 fra comandi Assembly e istruzioni binarie Pensato per essere più facile da leggere o scrivere per noi esseri umani, rispetto al linguaggio macchina: add $13, $4, $ VS Assembler: programma che effettua la traduzione. Fa per noi molti lavoretti che sarebbero tediosi ma banali, come: tradurre le operazioni in OP codes (di sei bit) tradurre in base 2 (o in CP2) gli indici dei registri e gli immediate calcolare gli offset delle destinazioni dei salti tenere traccia degli indirizzi a cui sono merizzati dati ed istruzioni altro, come vedremo Architettura degli elaboratori Architettura degli elaboratori - Assembly - 1 1

2 Istruzione in Assembly Registri su cui si opera (corrispondono ai campi Rt, Rs e Rd) L immediato (il campo imm16) add $13, $4, $3 le virgole sono opzionali codice mnemonico dell istruzione (corrisponde al campo OP e FUNCT) addi $13, $4, 162 «i» sta per immediate In Assembly, l ordine degli operandi è comodamente fisso: a differenza del MIPS binario, in cui varia fra le istruzioni R e I il PRIMO parametro rappresenta sempre il risultato il registro che viene scritto (se l op prevede di scrivere un reg) $13 in questo esempio Seguono gli operandi (che siano registri o immediate) Architettura degli elaboratori Commenti e indentazione In Assembly, spazi, tab e accapo vengono ignorati (posso indentare il programma come voglio) Per rendere il codice più comprensibile in Assembly posso aggiungere dei commenti Verranno semplicemente ignorati dal compilatore Sintassi: i commenti vanno dal carattere # alla fine della linea # commento add $13, $4, $3 # questo fa $13 <- $4 + $3 (sono questi due semplici ma cruciali elementi che rendono l Assembly molto più comprensibile del linguaggio macchina) Architettura degli elaboratori Architettura degli elaboratori - Assembly - 1 2

3 Traduzione delle istruzioni da Assembly a linguaggio macchina Esempio, l istruzione add $8, $17, $18 è tradotta così: add op = 0 = shamt = 0 = funct = 32 = $8 rd = 8 = $17 rs = 17 = $18 rt = 18 = op rs rt rd shamt funct Architettura degli elaboratori per operazioni aritmetiche Nome completo Esempio Significato Commenti. add add $1,$2,$3 $1 = $2 + $3 2 operandi registro; subtract sub $1,$2,$3 $1 = $2 $3 2 operandi registro; add immediate addi $1,$2,100 $1 = $ operandi: registro e costante; add unsigned addu $1,$2,$3 $1 = $2 + $3 2 operandi registro; subtract unsignedsubu $1,$2,$3 $1 = $2 $3 2 operandi registro; add imm. unsign. addiu $1,$2,99 $1 = $ operandi: registro e costante; multiply mult $2,$3 Hi Lo = $2 x $3 prodotto con segno: res in 64 bit multiply unsigned multu $2,$3 Hi Lo = $2 x $3 prodotto senza segno: res in 64 bit divide div $2,$3 Lo = $2 $3, Lo = quoziente, Hi = resto Hi = $2 mod $3 divide unsigned divu $2,$3 Lo = $2 $3, Quoziente e resto senza segno Hi = $2 mod $3 Move from Hi mfhi $1 $1 = Hi Copia Hi in un registro Move from Lo mflo $1 $1 = Lo Copia Lo in un registro Architettura degli elaboratori Architettura degli elaboratori - Assembly - 1 3

4 Operazioni aritmetiche «con la U» La «u» nei comandi artimetici (come addu) sta per «unsigned», ma il nome è fuorviante (ricorda: la somma di numeri in CP2, e la somma in binario senza segno sono la stessa operazione, cambia solo la gestione dell overflow) La vera differenza: il comando senza la «u» può generare eccezione di overflow il comando con la «u» semplicemente ignora l overflow In conclusione, si può verificare overflow solo in alcune istruzioni aritmetiche: add, sub, addi nelle altre op matematiche, o non si verifica o viene ignorato (non viene generate alcuna eccezione) nelle op logiche, non si verifica mai Architettura degli elaboratori Moltiplicazione / divisione Moltiplicazione / divisione: (mult e div) scrivono su una coppia di registri speciali: Hi e Lo (non fanno parte dei 32 registri) Ricorda: moltiplicando due numeri da n bit ottengo un numero da 2n bit. Il valore di Hi e Lo si travasa in normali registri con: mfhi rd ( Move From Hi ) mflo rd ( Move From Lo ) Registers Mult/Div Unit HI LO Architettura degli elaboratori Architettura degli elaboratori - Assembly - 1 4

5 per operazioni logiche Istruzioni Esempio Significato Commento and and $1,$2,$3 $1 = $2 & $3 AND bit a bit or or $1,$2,$3 $1 = $2 v $3 OR bit a bit xor xor $1,$2,$3 $1 = $2 $3 XOR bit a bit nor nor $1,$2,$3 $1 = ~($2 $3) NOR bit a bit and immediate andi $1,$2,10 $1 = $2 & 10 AND tra reg. e costante or immediate ori $1,$2,10 $1 = $2 10 OR tra reg. e costante xor immediate xori $1, $2,10 $1 = $2 10 XOR tra reg. e costante shift left logical sll $1,$2,10 $1 = $2 << 10 Shift a sinistra di una costante shift right logical srl $1,$2,10 $1 = $2 >> 10 Shift a destra di una costante shift right arithm. sra $1,$2,10 $1 = $2 >> 10 Shift a destra (con est. in segno) shift left logical sllv $1,$2,$3 $1 = $2 << $3 Shift a sinistra di una variabile shift right logical srlv $1,$2,$3 $1 = $2 >> $3 Shift a destra di una variabile shift right arithm. srav $1,$2,$3 $1 = $2 >> $3 Shift a destra di una variabile (con est. in segno) Architettura degli elaboratori per operazioni aritmetiche e logiche Il risultato dell op viene sempre memorizzato nel primo registro indicato Eccezione: mult e div, che scrivono invece due apposite registri speciali HI e LOW I due operandi dell op sono: nelle versioni non immediate (e negli shift con variabile): i due registri indicati nelle versioni immediate: (e negli shift senza variabile): un registro dato e un valore dato Il valore nelle istruzioni con immediate: E memorizzato nel campo imm16 di una istruzione I (di16 bit!) E in CP2 nelle op aritmetiche (e quindi viene esteso in segno). Val max =?. Val min =?. Senza segno nelle op logiche (ed quindi viene esteso con 0) Val max =?. Val min =?. Architettura degli elaboratori Architettura degli elaboratori - Assembly - 1 5

6 per operazioni logiche Le op logiche lavorano bit a bit Lo shift a sinistra fa apparire 0 da destra Corrisponde a dividere per 2^n Due versioni dello shift a destra: Far apparire 0 a sinistra (vers logica) Far apparire a sinistra il bit più significativo (vers aritmetica) Corrisponde a moltiplicare per 2^n (nella versione aritmetica: questo vale per i numeri in CP2) Lo shift di una costante, il valore di cui si shifta è memorizzato, in linguaggio macchina, nell apposito campo da 5 bit delle istruzioni R (quindi vale da 0 a 31 sempre sufficiente!) Architettura degli elaboratori per trasferire registri da/a la memoria Istruzione Commento sw $3, 500($4) sh $3, 502($2) sb $2, 41($3) Store word Store half Store byte da registro a mem (store) lw $1, 30($2) lh $1, 40($3) lhu $1, 40($3) lb $1, 40($3) lbu $1, 40($3) lui $1, 40($3) Load word Load halfword Load halfword unsigned Load byte Load byte unsigned Load Upper Immediate (16 bits shifted left by 16) da mem a registro (load) Architettura degli elaboratori Architettura degli elaboratori - Assembly - 1 6

7 per trasferire registri da/a la memoria L indirizzo a cui si legge o scrive è quello contenuto nel registro indicato fra parentesi, incrementato del valore eventualmente indicato prima della parentesi esempi: ($16) usare l inidirizzo contenuto nel registro ($4) usare l indirizzo contenuto nel registro 4, incrementato di 500 byte (cioè di 500/4 = 125 word) -4($16) usare l inidirizzo contenuto nel registro 16, decrementato di 4 Architettura degli elaboratori per trasferire registri da/a la memoria Store: si leggono 1, 2 o 4 byte dal registro indicato nel 1mo parametro (4 se word. 2 se half. 1 se byte. Se 1 o 2: i meno significativi) li si scrivono in 1, 2, o 4 byte consecutivi in memoria Load: caso word: si leggono 4 byte dalla memoria caso short/byte unsigned: si leggono 2/1 byte e si estendono con 0 caso short/byte: si leggono 2/1 byte e si estendono in segno caso lui: si leggono 2 byte e si shiftano a sinistra di 16 bit in tutti i casi: si scrivono tutti i 4 byte risultanti nel registro indicato Architettura degli elaboratori Architettura degli elaboratori - Assembly - 1 7

8 per branch (salti condizionali) Con confronto fra due registri beq rs, rt, dest equal, if R[rs] == R[rt] then jump to dest bne rs, rt, dest not equal, Con confronto fra un registro e zero blez rs, dest less-or-equal zero, if R[rs] <= 0 then jump bgtz rs, dest greater-then zero > bgez rs, dest greater-or-equal zero >= bgezal rs, dest come sopra «and link» (vedi poi) bltz rs, dest less-than zero < bltzal rs, dest come sopra «and link» (vedi poi) Architettura degli elaboratori per branch (salti condizionali) L instruction set MIPS mette a disposizioni molte varianti di branch (b-), diverse per: l operatore del paragone che determina se saltare oppure no: minore uguale (-le-), maggiore (-gt-), etc se il paragone avviene fra due registri, oppure fra un registro e lo zero (-z-) «and link» (-al) : se, in caso di salto, deve essere memorizzato l indirizzo dell istruzione che ha causato il salto, (in modo da poterci tornare con un apposita istruzione di ritorno) (utile quando il salto serve per eseguire una subroutines, vedi poi). ma non tutte le varianti possibili sono previste! (es: R1>R2 non lo è) Per implementare le varianti non previste, saranno necessarie due o più istruzioni: Prima: calcolo della condizione (es: R3 = R1-R2) Poi: salto condizionale (es: R3 > 0 ) (tipico esempio della filosofia RISC in azione!) Architettura degli elaboratori Architettura degli elaboratori - Assembly - 1 8

9 per branch (salti condizionali) L istruzione MIPS binaria come sappiamo memorizza la destinazione del salto come un offset rispetto al PC corrente (salto «relativo») L offset è memorizzato nel campo imm16 di una istruzione di tipo I L offset è un numero di 16 bit in CP2 L offset rappresenta il n. di istruzioni da saltare (avanti o indietro) Cioè il numero di words da sommare al PC Cioè il PC+4 va incrementato di Offset x 4 bytes (ext in segno) Il programmatore Assembly indica direttamente la destinaz. del salto L assembler calcola per lui l offset necessario per raggiungerla, e lo riporta nel campo imm16 (comodo!) La destinazione può seguire oppure precedere l istruzione del salto (perché offset ha il segno) Ma non può essere più lontana di 2^15 istruzioni! Altrimenti errore. Generato dall assembler (perché offset ha solo 16 bit in CP2). Sono salti corti! Architettura degli elaboratori per Jump (salti non condizionali) Istruzione Esempi Significato jump j vai all istruzione jump and link jal vai all istruzione and link jump register jr $31 vai all istruzione contenuta nel registro $31 Architettura degli elaboratori Architettura degli elaboratori - Assembly - 1 9

10 per Jump (salti non condizionali) Jump salta ad un indirizzo dato. L istruzione MIPS binaria corrispondente, di tipo J, memorizza la destinazione nel suo campo address E un campo di ben 26 bits (il tipo J esiste apposta per questo) Due zeri finali sono sottointesi (è l indice di un word) = 28 bits Il PC mantiene i primi 4 bits inalterati, e i suoi 28 bits meno significativi vengono sostituiti: salto (quasi) «assoluto» Quindi: l istruzione può saltare anche molto lontano. Salto lungo! L unico vincolo è che non si può uscire dal blocco di 2^26 istruzioni Tipicamente, il programmatore determina la destinazione attraverso un etichetta (vedi poi); address viene calcolato dall assembler. Jump address salta ad un indirizzo memorizzato in un registro dato PC viene sostituito del tutto dai 32 bit del registro: salto «assoluto» Si può saltare assoltamente ovunque nel codice. No limits. Salti lunghissimi! (ma bisogna approntare un registro) Architettura degli elaboratori per assegnamenti condizionali Istruzioni Esempi Significato set on less than slt $1,$2,$3 if ($2 < $3) $1=1; else $1=0 < (complemento a 2) set on less than slti $1,$2,100 if ($2 < 100) $1=1; else $1=0 immediate <costante (complemento a 2) set on less than sltu $1,$2,$3 if ($2 < $3) $1=1; else $1=0 unsigned < (numeri senza segno) set less then sltiu $1,$2,100 if ($2 < 100) $1=1; else $1=0 immediate unsigned <costante (numeri senza segno) Architettura degli elaboratori Architettura degli elaboratori - Assembly

11 Confronto con segno e senza R1= = 1 10 R2= = 2 10 R3= = oppure Esercizio: dopo l esecuzione di queste istruzioni: slt $4,$2,$1 ; slt $5,$3,$1 ; sltu $6,$2,$1 ; sltu $7,$3,$1 ; Quali valori si trovano nei registri r4 - r7? r4 = 0; r5 = 1; r6 = 0; r7 = 0 ; R2==2 non è minore di R1==1 R3==-1 è minore di R1==1 R2==2 non è minore di R1==1 R3== non è minore di R1==1 Architettura degli elaboratori Convenzioni nell'uso dei registri Per compilare una data procedura, il compilatore (o il programmatore umano) deve sapere quali registri può usare e quali sono in uso da parte di altre procedure. Da qui la necessità di regole e convenzioni per l'uso dei registri Non implementate in HW Compilatori e programmatori le devono seguire, pena bugs insidiosi, anche molto difficili da trovare. Architetture Architettura degli elaboratori - Assembly

12 Convenzioni nell'uso dei registri I registri $at (1), $k0 (26), e $k1 (27) riservati per l'assemblatore ($at) e il sistema operative ($k0-1) NON devono essere usati dai programmatori o dal compilatore I registri $a0 $a3 (4 7) usati per passare i primi 4 argomenti alle routine. (ulteriori eventuali argomenti sono passati sulla pila (molto più lenta!) I registri $v0 e $v1 (2, 3) usati dalle funzioni per restituire valori al chiamante. I registri $t0 $t9 (8 15, 24, 25) usati per memorizzare valori temporanei, quelli che non è necessario preservare tra una chiamata e l'altra. ogni procedura li può usare senza preoccuparsi di sporcarli I registri $s0 $s7 (16 23) usati per valori che devono essere preservati tra una chiamata e l'altra. Il loro significato non è locale alla chiamata corrente. Architetture Convenzioni nell'uso dei registri Il registro $gp (28) è un puntatore globale che punta ad un blocco di memoria da 64K nel segmento dei dati statici. Il registro $sp (29) è lo stack pointer, che indirizza l'ultima posizione dello stack (vedremo) Il registro $fp (30) è il frame pointer (vedremo). Il registro $ra (31) contiene l'indirizzo di rientro dalla chiamata di procedura (vedremo). Architetture Architettura degli elaboratori - Assembly

13 Scrittura di comandi in assembly: gli operandi che sono registri L Assembly ci consente di riferirci ai 32 registri anche attraverso dei sinonimi che riflettono il loro uso convenzionale Registro: $0 $1 $2 $3 $4 $5 $6 $7 Sinonimo: $r0 $at $v0 $v1 $a0 $a1 $a2 $a3 Registro: $8 $9 $10 $11 $12 $13 $14 $15 Sinonimo: $t0 $t1 $t2 $t3 $t4 $t5 $t6 $t7 Registro: $16 $17 $18 $19 $20 $21 $22 $23 Sinonimo: $s0 $s1 $s2 $s3 $s4 $s5 $s6 $s7 Registro: $24 $25 $26 $27 $28 $29 $30 $31 Sinonimo: $t8 $t9 $k0 $k1 $gp $sp $s8 $ra equivalente a add $s3, $t3, $t4 add $19, $11, $12 Architetture Scrittura di comandi in assembly: gli operandi che sono immediate Il campo immediate può essere scritto: In base 10 In base 16, precedendo le cifre con 0x Come carattere ascii, fra apicetti singoli addi $3, $3, 97 addi $3, $3, 0x61 addi $3, $3, a Sinonimi (il terzo registro viene incrementato di 97, il cui codice ASCII è a ) Architettura degli elaboratori Architettura degli elaboratori - Assembly

14 Pseudo-istruzioni L assembler MIPS supporta diverse pseudo-istruzioni: Non corrispondono ad istruzioni nell Instruction Set (l archiettura HW non le conosce!) Sono implementate mediante una o più istruzioni dell IS Semplificano la programmazione in linguaggio assembly La pseudo-istruzione move $t0, $t1 (copia $t1 in $t0) è implementata come add $t0, $zero, $t1 La pseudo-istruzione blt $s0, $s1, addr (branch less then salta se $s0<$s1) è implementata come due istruzioni: slt $at, $s0, $s1 bne $at, $zero, addr (nota: uso del registo riservato all assembler) Architettura degli elaboratori Pseudo-istruzioni La pseudo-istruzione la $t0, etichetta (load address, copia l indirizzo etichetta in $t0) è implementata calcolando val dall etichetta e ori $t0, $0, val (load unsigned immediate) La pseudo-istruzione li $t0, val (load immediate, copia il valore val in $t0) è implementata come ori $t0, $0, val (or bit a bit fra val e il registro $0 cioè il valore 0) Le pseudo-istruzioni rendono il linguaggio Assembly ancora un po più ad alto livello del linguaggio macchina (Rimane un linguaggio a bassissimo livello, rispetto a, per es, C o, ancor di più, Java) Architettura degli elaboratori Architettura degli elaboratori - Assembly

15 Un programma in assembly Ricorda che un programma è costitutito da due parti Dati, (in assembly: parte data ) Istruzioni (il codice che lavora sui dati), (in assembly: parte text ) memorizzate in due apposite aree della memoria (localizzate secondo alcune convenzioni che non ci interessano) Un programma Assembly non è altro che un file di testo che descrive il contenuto della memoria (in ciascuna delle due aree) Consiste quindi in due sequenza di parole consecutive (e/o mezze parole, e/o bytes) espresse in ASCII Architettura degli elaboratori Un programma in assembly Es un programma potrebbe essere: Questo programma (che non ha senso alcuno!) prescrive 2 words nella parte data e altre 2 words nella parte text Le parole (32 bits!) possono essere espresse in molti modi equivalenti: in decimale, es: 20.word 20 in esadecimale, es: 0x14.word 0x14 utile per la parte data con un carattere ascii, es: a.word 'a' con un comando assembly, es: add $t3, $s1, $s3.data.word 20, 10.text.word 30, 1234 utile per la parte text Architettura degli elaboratori Architettura degli elaboratori - Assembly

16 Direttive Comandi Assembly che spiegano all Assembler come tradurre un programma Non producono istruzioni macchina! Sintassi: cominciano sempre con un punto Il programma precedente usa due direttive:.data «Memorizza gli elementi successivi nel segmento dati».text «Memorizza gli elementi successivi nel segmento testo» Tipica struttura sorgente: dati comandi.data.text Architetture Direttive: dati Alcune direttive spiega il formato in cui tentere, in memoria, i dati successivi:.word «Memorizza i valori successivi in 4 bytes».half «Memorizza i valori successivi come half-word: cioè in coppie di byte».byte «Memorizza i valori successivi in un byte ciascuno».data.half 20, 2, 100.byte 4, 'c'.word 0x40, 300 Nel segmento data sono memorizzati in tutto 16 bytes Architetture Architettura degli elaboratori - Assembly

17 Direttive: dati Un scorciatoia speciale per dati consente di definire con facilità le stringe (intese come sequenze di caratteri, ciascuno reppresentato da un byte).ascii "anna" Equivalente a:.byte 'a', 'n', 'n', 'a Memorizza (in questo esempio): 4 bytes..asciiz "anna" Un byte per carattere, seguiti da un ulteriore byte terminatore zero. Equivalente a:.byte 'a', 'n', 'n', 'a', 0 Equivalente a:.ascii "anna".byte 0 Oppure a (in questo esempio): 5 bytes. Nota l uso del doppio apice. La convenzione di terminare le strighe col byte 0 è comune a molti linguaggi di programmazione ad alto livello (C, Java, C++ ), e dalle procedure di sistema (es quella che scrive stringhe su un monitor). Dette «null terminated strings» Architetture Direttive: dati.space n Lascia uno spazio di n Bytes nel segmento dati. Utile per riservare dei bytes nel segmento data dove memorizzare i dati prodotti dalle istruzioni.align n Lascia alcuni byte di spazio in modo che il dato successivo sia scritto in un indirizzo divisible per 2 n Utile per allineare i dati, ad esempio align 2 fa in modo che il word successive sia scritto ad un indirizzo che termina con 00, anche se i dati scritti in precedenza hanno occupato un numero dispari di bytes. Architetture Architettura degli elaboratori - Assembly

18 Etichette (label) Le etichette sono un altra parte del programma Assembly che l Assembler non traduce in alcuna istruzione macchina E un identificaore qualsiasi, scelto dal programmatore, introdotto come un nome seguito da un due-punti. Es: pippo:.word 19 Un etichetta è un meccanismo che consente al programmatore assembly di riferirsi all indirizzo a cui è stato memorizzato un dato o un istruzione sarebbe complicato per il programmatore ricostruire questo indirizzo, ma è banale per l assemnler. Architettura degli elaboratori Etichette (label): funzionamento Quando un etichetta viene definita (cioè coniata, inventata, introdotta nel programma), l assembler tiene traccia dell indirizzo in cui sta per scrivere il prossimo dato o istruzione Nella definizione, l etichetta appare seguita da due-punti ll programmatore può riferire (usare) un etichetta (definita altrove) usandola al posto di un operando in un comando. L assembler sostituisce l etichetta con l indirizzo corrispondente. Nel riferimento, l etichetta appare senza il due-punti Un etichetta può essere definita in un programma una sola volta, e essere riferita molte volte la definizione dell etichetta può precedere oppure seguire il suo riferimento (questo comporta che l assembler dovrà faticare un po, e leggere il programma due volte) Architettura degli elaboratori Architettura degli elaboratori - Assembly

19 Etichette (label): usi tipici Le etichette definite nella sezione data saranno riferite da comandi tipo load / store come indirizzo a cui leggere /scrivere quei dati.data popolaz:.word # definisco l etichetta.text la $t1, popolaz # carica l address popolaz in t1 lw $t2, 0($t1) # carica in $t1 Le etichette definite nella sezione text saranno riferite da comandi tipo jump / branch come indirizzo a cui saltare.text ite: sub $t2, $t2, 1 # t2 = t2-1 bgtz $t2, ite # if (t2 > 0) goto ite Architettura degli elaboratori Label e direttive per definire dati Tipico uso: Es: label:.tipo valore pippo:.word 19 «nel primo indirizzo libero, al quale io mi riferirò in futuro chiamandolo con pippo (l etichetta), piazza il valore 19 come un word (4 byte)» Somiglia molto al commando Java: int pippo = 19; Anche valori multipli label:.tipo val0, val1, pippo:.word 19, 12, 13 Architetture Architettura degli elaboratori - Assembly

20 Altre direttive.globl pippo L etichetta pippo determina quale sia il PC iniziale ( l esecuzione parte da lì ) Altre direttive sono descritte sul libro Architetture System call MIPS offre semplici servizi mediante chiamate di sistema (system call) predefinite Ogni chiamata è costituita da Codice dell operazione Argomenti (opzionali) Valori di ritorno (opzionali) Architetture Architettura degli elaboratori - Assembly

21 Funzioni di sistema Architetture Come fare una system call 1) Inserire il codice nel registro $v0 2) Inserire gli argomenti nei registri $a0-$a3 ($f12-$f15) 3) Eseguire l istruzione syscall 4) Il valore di ritorno è nel registro $v0 ($f0) Architetture Architettura degli elaboratori - Assembly

22 Riassumendo L Assembler semplifica la vita al programmatore, rispetto al linguaggio macchina, perché Traduce numeri da decimale, esadec, o ascii in binario Traduce codici mnemonici di op (come «add») in opcode binari Riordina i parametri a seconda che il comando sia di tipo R, o I, permettendoci di fornire i parametri in un ordine consistente (il risultato prima) Rinomina i registri, consentendo di usare nomi più significativi («$t1» invece di «$9») Mette a disposizione alcune utili (Pseudo) Istruzioni ulteriori (traducendole con una o due Istruzioni MIPS) Consente di indentare a piacere il codice (aggiungere accapi, spazi, tabulazioni) per renderlo più leggibile Consente di aggiungere commenti al codice (che semplicemente ignora) Tiene traccia degli indirizzi di dati ed istruzioni, attraverso il meccanismo delle etichette Calcola gli offset degli indirizzi rispetto al PC etc Tuttavia, programmare direttamente in Assembly rimane tremendamente difficile Nella realtà si usano sempre linguaggi più ad alto livello! Complilati e trasformati in Assembly o linguaggio macchina Architettura degli elaboratori Architettura degli elaboratori - Assembly