Il processore PD32 Set Istruzioni. Listruzione (almeno 32 bit) è divisa in più campi codice...

Il processore PD32

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

ADDW R2 , R1Codice mnemonico

Sorgente

DestinazioneTipo di dato

Formato istruzioni

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

Tipo23 16

K pos.15 14 13 12 11 9

Dest8 6 5 3 2 0

int i,j………i = i + j

Programma compilatore

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 tipod’istruzione

Specifica i dati su cui operare

Campo n°.Bits Commento

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

dato k 8

I/O 2

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

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

sorg3

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

dest3

Al''interno della classe viene indicato quale tra le operazioni disponibili deve essere eseguitaCampo contenente un dato utilizzato nelle istruzioni di rotazione e shift e nelle istruzioni di I/OCampo utilizzato nelle istruzioni di I/O, codifica il modo con cui l'indirizzo del device può essere recuperato

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

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

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

nel seguito s indica una lettera tra B (byte), W (word, 2 byte) L (long word, 4 byte)

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

byte

Esempi di traduzione istruzioni assembler in linguaggio macchina

MOVB R4,R3

001 0000 ….. … 00 000 100 000 011

Codice mnemonicoformato 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 destModo sorg

diretto con registro

4 3

Indirizzamento Immediato(vedi byte successivo)

byte

ADD B #20,R3

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

Codice mnemonicoformato 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 0

Ciclo Istruzione – Execute

Nel PD32 la fase di esecuzione di un ciclo istruzioneconsiste in un numero variabile di cicli macchina dipendente dal numero di accessi in memoria necessari (oltre al fetch)

ADDW R1, R2

1) R1 -> Temp12) R2 -> Temp23) ALU-OUT (Temp1+Temp2) -> R2

(nessun accesso a memoria esterna)

ADDW #20h, R2

1) PC -> MAR2) (MAR) -> MDR , R2 -> Temp13) MDR -> Temp2, PC + 2 -> PC4) ALU-OUT (Temp1+Temp2) -> R2

(1 accesso a memoria esterna)

Entrambi gli operandi sono contenutiin 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)

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

Un esempio di programma assembler

PC 1 MOVW (R5),R0 ; R0:=SPC+4 2 ADDW (R4),R0 ;R0:=R0+V1PC+8 3 ADDL #2,R4 ;punta al prossimo versamentoPC+16 4 ADDW (R4),R0 ;R0:=R0+V2PC+20 5 ADDL #2,R4 ;punta al prossimo versamentoPC+28 6 ADDW (R4),R0 ;R0:=R0+V3PC+32 7 SUBW (R3),R0 ;R0:=R0-P1PC+36 8 ADDL #2,R3 ;punta al prossimo prelievo

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

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

IpotesiTutti 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

Una prima soluzione

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

noSomma al saldo il vers.

R4 punta al vers. succ.

ora in memoria c’è il saldo aggiornato

INDIRIZZO CODICE COMMENTO0400 MOVL #1B00h,R5 ;inizializza il registro R50408 MOVL #1F00h,R4 ;inizializza il registro R40410 MOVW (R5),R0 ;carica in R0 il saldo attuale0414 MOVW (R4),R1 ;carica in R1 il movimento puntato da R40418 ADDW #0,R1 ;aggiorna il registro SR041E JZ 0440h

0426 ADDW R1,R0 ;aggiungi al saldo il movimento in R10430 ADDL #2,R4 ;incrementa il puntatore ai movimenti0438 JMP 0414h ;procedi con un nuovo movimento0440 MOVW R0,(R5) ;memorizza il nuovo saldo0444 HALT

;salta a memorizza il nuovo saldo se non vi sono altri movimenti

Il codice ASSEMBLER

Una soluzione “equivalente”

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

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,R1

• Significato: “Poni a 0 il byte meno signif. di R1”• Codice assembly

MOVB #0, R1

Tipo(byte) Sorgente

Destinazione

ORG 400HCODE

movb #0,R1HALT

END

operando

