Il processore PD32

(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)

ADDW R2 , R1

Codice mnemonico

Sorgente

Destinazione Tipo di dato

Formato Istruzione

L (longword) W (word) B (byte)

Classe I/O L-W-B Modo Sg Sorg. Modo Ds

Linguaggio Assembly (R2+R1 => R1)

Linguaggio Macchina (PD 32 ogni istruzione è rappresentata con 32 bit) Programma assemblatore (Assembler)

31 29 28 24

Tipo

23 16

K pos.

15 14 13 12 11 9

Dest

8 6 5 3 2 0

int i,j

………

i = i + j

Programma compilatore

(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

Codice Operativo Operandi

Specifica il tipo d’istruzione

Specifica i dati su cui operare

(5)

Campo n°.Bits Commento Classe

3 Indica la classe di istruzione (movimento dati, rotazione e shift, aritmetiche…)

Tipo 5 Al''interno della classe viene indicato quale tra le operazioni disponibili deve essere eseguita

dato k

8 Campo contenente un dato utilizzato nelle istruzioni di rotazione e shift e nelle istruzioni di I/O

I/O 2 Campo utilizzato nelle istruzioni di I/O, codifica il modo con cui l'indirizzo del device può essere recuperato

s 2 Indica il formato del dato che deve essere trattato dall'operazione.

modo s 3 Indica il modo di indirizzamento dell'operando sorgente.

sorg

3

In caso di indirizzamento diretto a registro, indiretto a registro, con predecremento e con postincremento indica uno degli otto registri di uso generale R0-R7

modo d 3 Indica il modo di indirizzamento dell'operando destinazione.

dest

3

In caso di indirizzamento diretto a registro, indiretto a registro, con predecremento e con postincremento indica uno degli otto registri di uso generale R0-R7

(6)

Ciclo Istruzione

(7)

PC

Il registro “Program Counter” contiene l’indirizzo da cui prelevare l’istruzione da eseguire.

Il SCO lo incrementa di 4 ad ogni fetch

IR = Instruction Register

Segnali di comando per la SCA e per lo SCO

Fetch

1) PC -> MAR 2) (MAR) -> MDR

3) MDR -> IR, PC + 4 -> PC

Bus memoria

^{MEMORIA DI}^LAVORO

Istruzione 1

Istruzione 2

Istruzione 3

Ciclo Istruzione - ^Fetch

(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)

byte

Esempi di traduzione istruzioni assembler in linguaggio macchina

MOVB R4,R3

001 0000 ….. … 00 000 100 000 011

Codice mnemonico formato dato campo s

operandi e modo indiriz. operandi

31 29 28 24 23 16 15 14 13 12 11 9 8 6 5 3 2 0

CLASSE TIPO

Modo dest Modo sorg

diretto con registro

4 3

(10)

Indirizzamento Immediato (vedi byte successivo) byte

ADD B #20,R3

010 0000 ….. … 00 001 …… 000 011

Codice mnemonico formato dato campo s

operandi e modo indiriz. operandi

31 29 28 24 23 16 15 14 13 12 11 9 8 6 5 3 2 0

CLASSE TIPO

Indirizzamento diretto con registro

3

Esempi di traduzione istruzioni assembler in linguaggio macchina (cont.)

00010100

7

(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)

ADDW R1, R2

1) R1 -> Temp1 2) R2 -> Temp2

3) ALU-OUT (Temp1+Temp2) -> R2 (nessun accesso a memoria esterna)

ADDW #20h, R2

1) PC -> MAR

2) (MAR) -> MDR , R2 -> Temp1 3) MDR -> Temp2, PC + 2 -> PC 4) ALU-OUT (Temp1+Temp2) -> R2

(1 accesso a memoria esterna)

Entrambi gli operandi sono contenuti in registri interni del PD32

(indirizzamento a registro)

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)

