Fondamenti di Informatica CdL Ingegneria Meccanica A.A. 2013/14

Fondamenti di Informatica CdL Ingegneria Meccanica A.A. 2013/14 Docente: Ing. Ivan Bruno Calcolatore e istruzioni assembler 1. Architettura del Calcolatore 2. Assembler e Linguaggio macchina 3. Esecuzione istruzioni 1

L elaboratore DATI RISULTATI DATI RISULTATI Programma Architettura generale di un calcolatore 2

Alcuni Cenni alle periferiche I/O, Input/Output, Ingressi/Uscita Input: keyboard (tastiera), mouse, scanner Output: monitor, printer Memory, Memoria Di base: RAM, ROM, stato solido. Di Massa: dischi (HD, FD), nastri, CPU, microprocessore ALU (Unità Logico Matematica) Unità di Controllo Registri etc. La Struttura del BUS di Sistema 3

Direzione dei Segnali sul BUS CPU RAM ROM IN OUT BUS ADDress BUS DATI READ/WRITE M/IO BUS Controlli La Memoria e l elaboratore Composta da celle o locazioni Ad ogni cella corrisponde un indirizzo Bus Indirizzi: N Bit di Indirizzamento, es: 32 bit Bus Dati: M bit Bus Controlli: Segnali di Controllo, Read, Write, Select. Tempo di lettura: tempo di accesso Si ha una capacita di M*2 N bit 4

Big-endian e little-endian Due metodi differenti usati dai calcolatori per immagazzinare in memoria dati di dimensione superiore al byte (es. word, dword, qword). Ad esempio, Intel e Digital usano il formato little endian mentre Motorola, IBM e Sun usano il formato big endian. Il big-endian, dato che è stato scelto come ordine standard in molti protocolli utilizzati in Internet, viene anche chiamato network byte order. Per contro viene chiamato host byte order l'ordine nativo dell'host in uso. big-endian: i byte più significativi sono memorizzati all'indirizzo di memoria più piccolo ed i byte successivi negli indirizzi più grandi little-endian: i byte meno significativi sono memorizzati all'indirizzo di memoria più piccolo ed i byte successivi ad indirizzi via via crescenti. Big-endian e little-endian Nel caso di una WORD (16 bit), il numero esadecimale 0x0123 verrà immagazzinato come: Little endian Big endian +----+----+ +----+----+ 0x23 0x01 0x01 0x23 +----+----+ +----+----+ byte: 0 1 0 1 Nel caso di una DWORD (32 bit), il numero esadecimale 0x01234567 verrà immagazzinato come: Little endian Big endian +----+----+----+----+ 0x67 0x45 0x23 0x01 +----+----+----+----+ 0x01 0x23 0x45 0x67 +----+----+----+----+ +----+----+----+----+ byte: 0 1 2 3 0 1 2 3 5

Transazioni sul bus, Ciclo macchina T1 T2 T3 CPU effettua un ciclo di lettura in 3 cicli di clock T1: CPU: asserisce l indirizzo di memoria, disasserisce i comandi di lettura READ e M T2: la memoria pilota il bus dati con il contenuto della cella T3: CPU legge dal bus dati Ta Ta = Tempo di Accesso Lettura dalla memoria Transazioni sul bus, Ciclo macchina Scrittura in memoria T1 T2 T3 CPU effettua un ciclo di scrittura in 3 cicli di clock T1: CPU: asserisce l indirizzo di memoria, il dato da scrivere e disasserisce il comando di lettura WRITE e M T2: L operazione id scrittura è in corso T3: scrittura completata Tempo di scrittura 6

Selezione, Memoria/IO R/W M/IO READ WRITE Action 0 0 0 ----none 0 0 1 Read Memory 0 1 0 Write Memory 0 1 1 ----imp 1 0 0 ----none 1 0 1 Read IO 1 1 0 Write IO 1 1 1 ----imp Architettura di Von Neuman Memoria indifferenziata per dati o istruzioni, solo l'interpretazione da parte della CPU stabilisce se una data configurazione di bit è da vedersi come un dato o come un'istruzione 7

