Struttura del Computer Unità Logico- Aritmetica (ALU) Unità di Input Memoria Unità di Output Unità di Controllo I/O CPU o Processore L’Unità di Input accetta informazioni codificate dall’Operatore Tale informazione può essere memorizzata o elaborata dall’ALU La sequenza di passi necessaria ad elaborare l’informazione Viene determinata da un programma residente in memoria I risultati sono presentati all’esterno tramite le unità di Output Tutte queste operazioni sono coordinate dall’unità di controllo

Istruzioni e Dati Istruzioni ( o istruzioni macchina) Sono comandi che: Governano il trasferimento di Informazioni sia all’interno del computer sia tra computer e dispositivi di I/O Specificano le operazioni Aritmetico-Logiche da effettuare Un’insieme di istruzioni che svolgono un determinato compito è un PROGRAMMA

Istruzioni e Dati (cont.) I DATI sono numeri o caratteri codificati (estesa) Ogni numero, carattere o istruzione è codificata con una Una stringa di cifre binarie dette BIT (BInary digiT) Ognuno dei quali può assumere il valore 0 oppure 1 0 = 0000  0*23+ 0*22+ 0*21+ 0*20 1 = 0001  0*23+ 0*22+ 0*21+ 1*20 2 = 0010  0*23+ 0*22+ 1*21+ 0*20 6 = 0110  0*23+ 1*22+ 1*21+ 0*20

Programma Alto Livello main() { int a,b,i; int c[100]; char *p; a=100; b=200; a=a+b; for (i=0;i<100;i++) c[i]=a+i; } b=0; load a,r1 load b,r2 add r1,r2 store r2,a I1  PC PC  MAR UC (Read: Load a,r1)  MDR MDR  IR a  MAR UC (Read: a)  MDR MDR  R1

Programma Alto Livello Memoria i1 i+1 a i+n b c Dati Istruz. 1 ……… Istruz. n Istruz. 2 Progr. 100 200 i ** …. c+1 c+100 main() { int a,b,i; int c[100]; char *p; a=100; b=200; a=a+b; for (i=0;i<100;i++) c[i]=a+i; } b=0;

Sommario Quali sono le istruzioni definite (Instruction Set) Come si definiscono i dati Come si accede ai dati da programma (Indirizzamento) Come si cambia in flusso di esecuzione di un programma in base a risultati di operazioni aritmetico-logiche (salti, condizioni)

Memoria Principale Composta di Celle di 1 BIT Accesso a gruppi di n BIT (word) Ogni Operazione elementare legge o scrive 1 word n = Lunghezza della word ([16-64]) n=32 Ogni word ha associato un indirizzo che è un numero binario a k BIT k bit  2k numeri nell’intervallo 0 – (2k –1) 2k = Spazio di indirizzamento Es: k=24  S.I. = 224 word  16 Mword k=32  S.I. = 232 word  4 Gword

Memoria (cont.) M E O R I A MDR = Memory Data Register Unità di controllo ALU M E O R I A M D R ….. R0 R1 Rn-1 M A R P C I R CPU MDR = Memory Data Register MAR = Memory Address Register PC = Program Counter IR = Instruction Register

Memoria Principale (cont.) n bit Word 0 1 Word 1 2 Word 2 3 2 1 Byte n n-1 3 2 1 i • • • • • • • Word i 2k-1 Word 2k-1 Ogni word può contenere DATI (numeri, caratteri) o ISTRUZIONI

Numeri [-2.147.483.647,+2.147.483.647] Modulo e Segno Modulo 1 2 30 31 Bit di segno 0 = Positivo 1 = Negativo Modulo è espresso in notazione binaria posizionale Modulo = b30* 230+ b29* 229+…….+ b1* 21+ b0* 20 [-2.147.483.647,+2.147.483.647]

? Numeri (cont.) AMBIGUITA’ Es: 35 = 0* 230+ 0* 229+……+ 1* 25+ 0* 24+ 0* 23+ 0* 22+ 1* 21+ 1* 20 +35 = 1 1 1 -35 = 1 1 1 1 +0 = 1 ? -0 = AMBIGUITA’

? Numeri (cont.) AMBIGUITA’ Complemento a 1: Numeri Positivi = come modulo e segno Numeri Negativi = si invertono i bit del corrispondente positivo +35 = 1 1 1 -35 = 1 1 1 1 1 1 +0 = 1 ? -0 = AMBIGUITA’

Numeri (cont.) Complemento a 2: Numeri Positivi = come modulo e segno Numeri Negativi = Complemento a 1 + 1 +35 = 1 1 1 -351 = 1 1 1 1 1 1 -352 = 1 1 1 1 1 1 1 +0 = 1 -01 = -02 =