(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

PC 1 MOVW (R5),R0 ; R0:=S

PC+4 2 ADDW (R4),R0 ;R0:=R0+V1

PC+8 3 ADDB #2,R4 ;punta al prossimo versamento PC+13 4 ADDW (R4),R0 ;R0:=R0+V2

PC+17 5 ADDB #2,R4 ;punta al prossimo versamento PC+22 6 ADDW (R4),R0 ;R0:=R0+V3

PC+26 7 SUBW (R3),R0 ;R0:=R0-P1

PC+30 8 ADDB #2,R3 ;punta al prossimo prelievo PC+35 9 SUBW (R3),R0 ;R0:=R0-P2

PC+39 10 MOVW R0,(R5) ;S:=R0

(14)

Altre istruzioni

JMP SALTO INCONDIZIONATO

JZ SALTO CONDIZIONATO

HALT FINE PROGRAMMA

MOVB #dato,R1

ESTENSIONE SEGNO #dato sui rimanenti bits di R1

MOVB #3,R4 R4 = 00h 00h 00h 00000100

MOVB #-1,R5 R5 = FFh FFh FFh 11111111

(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:=1B00 R4:=1F00 R0:=(R5) R1:=(R4) R1:=R1+0

JZ

R0:=R1+R0 R4:=2+R4

(R5):=R0 HALT R5 punta al Saldo

R4 punta al I vers.

R0 memorizza il Saldo R1 mem. il versamento

R1=0 ?

si

no

Somma al saldo il vers.

R4 punta al vers. succ.

ora in memoria c’è il

saldo aggiornato

(19)

Il codice ASSEMBLER

(20)

Una soluzione “equivalente”

(21)

START R5:=1B00 R4:=1F00 R0:=(R5) R0:=R0+(R4)

(R5):=R0

JNZ R4:=2+R4 R0:=(R4)+R0

HALT R1:=R0-(R5) R5 punta al Saldo

R4 punta al I vers.

R0 memorizza il Saldo Somma al saldo il vers.

scrivi il saldo in memoria R4 punta al vers. succ.

Somma al saldo il vers.

confronta il saldo attuale

con il saldo in mem. si

no

(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 Tipo

(byte) Sorgente

Destinazione

ORG 400H CODE

movb #0,R1 HALT

END

operando istruzione

400

01H

02H

00H

20H

00H

(24)

Contenuto memoria

20 00 02 01

? ? ? 00

?? ?? ?? ?

3 2 1 0

400 404 408

Prima istruzione Operando

Seconda istruzione

0x20 00 02 01

400: 0010 0000 0000 0000 0000 0010 0000 0001

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

2000101081 2000000200

FE

1111 1110

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

codemovl #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

CMPB R1,R2

R2-R1<0 (R1>R2)

C=1

C=0

R2-R1>=0 (R1<=R2)

Z=0

R1=R2

R1<R2

C=1 R1>R2 Z=1  R1=R2

C=0 and Z=0  R1<R2

C=0 R1<=R2 Z=0  R1<>R2

Z=1 or C=1  R1>=R2 Z=1

R1<>R2

Z=0

not

(44)

• CMPB R1,R2

Equivale ad eseguire R2-R1 senza aggiornare R2

CMPB R1,R2

R2-R1=0 (R1=R2)

Z=1 N=V

R2-R1>=0 (R2>=R1)

Z=0

R1<=R2

R2>R1

N=V R1>=R2 N<>V  R1<=R2 Z=1  R1=R2 Z=0  R1<>R2 N<>V

R1<>R2

Z=0

Confronto fra registri

Aritmetica segnata

R1,R2 rappresentati in complemento a 2

Z=0

R1<R2

(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”, CMP s , 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

I1

si: R1>R2

no: R1<=R2

cmpl R1 R2

JC L2 ;se R1>R2 ;salta ad I2 Istruzione I1

I2

R1>R2

I1

si: R1>R2

no: R1<=R2

I2

cmpl R1 R2

JNC L2 ;se R1<=R2 ;salta ad I2 Istruzione I1

L2: Istruzione I2

(49)

Esempio

R1>R2

I1 I2

si: R1>R2 no: 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

I3

if R1>R2 then <I1> else <I2>

<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

TIPO CODICE OPERANDI C N Z V P I COMMENTO

0 Ins dev, D0 - - - - Il dato contenuto nel

buffer del device dev è trasferito nella destinazione D0.

dev ->d0

1 OUTs S,dev - - - - Il dato sorgente S

viene trasferito nel buffer del device dev.

S->dev

2 START dev - - - - Viene azzerato il flip-

flop STATUS del dev e viene avviata l'operazione.

3 CLEAR dev - - - - Viene azzerato il flip-

flop STATUS del dev senza avviare

(55)

Esempio programma assembly

• Problema

– Trovare il massimo in un insieme di 15 interi positivi

• Ipotesi

– Assumiamo che i valori siano compresi nell’intervallo 0..255

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

Fine

i=0max=0

i<15

V[i]>max max=V[i]

no si

i=i+1

no V

i

max

0 1

14

(58)

Uso dei registri..

Memoria (mem)

R1 (i)

R2(max)

0 1

14

R3

0x1300

Inizio

Fine R1=0,R2=0

R3=0X1300

R1<15

mem[R3]>R2

R2=mem[R3]

no

si

R1=R1+1

no

(59)

Soluzione prima versione

Memoria (mem)

R1 (i)

R2(max)

0 1

14

R3

0x1300

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 Inizio

Fine R1=0,R2=0

R3=0X1300

R1>=15

mem[R3]>R2

R2=mem[R3]

si

no

R1=R1+1

no

R3=R3+1 si

(60)

Osservazioni

• Parametri nel codice

– 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 -0101b ;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

4095 ; è spostato in R0

MOVB #costante,R1 ; R1=4095

(62)

Soluzione seconda versione

org 1400h code

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

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:

end

(63)

Soluzione terza versione

org 1400h

base equ 1300h numel equ 15 code

MOVL #numel,R3 loop:

CMPL R3,R1 JNC fine;

MVLB base(R1),R2 skip:

end org 1400h

base equ 1300h numel equ 15

code XORL R1,R1 XORL R2,R2 loop:

CMPL #numel,R1 JNC fine;

MVLB Base(R1),R2 skip:

end

Un accesso in meno alla memoria

(64)

Scrittura ed assemblaggio

(65)

• 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

Confronto modi indirizzamento

(66)

Il problema

V1 V2

Array1 Array2

2500h 2504h 2508h

. . . 2536h

V3

… Vi

… V8 V9

V8

… Vi

… V3 V2 V1 V9

3000h 3004h

3036h

.

(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

DIM EQU ?

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

DIM EQU ?

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

Il processore PD32