Il processore PD32 Set Istruzioni.

Presentazione sul tema: "Il processore PD32 Set Istruzioni."— Transcript della presentazione:

1 Il processore PD32 Set Istruzioni

2 Set Istruzioni Sono organizzate in 8 classi Movimento dati
Aritmetiche (somma e sottrazione) Tipo Logico Rotazione e shift Operazioni sui bit di stato controllo del programma controllo della macchina ingresso/uscita

3 è rappresentata con 32 bit)
Formato Istruzione int i,j ……… i = i + j Programma compilatore Codice mnemonico ADDW R2 , R1 Linguaggio Assembly (R2+R1 => R1) Destinazione Tipo di dato Sorgente L (longword) W (word) B (byte) Programma assemblatore (Assembler) 31 29 28 24 23 16 15 14 13 12 11 9 8 6 5 3 2 Classe Tipo K pos. I/O L-W-B Modo Sg Sorg. Modo Ds Dest Linguaggio Macchina (PD 32 ogni istruzione è rappresentata con 32 bit)

4 Formato istruzioni Ogni istruzione (che non utilizza l’indirizzamento immediato) è lunga 32 bit (4 byte) ed è composta da 9 campi Alcune istruzioni ignorano alcuni campi CLASSE TIPO DATO K I/O S MODO S SORG MODO D DEST Operandi Codice Operativo Specifica il tipo d’istruzione Specifica i dati su cui operare

5

6 Ciclo Istruzione

7 Ciclo Istruzione - Fetch
Il registro “Program Counter” contiene l’indirizzo da cui prelevare l’istruzione da eseguire. Il SCO lo incrementa di 4 ad ogni fetch MEMORIA DI LAVORO Bus memoria Fetch PC -> MAR (MAR) -> MDR MDR -> IR, PC + 4 -> PC PC Istruzione 1 Istruzione 2 IR = Instruction Register Istruzione 3 Segnali di comando per la SCA e per lo SCO

8 Alcune istruzioni Assembler
MOVB R1,R2 copia il contenuto del primo byte di R1 in R2 MOVW R1,(R2) copia il contenuto dei primi 2 byte di R1 nei due byte di memoria il cui indirizzo iniziale è memorizzato in R2 MOVL (R1),R2 copia in R2 il contenuto dei 4 bytes di memoria il cui indirizzo è specificato in R1 SUBs R1,R2 sottrai il contenuto del primo, dei primi 2 o i 4 bytes del registro R1 con il corrispondente in R2, il risultato memorizzalo in R2 ADDs #d,R2 addiziona al contenuto del registro R2 la quantità d di dimensione s.

9 Esempi di traduzione istruzioni assembler in linguaggio macchina
MOVB R4,R3 operandi e modo indiriz. operandi formato dato campo s Codice mnemonico diretto con registro CLASSE TIPO byte 4 3 001 0000 ….. … 00 000 100 000 011 Modo sorg Modo dest

