Il processore PD 32 Set Istruzioni Set Istruzioni

Il processore PD 32 Set Istruzioni

Set Istruzioni L’istruzione (almeno 32 bit) è divisa in più campi • codice operativo specifica operazione (classe e tipo) • parte indirizzo specifica modalità di uso deidati – registri interni – registri di memoria (più modalità) – dati immediati (ad es. costanti): memorizzati nei byte successivi • nome simbolico

Set Istruzioni • Sono organizzate in 8 classi (3 bit codice operativo specificano la classe) – – – – Movimento dati Aritmetiche (somma e sottrazione) Tipo Logico Rotazione e shift Operazioni sui bit di stato controllo del programma controllo della macchina ingresso/uscita

Formato istruzioni int i, j ……… i=i+j Programma compilatore Codice mnemonico Tipo di dato L (longword) W (word) B (byte) ADDW R 2 , R 1 Linguaggio Assembly Destinazione Sorgente (R 2+R 1 => R 1) Programma assemblatore (Assembler) 31 29 28 24 23 16 15 14 13 12 11 9 8 6 5 3 2 0 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)

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 Codice Operativo Specifica il tipo d’istruzione DATO K I/O S MODO S SORG MODO D Operandi Specifica i dati su cui operare DEST

Alcune istruzioni Assembler MOVB R 1, R 2 - copia il contenuto del primo byte di R 1 in R 2 MOVW R 1, (R 2) - copia il contenuto dei primi 2 byte di R 1 nei due byte di memoria il cui indirizzo iniziale memorizzato in R 2 MOVL (R 1), R 2 - copia in R 2 il contenuto dei 4 bytes di memoria il cui indirizzo è specificato in R 1 nel seguito s indica una lettera tra B (byte), W (word, 2 byte) L (long word, 4 byte) SUBs R 1, R 2 sottrai il contenuto del primo, dei primi 2 o i 4 bytes del registro R 1 con il corrispondente in R 2, il risultato memorizzalo in R 2 - ADDs #d, R 2 - addiziona al contenuto del registro R 2 la quantità d di dimensione s

Esempi di traduzione istruzioni assembler in linguaggio macchina MOVB R 4, R 3 Codice mnemonico CLASSE 001 31 29 28 formato dato campo s diretto con registro TIPO 0000 24 23 operandi e modo indiriz. operandi byte …. . … 4 00 000 16 15 14 13 12 11 3 100 9 8 Modo sorg 000 6 5 011 32 Modo dest 0

Esempi di traduzione istruzioni assembler in linguaggio macchina (cont. ) ADD B Codice mnemonico CLASSE 010 31 29 28 #20, R 3 formato dato campo s TIPO 0000 24 23 operandi e modo indiriz. operandi byte …. . … Indirizzamento Immediato Indirizzamento (vedi byte diretto con registro successivo) 00 16 15 14 13 12 11 001 …… 9 8 000 6 5 3 011 32 0 00010100 7 0

Ciclo Istruzione – Execute Nel PD 32 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) Entrambi gli operandi sono contenuti in registri interni del PD 32 (indirizzamento a registro) ADDW R 1, R 2 1) 2) 3) R 1 -> Temp 1 R 2 -> Temp 2 ALU-OUT (Temp 1+Temp 2) -> R 2 4) (nessun accesso a memoria esterna) Uno degli operandi (0 x 20) è definito nell’istruzione- L’assembler lo memorizza nella locazione di memoria esterna immediatamente successiva a quella contenente l’istruzione (indirizzamento immediato) ADDW #20 h, R 2 1) 2) 3) 4) PC -> MAR (MAR) -> MDR , R 2 -> Temp 1 MDR -> Temp 2, PC + 2 -> PC ALU-OUT (Temp 1+Temp 2) -> R 2 (1 accesso a memoria esterna)

Un esempio di programma assembler • Saldo (S) nelle 2 celle puntate da R 5 (dato di una parola) • Tre versamenti (V 1, V 2, V 3) immagazzinati nelle tre coppie di celle consecutive puntate da R 4 • Due prelievi (P 1, P 2) immagazzinati nelle due coppie di celle puntate da R 3 S=S+V 1+V 2+V 3 -P 1 -P 2

Un esempio di programma assembler