Architettura Harward Due memorie distinte: la memoria istruzioni e la memoria dati. Il comando di lettura della memoria istruzioni è superfluo, in quanto si può immaginare che questa memoria sia sempre e soltanto letta Confronto Von Neuman Accesso a istruzioni e dati nella stessa memoria Flessibilità nello sfruttamento della memoria Rischio di manipolazione del codice Minore costi di realizzazione Harward Robustezza alla manipolazione del codice Accesso contemporaneo a codice e dati Costi maggiori di realizzazione Minore flessibilità 8

CPU Funzioni & Architettura Funzioni principali di una CPU sono: Trasferimento Dati Controllo di Flusso Elaborazioni Aritmetiche e Logiche (Addizioni e Sottrazioni, AND, OR, XOR, NOT, Incrementi, Decrementi, Shift, Clear, ecc ) Ogni CPU ha un array register con almeno: Un Registro ACCUMULATORE (W o Acc o R0) Il PROGRAM COUNTER (PCL) L INSTRUCTION REGISTER (IR) Lo STACK POINTER (SP) CPU - Architettura 9

Elementi delle CPU UC: Unità di Controllo, Control Unit Decodifica le istruzioni contenute nell IR e genera i segnali di controllo Controlla le altre unità al fine di completare l istruzione data in IR Produce i segnali che escono dalla CPU Legge alcuni segnali che entrano nella CPU, per esempio il Clock.. UO: Unità operativa Contiene i registri Contiene la ALU Registri di CPU MAR: Memory Address Register contiene l'indirizzo della locazione di memoria da leggere o scrivere. La dimensione di MAR determina l'ampiezza dello spazio di memoria fisica essendo legato al bus indirizzi (es: a 32 bit) DTR: Data Transfer Register registro attraverso il quale viene scambiata l'informazione tra la memoria e la CPU Tradizionalmente dà la misura del grado di parallelismo della macchina (8, 16, 32, 64 bit) R0, R1,...Rn: registri di uso generale Registri di uso generale (general purpose registers), elevata velocità, memorizzazione temporanea dei dati 10

Registri di CPU IR: Instruction Register Usato per contenere l'istruzione in corso di esecuzione. Caricato in fase di fetch dalla memoria. Rappresenta l'ingresso che determina le azioni svolte durante la fase di esecuzione. Dall IR viene decodificata l istruzione PC: Program Counter Tiene traccia dell'esecuzione del programma Contiene l indirizzo di memoria della prossima istruzione Viene aggiornato per indirizzare l istruzione successiva o parti di questa I Registri T0 e TI sono registri temporanei in appoggio alla ALU CPU - Esecuzione istruzioni L esecuzione di un istruzione da parte della CPU è divisa in MICROISTRUZIONI ed eseguite in 2 fasi: -Fase di FETCH -Fase di EXECUTE Le Microistruzioni sono la sequenza dei comandi di attivazione dei segnali che controllano e attivano i dispositivi interni alla CPU 11

CPU - Esecuzione istruzioni Fase di FETCH - La CPU carica sull address bus l indirizzo dell istruzione da eseguire (MAR) - L indirizzo caricato è fornito dal Program Counter (PC), registro allocato nella Control Unit della CPU - Sul control bus ci sono le informazioni (comandi attivi) per leggere la locazione di memoria il cui indirizzo è sull address bus, mentre sul data bus vengono caricati i dati dalla locazione di memoria contenuta nell instruction register (IR) - Il PC viene aggiornato ed ora punta alla prossima istruzione del programma da eseguire CPU - Esecuzione istruzioni Fase di EXECUTE L istruzione caricata nell IR viene decodificata Vengono eseguiti i trasferimenti di dati necessari e le operazioni logiche e/o aritmetiche derivate dalla decodifica dell op code Il risultato, a seconda del tipo di operazione eseguita è riscritto in un registro o in una locazione di memoria o su un dispositivo di I/O Normalmente, quindi, un istruzione per essere eseguita RICHIEDE ALMENO 2 CICLI MACCHINA (almeno 2 ACCESSI IN MEMORIA, uno in LETTURA e uno in SCRITTURA) 12