Caratteri ASCII (7 bit) 32 bit Es: “ALBA” 3 2 1 8 bit 8 bit 8 bit Carattere ASCII Carattere ASCII Carattere ASCII Carattere ASCII Es: “ALBA” 3 2 1 A B L A

Istruzioni Load a , r1 Add r1 , r2 Store r2 , b Opcode Operandi 32 bit Indirizzo Operando 28 = 256 istruzioni

Problema 1 ? 0100111000011010101011110000100 Da una configurazione binaria contenuta in una locazione di memoria, è possibile dire se si tratta di numero,carattere o istruzione ? NO Risposta?:

Convenzioni Minima unità indirizzabile è il Byte Big-Endian 1 2 30 31 31 30 29 1 Minima unità indirizzabile è il Byte 1 2 3 5 4 6 7 2k-3 2k-4 2k-2 2k-1 2 3 1 6 7 5 4 2k-2 2k-1 2k-3 2k-4 Big-Endian Little-Endian

Un calcolatore con memoria indirizzabile a Byte, Problema 2 ? Un calcolatore con memoria indirizzabile a Byte, Organizzato con word di 32 bit secondo lo schema Big-Endian. Se un programma legge da tastiera la parola “INFORMATICA” e la memorizza in byte consecutivi a partire dalla locazione 1000. Quale sarà il contenuto Della memoria? N I F O M R A T 1004 2k-4 … 1000 C 1008

Accesso alla Memoria Fetch (Lettura) Store (Scrittura) Copia il contenuto della memoria  CPU Store (Scrittura) CPU  Memoria

Linguaggi ad Alto Livello (Fortran, Cobol, C, C++, ecc.) Linguaggi di Programmazione Linguaggi ad Alto Livello (Fortran, Cobol, C, C++, ecc.) Compilatore Assemblatore Linguaggio Macchina Assembler LOAD R0, R1 00100010 0000000110001000010000

Istruzioni Istruzioni ( o istruzioni macchina) Sono comandi che: Governano il trasferimento di Informazioni sia all’interno del computer sia tra computer e dispositivi di I/O Specificano le operazioni Aritmetico-Logiche da effettuare Un’insieme di istruzioni che svolgono un determinato compito è un PROGRAMMA

Istruzioni Trasferimento dati tra Memoria e CPU Operazioni Aritmetiche e Logiche sui dati Controllo del flusso del programma Operazioni di I/O

Istruzioni (cont.) Indirizzi in memoria A, B, LOC, VAR Registri R0, R1, ACCUM, IOSTAT, IOREAD Trasferimento dati R0  [LOC] Operazioni C = A + B  C  [A] + [B]

Istruzioni (cont.) C  [A] + [B] Istruzione a 3 Indirizzi ADD A,B,C OpCode Source1,Source2,Destination

Istruzioni (cont.) C  [A] + [B] Istruzione a 2 Indirizzi OpCode Source1,Destination ADD A,B  B  [A] + [B] ADD A B

Istruzioni (cont.) C  [A] + [B] MOVE B,C  C  [B] ADD A,C  C  [A] + [C] MOVE B C ADD A

Istruzioni (cont.) C  [A] + [B] ADD A,B,C MOVE B,C  C  [B] ADD A,C  C  [A] + [C] MOVE B C ADD A

Istruzioni (cont.) Registri Ogni CPU ne ha da 8 a 64 8 registri  3 bit per indirizzarli 64 registri  6 bit per indirizzarli Sono più veloci Indirizzamento con numero minore di bit ADD R0, R1, R2 R0 ADD R1 R2 Compilatore deve ottimizzare l’uso dei registri

L’altro operando è implicito. E’ un registro fissato della CPU Istruzioni (cont.) Istruzioni ad 1 Operando OpCode Source OpCode Destination L’altro operando è implicito. E’ un registro fissato della CPU (ACCUMULATORE) MOVE B  ACC  [B] ADD A  ACC  [A] + [ACC] STORE C  C  [ACC] C  [A] + [B] MOVE B ADD A C STORE

Problema 3 ? Scrivere un Programma che valuti l’espressione: A*B + C*D In un processore con Accumulatore, ipotizzando che esistano le istruzioni: Load, Store, Add, Multiply

Esecuzione di Istruzioni C  [A] +[B] MOVE A, R0 ADD B, R0 MOVE R0, C n bit i i+1 A i+2 MOVE A, R0 ADD B, R0 MOVE R0, C B C Dati Programma Esecuzione in 2 Fasi: Fetch dell’Istruzione Esecuzione dell’Istruzione

Sequenze Lineari • i i+1 i+2 i+n-1 i+n C NUM1 NUM2 MOVE NUM1, R0 ADD NUM2, R0 i+2 ADD NUM3, R0 • i+n-1 ADD NUMn, R0 i+n MOVE R0, C C NUM1 NUM2