Altre istruzioni JMP SALTO INCONDIZIONATO JZ SALTO CONDIZIONATO HALT FINE PROGRAMMA MOVB #dato, R 1 ESTENSIONE SEGNO #dato sui rimanenti bits di R 1 MOVB #3, R 4 = 00 h 00 h 00000100 MOVB #-1, R 5 = FFh FFh 1111

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

Ipotesi Tutti i dati sono a 16 bit (word) Il saldo iniziale è memorizzato nella coppia di celle di indirizzo 00001 B 00 I movimenti (versamenti e prelievi) sono memorizzati in posizioni consecutive di memoria, a partire da quella di indirizzo 00001 F 00 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

Una prima soluzione

START R 5 punta al Saldo R 5: =1 B 00 R 4 punta al I vers. R 4: =1 F 00 R 0 memorizza il Saldo R 0: =(R 5) R 1 mem. il versamento R 1: =(R 4) R 1: =R 1+0 R 1=0 ? si JZ no R 0: =R 1+R 0 Somma al saldo il vers. R 4: =2+R 4 punta al vers. succ. (R 5): =R 0 ora in memoria c’è il saldo aggiornato HALT

Il codice ASSEMBLER

Una soluzione “equivalente”

START R 5 punta al Saldo R 5: =1 B 00 R 4 punta al I vers. R 4: =1 F 00 R 0 memorizza il Saldo R 0: =(R 5) Somma al saldo il vers. R 0: =R 0+(R 4) scrivi il saldo in memoria (R 5): =R 0 R 4 punta al vers. succ. R 4: =2+R 4 Somma al saldo il vers. R 0: =(R 4)+R 0 confronta il saldo attuale con il saldo in mem. R 1: =R 0 -(R 5) JNZ no HALT si

Assemblatore • Traduce il codice scritto in assembler in codice macchina • Ad ogni istruzione macchina è associato un codice mnemonico • 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.

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

Contenuto memoria 3 2 1 0 20 00 02 01 400 404 ? ? ? 00 ? ? ? 408 Prima istruzione Operando Seconda istruzione 0 x 20 00 02 01 400: 0010 0000 0010 0001 404: 0000 ….

Esempio MOVB #0, R 1 Indirizzo Iniziale

Altro esempio Il codice sarà caricato in posizione 0 x 600 ORG 600 H CODE movw r 2, r 1 movb #-2, r 0 HALT END 2000101081 2000000200 FE 1111 1110 Rappresentazione compl. a 2

Modi di indirizzamento • Stabiliscono la posizione degli operandi – Possono trovarsi nei registri (R 0. . R 7) – In memoria di lavoro (la posizione è stabilita dall’indirizzo di memoria in cui è memorizzato il valore) • Effective Address (EA): la posizione di un operando in memoria – EA può essere un registro o una locazione di memoria • Il valore di EA deve essere noto al tempo di esecuzione del programma (run-time); in generale non è noto al momento della sua scrittura (compiletime). Ciò consente di ottenere una grande flessibilità (rilocazione del codice)

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

Indirizzamento a registro • EA=Ri • Esempio: MOVL R 1, R 5 (significato: R 1 ->R 5)

Indirizzamento immediato • Il dato si trova in memoria immediatamente dopo l’istruzione • Esempio: MOVL #0, R 5 (significato: poni 0 in R 5) il dato è memorizzato nei 4 byte successivi al codice dell’istruzione

Indirizzamento assoluto • MOVL R 1, 1280 H (assegna il valore di R 1 alla cella di memoria di indirizzo 1280 H) • 1280 H, è memorizzato dopo l’istruzione ed è riferito da PC dopo che è stato incrementato) • Effective address = 1280 H

Indirizzamento relativo • Usato nei salti, permette di aggiornare il PC con valori differenti di semplici incrementi. • JMP LABEL(PC) (metti nel PC quanto ottenuto dalla somma del contenuto della locazione il cui indirizzo è dato da LABEL con il valore corrente del PC)

Indirizzamento relativo JMP LABEL(PC) (metti nel PC quanto ottenuto dalla somma del contenuto della locazione il cui indirizzo è dato da LABEL con il valore corrente del PC) • Label indica lo scostamento rispetto al valore corrente di PC • se il programma viene spostato in una diversa zona di memoria cambia il valore di PC in due diverse esecuzioni MA lo spostamento relativo non cambia • aritmetica in complemento a due (per permettere salti in avanti e indietro)

