ACSO 1

Ripasso codifica binaria

Complemento a due

Complemento a due: è un sistema di rappresentazione binario in cui il primo bit a sinistra (ovvero il più significativo) ha peso negativo.

2 1 0 −2 ∙ 1 + 2 ∙ 0 + 2 ∙ 1 = −3

Ad esempio la sequenza di bit 101 in complemento a due ha il valore.

Per invertire il numero in complemento a due si nega ogni bit del numero e si somma 1 alla posizione meno significativa.

01011 = 11

10100 + 1 = 10101 = −11

Overflow

Si ha overflow quando il risultato corretto dell’addizione eccede il potere di rappresentazione dei bit a disposizione. Quindi per il complemento a due:

• Se gli addendi sono tra loro discordi non si verifica mai;
• Se gli addendi sono tra loro concordi si verifica solo se il risultato è discorde.

Rappresentazione esadecimale

Si effettua tramite l’utilizzo dei simboli 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F con valori da 0 a 15.

2 1 0 2 1 07 = ∙ 16 + 7 ∙ 16 + ∙ 16 = 11 ∙ 16 + 7 ∙ 16 + 15 ∙ 16 = 2943.

Esempio da esadecimale a decimale: ℎ ℎ ℎ 01 0011 1101 0101 1011 = 135

Esempio da binario a esadecimale:

bin 01 0011 1101 0101 1011

dec 1 3 13 5 11

hex 1 3 D 5 B

740 = 1010 0111 1011 0100 0000 1100

Esempio da esadecimale a binario:

hex A 7 B 4 0 C

dec 10 7 11 4 0 12

bin 1010 0111 1011 0100 0000 1100

Assembler MIPS

CPU MEMORIA NB: la memoria

La CPU accede alla memoria con indirizzi scanditi è indirizzata ai PC (registro dal PC, che indicano celle contenenti le istruzioni singoli byte maprogram tutte le parole counter) devono sempre iniziare a indirizzi multipli di 4.

Instruction set architecture (ISA) del processore MIPS

ISA: l’insieme delle istruzioni direttamente interpretabili dalla microarchitettura della CPU, costituisce il linguaggio macchina (binario) di un calcolatore. Queste istruzioni operano sui registri della CPU e sulle celle di memoria.

Linguaggio assembler: è un linguaggio simbolico che consente di programmare usando le istruzioni binarie del linguaggio macchina. Il programma scritto in assembler viene tradotto dal programma assemblatore.

Registri della CPU

• Sono 32 = 2⁵, quindi indirizzabili con 5 bit e sono numerati da 0 a 31, lunghi 32 bit, il registro 0 contiene sempre la costante 0.
• In assembler possono essere indicati in due modi:
• Nome legato alle convenzioni
• ($s0, …, $s7) 8 registri per le variabili locali del programma
• ($t0, …, $t7) 8 registri per valori temporanei
• ($a0, …, $a3) 4 registri argomento usati dal chiamante per il passaggio dei parametri alla procedura
• ($v0, $v1) 2 registri valore usati dalla procedura per restituire i valori di ritorno
• ($ra) 1 registro di ritorno, memorizza l’indirizzo della prima istruzione del chiamante al termine della procedura
• Con un numero preceduto da “$”, $0, $1, …, $31
• NB: 3 registri non sono referenziabili (pc è il Program Counter, hi e lo servono per i risultati di moltiplicazioni e divisioni)
• NB: per convenzione il registro $0 contiene 0, il registro $1 è riservato all’assembler-linker (per espandere pseudoistruzioni e macro)

NB: tutte le istruzioni del MIPS vengono codificate da parole di 32 bit, i campi che indicano registri sono di 5 bit perché devono rappresentare 32 registri.

Istruzioni in formato R (register)

FORMATO R:

(bit 32) 6 bit 5 bit 5 bit 5 bit 5 bit 6 bit (bit 0)

cop rs rt rd shamt funct

• Codice operativo, Registro operando (indirizzo) Registro operando (indirizzo) Registro destinazione (indirizzo) Shift-timeout (usato nella funzione shift) Indica la funzione specifica (sempre a 0 per le istruzioni del formato R)

• Istruzioni aritmetiche:
• add: es. add $8, $9, $10, viene posta in $8 l’addizione dei contenuti dei registri 9 e 10;
• sub: es. sub $8, $9, $10, viene posta in $8 la sottrazione dei contenuti dei registri 9 e 10 ($9 - $10);
• mult: non usa rd perché il risultato viene rappresentato nei registri hi e lo, es. mult $t0, $t1 dà Hi|Lo=t0*t1;
• mflo, mfhi: istruzioni ausiliarie per copiare il contenuto di hi e lo in altri registri: mflo $t0 dà t0=lo.
• Istruzioni aritmetiche “unsigned”: addu, subu: servono se si opera su numeri naturali (in particolare indirizzi), non generano errore in caso di overflow perché si parla di numeri che non utilizzano complemento a 2.
• Istruzioni “bitwise” (logiche): and (prodotto, utile per isolare singoli bit), or (somma), nor (not or, utile per realizzare il not). Utilizzano tutte il formato $rd, $rs, $rt.
• Istruzioni di scorrimento: NB: non utilizzano il campo rs, il campo “shamt” indica il numero di posizioni di scorrimento. Possono essere usate per moltiplicare o dividere per potenze di 2, ad es. sll $8, $9, 2 con $9=5 trasforma 101 in 10100, ovvero 5 in 20.
• sll: es. sll $8, $9, cost, scorrimento a sx di cost posizioni, inserimento degli 0 da dx;
• srl: es. srl $8, $9, cost, scorrimento a dx di cost posizioni, inserimento degli 0 da sx.
• Istruzioni di confronto: slt: “set on less than”, es. slt $8, $9, $10 se $9<$10 allora assegna ad $8 il valore 1 altrimenti 0;
• sltu: la versione unsigned, serve per confrontare numeri naturali.