10 Esempi di traduzione istruzioni assembler in linguaggio macchina (cont
ADD B #20,R3 operandi e modo indiriz. operandi formato dato campo s Codice mnemonico Indirizzamento Immediato (vedi byte successivo) Indirizzamento diretto con registro CLASSE TIPO byte 3 010 0000 ….. … 00 001 …… 000 011

11 Ciclo Istruzione – Execute
Nel PD32 la fase di esecuzione di un ciclo istruzione consiste in un numero variabile di cicli macchina dipendente dal numero di accessi in memoria necessari (oltre al fetch) Uno degli operandi (0x20) è definito nell’istruzione L’assembler lo memorizza nella locazione di memoria esterna immediatamente successiva a quella contenente l’istruzione (indirizzamento immediato) Entrambi gli operandi sono contenuti in registri interni del PD32 (indirizzamento a registro) ADDW R1, R2 R1 -> Temp1 R2 -> Temp2 ALU-OUT (Temp1+Temp2) -> R2 (nessun accesso a memoria esterna) ADDW #20h, R2 PC -> MAR (MAR) -> MDR , R2 -> Temp1 MDR -> Temp2, PC + 2 -> PC ALU-OUT (Temp1+Temp2) -> R2 (1 accesso a memoria esterna)

12 Un esempio di programma assembler
Saldo (S) nelle 2 celle puntate da R5 (dato di una parola) Tre versamenti (V1,V2,V3) immagazzinati nelle tre coppie di celle consecutive puntate da R4 Due prelievi (P1,P2) immagazzinati nelle due coppie di celle puntate da R3 S=S+V1+V2+V3-P1-P2

13 Un esempio di programma assembler

14 ESTENSIONE SEGNO #dato sui rimanenti bits di R1
Altre istruzioni JMP SALTO INCONDIZIONATO JZ SALTO CONDIZIONATO HALT FINE PROGRAMMA MOVB #dato,R1 ESTENSIONE SEGNO #dato sui rimanenti bits di R1 00h 00h 00h MOVB #3,R4 R4 = FFh FFh FFh MOVB #-1,R5 R5 =

15 Un programma per l’aggiornamento del saldo di un conto bancario

16 Ipotesi Tutti i dati sono a 16 bit (word)
Il saldo iniziale è memorizzato nella coppia di celle di indirizzo 00001B00 I movimenti (versamenti e prelievi) sono memorizzati in posizioni consecutive di memoria, a partire da quella di indirizzo 00001F00 I movimenti non hanno un ordine particolare: i versamenti sono positivi e i prelievi negativi Non è noto il numero dei movimenti effettuati L’ultimo movimento è seguito da una posizione di memoria contente il numero 0

17 Una prima soluzione

18 START R5 punta al Saldo R5:=1B00 R4 punta al I vers. R4:=1F00 R0 memorizza il Saldo R0:=(R5) R1 mem. il versamento R1:=(R4) R1:=R1+0 R1=0 ? JZ no Somma al saldo il vers. si R0:=R1+R0 R4 punta al vers. succ. R4:=2+R4 ora in memoria c’è il saldo aggiornato (R5):=R0 HALT

19 Il codice ASSEMBLER

20 Una soluzione “equivalente”

21 scrivi il saldo in memoria (R5):=R0
START R5 punta al Saldo R5:=1B00 R4 punta al I vers. R4:=1F00 R0 memorizza il Saldo R0:=(R5) Somma al saldo il vers. R0:=R0+(R4) scrivi il saldo in memoria (R5):=R0 R4 punta al vers. succ. R4:=2+R4 Somma al saldo il vers. R0:=(R4)+R0 R1:=R0-(R5) confronta il saldo attuale con il saldo in mem. si JNZ no HALT

22 Assemblatore Traduce il codice scritto in assembly in codice macchina
Ad ogni istruzione macchina è associato un codice menmonico E’ possibile usare riferimenti simbolici E’ possibile inserire delle direttive che indicano all’assemblatore come procedere nella traduzione Ad esempio, ORG specifica dove sarà caricato il programma una volta tradotto. Questo serve a tradurre i riferimenti simbolici assoluti nel codice sorgente. Ad esempio, CODE .. END indicano l’inizio e la fine della sezione codice.

23 Esempio MOVB #0,R1 Significato: “Poni a 0 il byte meno signif. di R1”
Codice assembly MOVB #0, R1 Destinazione Tipo (byte) Sorgente ORG 400H CODE movb #0,R1 HALT END 01H 02H 00H 20H 400 istruzione operando

24 Contenuto memoria 400 Prima istruzione 20 00 02 01 Operando 404 ? ? ? 00 Seconda istruzione ?? ?? ?? ? 408 0x 400: 404: 0000 ….

25 Esempio MOVB #0,R1 Indirizzo Iniziale

26 Altro esempio ORG 600H CODE movw r2, r1 movb #-2, r0 HALT END
Il codice sarà caricato in posizione 0x600 ORG 600H CODE movw r2, r1 movb #-2, r0 HALT END FE Rappresentazione compl. a 2

27 Modi di indirizzamento
Stabiliscono la posizione degli operandi Possono trovarsi nei registri (R0..R7) In memoria di lavoro (la posizione è stabilita dall’indirizzo di memoria in cui è memorizzato il valore) Chiamiamo la posizione di un operando Effective Address (EA) EA può essere pertanto un registro o una locazione di memoria Il valore di EA deve essere noto al tempo di esecuzione del programma (run-time), può però non essere noto al momento della sua scrittura (compile-time). Ciò consente di ottenere una grande flessibilità

28 Modi di indirizzamento
Modi diretti Diretto con registro Immediato Assoluto Modi indiretti Indiretto con registro Indiretto con spiazzamento Relativo Indiretto con predecremento Indiretto con postdecremento

29 Indirizzamento a registro
EA=Ri Esempio: MOVL R1,R5 (significato: R1->R5)

30 Indirizzamento immediato
Il dato si trova in memoria immediatamente dopo l’istruzione Esempio: MOVL #0,R5 (significato: poni 0 in R5)

31 Indirizzamento assoluto
Esempio: MOVB R1,1280H (sposta il byte basso di R1 nella cella di memoria di indirizzo 1280H. Tale valore, 1280H, è memorizzato dopo l’istruzione ed è riferito da PC dopo che è stato incrementato) Effective address = 1280H

32 Indirizzamento indiretto con registro
Il registro contiene l’indirizzo dell’operando (corrisponde alla nozione di puntatore nei linguaggi di programmazione) Esempio: MOVL (R5),R1 (significato: sposta in R1 in contenuto della locazione il cui indirizzo è contenuto in R5)

33 Indirizzamento indiretto con registro e con predecremento
Il registro, opportunamente decrementato, contiene l’indirizzo dell’operando Esempio: MOVL R1,-(R7) (sposta nella locazione il cui indirizzo è pari al contenuto in R7 meno 4 ciò che è memorizzato in R1)

34 Indirizzamento indiretto con registro e con postincremento
Il registro contiene l’indirizzo dell’operando, una volta acceduto la memoria il registro viene opportunamente incrementato Esempio: MOVL (R7)+,R1 (sposta in R1 quanto memorizzato nella locazione il cui indirizzo è pari al contenuto in R7, dopodiché incrementare di 4 ciò che è memorizzato in R7)

35 Indirizzamento con spiazzamento
L’indirizzo effettivo dell’operando è la somma di un valore base (mem. in un reg.) con il valore di spiazzamento Esempio: MOVB D(R0),R1 (significato: sposta in R1 il contenuto della cella con indirizzo D+R0)

36 Indirizzamento relativo
Usato nei salti, per consentire riferimenti relativi e caricare il PC con valori differenti da quelli ottenuti con semplici incrementi. Esempio: JMP LABEL(PC) (metti nel PC quanto ottenuto dalla somma del contenuto della locazione il cui indirizzo è dato dall’etichetta LABEL con il valore corrente del PC)

37 Indirizzamento Riepilogo
org 400h code movl #20, r1 ; r1=20, ind. immediato addl r1,r1 ; r1=40, ind. a registro movb #0FFh, 800h ;mem[0x800]=0xFF, ind. assoluto movl #800h,r2 ;r2=0x800 movb #0EEh, (r2) ;mem[r2]=0xEE, ind. con registro movb #0FFh, -(r2) ;r2=0x800-0x1=0x7FF, mem[0x7FF]=0xFF ;ind. con predecremento movb #0AAh, (r2)+ ;mem[0x7FF]=0xAA, r2=0x800 ;ind. con postincremento movb #0FFh, 8(r2) ;mem[0x808]=0xFF, r2=0x800 ;ind. con spiazzamento end

38 Tipi di istruzioni Set Istruzioni Sono organizzate in 8 classi
Movimento dati Aritmetiche (somma e sottrazione) Tipo Logico Rotazione e shift Operazioni sui bit di stato controllo del programma controllo della macchina ingresso/uscita

39 Istruzioni Movimento dati

40 Istruzioni MOVs Sono usate per copiare dati da Registro-registro
movl r1,r2 Registro-memoria movl r1,(r2) Memoria-registro movl (r1),r2 Memoria-memoria movl (r1),(r2)

41 Istruzioni aritmetiche

42 Istruzione CMP CMPL R1,R2

43 Confronto fra registri
Aritmetica non segnata CMPB R1,R2 (ipotesi: R1,R2>=0) Equivale ad eseguire R2-R1 senza aggiornare R2 C=1 R1>R2 Z=1  R1=R2 C=0 and Z=0  R1<R2 CMPB R1,R2 Z=0 C=1 Z=1 C=0 R2-R1<0 (R1>R2) R1=R2 R1<>R2 not R2-R1>=0 (R1<=R2) C=0 R1<=R2 Z=0  R1<>R2 Z=1 or C=1  R1>=R2 Z=0 R1<R2

44 Confronto fra registri
Aritmetica segnata R1,R2 rappresentati in complemento a 2 CMPB R1,R2 Equivale ad eseguire R2-R1 senza aggiornare R2 N=V R1>=R2 N<>V  R1<=R2 Z=1  R1=R2 Z=0  R1<>R2 CMPB R1,R2 Z=0 Z=1 N<>V N=V R2-R1=0 (R1=R2) R1<=R2 R1<>R2 R2-R1>=0 (R2>=R1) Z=0 Z=0 R1<R2 R2>R1

45 Esempio … movl #100,r1 movl #99,r2 ; a questo punto del codice, r1 ed r2 ; contengono valori positivi cmpl r1,r2 ;c=1, n=1, z=0 movl #100,r2 cmpl r1,r2 ;c=0, n=0, z=1 movl #101,r2 cmpl r1,r2 ;c=0, n=0, z=0

46 Istruzioni controllo di programma

47 Istruzioni di controllo esecuzione
Istruzioni di salto incondizionato JMP, JSR, RET, RETI Istruzioni di salto condizionato Jc Label, (salta a Label se c=1), JNc (salta a Label se c<>1) c qualunque flag: C (Carry), N (Negative) , Z (Zero) V (oVerflow), P (Parity), I (Interrupt Enable) I flag sono modificati dopo un’istruzione. Si usa solitamente l’istruzione “compare”, CMPs , che equivale ad eseguire una sottrazione ma senza modificare il registro di destinazione Ex: CMPL R1,R2 (equivale ad eseguire R2-R1, ma senza modificare il registro destinazione R2)

48 Esempio R1>R2 R1>R2 I1 I1 I2 I2 cmpl R1 R2 cmpl R1 R2
si: R1>R2 si: R1>R2 no: R1<=R2 no: R1<=R2 I1 I1 I2 I2 cmpl R1 R2 JNC L ;se R1<=R2 ;salta ad I2 Istruzione I1 L2: Istruzione I2 cmpl R1 R2 JC L ;se R1>R2 ;salta ad I2 Istruzione I1 L2: Istruzione I2

49 Esempio if R1>R2 then <I1> else <I2> <I3>
no: R1<=R2 si: R1>R2 cmpl R1 R2 ;R2-R1 JNC L2 ;se R2<=R1 ;esegui I2 L1: I1 ;ramo then jmp L3 L2: I2 ;ramo else L3: I3 ;continua I2 I1 I3

50 Istruzioni controllo macchina:
CLASSE 0

51 Istruzioni di tipo logico: Classe 3

52 Istruzioni di rotazione e shift
Classe 4

53 Istruzioni di rotazione e shift

54 Istruzioni (sottoinsieme)
di Ingresso Uscita Classe 7

55 Esempio programma assembly
Problema Trovare il massimo in un insieme di 15 interi positivi Ipotesi Assumiamo che i valori siano compresi nell’intervallo Programma 15 interi fra 0 e 255 Valore massimo

56 Esempio programma assembly (cont)
Dobbiamo stabilire Che tipo e quanti variabili usare Dove memorizzare i valori in ingresso -> Vettore V di 15 elementi Quali variabili ausiliare sono eventualmente necessarie Dove memorizzare il valore di uscita registro Algoritmo che risolve il problema Per esempio, ipotizzare come valore massimo 0 e confrontarlo con tutti i 15 valori, aggiornandolo ogni volta che se ne trova uno maggiore

57 Algoritmo e dati Inizio V i no Fine max si no i=0 max=0 1 14 i<15
1 14 no i<15 Fine max si V[i]>max no max=V[i] i=i+1

58 Uso dei registri.. Memoria (mem) R3 R1 (i) R2(max) 1 14 Inizio
R3=0X1300 R3 R1 (i) 0x1300 1 14 R1<15 no Fine si mem[R3]>R2 no R2=mem[R3] R2(max) R1=R1+1 R3=R3+1

59 Soluzione prima versione
Inizio Memoria (mem) XORL R1,R1 XORL R2,R2 MOVL #1300h,R3 loop: CMPB #15,R1 JNC fine; //SALTA QUANDO R1=15 CMPB (R3),R2 JNC skip MVLB (R3),R2 skip: ADDL #1,R3 ADDB #1,R1 jmp loop fine: halt R1=0,R2=0 R3=0X1300 R3 R1 (i) 0x1300 1 14 R1>=15 si Fine no mem[R3]>R2 no si R2=mem[R3] R2(max) R1=R1+1 R3=R3+1

60 Osservazioni Parametri nel codice Uso di due registri
L’indirizzo dell’inizio del vettore Numero di elementi Uso di due registri Contare il numero di iterazioni Individuare l’elemento nel vettore in memoria

61 Direttiva di definizione costanti
label EQU n costante1 EQU 4 ;il simbolo costante1=4 costante2 EQU b ;il simbolo costante2=-5 costante EQU 0fffh ;il simbolo costante=4095 Il simbolo label è un numero puro che può essere utilizzato come un dato o un indirizzo. …. MOVB costante, R0 ; il byte all’indirizzo ; è spostato in R0 MOVB #costante,R1 ; R1=4095

62 Soluzione seconda versione
org 1400h base equ 1300h numel equ 15 code XORL R1,R1 XORL R2,R2 loop: CMPL #numel,R1 JNC fine; CMPB base(R1),R2 JNC skip MVLB base(R1),R2 skip: ADDB #1,R1 jmp loop fine: halt end org 1400h code XORL R1,R1 XORL R2,R2 MOVL #1300h,R3 loop: CMPB #15,R1 JNC fine; CMPB (R3),R2 JNC skip MVLB (R3),R2 skip: ADDL #1,R3 ADDB #1,R1 jmp loop fine: halt end

63 Soluzione terza versione
Un accesso in meno alla memoria org 1400h base equ 1300h numel equ 15 code XORL R1,R1 XORL R2,R2 MOVL #numel,R3 loop: CMPL R3,R1 JNC fine; CMPB base(R1),R2 JNC skip MVLB base(R1),R2 skip: ADDB #1,R1 jmp loop fine: halt end org 1400h base equ 1300h numel equ 15 code XORL R1,R1 XORL R2,R2 loop: CMPL #numel,R1 JNC fine; CMPB base(R1),R2 JNC skip MVLB Base(R1),R2 skip: ADDB #1,R1 jmp loop fine: halt end

64 Scrittura ed assemblaggio

65 Confronto modi indirizzamento
Problema dato un array di 10 longword allocato a partire dalla locazione 2500h costruirne l‘inverso a partire dalla locazione 3000h Soluzione 1: indirizzamento indiretto con registro Soluzione 2: indirizzamento con post-incremento e pre-decremento Soluzione 3: indirizzamento con spiazzamento

66 Il problema Array1 Array2 V1 V9 V2 V8 V3 … … Vi Vi … … V3 V8 V2 V9 V1
2500h V1 3000h V9 2504h V2 3004h V8 V3 . … 2508h … Vi . Vi … … V3 V8 V2 2536h V9 3036h V1

67 Soluzione 1: indirizzamento indiretto con registro

68 ORG 400H ;****************Dichiarazione Costanti******************** DIM EQU 10 ARRAY1 EQU 2500H ARRAY2 EQU 3000H ;******************Corpo del Programma********************* CODE MOVL #ARRAY1,R1 ; carica in R1 l'indirizzo base dell'array originale MOVL #ARRAY2,R2 ; carica in R2 l'indirizzo base dell'array invertito MOVL #DIM,R0 ; carica in R0 la dimensione (numero di elementi) dell'array da invertire SUBL #1,R0 ; decrementa il contatore R0, R0=#DIM-1 ASLL #2,R0 ; R0=R0*4, calcola l'offset da sommare all'ind.base ; del'array per ottenere l'ind. dell'ultimo elemento ADDL R0,R2 ; pone in R2 l'ind. dell'ultimo elemento dell'array MOVL #DIM,R0 ; ricarica la dimensione dell'array in R0 per usarlo come contatore REPEAT: MOVL (R1),(R2) ; copia memoria memoria di ARRAY1[i] in ARRAY2[#DIM-1-i] ; i=[0...#DIM-1] ADDL #4,R1 ; R1 ora punta all'elemento succ. di ARRAY1 SUBL #4,R2 ; R2 ora punta all'elemento prec. di ARRAY2 SUBL #1,R0 ; decrementa il contatore R0 di 1 JNZ REPEAT ; salta a REPEAT se R0 diverso da 0 HALT ; fine programma END

69 Soluzione 2: indirizzamento con post-incremento e pre-decremento

70 ORG 400H ;****************Dichiarazione Costanti******************** DIM EQU ? ARRAY1 EQU 2500H ARRAY2 EQU 3000H ;******************Corpo del Programma********************* CODE MOVL #ARRAY1,R1 ; carica in R1 l'indirizzo base dell'array originale MOVL #ARRAY2,R2 ; carica in R2 l'indirizzo base dell'array invertito MOVL #DIM,R0 ; carica in R0 la dimensione (numero di elementi) dell'array da invertire ASLL #2,R0 ; calcola l'offset da sommare ad #ARRAY2 per puntare locazione ; corrispondente a ARRAY2[#DIM] NB: se ARRAY2 è di dimensione #DIM ; allora ARRAY2[0..#DIM-1] ADDL R0,R2 ; R2 ora punta a ARRAY[#DIM] MOVL #DIM,R0 ; Inizializza R0 a #DIM REPEAT: MOVL (R1)+,-(R2) ; Copia memoria memoria dalla cella puntata da R1 in quella puntata da ; R2-4 (MOVL!). Alla fine del com. R1=R1+4, R2=R2-4 SUBL #1,R0 ; Decrementa il contatore R0 JNZ REPEAT ; Se R0!=0 salta a REPEAT HALT ; Fine programma END

71 Soluzione 3: indirizzamento con spiazzamento

72 ORG 400H ;****************Dichiarazione Costanti******************** DIM EQU ? ARRAY1 EQU 250H ARRAY2 EQU 278H ;******************Corpo del Programma********************* CODE MOVL #DIM,R0 ; carica in R0 la dimensione (numero di elementi) dell'array da invertire SUBL #1,R0 ; decrementa il contatore R0, R0=#DIM-1 ASLL #2,R0 ; R0=R0*4, calcola l'offset da sommare all'ind.base ; del'array per ottenere l'ind. dell'ultimo elemento (ARRAY[#DIM-1]) MOVL R0,R2 ; Copia il contenuto di R0 in R2 MOVL #DIM,R0 ; ed inizializza R0 a #DIM REPEAT: MOVL ARRAY1(R1),ARRAY2(R2) ; Copia memoria memoria dall'indirizzo ARRAY1[i] in ; ARRAY2[#DIM-1-i], i=[0..#DIM-1] ADDL #4,R1 ; Incrementa di 4 byte R1 (gli elementi dell'array sono longwords!) SUBL #4,R2 ; Decrementa di 4 byte R2 ; R1=i*4, R2=(#DIM-1-i)*4 SUBL #1,R0 ; Decrementa il contatore R0 JNZ REPEAT HALT END