Controllo di Flusso: Salto MOVE N, R1 i+1 CLEAR R0 LOOP Determino l’indirizzo del NUM successivo ed Eseguo ADD NUM,R0 DEC R1 Branch > 0 LOOP MOVE R0, C N K C NUM1 NUM2 • NUMK

Controllo di Flusso: Condizioni Registro di Stato C V Z N N = 1 L’operazione corrente produce un risultato negativo Z = 1 L’operazione corrente produce un risultato zero V = 1 L’operazione corrente produce un overflow C = 1 L’operazione corrente produce un riporto

Modalità di indirizzamento Indirizzamento a Registro Operando contenuto in un registro della CPU. Il nome del registro è specificato nell’istruzione ADD A, R0 Indirizzamento Assoluto Operando è una locazione di memoria. L’indirizzo della locazione è specificato nell’istruzione ADD A, R0

Modalità di indirizzamento (cont.) Indirizzamento immediato Operando definito esplicitamente nell’istruzione. ADD #200, R0 Indirizzamento indiretto Indirizzo dell’operando è contenuto in un registro o una locazione di memoria (puntatori). ADD (A), R0

Modalità di Indirizzamento (cont.) Indirizzamento indiretto (cont.) i MOVE (A), R0 • A C C Operando

Modalità di Indirizzamento (cont.) MOVE N, R1 i+1 CLEAR R0 LOOP Determino l’indirizzo del NUM successivo ed Eseguo ADD NUM,R0 Move N, R1 Clear R0 Move #NUM1, R2 LOOP: Add (R2), R0 Inc R2 Dec R1 Branch > 0 LOOP Move R0,C DEC R1 Branch > 0 LOOP MOVE R0, C N K C NUM1 NUM2 • NUMK

Problema 4 ? Scrivere un programma per eseguire il calcolo C = A1*B1 + A2*B2 + A3*B3 Programma che esegue una sequenza lineare Scrivere un programma con ciclo Calcolare il numero di accessi alla memoria richiesti sia per a) che b).

Problema 5 ? Scrivere un programma per eseguire il calcolo Il valore n è memorizzato alla locazione N. Calcolare i valori di k1 e k2 nella formula k1+k2n Che rappresenta il numero di accessi alla memoria Per il programma scritto.

Verifica R1 R2 ADD #200, R2 ADD A, R2 MOV #A,R1 ADD (R1), R2 500 100 ADD #200, R2 ADD A, R2 • 1000 100 MOV #A,R1 ADD (R1), R2 A=1200 1500 C=1500 1000 ADD (C), R2

Problema 6 ? Avere un gran numero di registri riduce Gli accessi alla memoria? Suggerire un semplice problema computazionale Che evidenzi ciò e mostrare la validità su una Macchina con 2 registri ed una con 4. “ Dati due array di k numeri A e B trovare il massimo di A ed il massimo di B e sommare i due massimi. “

Soluzione Problema 6 CONT = K START MAX=0 Trovare il MAX di A MAX < A(CONT) ? MAX=A(CONT) CONT = CONT-1 CONT > 0 ? SI NO MAX_A=MAX START Trovare il MAX di A Trovare il MAX di B Sommare i due MAX END

Soluzione Problema 6 CONT = K START MAX=0 SI Trovare il MAX di A MAX < B(CONT) ? MAX=B(CONT) NO Trovare il MAX di B CONT = CONT-1 Sommare i due MAX SI CONT > 0 ? NO END MAX_B=MAX

R0  #K CONT = K R1  #0 MAX=0 R2  #A SI MAX < A(CONT) ? R3  R1-[(R2)] SI MAX=A(CONT) NO R3 < 0 ? R1  [(R2)] NO CONT = CONT-1 R2  [R2] + 1 SI CONT > 0 ? R0  [R0] - 1 NO SI R0 > 0 ? MAX_A=MAX NO MAX_A  [R1]

R0  #K MOV #K, R0 R1  #0 MOV #0, R1 R2  #A MOV #A, R2 R3  [(R2)] – R1 LOOP_A: SUB (R2), R1, R3 NO BRANCH < 0 STEP_A R3 < 0 ? R1  [(R2)] MOV (R2), R1 SI STEP_A: INC R2 R2  [R2] + 1 DEC R0 R0  [R0] - 1 SI BRANCH > 0 LOOP_A R0 > 0 ? NO MOV R1,MAX_A MAX_A  [R1]

MOV #K, R0 MOV #K, R0 MOV #0, R1 MOV #0, R1 MOV #A, R2 MOV #A, R2 LOOP_A: SUB (R2), R1, R3 LOOP_A: MOV R1,R3 SUB (R2), R3 BRANCH < 0 STEP_A BRANCH < 0 STEP_A MOV (R2), R1 MOV (R2), R1 STEP_A: INC R2 STEP_A: INC R2 DEC R0 DEC R0 BRANCH > 0 LOOP_A BRANCH > 0 LOOP_A MOV R1,MAX_A MOV R1,MAX_A