CISC vs RISC Esistono 2 grandi famiglie di CPU: CISC e RISC. CISC (Complex Instruction Set Computer) In genere le CPU commerciali sono CISC Normalmente utilizzano architetture Von Neumann classiche Molte istruzioni (>100) Molti metodi di indirizzamento Più di 1 ciclo macchina per eseguire un istruzione RISC (Reduced Instruction Set Computer) Poche istruzioni (<50) Pochi metodi di indirizzamento (solo diretto e indiretto) 1 ciclo macchina per eseguire un istruzione (a parte salti e call) Linguaggio Macchina e Assembly Ogni processore e' in grado di eseguire un certo numero di istruzioni, cioè può eseguire un numero più o meno grande di operazioni elementari. Un programma è costituito da una sequenza di tali istruzioni che permette al microprocessore di assolvere ad un determinato compito di calcolo e/o di controllo. Le istruzioni che il microprocessore deve leggere ed eseguire sono immagazzinate nella memoria in forma di codice binario ovvero sono espresse in quello che si chiama "LINGUAGGIO MACCHINA". L'uso del linguaggio Assembly permette di adottare una forma simbolica testuale (codice mnemonico) che richiama con una notazione sintetica il modo di operare di ogni istruzione. 13

Linguaggio Macchina e Assembly Il linguaggio Assembly è pertanto più agevole e conserva tutti i vantaggi di sintesi e di capacità di esecuzione, in quanto a ogni istruzione in linguaggio Assembly corrisponde una sola istruzione in linguaggio macchina. La corrispondenza uno a uno fra istruzione di linguaggio Assembly e istruzione in linguaggio macchina vieta la possibilità di un unico linguaggio Assembly che, pertanto, è diverso da microprocessore a microprocessore. Per essere eseguito, un programma in linguaggio Assembly deve essere tradotto in linguaggio macchina da uno specifico programma chiamato Assembler. ASSEMBLY ASSEMBLER CODICE OGGETTO Linguaggio Macchina e Assembly Il codice sorgente di un programma in Assembly è un file di testo, cioè un insieme di caratteri ASCII. Successivamente l Assembler (assemblatore) si occupa di tradurre il file sorgente in un file oggetto, ovvero in un file espresso/codificato in linguaggio macchina. Il file prodotto dall'assemblatore viene poi trattato dal programma detto Linker che fornisce un file effettivamente eseguibile dalla CPU. L'ultimo passo del processo consiste nel caricare e far eseguire il file creato dal linker. Librerie (codici oggetto precedentemente generati) ASSEMBLY ASSEMBLER CODICE OGGETTO LINKER Exe 14

Assembly : Tipi di Istruzioni Istruzioni aritmetico-logiche Sono le istruzioni aritmetiche, logiche o in generale tutte le istruzioni che effettuano manipolazioni sui dati. Esse devono specificare i dati su cui devono essere compiute le operazioni e dove depositare il risultato. Istruzioni di ingresso-uscita (READ,WRITE) Adempiono la funzione di trasferimento dati all'interno o all'esterno dell'elaboratore. Esse indicano sia l'unità periferica che deve essere utilizzata sia dove si trova il dato che deve essere emesso all'esterno (oppure dove deve essere depositato il dato immesso all'interno). Istruzioni di salto e controllo di flusso (JMP) Servono per alterare l'esecuzione sequenziale di un programma. Il salto può essere incondizionato o condizionato. Nel primo caso è specificato l'indirizzo di memoria in cui si trova la successiva istruzione da eseguire. Nel secondo caso è specificato anche una condizione necessaria perché il salto avvenga. Istruzioni per il controllo del contesto: permettono di gestire le interruzioni e di salvare e ripristinare il contesto del microprocessore Istruzioni aritmetico-logiche add, addi Problema: a=b+c add a, b, c Somma b con c e memorizza il risultato in a. Quindi: b!=0 e c==0, a assume il valore di b b==0 e c!=0, a assume il valore di c b!=0 e c!=0, a assume il valore di b+c Problema: x=a+b+c add tmp, a, b add x, tmp, c Occorre una variabile di appoggio tmp. 15

Istruzioni aritmetico-logiche add, addi Problema: a=b+10 addi a, b, 10 Somma b con il valore costante 10 e memorizza il risultato in a. add immediate opera quindi addizioni nelle situazioni in cui il secondo operando è un valore costante La differenza con add (come vedremo) è nella definizione in termini di linguaggio macchina Istruzioni aritmetico-logiche OSSERVAZIONE: gli operandi a, b, c, tmp. non sono riferimenti a variabili di memoria, in quanto operazioni che coinvolgono la memoria avrebbero il difetto di essere costose dal punto di vista del tempo di esecuzione in quanto il tempo di accesso alla memoria sarebbe dominante (msec). Pertanto le operazioni aritmetiche e logiche vengono eseguite internamente alla CPU e i dati devono trovarsi già all interno gli operandi sono quindi legati ai registri interni alla CPU che hanno tempi di accesso molto più veloci rispetto alla memoria (nsec). 16