istruzione400

01H02H00H20H00H

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 0001404: 0000 ….

Esempio MOVB #0,R1 Indirizzo Iniziale

Altro esempio

ORG 600HCODE movw r2, r1 movb #-2, r0HALTEND

Il codice sarà caricato in posizione 0x600

20001010812000000200

FE

1111 1110Rappresentazione compl. a 2

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)

• 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 (compile-time). 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 R1,R5 (significato: R1->R5)

Indirizzamento immediato

• Il dato si trova in memoria immediatamente dopo l’istruzione

• Esempio: MOVL #0,R5 (significato: poni 0 in R5)

il dato èmemorizzato nei 4 byte successivi al codice dell’istruzione

Indirizzamento assoluto• MOVL R1,1280H (assegna il valore di R1 alla

cella di memoria di indirizzo 1280H) • 1280H, è memorizzato dopo l’istruzione ed è

riferito da PC dopo che è stato incrementato)• Effective address = 1280H

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 (R5),R1 (sposta in R1 in contenuto della locazione di mem. il cui indirizzo è contenuto in R5)

Indirizzamento indiretto con registro

se si aggiorna il registro cambia l’indirizzo di memoria

esempio inserendo in un ciclo il frammento di istruzioni

ADDL (R2),R1 ADDB #4, R2

- somma a R1 il contenuto della locazione di mem. il cui indirizzo è contenuto in R2)

- somma 4 a R2 permette di sommare a R1 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 R1,-(R7) (sposta nella locazione il cui indirizzo è pari al contenuto in R7 meno 4 ciò che è memorizzato in R1)

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)

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(R0),R1 (significato: sposta in R1 il contenuto della cella con indirizzo D+R0)

Indirizzamento Riepilogoorg 400hcodemovl #20, r1 ; r1=20, ind. immediatoaddl r1,r1 ; r1=40, ind. a registro

movb #0FFh, 800h ;mem[0x800]=0xFF, ind. assoluto

movl #800h,r2 ;r2=0x800movb #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

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 r1,r2

– Registro-memoria• movl r1,(r2)

– Memoria-registro• movl (r1),r2

– Memoria-memoria• movl (r1),(r2)

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• oVerflow, 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 CMP

CMPs effettua la sottrazione SENZA modificarela destinazione es. CMPL R1,R2

sottrai R1 a R2 aggiorna registro stato ma NON modificare R2

registri di stato di interesse aritmeticoZ risultato è zeroC segnala segno (ricorda la rappresentazione circuito per la sottrazione in compl. a 2)

Istruzione CMP

CMPs effettua la sottrazione SENZA modificarela destinazione es. CMPL R1,R2

Confronto fra registri Aritmetica non segnata

• CMPL R1,R2 (ipotesi: R1,R2>=0)– Equivale ad eseguire R2-R1 senza

aggiornare R2

CMPL R1,R2

R2-R1<0(R1>R2)

C=1C=0

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

Z=0

R1=R2

R1<R2

C=1 R1>R2Z=1 R1=R2C=0 and Z=0 R1<R2

C=0 R1<=R2Z=0 R1<>R2Z=1 or C=1 R1>=R2

Z=1

R1<>R2

Z=0

not

• CMPB R1,R2 Equivale ad eseguire R2-R1 senza aggiornare R2

CMPB R1,R2

R2-R1=0(R1=R2)

Z=1N=V

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

Z=0

R1<=R2

R1>R2

N=V R1>=R2N<>V R1<=R2

Z=1 R1=R2Z=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

Esempio

…

movl #100,r1