MOV #K, R0 MOV #0, R1 MOV #A, R2 LOOP_A: MOV R1,R3 SUB (R2), R3 BRANCH < 0 STEP_A MOV (R2), R1 STEP_A: INC R2 DEC R0 BRANCH > 0 LOOP_A MOV R1,MAX_A MOV #B, R2 LOOP_B: MOV R1,R3 BRANCH < 0 STEP_B STEP_B: INC R2 BRANCH > 0 LOOP_B ADD MAX_A, R1 MOV R1,SOMMA

R0  #K CONT  #K MAX_A  #0 R1  #0 R0  #A R2  #A R1 [MAX_A] R3  [(R2)] – R1 R1  [(R0)] – R1 NO R3 < 0 ? NO R1 < 0 ? R1  [(R2)] SI R1  [(R0)] SI R2  [R2] + 1 MAX_A  [R1] R0  [R0] + 1 R0  [R0] - 1 R1  [CONT] SI R0 > 0 ? R1  [R1] - 1 NO NO SI MAX_A  [R1] R1 > 0 ? CONT  [R1]

CONT  #K MAX_A  #0 R0  #A R1 [MAX_A] MOV #K,CONT MOV #0,MAX_A MOV #A,R0 LOOP_A: MOV MAX_A,R1 SUB (R0),R1 BRANCH < 0 STEP_A MOV (R0),R1 MOV R1,MAX_A STEP_A: INC R0 MOV CONT,R1 DEC R1 BRANCH = 0 OUT_A MOV R1,CONT BRANCH LOOP_A OUT_A: R1  [(R0)] – R1 NO R1 < 0 ? R1  [(R0)] SI MAX_A  [R1] R0  [R0] + 1 R1  [CONT] R1  [R1] - 1 NO SI R1 > 0 ? CONT  [R1]

MOV #K,CONT MOV #0,MAX_A MOV #A,R0 LOOP_A: MOV MAX_A,R1 SUB (R0),R1 BRANCH < 0 STEP_A MOV (R0),R1 MOV R1,MAX_A STEP_A: INC R0 MOV CONT,R1 DEC R1 BRANCH = 0 OUT_A MOV R1,CONT BRANCH LOOP_A OUT_A: MOV #K,CONT MOV #0,MAX_B MOV #B,R0 LOOP_B: MOV MAX_B,R1 BRANCH < 0 STEP_B MOV R1,MAX_B STEP_B: INC R0 DEC R1 BRANCH = 0 OUT_B MOV R1,CONT BRANCH LOOP_B OUT_B: MOV MAX_A,R1 ADD MAX_B,R1 MOV R1,SOMMA

Altre Modalità di indirizzamento Indirizzamento con autoincremento Indirizzo dell’operando è contenuto nel registro specificato. Dopo l’accesso all’operando, il contenuto del registro è Incrementato di 1 per puntare all’elemento successivo Della lista. ADD (R1)+, R0 Indirizzamento con autodecremento Il contenuto del registro è decrementato. Il nuovo Contenuto è usato come indirizzo dell’operando. ADD -(R1), R0

Altre Modalità di Indirizzamento (cont.) Move #K, R1 Clear R0 Move #NUM1, R2 LOOP: Add (R2), R0 Inc R2 Dec R1 Branch > 0 LOOP Move R0,C Move #N, R1 Clear R0 Move #NUM1, R2 LOOP: Add (R2)+, R0 Dec R1 Branch > 0 LOOP Move R0,C

Altre Modalità di indirizzamento Indirizzamento indicizzato Indirizzo dell’operando è ottenuto sommando un valore Costante (offset) al contenuto di un registro (registro indice) ADD 30(R0), R1 ADD 30(R0), R1 • R0 R1 800 200 830 1000 500 Offset = 30

Altre Modalità di indirizzamento Indirizzamento indicizzato Indirizzo dell’operando è ottenuto sommando un valore Costante (offset) al contenuto di un registro (registro indice) ADD 10(R1), R0 ADD (R1, R2) , R0 ADD 10(R1, R2) , R0

Una centralina metereologica ha 3 sensori: Problema 7 ? NUM LISTA N Ora 1 Umidità • Temperatura Pressione Ora 2 Ora N Una centralina metereologica ha 3 sensori: Temperatura, Pressione, Umidità. Ogni ora esegue le tre letture e le memorizza in locazioni di memoria consecutive. Il numero di letture effettuate è memorizzato in una locazione NUM. Scrivere un Programma che effettui la media Di tutte le misure relative allo stesso sensore.

Problema 7 (Soluzione) Mov #LISTA, R0 Mov NUM, R1 Clear R2 Clear R3 Clear R4 LOOP: Add 1(R0), R2 Add 2(R0), R3 Add 3(R0), R4 Add #4, R0 Dec R1 Branch > 0 LOOP Mov NUM, R1 Div R2, R1 Mov R1, MediaTemp Div R3, R1 Mov R1, MediaPress Div R4, R1 Mov R1, MediaUmid