Istruzioni aritmetico-logiche In virtù di quanto detto, la definizione delle istruzioni add e addi diventano: add $x, $y, $z; addi $x, $y, value; Con: $x: registro destinazione $y e $z: registri sorgente value: il valore della costante (considerata col segno) In modo analogo si definisco le istruzioni: sub (sottrazione), mult (moltiplicazione), and (operatore logico AND bit a bit), Istruzioni aritmetico-logiche Comparazione valori: set on less than slt $x, $y, $z; Con: $x: registro destinazione $y e $z: registri oggetto della comparazione $x=1 se $y<$z, $x=0 altrimenti 17

Istruzioni di ingresso-uscita (READ,WRITE) Istruzioni per il trasferimento dati dalla memoria ai registri. Load-word (Read) lw $x, Base[$y]; Carica il registro $x col valore prelevato all indirizzo dato dalla somma del numero Base con il contenuto del registro $y Il valore letto è a 4 byte Store-word (Write) sw $x, Base[$y]; Scrive il valore contenuto nel registro $x all indirizzo dato dalla somma del numero Base con il contenuto del registro $y Indirizzamento Base+offset Nelle istruzioni lw e sw l indirizzamento in memoria prende il nome di Base + offset Base = 100 + word Indirizzi crescenti Offset = 4 Indirizzo = 104 100 101 102 103 104 105 0E01 AAFF 111A 0000 C0C0 D1CA ACCA 2345 18

Istruzioni di salto e controllo di flusso Consentono di cambiare il regolare flusso di esecuzione sequenziale operando dei salti Consentono: Esecuzione di porzioni di istruzioni assembly in modo ciclico fino al verificarsi di particolari condizioni logico-matematico Saltare ad un porzione di codice al verificarsi di particolari condizioni logicomatematico Sono necessari un test e un riferimento, detto label, all istruzione cui saltare Istruzioni che integrano test+label si definisco istruzioni di conditional brach Istruzioni che eseguono un salto senza un test si definiscono istruzioni di salto incondizionato Istruzioni di salto e controllo di flusso Salto condizionato con l istruzione beq (brach if equal) beq $x,$y,label I valori in $x, $y sono comparati e se: $x==$y si salta ad eseguire l istruzione indicata da label e da lì continua l esecuzione $x!=$y si esegue l istruzione successiva (eseguendo il regolare flusso di istruzioni) Si tratta quindi di un test di uguaglianza In abbinamento all istruzione slt si possono realizzare test basati su condizioni di >, >=, <, <= 19

Istruzioni di salto e controllo di flusso Esempio: assumendo $x=0, label = pippo pippo: add $a,$b,$c slt $y,$t,$s beq $x,$y,pippo add $x,$y,$t Si salterà all istruzione identificata da pippo quando $t>=$s ( $y=0) Si continua a saltare fintanto che si verifica la condizione $t>=$s Istruzioni di salto e controllo di flusso Salto incondizionato con l istruzione j (jump) j label Si salta ad eseguire l istruzione indicata da label e da lì continua l esecuzione 20

I registri dell R4000 Sono 32 e denotati come $0, $1,,$31 All inizio dell esecuzione di ogni istruzione il registro $0 contiene il valore 0 x=a+b+c l avevamo scritta come add tmp, a, b; add x, tmp, c; Se si considerano pre-caricati i registri: $2 con il valore di a $3 con il valore di b $4 con il valore di c e: $5 il registro d appoggio col ruolo di tmp $6 il registro finale con il risultato finale L espressione precedente diventa: add $5, $2, $3; add $6, $5, $4; Esempio di codice assembly a=b+15-c[2]-c[3] Supponendo che a, b e c siano rispettivamente agli indirizzi 100, 104 e 108, $5 contiene il risultato e $0 ad ogni istruzione contiene lo 0 lw $5, 104[$0]; addi $5, $5,15; addi $6, $0, 2; lw $7, 108[$6]; sub $5, $5, $7; addi $6, $6, 1; lw $7, 108[$6]; sub $5, $5, $7; sw $5, 100[$0]; 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 word 0004 0101 1100 0110 00AF 0000 00A1 01AB 0000 1111 00A1 000F 0003 0041 0100 00FF 21

