Sei sulla pagina 1di 32

PD-32

Architettura assembler
Punto di vista del programmatore
CPU
Registri
Bit di condizione
Unita per op.
logico-aritmetiche
NENOR!A
!ndirizzo
Dati
!struzioni
Calcolatori Elettronici, Beraldi, aa05f06
Codice
Dati
statici
Stack
27FC
0
R7
.
.
R0
R. Stato
!l processore dal punto di vista del programmatore
CPU
Disp. !fO
Calcolatori Elettronici, Beraldi, aa05f06
!l simulatore.
Classi di istruzioni
Controllo della macchina (classe 0)
HALT, NOP, RESET
Novimento dati (classe 1)
NOvL,.
Aritmetiche (classe 2)
ADDL ,.
Tipo Logico (classe 3)
AND,..
Rotazione e shift (classe +)
ASLW, .
Operazioni sui bit di stato (classe 5)
SET!, ..
Controllo del programma (classe 6)
JNP, ..
!ngressofUscita (classe 7)
!NW, ..
OPs SORG,DEST
Sintassi
s=B,W,L
Calcolatori Elettronici, Beraldi, aa05f06
Assembly PD32
Un programma in
Assembly PD32
composto da un un solo
file sorgente, composto da
una sequenza di statment
Non previsto il linker"
per collegare diversi
moduli
ORG <indirizzo in memoria>
<D!RETT!vE>
CODE
<COD!CE>
END
Calcolatori Elettronici, Beraldi, aa05f06
Direttive per la definizione di dati
DB Define Byte (riserva un'area dati per un byte)
DW Define Word
DL Define Long Word
org 400h
varByte DB 11h
varWord DW 1122h
varLong DL 11223344h
code
end
33
44
.
22
11
22
11
11 0x+00
NENOR!A
Calcolatori Elettronici, Beraldi, aa05f06
Direttive per la definizione di dati
C Assembly
int x=1,y=2;
double z=3;
int a[3]={0,1,2};
int main ()
{
return (1);
}
x DW 1
y DW 2
z DL 3
a DW 0,1,2
!n altri ambienti, es. NASN, presenta la clausola times"
che consente di ripetere la direttiva. Non esiste nell'assemblatore
del pd32
Calcolatori Elettronici, Beraldi, aa05f06
Copiare dati da una posto ad un altro un'operazione
fondamentale in assembly.
L'istruzione per copiare dati l'istruzione NOvE"
NOvs <SORGENTE><DEST!NAZ!ONE>
s = B,L,W
Muovere i dati
Calcolatori Elettronici, Beraldi, aa05f06
Esempio: indirizzamento immediato
C Assembly
int a;
int main ()
{
a = 123;
}
A DW 0
CODE
MOVW #123,A
END
Calcolatori Elettronici, Beraldi, aa05f06
Indirizzamento immediato {modo 1)
Esempio: NOvL #123,R5
R5 123" (Poni il valore 123 in R5)
!l dato si trova in memoria immediatamente dopo l'istruzione
Calcolatori Elettronici, Beraldi, aa05f06
Esempio: indirizzamento assoluto
C Assembly
int a;
int b;
int main ()
{
a = 123;
b = a;
}
ORG 400H
A DW 0
B DW 0
CODE
MOVW #123,A
MOVW A,B
END
A e B rappresentano l'indirizzo effettivo (EA) in memoria..
NEN[0x+00|NEN[0x402|
Quante volte accedo in memoria?
Prelevo EA di A e di B, leggo il valore di A e scrivo il valore in B: + volte
Indirizzamento assoluto {modo 2)
Esempio: NOvB R1, 1280H
MEM[12S0h] R1
8
Calcolatori Elettronici, Beraldi, aa05f06
Esempio: indirizzamento diretto a registro
C Assembly
int a;
int b;
int main ()
{
a = 123;
b = a;
}
CODE
MOVW #123, R0
MOVW R0,R1
END
Se i registri possono essere usati per contenere variabili il tempo di
esecuzione dimunisce rispetto al caso in cui gli operandi sono in RAN
R0 A, R1 B
Calcolatori Elettronici, Beraldi, aa05f06
Indirizzamento diretto a registro {modo 0)
Esempio: NOvL R1,R5
!l valore in R1 non viene cancellato. Si tratta in realta di una
copia.
R5 R1 (copia la longword da R1 in R5)
Calcolatori Elettronici, Beraldi, aa05f06
!l carattere #
C Assembly
#define CONST 3
int a;
int main ()
{
a = CONST;
}
A DW 0
CONST EQU 3
CODE
MOVW #CONST, A
END
Costanti sono utili per parametrizzare il programma.
Con EQU, cosi come per le #define in C, non viene riservata alcuna memoria.
Calcolatori Elettronici, Beraldi, aa05f06
!l carattere #
C Assembly
int a;
int* pi;
int main ()
{
pi = &a;
}
A DW 0
PI DL 0
CODE
MOVL #A, PI
END
Se premesso ad una variabile il carattere # denota l'indirizzo della variabile
Equivale all'operatore addressOf del C
Calcolatori Elettronici, Beraldi, aa05f06
!l carattere #
org 400h
varByte db 11h
varWord dw 1122h
varLong dl 11223344h
code
MOVB varByte, R0 ; R0 MEM[400]
MOVL #varByte, R0 ; R0 0x400
MOVL #varWord, R0 ; R0 0x401
HALT
end
Calcolatori Elettronici, Beraldi, aa05f06
!ndirizzamento indiretto con registro..
C Assembly
int a;
int* pi;
int main ()
{
pi = &a;
.
*pi = 123;
}
A DW 0
CODE
; pi corrisponde ad r0
MOVL #A, R0
;.
MOVW #123,(R0)
END
Nediante questo tipo di indirizzamento, l'indirizzo di un operando contenuto in
in registro.
Corrisponde alla nozione di puntatore
!ndirizzamento indiretto con spiazzamento
C Assembly
int a[5]={0,1,2,3,4};
int main ()
{
a[4] = 123;
}
A DW 0,1,2,3,4
CODE
MOVL #A, R0
MOVW #123,4(R0)
END
Utile per trattare array
Calcolatori Elettronici, Beraldi, aa05f06
!struzioni aritmetiche
Hanno sintassi <OPs> <S><REG>
OP indica l'operatore (ad esempio, ADD)
s la dimensione (B,W,L)
S la sorgente
(individuata mediante qualunque indirizzamento)
REG, un registro (R0.R7)
Gli operandi di partenza sono in <S> e <REG>, il risultato scritto in
<REG>
Solo valori interi in complemento a 2
Alcune !SA ammettono 3 operandi
!A-6+ (ADD r1,r2,r3)
Calcolatori Elettronici, Beraldi, aa05f06
!struzioni aritmetiche: addizione
Esempio: ADDs R0,R1; R1R0+R1
C Assembly
int a = 1;
int b = 2;
int c;
int main ()
{
c=a+b;
}
A DW 1
B DW 2
C DW 0
CODE
MOVW A,R0
ADDW B, R0
MOVW R0,C
END
Uso R0 come registro temporaneo
Calcolatori Elettronici, Beraldi, aa05f06
Status register
Fornisce informazioni sullo stato della CPU
Carry
1 se l'ultima l'operazione eseguita ha prodotto un riporto
Attenzione in caso di sottrazione il significato Borrow
Negative
1 se l'ultima operazione eseguita ha prodotto un valore negativo
Zero
1 se l'ultima operazione eseguita ha avuto risultato nullo
overflow
1 se l'ultima operazione eseguita ha provocato overflow
Parity
1 se il risultato delll'ultima operazione eseguita ha un numero pari di
bit
!nterrupt enable
Se posto ad 1 abilita la CPU ad accettare interruzioni
Calcolatori Elettronici, Beraldi, aa05f06
!struzioni aritmetiche: sottrazione.
Esempio: SUBs R0,R1; R1R0-R1
ORG 400h
code
MOVB #8,R0
MOVB #7,R1
SUBB R0,R1; 7-8
end
PR!NA
DOPO
-Carry (Borrow) = 1 il risultato ha generato prestito
-Negative =1, il risultato negativo (ossia NSB=1)
-Parity =1, il numero di 1 del risultato pari
Calcolatori Elettronici, Beraldi, aa05f06
Relazione (d'ordine) fra 2 interi
caso unsigned"
A < B (ossia, A-B<0)
A = B (ossia A-B=0)
Se A-B<0 c=1
Se A-B=0 z=1
L'istruzione CONPARE" effettua la differenza non distruttiva
(ossia aggiorna il solo registro di stato)
CNPs R1,R2 come SUBs R1,R2 ma non aggiorna R2
Calcolatori Elettronici, Beraldi, aa05f06
Confronto fra valori positivi
R1>R2: R2-R1 c=1 CNPs R1,R2
R1 R2: R1-R2 c=0 CNPs R2,R1
R1 = R2: R1-R2 z=1 CNPs R2,R1 (oppure CNPs R1,R2)
R1<>R2: R1-R2 z=0 CNPs R2,R1 (oppure CNPs R1,R2)
S = B,W,L
Condizione
verifica
Calcolatori Elettronici, Beraldi, aa05f06
!struzione
Esempio, trova il massimo
C Assembly
int a=..;b=.;max;
int main ()
{
if (a>b) max=a;
else max=b;
}
ORG 400h
A DW ? ;Assumo una word per int.
B DW ?
MAX DW 0
CODE
MOVW B,R0
CMPW A,R0; B-A<0 ?
JNC ELSE ; no: B-A>=0 B>=A
THEN:
MOVW A,MAX
JMP FINE
ELSE:
MOVW B,MAX
FINE:
HALT
END
Calcolatori Elettronici, Beraldi, aa05f06
Construtto standard if-then-else
CNPL R1, R2 ;R2-R1
JNC ELSE ;c=0 se
; R2>=R1
THEN:
; !1 ;ramo then
JNP CONT
ELSE: ;ramo else
; !2
CONT:
; !3 ;continua
if {R1>R2) I1;
else I2;
I3
Codice C
Codice Assembler
R1>R2
I1 I2
si: R1>R2 no: R1<=R2
I3
ELSE THEN
Calcolatori Elettronici, Beraldi, aa05f06
Cicli a conteggio
C Assembly
int V[8];
int main ()
{
for (int i=0;i<8;i++)
V[i]=i;
}
ORG 400h
V DW 0,0,0,0,0,0,0,0
CODE
XORB R0,R0 ; i va in R0
MOVL #V,R1 ; indirizzo di V in r1
MOVB #8,R2; r2 per i
MOVB #1,r3 ; step incremento di i
FOR:
CMPB R2,R0; R0-R2<0 ?
JNC ENDFOR; no: R0>=R2 i>=8
MOVW R0,(R1)+
ADDL R3,R0
JMP FOR
ENDFOR:
HALT
END
Calcolatori Elettronici, Beraldi, aa05f06
Costrutti standard cicli
.
while {R1l=0) do {
I
}
.
Condizione
I
Condizione vera
Condizione
falsa
.
WH!LE: CNPL #0, R1
JZ EX!T
; !
JNP WH!LE
EX!T:
;
.
Calcolatori Elettronici, Beraldi, aa05f06
Costrutti standard cicli
.
do {
I
} while {R1l=0)
.
Condizione
I
Condizione vera
Condizione
falsa
DO:
; !
CNPL #0, R1
JNZ DO
;
.
Codice C-like
Calcolatori Elettronici, Beraldi, aa05f06
Tutte le istruzioni aritmetiche
Calcolatori Elettronici, Beraldi, aa05f06
Esercizi
Esercizio 1: Trovare il massimo in un vettore di interi positivi
Esercizio 2: Data una matrice, costruire un vettore con le
somme delle colonne
Calcolatori Elettronici, Beraldi, aa05f06
Esercizio
Problema
Trovare il massimo in un insieme di 15 interi positivi compresi
nell'intervallo 0..255
Programma
15 interi
fra 0 e 255
valore massimo
Calcolatori Elettronici, Beraldi, aa05f06

Dobbiamo stabilire
Che tipo e quante 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
Calcolatori Elettronici, Beraldi, aa05f06
Algoritmo e dati
!nizio
Fine
i=0
max=0
i<15
v[i|>max
max=v[i|
no
si
i=i+1
no
V
i
max
0
1
14
unsigned char max,i;
.
max=0;
for (i=0; i<15;i++)
if (v[i|>max) max=v[i|;
.
Calcolatori Elettronici, Beraldi, aa05f06
Uso dei registri come variabili
Memoria (mem)
R1 (i)
R2(max)
0
1
14
R3
0x300
!nizio
Fine
R1=0,R2=0
R3=0x300
R1<15
(R3)>R2
R2=(R3)
no
si
R1=R1+1
no
R3=R3+1
Calcolatori Elettronici, Beraldi, aa05f06
Soluzione prima versione
Memoria (mem)
R1 (i)
R2(max)
0
1
14
R3
0x300
XORL R1,R1
XORL R2,R2
NOvL #300h,R3
loop: CNPB #15,R1
JNC fine
CNPB (R3),R2
JNC skip
NvLB (R3),R2
skip: ADDL #1,R3
ADDB #1,R1
jmp loop
fine: halt
!nizio
Fine
R1=0,R2=0
R3=0x300
R1>=15
(R3)>R2
R2=(R3)
si
no
R1=R1+1
no
R3=R3+1
si
Calcolatori Elettronici, Beraldi, aa05f06
Osservazioni
Parametri nel codice
L'indirizzo dell'inizio del vettore
Numero di elementi
Uso di due registri
Contare il numero di iterazioni
!ndividuare l'elemento nel vettore in memoria
Calcolatori Elettronici, Beraldi, aa05f06
Soluzione seconda versione
org +00h
code
XORL R1,R1
XORL R2,R2
NOvL #300h,R3
loop: CNPB #15,R1
JNC fine;
CNPB (R3),R2
JNC skip
NvLB (R3),R2
skip: ADDL #1,R3
ADDB #1,R1
jmp loop
fine: halt
end
org +00h
base equ 300h
numel equ 15
code
XORL R1,R1
XORL R2,R2
loop:
CNPL #numel,R1
JNC fine;
CNPB base(R1),R2
JNC skip
NvLB base(R1),R2
skip:
ADDB #1,R1
jmp loop
fine: halt
end
Calcolatori Elettronici, Beraldi, aa05f06
Soluzione terza versione
org +00h
base equ 300h
numel equ 15
code
XORL R1,R1
XORL R2,R2
loop:
CNPL #numel,R1
JNC fine;
NOvB base(R1),R3
CNPB R3,R2
JNC skip
NvLB R3,R2
skip:
ADDB #1,R1
jmp loop
fine: halt
end
org +00h
base equ 300h
numel equ 15
code
XORL R1,R1
XORL R2,R2
loop:
CNPL #numel,R1
JNC fine;
CNPB base(R1),R2
JNC skip
NvLB Base(R1),R2
skip:
ADDB #1,R1
jmp loop
fine: halt
end
Un accesso in meno alla memoria
Calcolatori Elettronici, Beraldi, aa05f06
Istruzioni di rotazione e shift
Calcolatori Elettronici, Beraldi, aa05f06
Istruzioni di rotazione e shift
Calcolatori Elettronici, Beraldi, aa05f06
Esercizio
Assembly
int a = .;
char b;
int main ()
{
if(a%2==0)
b = 0;
else b = 1;
}
ORG 400h
A DW 1
B DB 0
CODE
MOVW A,R0
ASRW #1,R0
JC ELSE
MOVB #0,B
JMP FINE
ELSE:
MOVB #1,B
FINE:
HALT
END
Calcolatori Elettronici, Beraldi, aa05f06
Esercizio (cont)
int i,j,h,g,f,k;
..
main ()
{
.
case(k) {
case 0: f = i+j;break;
case 1: f = g+h;break;
case 2: f = g - h;break;
case 3: f = i - j;break;
}
}
R1 g
R2 i
R3 j
R4 k
R5 h
R6 f
Si implementa in memoria
una tavola di indirizzi di salto
(Jump Vector Table, JVT)
Case0
Case1
Case2
Case3
JvT[0|
JvT[1|
JvT[2|
JvT[3|
Calcolatori Elettronici, Beraldi, aa05f06
Esercizio
ORG 400h
JVA EQU 400h
JVT DL 0,0,0,0 ;Jump Vector
Table
CODE
movL #case0, JVA
movL #case1, JVA+4
movL #case2, JVA+8
movL #case3, JVA+12
movW #3, R4;esempio
aslW #2, R4
movL JVT(R4),R0
jmp (R0)
;..
Case0:
movW R2, R6
addW R3, R6
JMP Exit
Case1:
movW R1, R6
addW R5, R6
JMP Exit
Case2:
movW R1, R6
subW R5, R6
JMP Exit
Case3:
movW R2, R6
subW R3, R6
Exit:
HALT
END Calcolatori Elettronici, Beraldi, aa05f06
Istruzioni di tipo logico
0
1
1
0
A XOR B
1 1 1 1
1 0 0 1
1 0 1 0
0 0 0 0
A OR B A AND B B A
0 1
1 0
NOT A
Calcolatori Elettronici, Beraldi, aa05f06
Esercizio
Supponiamo che un carattere ASC!! sia memorizzato in una
variabile char. Scrivere un programma che modifichi il
contenuto di char in modo che il numero di bit pari ad 1 sia pari.
Calcolatori Elettronici, Beraldi, aa05f06
org +00h
char db 035
code
movb char,r0
andb r0,r0; aggiorna p
jp fine
orb #80h,r0; x80 = 1000000
movb r0,char
fine:
halt
end
Esercizio
Calcolatori Elettronici, Beraldi, aa05f06
Controllo del flusso di esecuzione
Salti condizionati (es: jc)
Salti incondizionati (jmp)
Subroutine (jsr.ret)
!nterrupt esterni
!nterrupt sw
non esistono nel PD32, ma sono il supporto fondamentale per
realizzare chiamate a sistema operativo (es: !NT 21)
Calcolatori Elettronici, Beraldi, aa05f06
Subroutine
E' il meccanismo base per realizzare la modularizzazione del
codice
Neccanismo di attivazione
Come attivarne l'esecuzione
Nodalita di passaggio dei parametri
Nediante lo stack, o se possibile registri
Calcolatori Elettronici, Beraldi, aa05f06
Meccanismo si attivazione subroutine e ritorno
Per attivare una subroutine JSR <indirizzo>
Salva il contenuto di PC (istruzione successiva alla JSR) in cima allo stack
Per ritornare da una subroutine RET
Copia in PC il contenuto della cima dello stack (l'esecuzione riprende
dall'istruzione successiva a JSR)
org 400h
code
jsr foo
halt
foo:
ret
end
+00: C1002010 jsr
+0+: 00000+0C
+08: 00000000 halt
+0C: C2002000 ret
PC: +00,+0C,+08
Calcolatori Elettronici, Beraldi, aa05f06
Meccanismo di attivazione
1. Controllo passato a CALCOLO
- PC!nirizzo di calcolo
2. Controllo ritorna al main
- PC !ndirizzo di ritorno
3. Chiamata di CALCOLO
+. Ritorno al chiamante
E' necessario memorizzare
l'indirizzo di ritorno
Si usa uno STACK
Cio consente l'attivazione ricorsiva
R7 punta all'elemento affiorante
Calcolatori Elettronici, Beraldi, aa05f06
Sottoprogrammi attivazione multipla
Calcolatori Elettronici, Beraldi, aa05f06
Stack Operazioni inserimentoJrimozione
Calcolatori Elettronici, Beraldi, aa05f06
Meccanismo di attivazione
.
JSR CALCOLO
.
CALCOLO:
...
RET
;chiamata.
PUSH PC .. Ossia -(R7)PC,
PC CALCOLO
;ritorno
POP PC,. ossia PC (R7)+
Calcolatori Elettronici, Beraldi, aa05f06
Passaggio dei parametri
!l chiamante puo usare lo stack per comunicare i valori dei
parametri su cui la subroutine puo agire
! valori sono scritti prima dell'attivazione della subroutine
Si accede ai dati per spiazzamento rispetto ad un indirizzo base,
di solito memorizzato in R6 (detto anche Base Pointer, o Frame
Pointer)
Calcolatori Elettronici, Beraldi, aa05f06
Schema passaggio parametri.
push R0 ; primo parametro
push R1 ; secondo parametro
jsr PROC; chiamo la subroutine
addl #8,R7; libera area dati: +*numero_parametri
.
PROC:
PUSH R6; salva vecchio Base Pointer
NOvL R7,R6; setta BP corrente
; primo parametro ad offset 8..
.
POP R6; ripristino BP
RET
R6 (old)
!ndirizzo ritorno
R6,R7
!
n
d
i
r
i
z
z
i

c
r
e
s
c
e
n
t
i
.
R0
R1
R6++
R6+8
R6+12
Calcolatori Elettronici, Beraldi, aa05f06
Allocazione variabili locali
.
PROC:
PUSH R6; salva vecchio Base Pointer
NOvL R7,R6; setta" BP corrente
SUBL #12,R7; alloca 12 byte
; i parametri sono sempre al solito offset.
.
ADDL#12,R7; libera 12 byte
POP R6; ripristino BP
RET
vAR_LOCALE
vAR_LOCALE
R6
!
n
d
i
r
i
z
z
i

c
r
e
s
c
e
n
t
i
.
R6 (old)
R0
R1
R6++
R6+8
R6+12
vAR_LOCALE
R7
!ndirizzo ritorno
Calcolatori Elettronici, Beraldi, aa05f06
Salvataggio del contesto.
.
PROC:
PUSH R6; salva vecchio Base Pointer
NOvL R7,R6; setta" BP corrente
SUBL #12,R7; alloca 12 byte
; i parametri sono sempre al solito offset.
PUSHSR; push status register
..
POPSR; pop status register
ADDL#12,R7; libera 12 byte
POP R6; ripristino BP
RET
SR
vAR_LOCALE
vAR_LOCALE
R6
!
n
d
i
r
i
z
z
i

c
r
e
s
c
e
n
t
i
.
R6 (old)
R0
R1
R6++
R6+8
R6+12
vAR_LOCALE
R7
!ndirizzo ritorno
Calcolatori Elettronici, Beraldi, aa05f06
Possibile ordine delle informazioni
Passaggio Parametri di ingresso e
di uscita
!l valore di ogni parametro
copiato dal chiamante nello stack
Per aumentare l'efficienza, se il
numero lo consente, si possono
usare i registri
!l chiamato salva il BP attuale
Necessario per piu chiamate
!l chiamato alloca, se necessario,
l'area dati per le variabili locali
!l chiamato salva, prima di usarli, i
registri che modifichera
(salvataggio del contesto)
BP
SP
Contesto
Variabili
locali
Parametri
Indirizzo
di ritorno
A

c
u
r
a

d
e
l

c
h
i
a
m
a
t
o
A cura del
chiamante
return address
parametro 1
parametro 2
.
parametro n
BP (old)
var locale 1
..
var locale m
.
..
+12
+4+4n
-4m
-4
+ byte
+S
Calcolatori Elettronici, Beraldi, aa05f06
Esempio: calcola massimo
void max (int,int,int*);
main (void) {
int
a=2, b=3, c;
max(a,b,8c)
)
void max(int x,int y, int* z)
{
if (x>y) *z=x;
*z=y;
)
Codice C
Calcolatori Elettronici, Beraldi, aa05f06
ORG +00h;
CODE
NA!N:
subl #12,R7; alloca lo spazio per a,b e c nello stack
movl #2,(R7) ; c = 2 ! c ! <--R7
movl #+,+(R7) ; b = 3 ! b !
movl #3,8(R7) ; a = + ! a !
;prepara i parametri da passare alla funzione
movl R7,R6 ; R6 Base Pointer...
push R6 ; passo 8c
push +(R6); copio b
push 8(R6); copio a
jsr max ;call max(a,b,8c) ;
addl #12,R7 ; dealloca area parametri
halt
NAX: ;max(int x,int y, int* z)
movl R7,R6 ; R6 come BP
pushsr ;salva il contesto
movl +(R6),R0 ; R0=x=a
movl 8(R6),R1 ; R1=y=b
movl 12(R6),R2 ; R2=z=8c
cmpl R1,R0 ;confronta x con y
jc skip ; y>x
movl R0,(R2) ; *z=x
jmp skip2
skip: movl R1,(R2) ;*z=y
skip2:
popsr ;ripristina il contesto
ret ;ritorna
END
a
b
c
Frame del main
R7
SR
RET
a
b
a
b
c
8c
BP (R6)
{ contesto {
{ ritorno {
{ parametri {
FP (R7)
Frame di max
Frame del main
Calcolatori Elettronici, Beraldi, aa05f06
Esempio: scambio di valori
void swap(int *x,int*y) {
int tmp;
tmp=*y;
*y=*x;
*x=tmp;
)
int a=2;
int b=3;
main () {
swap(8a,8b);
)
org +00h
a dl 0
b dl 3
CODE
MAIN:
movl #a,R0
push R0
movl #b,R0
push R0
jsr swap ; swap(8a,8b)
addl #8,R7
halt
SWAP:
movl R7,R6 ;salva BP
subl #+,R7 ;tmp in BP-+
push R0 ;contesto
push R1 ;
movl +(R6),R0 ;R0=8b=y
movl 8(R6),R1 ;R1=8a=x
movl (R0),-+(R6) ; tmp=*y
movl (R1),(R0) ; *y=*x
movl -+(R6),(R1) ; *x=tmp
pop R1 ;ripristino
pop R0 ;ripristino
addl #+,R7 ;libero area tmp
ret
END
Codice C
Calcolatori Elettronici, Beraldi, aa05f06