Assemblatore Programma del sistema operativo che traduce la sequenza di istruzioni simboliche dell’utente (programma sorgente) in una sequenza di istruzioni in linguaggio macchina (programma oggetto). Esiste una corrispondenza 1 a 1 tra istruzioni Sorgenti e quelle oggetto. Ad 1 istruzione sorgente corrisponde 1 in linguaggio macchina

Assemblatore (cont.) C EQU 200 ORIGIN 201 N DATA 300 NUM1 RESERVE 300 100 MOVE N, R1 C EQU 200 ORIGIN 201 N DATA 300 NUM1 RESERVE 300 ORIGIN 100 START MOVE N,R1 MOVE #NUM1,R2 CLR R0 LOOP ADD (R2),R0 INC R2 DEC R1 BGTZ LOOP MOVE R0,C RETURN END START 101 MOVE #NUM1, R2 102 CLEAR R0 LOOP 103 ADD (R2) , R0 104 INC R2 105 DEC R1 106 Branch > 0 LOOP 107 MOVE R0, C 108 • C 200 N 201 300 202 NUM1 203 NUM2 • 501 NUMK

Organizzazione dei dati NUM LISTA N Ora 1 Umidità • Temperatura Pressione Ora 2 Ora N LISTA o ARRAY

Organizzazione dei dati (cont.) STACK o PILA E’ una lista di dati in cui gli elementi possono essere Inseriti o letti solo da una estremità (TOP). L’estremità Opposta è detta BOTTOM. LIFO (Last-In-First-Out)

Organizzazione dei dati: STACK 100 PUSH (Inserimento) Dec SP Move LOC,(SP) 101 102 100 Current TOP (Stack Pointer) 103 -38 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • POP (Estrazione) Move (SP),LOC Inc SP 200 201 202 203 • 501

Organizzazione dei dati: STACK 100 PUSH (Inserimento) Dec SP Move LOC,(SP) 101 102 100 SP 103 -38 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • LOC = 1000 SP= 102 200 201 202 203 • 501

Organizzazione dei dati: STACK 100 PUSH (Inserimento) Dec SP Move LOC,(SP) 101 SP 102 100 103 -38 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • LOC = 1000 SP= 101 200 201 202 203 • 501

Organizzazione dei dati: STACK 100 PUSH (Inserimento) Dec SP Move LOC,(SP) 101 1000 SP 102 100 103 -38 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • LOC = 1000 SP= 101 200 201 202 203 • 501

Organizzazione dei dati: STACK 100 POP (Estrazione) Move (SP),LOC Inc SP 101 102 100 SP 103 -38 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • LOC = 222 SP= 102 200 201 202 203 • 501

Organizzazione dei dati: STACK 100 POP (Estrazione) Move (SP),LOC Inc SP 101 102 100 SP 103 -38 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • LOC = 100 SP= 102 200 201 202 203 • 501

Organizzazione dei dati: STACK 100 POP (Estrazione) Move (SP),LOC Inc SP 101 102 100 103 -38 SP 104 25 105 738 106 15 107 1002 BOTTOM 108 200 • LOC = 100 SP= 103 200 201 202 203 • 501

Organizzazione dei dati (cont.) QUEUE o CODA E’ una lista di dati in cui gli elementi sono inseriti da una estremità (START) e letti da quella opposta è detta (END). FIFO (First-In-First-Out)

Organizzazione dei dati: QUEUE 100 PUSH (Inserimento) Inc END Move LOC,(END) 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 END 108 200 • POP (Estrazione) Move (START),LOC Inc START 200 201 202 203 • 501

Organizzazione dei dati: QUEUE 100 PUSH (Inserimento) Inc END Move LOC,(END) 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 END 108 200 • LOC = 1000 END = 108 200 201 202 203 • 501

Organizzazione dei dati: QUEUE 100 PUSH (Inserimento) Inc END Move LOC,(END) 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 108 200 109 END 200 LOC = 1000 END = 109 201 202 203 • 501

Organizzazione dei dati: QUEUE 100 PUSH (Inserimento) Inc END Move LOC,(END) 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 108 200 109 1000 END 200 LOC = 1000 END = 109 201 202 203 • 501

Organizzazione dei dati: QUEUE 100 POP (Estrazione) Move (START),LOC Inc START 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 END 108 200 • LOC = 1000 START = 102 200 201 202 203 • 501

Organizzazione dei dati: QUEUE 100 POP (Estrazione) Move (START),LOC Inc START 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 END 108 200 • LOC = 100 START = 102 200 201 202 203 • 501