Memoria organizzata a 32 bit a=b+15-c[2]-c[3] Supponendo che a, b e c siano rispettivamente agli indirizzi 100, 104 e 108, $5 contiene il risultato e $0 ad ogni istruzione contiene lo 0 lw $5, 104[$0]; addi $5, $5,15; addi $6, $0, 2; lw $7, 108[$6]; sub $5, $5, $7; addi $6, $6, 1; lw $7, 108[$6]; sub $5, $5, $7; sw $5, 100[$0]; 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 dword 0000 0004 0000 0101 0000 1100 0000 0110 0000 00AF 0000 0000 0000 00A1 0000 01AB 0000 0000 0000 1111 0000 00A1 0000 000F 0000 0003 0000 0041 0000 0100 0000 00FF Ciclo iterativo in assembly addi $4, $0, 0; addi $5, $0, 0; addi $6, $0, 10; start_loop: slt $1, $5, $6; beq $0,$1, end_loop; lw $7, 100[$5]; add $4, $4, $7; addi $5, $5, 1; j start_loop; end_loop: sw $4, 612[$0]; 22

Formato istruzioni in linguaggio macchina Un'istruzione in linguaggio macchina può essere rappresentata graficamente secondo questo schema generale: CODICE OPERATIVO OPERANDI Il codice operativo specifica l'operazione da compiere. Se si hanno N bit allora e possibile identificare diverse istruzioni. Gli operandi specificano le locazioni delle celle di memoria cui ciascuna operazione si riferisce. Il codice operativo è sempre presente; mentre gli operandi possono mancare. La lunghezza di un'istruzione varia a seconda del tipo di elaboratore. La lunghezza può variare anche da istruzione a istruzione. Il repertorio delle istruzioni Repertorio stile RISC (Mips) caso R4000 le istruzioni hanno tutte la stessa dimensione (4 byte) il campo del codice di operazione (OP) occupa uno spazio predefinito esiste un numero estremamente limitato di formati Formato R (Registri operandi) Formato I (Immediate offset) Formato J (Jump INDirizzo) 23

Formato istruzioni add, sub e addi Codifica istruzioni add e sub usa il Formato R op rs rt rd - funct 6 5 5 5 5 6 op = 0 per tutte le istruzioni aritmetico-logiche funct definisce il codice dell operazione rs, rt, rd codificano i registri interessati nell operazione Con 5 bit a disposizione si hanno 32 registri numerati da 0 a 31 bit Per la somma (add) funct vale 32 e la codifica è: add $rd, $rs, $rt op=0 rs rt rd - funct=32 000000 xxxxx xxxxx xxxxx 00000 100000 Per la sottrazione (sub) funct vale 34 e la codifica è: sub $rd, $rs, $rt op=0 rs rt rd - funct=34 000000 xxxxx xxxxx xxxxx 00000 100010 Formato istruzioni addi L istruzione addi usa il Formato I op = 8 op rs rd value 6 5 5 16 value definisce il valore della costante rs, rd codificano i registri interessati nell operazione bit Pertanto: addi $rd, $rs, value op=8 rs rd value 001000 xxxxx xxxxx xxxxxxxxxxxxxxxx La costante è codificata a 16 bit e consente 2 16 =65536 valori 24

Formato istruzione slt (set on less) op rs rt rd - funct 6 5 5 5 5 6 slt Usa il Formato R (è un istuzione aritmentico logico) op=0 Funct = 42 rs, rd, rt codificano i registri interessati nell operazione $rd=1 se $rs<$rt, $rd=0 altrimenti Pertanto: bit slt $rd, $rs, $rt op=0 rs rt rd - funct=42 000000 xxxxx xxxxx xxxxx 00000 101010 Formato istruzioni load e store word Le istruzioni lw e sw usano il Formato I lw op rs rd base 6 5 5 16 bit op = 35 base definisce il valore della costante come riferimento dell indirizzo di memoria ed è codificata a 16 bit rs, rd codificano i registri interessati nell operazione $rd registro caricato col valore letto Pertanto: lw $rd,base[$rs] op=35 rs rd base 100011 xxxxx xxxxx xxxxxxxxxxxxxxxx 25