Indirizzamento indiretto con registro • Il registro contiene l’indirizzo dell’operando (corrisponde alla nozione di puntatore nei linguaggi di programmazione) • MOVL (R 5), R 1 (sposta in R 1 in contenuto della locazione di mem. il cui indirizzo è contenuto in R 5)

Indirizzamento indiretto con registro se si aggiorna il registro cambia l’indirizzo di memoria esempio inserendo in un ciclo il frammento di istruzioni ADDL (R 2), R 1 ADDB #4, R 2 - somma a R 1 il contenuto della locazione di mem. il cui indirizzo è contenuto in R 2) - somma 4 a R 2 permette di sommare a R 1 i contenuti di locazine di memoria successive - domanda perché somma 4 e non 1 o 2?

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

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 (R 7)+, R 1 (sposta in R 1 quanto memorizzato nella locazione il cui indirizzo è pari al contenuto in R 7, dopodiché incrementare di 4 ciò che è memorizzato in R 7)

Indirizzamento con spiazzamento • L’indirizzo effettivo dell’operando è la somma di un valore base (mem. in un reg. ) con il valore di spiazzamento • Esempio: MOVL D(R 0), R 1 (significato: sposta in R 1 il contenuto della con indirizzo D+R 0)

Indirizzamento Riepilogo org 400 h code movl #20, r 1 addl r 1, r 1 ; r 1=20, ind. immediato ; r 1=40, ind. a registro movb #0 FFh, 800 h ; mem[0 x 800]=0 x. FF, ind. assoluto movl #800 h, r 2 movb #0 EEh, (r 2) ; r 2=0 x 800 ; mem[r 2]=0 x. EE, ind. con registro movb #0 FFh, -(r 2) ; r 2=0 x 800 -0 x 1=0 x 7 FF, mem[0 x 7 FF]=0 x. FF ; ind. con predecremento movb #0 AAh, (r 2)+ ; mem[0 x 7 FF]=0 x. AA, r 2=0 x 800 ; ind. con postincremento ; mem[0 x 808]=0 x. FF, r 2=0 x 800 ; ind. con spiazzamento movb #0 FFh, 8(r 2) end

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

Istruzioni Movimento dati

Istruzioni MOVs • Sono usate per copiare dati da – Registro-registro • movl r 1, r 2 – Registro-memoria • movl r 1, (r 2) – Memoria-registro • movl (r 1), r 2 – Memoria-memoria • movl (r 1), (r 2)

Istruzioni aritmetiche

Registri di stato il registro di stato contiene informazioni sull’ultima operazione eseguita • • • Carry, C: 1 se c’e’ stato riporto Negative, N: 1 se risultato ultima oper. è neg. Zero, Z: 1 se ultima oper. ha 0 come risultato o. Verflow, V: 1 se ultima oper. da overflow Parity, P: 1 se risultato ult. oper. ha numero pari di 1 Interrupt enable: se la CPU può accettare interruzioni esterne (es. per operazioni di I/O)

Istruzione CMPs effettua la sottrazione SENZA modificare la destinazione es. CMPL R 1, R 2 sottrai R 1 a R 2 aggiorna registro stato ma NON modificare R 2 registri di stato di interesse aritmetico Z risultato è zero C segnala segno (ricorda la rappresentazione circuito per la sottrazione in compl. a 2)

Istruzione CMPs effettua la sottrazione SENZA modificare la destinazione es. CMPL R 1, R 2

Confronto fra registri Aritmetica non segnata • CMPL R 1, R 2 (ipotesi: R 1, R 2>=0) – Equivale ad eseguire R 2 -R 1 senza aggiornare R 2 CMPL R 1, R 2 Z=0 C=1 C=0 R 2 -R 1<0 (R 1>R 2) Z=1 R 2 -R 1>=0 R 1=R 2 R 1<>R 2 (R 1<=R 2) Z=0 R 1<R 2 C=1 R 1>R 2 Z=1 R 1=R 2 C=0 and Z=0 R 1<R 2 not C=0 R 1<=R 2 Z=0 R 1<>R 2 Z=1 or C=1 R 1>=R 2

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