Organizzazione dei dati: QUEUE 100 POP (Estrazione) Move (START),LOC Inc START 101 102 100 103 -38 START 104 25 105 738 106 15 107 1002 END 108 200 • LOC = 100 START = 103 200 201 202 203 • 501

Organizzazione dei dati: QUEUE con Buffer Circolare 100 BufStart PUSH (Inserimento) Inc END Cmp END,BufEnd Branch > 0 INIT Move LOC,(END) Return INIT Move #BufStart,END 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 END 108 200 109 200 201 BufEnd 202 203 • 501

Organizzazione dei dati: QUEUE con Buffer Circolare 100 BufStart 101 102 100 START 103 -38 104 25 105 738 106 15 107 1002 END 108 200 POP (Estrazione) Move START,LOC Inc START Cmp START,BufEnd Branch > 0 INIT Return INIT Move #BufStart,START 109 200 201 BufEnd 202 203 • 501

SUBROUTINE Ordinamento decrescente di numeri positivi max(int *a,int *ind) { int max; int i; max=a[0]; ind=0; for (i=1;i<5;i++) { if (a[i] > max) { max=a[i]; *ind=i; } return; main() { int lista[5]={5,10,4,7,3}; int ord[5]={0,0,0,0,0}; int pos=0; int posmax; int i; for (i=0;i<5;i++) { max(lista,&posmax); ord[pos]=lista[posmax]; pos++; lista[posmax]=0; }

SUBROUTINE PC Link Register 100 101 102 102 103 104 105 106 107 108 • PC 101 • 102 Call MAX 102 103 Istruz. Success. 104 • 105 • 106 END 107 108 Link Register 109 200 Sub MAX Istruz. 1 201 202 Istruz. 2 203 • Return 501

SUBROUTINE PC Link Register 100 101 102 102 103 104 105 106 103 107 • PC 101 • 102 Call MAX 102 103 Istruz. Success. 104 • 105 • 106 END 103 107 108 Link Register 109 200 Sub MAX Istruz. 1 201 202 Istruz. 2 203 • Return 501

SUBROUTINE PC Link Register 100 101 102 200 103 104 105 106 103 107 • PC 101 • 102 Call MAX 200 103 Istruz. Success. 104 • 105 • 106 END 103 107 108 Link Register 109 200 Sub MAX Istruz. 1 201 202 Istruz. 2 203 • Return 501

SUBROUTINE PC Link Register 100 101 102 103 103 104 105 106 103 107 • PC 101 • 102 Call MAX 103 103 Istruz. Success. 104 • 105 • 106 END 103 107 108 Link Register 109 200 Sub MAX Istruz. 1 201 202 Istruz. 2 203 • Return 501

SUBROUTINE 1 - Passaggio dei parametri 2 - Procedure Annidate PC 100 Call MAX 101 102 103 104 105 106 107 108 Return 200 201 202 203 501 109 • END Istruz. Success. Sub MAX Call SUB1 Istruz. 2 Sub SUB1 1 - Passaggio dei parametri 2 - Procedure Annidate PC Link Register

SUBROUTINE PC 100 • 200 101 • 102 Call MAX 103 Istruz. Success. 104 • 105 • STACK 106 END 107 108 109 200 Sub MAX 201 Call SUB1 202 Istruz. 2 203 Return 501 Sub SUB1 103 Bottom

SUBROUTINE PC 100 • 501 101 • 102 Call MAX 103 Istruz. Success. 104 • 105 • STACK 106 END 107 108 109 200 Sub MAX 201 Call SUB1 202 Istruz. 2 203 Return 202 501 Sub SUB1 103 Bottom

SUBROUTINE Passaggio dei parametri main() { int lista[5]={5,10,4,7,3}; int ord[5]={0,0,0,0,0}; int pos=0; int posmax; int i; for (i=0;i<5;i++) { max(lista,&posmax); ord[pos]=lista[posmax]; pos++; lista[posmax]=0; } STACK posmax lista Indirizzo di ritorno Bottom

SUBROUTINE Passaggio dei parametri 100 Move #LISTA, -(SP) 101 Move N, -(SP) 102 Call LISTADD 103 Move 1(SP),SOMMA STACK 103 Top K LISTA Bottom

SUBROUTINE Passaggio dei parametri 100 Move #LISTA, -(SP) 101 Move N, -(SP) 102 Call LISTADD 103 Move 1(SP),SOMMA LISTADD Move_Mult R0-R2, -(SP) Move 4(SP),R1 Move 5(SP),R2 Clear R0 LOOP Add (R2)+,R0 Dec R1 Branch > 0 LOOP Move R0, 5(SP) Move_Mult (SP)+,R0-R2 Return [R2] Top [R1] [R0] 103 K LISTA Bottom

Riepilogo Organizzazione della Memoria e dei Registri (lunghezza della word, big-endian,ecc.) Struttura delle istruzioni Metodo di Indirizzamento Organizzazione dei dati Controllo di flusso del programma

Motorola 68000

Motorola 68000:Memoria Lunghezza word = 16 bit Gestisce anche i byte e le Longword (32 bit) word Byte Il 68000 ha 64 bit 16 bit per i dati 24 bit per indirizzi 24 bit per controllo e aliment. 1 2 15 8 2 224-2 Spazio indirizzamento 16 MB Big-Endian

Motorola 68000: Registri Longword A0 word Byte A1 D0 A2 D1 A3 D2 A4 D3 31 A0 A1 A2 A3 A4 A5 A6 A7 SP allo stack Utente SP allo Stack Supervisore SR

Motorola 68000: Indirizzamento 100 Istruzione 101 102 103 104 105 106 107 108 Array 2 200 201 202 203 501 109 • END Istruz. Success. N Data Array 1 Array N Bval Rm PC Immediate #val Short Absolute val (word) Long Absolute val (Longword) Register Rn Indirect Register (An) Autoincrement (An)+ Autodecrement -(An) Indexed Wval(An) Extended Indexed Bval(An,Rm.S) Relative Wval(PC) Extended Relative Bval(PC,Rm.S)

Motorola 68000: Formato Istruzioni ADD #9,D3 15 12 9 7 6 5 dst src opcode size 1101 011 0 01 111100 Opcode ADD Registro 3 word Immediate 1101 0110 0111 1100 D 6 7 C D67C 9

Motorola 68000: Formato Istruzioni 63910 B=201152 -21510 201200 Opcode word MOVE A, D0 201202 20 201204 1150 201206 Opcode word 201208 20 ADD B, D0 20120A 1152 20120C Opcode word 20 MOVE D0, C 20120E 201210 2200 201212 C= 202200

Motorola 68000: Assemblatore EQU C EQU $1222186 ORG ORG %11100101 DC.S A DC.W 639 A DC.L 65536 STR DC.L “ALBA” DS.S ARRAY DS.W 200 ARRAY DS.L 200

Motorola 68000: Controllo di Flusso Status Register 0 = C (carry) 1 = V (overflow) 2 = Z (zero) 3 = N (negative) 4 = X (Extension) 8-10 = Interrupt mask 13 = S (Supervisor Mode) 15 = T (Trace Mode – Debugger) C= 202200

Motorola 68000: Salti LOOP ADD.W (A2)+,D0 SUBQ.W #1, D1 BGT LOOP 1002 1004 1006 Opcode word Opcode -6 LOOP ADD.W (A2)+,D0 SUBQ.W #1, D1 BGT LOOP DBGT D1,LOOP LOOP ADD.W (A2)+,D0 DBGT D1,LOOP

Motorola 68000: Subroutine STACK MOVE.L PARAM1,-(A7) 2010 BSR SUB1 MOVE.L 4(A7),RISULTATO ADDI.L #8,A7 Prima Procedura 2100 SUB1 MOVEM.L D0-D2/A0-A1,-(A7) MOVEA.L 28(A7),A0 ……….. MOVE.L PARAM3,-(A7) BSR SUB2 ADDI.L #4,A7 ………. MOVE.L D2,28(A7) MOVEM.L (A7)+,D0-D2/A0-A1 RTS Seconda Procedura SUB2 MOVE.L D0,-(A7) MOVE.L (A7)+,D0 1046 STACK PARAM1 [D0] da SUB PARAM3 PARAM2 2012 2154 [D0] da SUB1 [D1] da SUB [D2] da SUB [A0] da SUB [A1] da SUB 1042 1038 1034 1030 1026 1022 1018 1014 1010 1006

PowerPC 601

PowerPC: Architettura Instruction Management Unit Floating Point ALU Integer ALU CACHE RAM

PowerPC:Memoria Lunghezza word = 32 bit Gestisce anche i byte, Halfword (16 bit), Doubleword (64 bit) Double word word Halfword 1 2 3 4 5 6 7 8 15 31 32 63 232-8 Big-Endian Spazio indirizzamento 4 GB

PowerPC: Registri FR0 FR1 • FR31 63 R0 CTR R1 31 R2 CR • 31 XER 31 R31 63 R0 CTR R1 31 R2 CR • 31 XER 31 R31 LINK 31 31

PowerPC: Istruzioni Istruzioni che trasferiscono dati tra memoria e registri (Load e Store) Istruzioni Aritmetico-Logiche tra i registri R0-R31 (2 o 3 operandi) Istruzioni per il controllo di flusso Istruzioni in floating-point Istruzioni per il controllo del processore (Cache,I/O,ecc.)

PowerPC: Indirizzamento Indexed HWval(Rn) Register Indexed (Rn,Rm)

PowerPC: Controllo di Flusso 31 CR 31 XER CR XER 0 = LT (1 se risultato < 0) 1 = GT (1 se risultato > 0) 2 = EQ (1 se risultato = 0) 3 = SO (Summary Overflow) 0 = SO (Summary Overflow) 1 = OV (Overflow) 2 = CA (Carry) C= 202200

PowerPC: Salti B Salto Incondizionato all’indirizzo specificato BC Salto all’indirizzo specificato se verificata la condizione (BGT, BLT, BEQ, BNE, ecc.) Indirizzamento nel salto Relativo offset con l’istruzione destinaz. Specificata Assoluto destinazione Specificata Indiretto a Registro destinaz. Specificata in registro

PowerPC: Subroutine Non esiste una istruzione specifica di chiamata a subroutine. Esiste una istruzione di ritorno (BLR) Ogni istruzione di salto memorizza l’indirizzo di ritorno nel LINK Register Per le procedure annidate e passaggio dei parametri, ad ogni procedura È riservata un area sullo stack (stack frame) a gestione della procedura

IA-32

IA-32: Evoluzione 8086-8088 (1978): 16 bit , segmentation 80286 (1982): 24 bit, protected mode, virtual memory 80386 (1985): 32 bit, parallelism 80486 (1989): more parallelism, cache, FPU Pentium (1993): two pipeline, more cache, data paths da 128 e 256 bits, dual processor Pentium P6 (1995-99): (Pro, II, Celeron, III, III Xeon): two cache, more pipeline, MMX, SIMD Pentium 4 (2000-2003) (4, Xeon, M): Netburst, Hyperthreading

IA-32:Memoria Lunghezza word = 32 bit Gestisce anche i byte, Halfword (16 bit), doubleword (64 bit), Fpword (80-bit) word Halfword Spazio indirizzamento 4 GB 3 2 1 4 31 15 Memoria Segmentata 232-4 Little-Endian

IA-32: Operating Mode Protected Mode: 64GB di Memoria Real Address Mode: 4GB Memoria System Management Mode

IA-32: Registri General Purpose Register Segment Register EAX EBX ECX EDX EBP ESP ESI EDI AL AH AX Segment Register CS DS ES FS GS SS 16 31 EFLAGS EIP

IA-32: Indirizzamento Immediate Es: ADD EAX ,14 Register All Register (EAX,AX,AL,AH) Memory: Segment Selector (CS,SS,DS,ES) Indirizzo nel segmento (Offset) MOV ES:[EBX], EAX

IA-32: Indirizzamento (cont.) Offset (Indirizzo effettivo): Base + (index*scale)+displacement Base = registro (EAX,EBX,ECX,EDX,ESP,EBP,ESI,EDI) Index = registro (EAX,EBX,ECX,EDX,EBP,ESI,EDI) Scale = numero (1,2,4,8) Displacement = numero (none, 8-bit, 16-bit, 32-bit)

IA-32: Istruzioni General Purpose Instructions FPU e SIMD Instructions MMX Instructions SSE,SSE2,SSE3 Instructions System Instructions

IA-32: controllo di flusso Condizioni verificate con EFLAGS register bits

IA-32: Subroutine CALL e RET (Near CALL, far CALL) ENTER e LEAVE

IA-32: Program Template TITLE <nome programma> (templat.asm) ; Autore ; Data ; Revisione INCLUDE <nome file> .data < dichiarazioni dei dati> .code main PROC < istruzioni> Main ENDP < procedure> END main

Esempio: somma e differenza (versione 2) TITLE Somma e Sottrai (addsub.asm) ; Questo programma somma e sottrae tre interi .code main PROC mov eax, 10000h ; Eax= 10000h add eax, 40000h ; Eax = Eax+40000h sub eax, 20000h ; Eax = Eax-20000h main ENDP END main

Esempio: somma e differenza TITLE Somma e Sottrai (versione2) (addsub2.asm) ; Questo programma somma e sottrae tre interi .data val1 DWORD 10000h val2 DWORD 40000h val3 DWORD 20000h risul DWORD ? .code main PROC mov eax, val1 ; Eax= 10000h add eax, val2 ; Eax = Eax+40000h sub eax, val3 ; Eax = Eax-20000h mov risul,eax main ENDP END main

IA-32: Altri comandi Costanti const EQU 100 const = 100 Array list BYTE 10,20,30,40 var2 DWORD 10 DUP(0) var2 DWORD 10 DUP(?)

Esempio: somma e differenza in Real-address mode TITLE Somma e Sottrai (versione2) (addsub2.asm) ; Questo programma somma e sottrae tre interi .data val1 DWORD 10000h val2 DWORD 40000h val3 DWORD 20000h risul DWORD ? .code main PROC mov ax,@data mov ds,ax mov eax, val1 ; Eax= 10000h add eax, val2 ; Eax = Eax+40000h sub eax, val3 ; Eax = Eax-20000h mov risul,eax main ENDP END main