Formato istruzioni load e store word op rs rd base 6 5 5 16 sw op=43 base definisce il valore della costante come riferimento dell indirizzo di memoria ed è codificata a 16 bit rs, rd codificano i registri interessati nell operazione $rd registro contenente il valore da scrivere in memoria bit Pertanto: sw $rd,base[$rs] op=43 rs rd base 101011 xxxxx xxxxx xxxxxxxxxxxxxxxx Formato istruzioni di salto beq e jump op rs rd label 6 5 5 16 beq Usa il Formato I op=4 label definisce il valore della costante che esprime la distanza tra l istruzione corrente e quella a cui saltare (spiazzamento). Si possono indirizzare 65536 locazioni, però considerando lo spazio occupato da ciascuna istruzione (4byte), il range di salto effettivo è [-128KB,+128KB] Si utilizza per salti locali ovvero le istruzioni sono vicine rs, rd codificano i registri interessati nell operazione di confronto Pertanto: bit beq $rd, $rs, label op=4 rs rd label 000100 xxxxx xxxxx xxxxxxxxxxxxxxxx 26

Formato istruzioni di salto beq e j j op label 6 26 Salto incondizionato Usa il Formato J op=2 label a 26 bit (ampiezza salto o spiazzamento) permette salti >128KB Pertanto: bit j label op=2 label 000010 xxxxxxxxxxxxxxxxxxxxxxxxxx 27

Codifica assembly in forma numerica: linguaggo macchina addi $4, $0, 0; addi $5, $0, 0; addi $6, $0, 10; start_loop: slt $1, $5, $6; beq $0,$1, end_loop; lw $7, 100[$5]; add $4, $4, $7; addi $5, $5, 1; j start_loop; end_loop: sw $4, 612[$0]; 8 0 4 0 8 0 5 0 8 0 6 10 0 5 6 1-42 4 0 1 +16 35 5 7 100 0 4 7 4-32 8 5 5 1 2-24 43 0 4 612 28

Esecuzione su un processore Sommatore Porta AND Espansore di Bit Multiplexer Nota: non rappresenta il RISC4000 ma è un modello didattico semplificato Alcuni elementi circuitali L1 L0 n 1/0 Linea dati/indirizzi Una linea di comunicazione a n bits Segnale di Controllo - Abilitata/disabilita un dispositivo es. il wr_enable verso la memoria Multiplexer - Abilitata uno degli ingressi in base al valore del segnale di controllo in ingresso, se 0 attiva la linea L0, se 1 attiva la linea L1. Espansore di bit Estende il numero di bit da 16 a 32, riempendo con 0 la parte significativa a 16 bit. Esempio: la sequenza 0101 0011 0011 0001 diventa 0000 0000 0000 0000 0101 0011 0011 0001 Porta AND A due ingressi, con uscita asserita (1) se entrambi gli ingressi sono asseriti (1), 0 altrimenti 29

Alcuni elementi circuitali Sommatore e PC Sommatore ALU semplificata e ridotta al solo calcolo delle addizioni PC (Program Counter) Registro a 32 bit contenente l istruzione successiva da eseguire. Nel modello utilizzato ogni istruzione occupa 32 bit, il sommatore abbinato al PC ha un ingresso +4 che consente di eseguire l operazione PC=PC+4 Istruzione add data_wr: registro con il risultato dell operazione addr_wr: indirizzo interno del registro di scrittura (rd) $_rs e $_rt: valore operandi in ingresso alla ALU ALU_out: risultato dell operazione op=0 rs rt rd - funct=32 0:5 6:10 11:15 16:20 21:25 26:31 Codifica istruzione add 30

Istruzione addi op=8 rs rd value 0:5 6:10 11:15 16:31 Codifica istruzione addi Istruzione sw addr = base + $_rs data_in = $_rt ($rd) op=43 rs rd base 0:5 6:10 11:15 16:31 Codifica istruzione sw 31

Istruzione lw addr = base + $_rs data_wr = data_out addr_wr = data_wr ($rd) op=35 rs rd base 0:5 6:10 11:15 16:31 Codifica istruzione lw Istruzione beq PC = PC+4 PC + label rt L1 L0 $_rt brach=1 zero_bit=1 se ($_rs-$_rt)=0 branch AND zero_bit = 1 L1 op=4 rs rt label 0:5 6:10 11:15 16:31 Codifica istruzione beq 32