Il processore PD32 Set Istruzioni

Listruzione (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, R1 Codice mnemonico Sorgente Destinazione Tipo di dato Formato istruzioni L (longword) W (word) B (byte) Classe I/OL-W-BModo SgSorg.Modo Ds Linguaggio Assembly (R2+R1 => R1) Linguaggio Macchina (PD 32 ogni istruzione è rappresentata con 32 bit) Programma assemblatore (Assembler) Tipo 2316 K pos Dest int i,j ……… i = i + j Programma compilatore

Formato istruzioni Ogni istruzione (che non utilizza lindirizzamento immediato) è lunga 32 bit (4 byte) ed è composta da 9 campi Alcune istruzioni ignorano alcuni campi CLASSETIPODATO KI/OSMODO SSORGMODO DDEST Codice Operativo Operandi Specifica il tipo distruzione Specifica i dati su cui operare

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,R …..… Codice mnemonico formato dato campo s operandi e modo indiriz. operandi CLASSETIPO Modo destModo sorg diretto con registro 43

Indirizzamento Immediato (vedi byte successivo) byte ADD B #20,R …..…00001…… Codice mnemonico formato dato campo s operandi e modo indiriz. operandi CLASSETIPO Indirizzamento diretto con registro 3 Esempi di traduzione istruzioni assembler in linguaggio macchina (cont.)

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 nellistruzione- Lassembler lo memorizza nella locazione di memoria esterna immediatamente successiva a quella contenente listruzione (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

Altre istruzioni JMP SALTO INCONDIZIONATO JZ SALTO CONDIZIONATO HALTFINE PROGRAMMA MOVB #dato,R1 ESTENSIONE SEGNO #dato sui rimanenti bits di R1 MOVB #3,R4R4 = 00h MOVB #-1,R5R5 = FFh

Un programma per laggiornamento 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 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 Lultimo 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 no Somma al saldo il vers. R4 punta al vers. succ. ora in memoria cè il saldo aggiornato

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 allassemblatore 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 linizio 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 400H CODE movb #0,R1 HALT END operando istruzione H 02H 00H 20H 00H

Contenuto memoria ???00 ?? ? Prima istruzione Operando Seconda istruzione 0x : : 0000 ….

Esempio MOVB #0,R1 Indirizzo Iniziale

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

Modi di indirizzamento Stabiliscono la posizione degli operandi –Possono trovarsi nei registri (R0..R7) –In memoria di lavoro (la posizione è stabilita dallindirizzo 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 listruzione Esempio: MOVL #0,R5 (significato: poni 0 in R5) il dato è memorizzato nei 4 byte successivi al codice dellistruzione

Indirizzamento assoluto MOVL R1,1280H (assegna il valore di R1 alla cella di memoria di indirizzo 1280H) 1280H, è memorizzato dopo listruzione 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 lindirizzo delloperando (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 lindirizzo 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 lindirizzo delloperando 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 lindirizzo delloperando, 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 Lindirizzo effettivo delloperando è 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 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

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 sullultima operazione eseguita Carry, C: 1 se ce 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 modificare la destinazione es. CMPL R1,R2 sottrai R1 a R2 aggiorna registro stato ma NON modificare R2 registri di stato di interesse aritmetico Z risultato è zero C segnala segno (ricorda la rappresentazione circuito per la sottrazione in compl. a 2)

Istruzione CMP CMPs effettua la sottrazione SENZA modificare la 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=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

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

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 unistruzione. Si usa solitamente listruzione 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 I1 L2: Istruzione I2 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

Esempio R1>R2 I1I2 si: R1>R2no: 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 else

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 nellintervallo Programma 15 interi fra 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 dati Inizio Fine i=0 max=0 i<15 V[i]>max max=V[i] no si i=i+1 no V i max

Uso dei registri.. Memoria (mem) R1 (i) R2(max) R3 0x1300 Inizio Fine R1=0,R2=0 R3=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) R3 0x1300 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 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

Osservazioni Parametri nel codice –Lindirizzo dellinizio del vettore –Numero di elementi Uso di due registri –Contare il numero di iterazioni –Individuare lelemento 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 allindirizzo 4095 ; è spostato in R0 MOVB #costante,R1; R1=4095

Soluzione seconda versione 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 org 1400h base equ 1300h numel equ 15 code XORL R1,R1 XORL R2,R2 loop: CMPB #numel,R1 JNC fine; CMPB base(R1),R2 JNC skip MVLB base(R1),R2 skip: ADDB #1,R1 jmp loop fine:halt end

Soluzione terza versione org 1400h base equ 1300h numel equ 15 code XORL R1,R1 XORL R2,R2 loop: CMPL #numel,R1 JNC fine; movb base(R1),R3 CMPB R3,R2 JNC skip MVLB R3,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 Un accesso in meno alla memoria

Scrittura ed assemblaggio

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

Il problema V1 V2 Array1Array2 2500h 2504h 2508h h V3 … Vi … V8 V9 V8 … Vi … V3 V2 V1 V9 3000h 3004h 3036h

Soluzione 1: indirizzamento indiretto con registro

ORG 400H ;****************Dichiarazione Costanti******************** DIM EQU 10 ARRAY1 EQU 2500H ARRAY2 EQU 3000H ;******************Corpo del Programma********************* CODE XORL R0,R0 ; resetta R0 XORL R1,R1 ; resetta R1 XORL R2,R2 ; resetta R2 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

Soluzione 2: indirizzamento con post- e pre-incremento

ORG 400H ;****************Dichiarazione Costanti******************** DIM EQU ? ARRAY1 EQU 2500H ARRAY2 EQU 3000H ;******************Corpo del Programma********************* CODE XORL R0,R0 ; resetta R0 XORL R1,R1 ; resetta R1 XORL R2,R2 ; resetta R2 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

Soluzione 3: indirizzamento con spiazzamento

ORG 400H ;****************Dichiarazione Costanti******************** DIM EQU ? ARRAY1 EQU 250H ARRAY2 EQU 278H ;******************Corpo del Programma********************* CODE XORL R0,R0 ; resetta R0 XORL R1,R1 ; resetta R1 XORL R2,R2 ; resetta R2 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

Ordinamento per selezione (selection-sort) Si cerca lelemento più piccolo e si scambia con lelemento in posizione i=0 Si cerca lelemento più piccolo tra i rimanenti N-i e si scambia con lelemento in posizione i, per i=1..N-1

org 400h ARRAY EQU 200h; indirizzo base array DIM EQU 4; num.elementi array code XORL R0,R0 ;registro posizione di inizio della ricerca del minimo XORL R1,R1 ;minimo temporaneo XORL R4,R4 ;registro contenente il dato da analizzare iniziomin: CMPB #DIM,R0 ;R0-DIM JZ fine XORL R3,R3 ;registro di spiazzamento MOVL R0,R3 ;copio per usare R0 come spiazzamento MOVB ARRAY(R3),R1 ;inizializzo il minimo parziale ciclomin: CMPL #DIM,R3 ;R3-DIM JZ finemin MOVB ARRAY(R3),R4 ;R4 <= Valore corrente dell'array ADDL #1,R3 CMPB R4,R1 ;R1-R4 se R4 < R1 allora Carry = 0 ed R4 è il nuovo minimo JC ciclomin MOVB R4,R1 ;swap minimo MOVB R3,R5 ;mi salvo la posizione JMP ciclomin finemin: SUBB #1,R5 MOVB ARRAY(R0),ARRAY(R5) ;swap con il valore da ordinare MOVB R1,ARRAY(R0) ADDL #1,R0 ;aumento la posizione del vettore JMP iniziomin fine: halt end