Esempio … movl #100, r 1 movl #99, r 2 ; a questo punto r 1 ed r 2 ; contengono valori positivi cmpl r 1, r 2 ; c=1, n=1, z=0 movl #100, r 2 cmpl r 1, r 2 ; c=0, n=0, z=1 movl #101, r 2 cmpl r 1, r 2 … ; c=0, n=0, z=0

Istruzioni controllo di programma

Istruzioni di controllo esecuzione Istruzioni di salto incondizionato JMP, JSR, RET, RTI – JMP: serve a modificare il contenuto del PC – JSR: modifica il contenuto del PC ma SALVA il valore corrente del PC in una pila (utile nelle chiamate di sottoprogramma) – RET modifica il valore del PC con il valore salvato precedentemente in cima alla pila – RTI come RET ma quando il salto è causato da una interruzione

Istruzioni di controllo esecuzione Istruzioni di salto condizionato: J, JN – 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 (o. Verflow), 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 R 1, R 2 (esegue R 2 -R 1, non modifica R 2)

Esempio R 1>R 2 si: R 1>R 2 no: R 1<=R 2 I 1 I 2 cmpl R 1 R 2 JC L 2: Istruzione I 1 Istruzione I 2 cmpl R 1 R 2 JNC L 2 ; se R 1>R 2 ; salta ad I 2 L 2: Istruzione I 1 Istruzione I 2 ; se R 1<=R 2 ; salta ad I 2 I 1

Esempio if R 1>R 2 then <I 1> else <I 2> <I 3> no: R 1<=R 2 R 1>R 2 I 2 si: R 1>R 2 cmpl R 1 R 2 JNC L 2 ; R 2 -R 1 ; se R 2<=R 1 ; esegui I 2 L 1: I 1 jmp L 3 ; ramo then L 2: I 2 ; ramo else L 3: I 3 ; continua I 1 I 3

Istruzioni controllo macchina: CLASSE 0

Istruzioni di tipo logico: Classe 3

Istruzioni di rotazione e shift Classe 4

Istruzioni di rotazione e shift

Istruzioni (sottoinsieme) di Ingresso Uscita Classe 7

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 15 interi fra 0 e 255 Programma Valore massimo

Esempio programma assembly (cont) • Decidere tipo e numero variabili da usare – Dove memorizzare i valori in ingresso • -> Vettore V di 15 elementi – Quali variabili ausiliare sono necessarie – Dove memorizzare il valore di uscita • registro • Algoritmo che risolve il problema – ipotizzare come valore massimo 0 e confrontarlo con tutti i 15 valori, aggiornandolo ogni volta che se ne trova uno maggiore

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

Uso dei registri. . Memoria (mem) R 3 0 x 1300 R 1 (i) 0 1 14 Inizio R 1=0, R 2=0 R 3=0 X 1300 R 1<15 si mem[R 3]>R 2 R 2(max) no R 2=mem[R 3] R 1=R 1+1 R 3=R 3+1 no Fine

Soluzione prima versione Memoria (mem) R 3 0 x 1300 R 1 (i) 0 1 14 Inizio R 1=0, R 2=0 R 3=0 X 1300 R 1>=15 si Fine loop: CMPB #15, R 1 JNC fine; no mem[R 3]>R 2 si R 2=mem[R 3] R 2(max) XORL R 1, R 1 XORL R 2, R 2 MOVL #1300 h, R 3 no skip: R 1=R 1+1 R 3=R 3+1 fine: CMPB (R 3), R 2 JNC skip MVLB (R 3), R 2 ADDL #1, R 3 ADDB #1, R 1 jmp loop halt

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

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

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

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

Scrittura ed assemblaggio

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

Il problema Array 1 2500 h 2504 h 2508 h. . . 2536 h V 1 V 2 V 3 … Vi … V 8 V 9 Array 2 3000 h 3004 h. . 3036 h V 9 V 8 … Vi … V 3 V 2 V 1

Soluzione 1: indirizzamento indiretto con registro

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

Soluzione 2: indirizzamento con post- e pre-incremento

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

Soluzione 3: indirizzamento con spiazzamento

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