Istruzioni con costanti, in formato I (immediate)

FORMATO I:

(bit 32) 6 bit 5 bit 5 bit 16 bit (bit 0)

cop rs rt Costante

• Codice operativo Registro operando (indirizzo) Registro destinazione (indirizzo)

• Istruzioni aritmetiche: NB: la costante è estesa in segno.
• addi: es. addi $8, $9, -5, pone in $8 la somma tra la costante -5 e il contenuto di $9;
• addiu: versione “unsigned”.
• Istruzioni logiche “bitwise”: NB: la costante è estesa con 16 zeri.
• andi, ori.
• Istruzioni gestione: lui: usata per caricare in un registro una costante (o indirizzo) a 32 bit, non si usa rs. lui carica prima una costante da 16 bit nei 16 bit più significativi di un registro, poi azzera i 16 bit meno significativi. Si usa “ori” per caricare i 16 bit meno significativi del registro, es. lui $s0, costante.
• Istruzioni di salto condizionato: ovvero un salto eseguito solo se viene soddisfatta una certa condizione. La grandezza “d” (distanza) è il numero di istruzioni da saltare nella memoria (in avanti o indietro in base al segno) a partire dalla successiva (PC sulla successiva).
• beq es. beq r1, r2, d; si ha il salto se r1==r2;
• bne es. bne r1, r2, d; si ha il salto se r1!=r2.

Accesso alla memoria del MIPS

La memoria è vista come un unico array monodimensionale, i contenuti delle sue allocazioni possono contenere sia indirizzi che dati. Un indirizzo di memoria è un indice dell’array, il MIPS usa un indirizzamento al byte quindi l’indice punta ai byte di memoria. Gli indirizzi di parole (32 bit o 4 byte) consecutive differiscono di un fattore 4.

• Istruzioni di trasferimento dati: hanno tre operandi. “rt” indica un registro destinazione o sorgente (per lw o sw) del trasferimento dati. L’indirizzo della parola di memoria da cui prendere i dati invece viene specificato tramite la somma tra l’indirizzo di un registro base (indicato in “rs”) e un offset (costante a 16 bit).
• lw “load word”, trasferisce una parola di memoria in un registro, es. lw $t0, 8($s3) ovvero il contenuto della memoria all’indirizzo 8+$s3 viene copiato nel registro $t0;
• sw “store word”, per trasferire il contenuto di un registro in una parola di memoria;
• lb, sb: accedono a un byte e lo pongono nella posizione meno significativa del registro;
• lh, sh: accedono a 16 bit;
• NB: delle istruzioni per byte e per halfword esiste anche la versione unsigned che non utilizza la sign-extension (ovvero non replica il primo bit).

Istruzioni in formato J

FORMATO J:

(bit 32) 6 bit 26 bit (bit 0)

Op Indirizzo

• I 26 bit di indirizzo corrispondono ad un indirizzo di 28 bit, nel registro PC l’istruzione jump rimpiazza solo i 28 bit meno significativi: PC[31:28] questi 4 bit vengono lasciati inalterati 26 bit 00 (perché gli indirizzi sono multipli di 4 Byte) 28 26
• In totale in questo modo è possibile spostarsi in un intorno di 2 Byte o 2 word dal PC.
• Istruzioni di salto incondizionato:
• j: es. j L1, con L1 etichetta;
• jal: (jump and link), salva l’indirizzo di partenza già incrementato (PC+4) nel registro $31($ra);
• jr: (jump register) usa il formato R, esegue un salto all’indirizzo contenuto nel registro (es. jr $n).

Assembler

Oltre a permettere di usare codici simbolici per istruzioni e registri fornisce altre funzioni per facilitare la scrittura di programmi:

Direttive

• Per riservare memoria:
• .ascii s riserva spazio per la stringa “s” senza terminatore di stringa;
• .asciiz s riserva spazio per la stringa “s” con terminatore di stringa;
• .byte n1, … riserva spazio per i byte elencati e li inizializza con i valori a 8 bit “n1”, …;
• .word w1,... riserva spazio per le parole elencate e le inizializza con i valori a 32 bit “w1”, …;
• .space n riserva spazio nel segmento dati per “n” byte senza inizializzarli.
• Per strutturare il programma:
• .text i dichiara il segmento testo con indirizzo iniziale “i” (default 0x0040000);
• .data i dichiara il segmento dati con indirizzo iniziale “i” (default 0x10000000).
• Altre direttive:
• .globl s1, … dichiara che i simboli “s1”, … sono globali e permette di riferirsi ad essi in altri moduli o file;
• .eqv s,v dichiara un simbolo “s” con valore numerico “v”, senza allocare memoria.

Etichette

È il nome simbolico al quale l’assemblatore fa corrispondere un valore numerico (nella maggior parte dei casi il valore è l’indirizzo del punto in cui si trova l’etichetta).