movl #99,r2 ; a questo punto 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…

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 (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 (esegue R2-R1, non modifica R2)

Esempio

R1>R2

I1

si: R1>R2

no: R1<=R2

cmpl R1 R2 JC L2 ;se R1>R2

;salta ad I2 Istruzione I1L2: Istruzione I2

I2

R1>R2

I1

si: R1>R2

no: R1<=R2

I2

cmpl R1 R2 JNC L2 ;se R1<=R2

;salta ad I2Istruzione I1

L2: Istruzione I2

Esempio

R1>R2

I1I2

si: R1>R2no: R1<=R2

cmpl R1 R2 ;R2-R1JNC L2 ;se R2<=R1

;esegui I2

L1: I1 ;ramo thenjmp L3

L2: I2 ;ramo else

L3: I3 ;continua

I3

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

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 7TIPO CODICE OPERANDI C N Z V P I COMMENTO

0 Ins dev, D0 - - - - - -

1 OUTs S,dev - - - - - -

2 START dev - - - - - -

3 CLEAR dev - - - - - -

Il dato contenuto nel buffer del device dev è

trasferito nella destinazione D0.

dev ->d0

Il dato sorgente S viene trasferito nel buffer del

device dev.S->dev

Viene azzerato il flip-flop STATUS del dev e viene

avviata l'operazione.

Viene azzerato il flip-flop STATUS del dev senza

avviare l'operazione.

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

Programma15 interifra 0 e 255

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 datiInizio

Fine

i=0max=0

i<15

V[i]>max

max=V[i]

no

si

i=i+1

no

V

i

max

0 1

14

Uso dei registri..Memoria (mem)

R1 (i)

R2(max)

0 1

14

R30x1300

Inizio

Fine

R1=0,R2=0R3=0X1300

R1<15

mem[R3]>R2

R2=mem[R3]

no

si

R1=R1+1

no

R3=R3+1

Soluzione prima versione

Memoria (mem)

R1 (i)

R2(max)

0 1

14

R30x1300

XORL R1,R1XORL R2,R2MOVL #1300h,R3

loop: CMPB #15,R1JNC fine;

CMPB (R3),R2JNC skipMVLB (R3),R2

skip: ADDL #1,R3ADDB #1,R1jmp loop

fine: halt

Inizio

Fine

R1=0,R2=0R3=0X1300

R1>=15

mem[R3]>R2

R2=mem[R3]

si

no

R1=R1+1

no

R3=R3+1

si

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

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

Soluzione seconda versione

org 1400hcode

XORL R1,R1XORL R2,R2MOVL #1300h,R3

loop:CMPB #15,R1JNC fine;

CMPB (R3),R2JNC skipMVLB (R3),R2

skip: ADDL #1,R3

ADDB #1,R1jmp loop

fine: halt

end

org 1400hbase equ 1300hnumel equ 15

codeXORL R1,R1XORL R2,R2

loop:CMPB #numel,R1JNC fine;CMPB base(R1),R2JNC skipMVLB base(R1),R2

skip: ADDB #1,R1jmp loop

fine: halt

end

Soluzione terza versione

org 1400hbase equ 1300hnumel equ 15

codeXORL R1,R1XORL R2,R2

loop:CMPL #numel,R1JNC fine;movb base(R1),R3CMPB R3,R2JNC skipMVLB R3,R2

skip: ADDB #1,R1jmp loop

fine: halt

end

org 1400hbase equ 1300hnumel equ 15

codeXORL R1,R1XORL R2,R2

loop:CMPL #numel,R1JNC fine;CMPB base(R1),R2JNC skipMVLB Base(R1),R2

skip: ADDB #1,R1jmp loop

fine: halt

end

Un accesso in meno alla memoria

Scrittura ed assemblaggio

• Problemadato un array di 10 longword allocato a partire dalla locazione 2500h costruirne l‘inverso a partire dalla locazione 3000h

Soluzione 1: indirizzamento indiretto con registroSoluzione 2: indirizzamento con post- e pre-incrementoSoluzione 3: indirizzamento con spiazzamento

Confronto modi indirizzamento

Il problema

V1V2

Array1 Array2

2500h

2504h

2508h

.

.

.

2536h

V3…Vi…V8V9

V8…Vi…V3V2V1

V93000h

3004h

3036h

.

.

.

.

Soluzione 1: indirizzamento indiretto con

registro

ORG 400H;****************Dichiarazione Costanti********************

DIM EQU 10ARRAY1 EQU 2500HARRAY2 EQU 3000H

;******************Corpo del Programma*********************CODE

XORL R0,R0 ; resetta R0XORL R1,R1 ; resetta R1XORL R2,R2 ; resetta R2

MOVL #ARRAY1,R1 ; carica in R1 l'indirizzo base dell'array originaleMOVL #ARRAY2,R2 ; carica in R2 l'indirizzo base dell'array invertitoMOVL #DIM,R0 ; carica in R0 la dimensione (numero di elementi) dell'array da invertire SUBL #1,R0 ; decrementa il contatore R0, R0=#DIM-1ASLL #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'arrayMOVL #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 ARRAY1SUBL #4,R2 ; R2 ora punta all'elemento prec. di ARRAY2SUBL #1,R0 ; decrementa il contatore R0 di 1JNZ REPEAT ; salta a REPEAT se R0 diverso da 0

HALT ; fine programmaEND

Soluzione 2: indirizzamento con post- e pre-incremento

ORG 400H;****************Dichiarazione Costanti********************

DIM EQU ?ARRAY1 EQU 2500HARRAY2 EQU 3000H

;******************Corpo del Programma*********************CODE

XORL R0,R0 ; resetta R0XORL R1,R1 ; resetta R1XORL R2,R2 ; resetta R2MOVL #ARRAY1,R1 ; carica in R1 l'indirizzo base dell'array originaleMOVL #ARRAY2,R2 ; carica in R2 l'indirizzo base dell'array invertitoMOVL #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-4SUBL #1,R0 ; Decrementa il contatore R0JNZ REPEAT ; Se R0!=0 salta a REPEAT

HALT ; Fine programmaEND

Soluzione 3: indirizzamento con spiazzamento

ORG 400H;****************Dichiarazione Costanti********************

DIM EQU ?ARRAY1 EQU 250HARRAY2 EQU 278H

;******************Corpo del Programma*********************CODE

XORL R0,R0 ; resetta R0XORL R1,R1 ; resetta R1

XORL R2,R2 ; resetta R2MOVL #DIM,R0 ; carica in R0 la dimensione (numero di elementi) dell'array da invertire SUBL #1,R0 ; decrementa il contatore R0, R0=#DIM-1ASLL #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 R2MOVL #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)*4SUBL #1,R0 ; Decrementa il contatore R0JNZ REPEAT

HALTEND

Ordinamento per selezione (selection-sort)• Si cerca l’elemento più piccolo e si scambia con l’elemento in posizione i=0

• Si cerca l’elemento più piccolo tra i rimanenti N-i e si scambia con l’elemento in

posizione i, per i=1..N-1

org 400hARRAY EQU 200h ; indirizzo base arrayDIM EQU 4 ; num.elementi arraycode

XORL R0,R0 ;registro posizione di inizio della ricerca del minimoXORL R1,R1 ;minimo temporaneoXORL R4,R4 ;registro contenente il dato da analizzare

iniziomin:CMPB #DIM,R0 ;R0-DIMJZ fineXORL R3,R3 ;registro di spiazzamentoMOVL R0,R3 ;copio per usare R0 come spiazzamentoMOVB ARRAY(R3),R1 ;inizializzo il minimo parziale

ciclomin:CMPL #DIM,R3 ;R3-DIMJZ fineminMOVB ARRAY(R3) ,R4 ;R4 <= Valore corrente dell'arrayADDL #1,R3CMPB R4,R1 ;R1-R4 se R4 < R1 allora Carry = 0 ed R4 è il nuovo minimoJC ciclominMOVB R4,R1 ;swap minimoMOVB R3,R5 ;mi salvo la posizioneJMP ciclomin

finemin:SUBB #1,R5MOVB ARRAY(R0),ARRAY(R5) ;swap con il valore da ordinareMOVB R1,ARRAY(R0)

ADDL #1,R0 ;aumento la posizione del vettoreJMP iniziomin

fine: haltend