corso di mal (micro assembly language) architettura degli
TRANSCRIPT
1 Architetture degli Elaboratori
Corso diCorso diArchitettura degli ElaboratoriArchitettura degli Elaboratori
Il livello della microarchitettura:il microprogramma per il Mic-1
che implementa IJVM (un esempio)
Matteo Baldoni
Dipartimento di InformaticaUniversità degli Studi di Torino
C.so Svizzera, 185 – I-10149 [email protected]
http:/ /www.di.unito.it/ ~baldoni
2 Architetture degli Elaboratori
MAL (Micro Assembly Language)MAL (Micro Assembly Language)
� Una notazione sintatticamente piu ̀leggibile degli 0 e 1, esempio:
� SP = SP + 1; rd
� Z = TOS; if (Z) goto L1; else goto L2 (nasconde TOS = TOS)
� Sono possibili assegmaneti multipli (in coerenza con l'uso del bus C)
� SP = MDR = SP + 1
xxxxxxxxx 000 00 110101 000001000 010 0100
xxxxxxxxx 000 00 110101 000001010 000 0100
xxxxxxxxx 001 00 010100 001000000 000 0111
3 Architetture degli Elaboratori
MAL (Micro Assembly Language)MAL (Micro Assembly Language)
� Ancora notazione
� MDR = H + SP
� MDR = SP + H è equivalente ma è preferibile che “H” sia l'operando di sinistra
� MDR = SP + MDR non è legale (le operazioni binarie hanno necessariamente H come operandodi sinistra)
xxxxxxxxx 000 00 111100 000000000 000 0100
4 Architetture degli Elaboratori
MAL (Micro Assembly Language)MAL (Micro Assembly Language)
� Per realizzare questa presentazione ho utilizzato il simulatore presente a questa pagina http:/ /www.ontko.com/mic1/
� L'esempio che vedremo (assegnamento.jas) mostra solo alcune delle istruzioni (forse le piu ̀semplici) ma da un'idea del funzionamento generale del microprogramma
� Comando:java -classpath classes.zip:. mic1sim mic1ijvm.mic1 assegnamento.ijvm
5 Architetture degli Elaboratori
MAL vs IJVMMAL vs IJVM
� Il microinterprete (livello 1) interpreta, pilotando il data-path, il programma scritto in IJVM (livello 2)
� Sia MAL che IJVM sono assemblati da opportuni programmi (l'assemblatore e il microassemblatore)
AssemblatoreIJVM
Programmain IJVM
Programmabinario
Microinterpretecaricato in ROM
OutputdelprogrammaIJVM
Micro-Assemblatore
MAL
Microinterpretescritto in MAL
Compilatore(es. javacc)
Programma inlinguaggio di alto livello (es. java)
6 Architetture degli Elaboratori
Un esempioUn esempio
� Vediamo l'esecuzione del calcolo dell'espressione a lato, si supponga che i e j abbiano offset 0 e 1 rispettivamente all'interno della procedura
� Si noti che l'espressione 3 + j e ̀in pratica riportata in RPN
� Il risultato dell'espressione si trovera ̀sul top dello operand stack, da qui prelevato e memorizzato in i
BIPUSH3
ILOADj
IADDISTORE
i
...i = 3 + j...
0x00x10x20x30x40x50x6
0x100x3
0x150x1
0x600x360x0
7 Architetture degli Elaboratori
Cycle 1: Via!Cycle 1: Via!
-----------------Start cycle 1----------------------goto 0x2MDR: Put 0x0H: Put 0x0ALU: 0 AND 0 = 0x0Goto ADDR: 0x2
BIPUSH3
ILOADj
IADDISTORE
i
In realta ̀questa istruzionesi trova all'indirizzo 0x0!
8 Architetture degli Elaboratori
Cycle 2: esegue Main1Cycle 2: esegue Main1BIPUSH
3ILOAD
jIADD
ISTOREi
richiesta la lettura di-----------------Start cycle 2----------------------PC=PC+1;fetch;goto (MBR)PC: Put FFFFFFFFH: Put 0x0ALU: 0 + B + 1 = 0x0PC: Store 0PC: Fetch byte 0MEM: Fetch from byte# 0x0 requested. Processing...Goto MBR: 0x0
9 Architetture degli Elaboratori
Cycle 3Cycle 3BIPUSH
3ILOAD
jIADD
ISTOREi
-----------------Start cycle 3----------------------goto 0x2MDR: Put 0x0H: Put 0x0ALU: 0 AND 0 = 0x0MEM: Fetch value 0x10 from address 0x0MBR: Store 0x10Goto ADDR: 0x2
memorizzato sul fronte di salita!
10 Architetture degli Elaboratori
Cycle 4: torna a Main1Cycle 4: torna a Main1BIPUSH
3ILOAD
jIADD
ISTOREi
-----------------Start cycle 4----------------------PC=PC+1;fetch;goto (MBR)PC: Put 0H: Put 0x0ALU: 0 + B + 1 = 0x1PC: Store 1PC: Fetch byte 1MEM: Fetch from byte# 0x1 requested. Processing...Goto MBR: 0x10
richiesta la lettura di
11 Architetture degli Elaboratori
Salto a più vie: goto (MBR)Salto a più vie: goto (MBR)
� La prima microistruzione della microprocedura che interpreta una determinata istruzione IJVM è memorizzata nel control store a partire dalla posizione data dal suo opcode che la rappresenta
Main1 goto (MBR)
0x10 microcodice della BIPUSH ....
0x60 microcodice della IADD ....
0x64 microcodice della ISUB ....
Control store
12 Architetture degli Elaboratori
Cycle 5: inizia la BIPUSHCycle 5: inizia la BIPUSHBIPUSH
3ILOAD
jIADD
ISTOREi
-----------------Start cycle 5----------------------SP=MAR=SP+1;goto 0x16SP: Put 0x8000H: Put 0x0ALU: 0 + B + 1 = 0x8001MAR: Store 0x8001SP: Store 0x8001MEM: Fetch value 0x3 from address 0x1MBR: Store 0x3Goto ADDR: 0x16
memorizzato sul fronte di salita!
13 Architetture degli Elaboratori
Cycle 6Cycle 6BIPUSH
3ILOAD
jIADD
ISTOREi
-----------------Start cycle 6----------------------PC=PC+1;fetch;goto 0x17PC: Put 1H: Put 0x0ALU: 0 + B + 1 = 0x2PC: Store 2PC: Fetch byte 2MEM: Fetch from byte# 0x2 requested. Processing...Goto ADDR: 0x17
richiesta la lettura di
14 Architetture degli Elaboratori
Cycle 7Cycle 7BIPUSH
3ILOAD
jIADD
ISTOREi
-----------------Start cycle 7----------------------TOS=MDR=MBR;wr;goto 0x2MBR: Put 0x3H: Put 0x0ALU: 0 OR B = 0x3MDR: Store 0x3TOS: Store 0x3MAR: Write to word 0x8001MDR: Write 0x3MEM: Write value 0x3 to word# 0x20004 requested. Processing...MEM: Fetch value 0x15 from address 0x2MBR: Store 0x15Goto ADDR: 0x2
nota: MBR conterra ̀l'opcodedi ILOAD solo alla fine di questociclo
durante il ciclo
Su display compareil valore memorizzatoa fine ciclo, durante ilfronte di salita delclock
15 Architetture degli Elaboratori
PC = PC + 1; fetchPC = PC + 1; fetch
� bipush2 è la microistruzione “PC = PC + 1; fetch”
� per microinterpretare la bipush sarebbero sufficienti le microistruzioni bipush1 e bipush3 ma...
� l'obiettivo è di arrivare al Main1 con memorizzato in MBR l'opcode dell'istruzione successiva in modo da non dover “perdere tempo” attraverso la microistruzione nop1 come durante lo start-up: è importante precaricare MBR durante la microinterpretazione di una istruzione con l'opcode dell'istruzione successiva
� pc = pc + 1; fetch non potrebbe essere la prima istruzione (perderei l'operando della bipush) né l'ultima (non ci sarebbe il tempo di attendere l'opcode dalla memoria prima di andare nuovamente a Main1)
16 Architetture degli Elaboratori
Cycle 8: torna a Main1Cycle 8: torna a Main1BIPUSH
3ILOAD
jIADD
ISTOREi
-----------------Start cycle 8----------------------PC=PC+1;fetch;goto (MBR)PC: Put 2H: Put 0x0ALU: 0 + B + 1 = 0x3PC: Store 3PC: Fetch byte 3MEM: Write value 0x3 to address 0x20004MEM: Fetch from byte# 0x3 requested. Processing...Goto MBR: 0x15
Nota: qui io salto a 0x15(attuale valore di MBR)e ho richiesto di caricareMBR (attendo il valore j)
17 Architetture degli Elaboratori
Cycle 9: inizia la ILOADCycle 9: inizia la ILOADBIPUSH
3ILOAD
jIADD
ISTOREi
-----------------Start cycle 9----------------------H=LV;goto 0x18LV: Put 0xC000H: Put 0x0ALU: 0 OR B = 0xC000H: Store 0xC000MEM: Fetch value 0x1 from address 0x3MBR: Store 0x1Goto ADDR: 0x18
e ̀un offset! va sommatoa LV per recuperare ilvalore di j
a fine ciclo si hail valore di MBR dallamemoria
18 Architetture degli Elaboratori
Cycle 10Cycle 10BIPUSH
3ILOAD
jIADD
ISTOREi
-----------------Start cycle 10----------------------MAR=H+MBRU;rd;goto 0x19MBR: Put 0x1H: Put 0xC000ALU: A + B = 0xC001MAR: Store 0xC001MAR: Read from word 0xC001MEM: Read from word# 0x30004 requested. Processing...Goto ADDR: 0x19
e ̀un offset! va sommatoa LV per recuperare ilvalore di j
MAR ora contienel'indirizzo di j e puo`quindi recuperarneil valore
MAR * 4!
19 Architetture degli Elaboratori
Cycle 11Cycle 11BIPUSH
3ILOAD
jIADD
ISTOREi
-----------------Start cycle 11----------------------SP=MAR=SP+1;goto 0x1ASP: Put 0x8001H: Put 0xC000ALU: 0 + B + 1 = 0x8002MAR: Store 0x8002SP: Store 0x8002MDR: Read 0x0MEM: Read value 0x0 from address 0x30004Goto ADDR: 0x1A
In MDR, a fine ciclo,e ̀disponibile in valore di j
prepara lo spazio sul topdello stack per mettere ilvalore di MDR
20 Architetture degli Elaboratori
Cycle 12Cycle 12BIPUSH
3ILOAD
jIADD
ISTOREi
-----------------Start cycle 12----------------------PC=PC+1;wr;fetch;goto 0x1BPC: Put 3H: Put 0xC000ALU: 0 + B + 1 = 0x4PC: Store 4PC: Fetch byte 4MAR: Write to word 0x8002MDR: Write 0x0MEM: Write value 0x0 to word# 0x20008 requested. Processing...MEM: Fetch from byte# 0x4 requested. Processing...Goto ADDR: 0x1B
Ordina il caricamento dellaprossima istruzione e lascrittura del valore in MDR sultop dello stack
21 Architetture degli Elaboratori
Cycle 13Cycle 13BIPUSH
3ILOAD
jIADD
ISTOREi
-----------------Start cycle 13----------------------TOS=MDR;goto 0x2MDR: Put 0x0H: Put 0xC000ALU: 0 OR B = 0x0TOS: Store 0x0MEM: Write value 0x0 to address 0x20008MEM: Fetch value 0x60 from address 0x4MBR: Store 0x60Goto ADDR: 0x2
Aggiorna il valore del registro TOS(Top Of the Stack) e torna al cicloprincipale (in MBR addento per fineciclo la prossima istruzione)
opcode di IADD
22 Architetture degli Elaboratori
Cycle 14: torna al Main1Cycle 14: torna al Main1
-----------------Start cycle 14----------------------PC=PC+1;fetch;goto (MBR)PC: Put 4H: Put 0xC000ALU: 0 + B + 1 = 0x5PC: Store 5PC: Fetch byte 5MEM: Fetch from byte# 0x5 requested. Processing...Goto MBR: 0x60
richiede la prossimaistruzione
BIPUSH3
ILOADj
IADDISTORE
i
23 Architetture degli Elaboratori
Cycle 15: inizia IADDCycle 15: inizia IADD
-----------------Start cycle 15----------------------SP=MAR=SP-1;rd;goto 0x3SP: Put 0x8002H: Put 0xC000ALU: NOT 0 + B = 0x8001MAR: Store 0x8001SP: Store 0x8001MAR: Read from word 0x8001MEM: Read from word# 0x20004 requested. Processing...MEM: Fetch value 0x36 from address 0x5MBR: Store 0x36Goto ADDR: 0x3
in MBR e ̀arrivatol'opcode di ISTORE
BIPUSH3
ILOADj
IADDISTORE
i
Richiede in memoria il valoredel top dello stack - 1 (il secondoaddendo, il primo e ̀gia ̀in TOS)
24 Architetture degli Elaboratori
Cycle 16Cycle 16
-----------------Start cycle 16----------------------H=TOS;goto 0x4TOS: Put 0x0H: Put 0xC000ALU: 0 OR B = 0x0H: Store 0x0MDR: Read 0x3MEM: Read value 0x3 from address 0x20004Goto ADDR: 0x4
BIPUSH3
ILOADj
IADDISTORE
i
Sposta TOS in H mentre attende il secondo addendo che sara ̀inMDR a fine di questo ciclo
Il valore in top dellostack - 1
25 Architetture degli Elaboratori
Cycle 17Cycle 17
-----------------Start cycle 17----------------------TOS=MDR=H+MDR;wr;goto 0x2MDR: Put 0x3H: Put 0x0ALU: A + B = 0x3MDR: Store 0x3TOS: Store 0x3MAR: Write to word 0x8001MDR: Write 0x3MEM: Write value 0x3 to word# 0x20004 requested. Processing...Goto ADDR: 0x2
BIPUSH3
ILOADj
IADDISTORE
i
Somma il valore in MDR a H, lorimette in MDR e ordina la scritturae quindi torna a Main1
Nota: MAR contenevagia ̀l'indice correttoper la memorizzazionedel risultato
26 Architetture degli Elaboratori
Cycle 18: torna a Main1Cycle 18: torna a Main1
-----------------Start cycle 18----------------------PC=PC+1;fetch;goto (MBR)PC: Put 5H: Put 0x0ALU: 0 + B + 1 = 0x6PC: Store 6PC: Fetch byte 6MEM: Write value 0x3 to address 0x20004MEM: Fetch from byte# 0x6 requested. Processing...Goto MBR: 0x36
Richiede l'operando di ISTORE esalta al suo codice
BIPUSH3
ILOADj
IADDISTORE
i
27 Architetture degli Elaboratori
Cycle 19: inizia ISTORECycle 19: inizia ISTORE
-----------------Start cycle 19----------------------H=LV;goto 0x1CLV: Put 0xC000H: Put 0x0ALU: 0 OR B = 0xC000H: Store 0xC000MEM: Fetch value 0x0 from address 0x6MBR: Store 0x0Goto ADDR: 0x1C
Mi preparo a sommare a LV l'offsetche sto attendendo per la fine diquesto ciclo
BIPUSH3
ILOADj
IADDISTORE
i
A fine ciclo e ̀arrivatol'offset della variabile i
28 Architetture degli Elaboratori
Cycle 20Cycle 20
-----------------Start cycle 20----------------------MAR=H+MBRU;goto 0x1DMBR: Put 0x0H: Put 0xC000ALU: A + B = 0xC000MAR: Store 0xC000Goto ADDR: 0x1D
Sommo a H (base del record di attivazione) il valore dell'offsetdella variabile i
BIPUSH3
ILOADj
IADDISTORE
i
29 Architetture degli Elaboratori
Cycle 21Cycle 21
-----------------Start cycle 21----------------------MDR=TOS;wr;goto 0x1ETOS: Put 0x3H: Put 0xC000ALU: 0 OR B = 0x3MDR: Store 0x3MAR: Write to word 0xC000MDR: Write 0x3MEM: Write value 0x3 to word# 0x30000 requested. Processing...Goto ADDR: 0x1E
Preparo in MDR il valore dascrivere nella variabile i, quindirichiedo la scrittura
BIPUSH3
ILOADj
IADDISTORE
i
Nota: TOS mi fa risparmiarequi una lettura in memoria!
30 Architetture degli Elaboratori
Cycle 22Cycle 22
-----------------Start cycle 22----------------------SP=MAR=SP-1;rd;goto 0x1FSP: Put 0x8001H: Put 0xC000ALU: NOT 0 + B = 0x8000MAR: Store 0x8000SP: Store 0x8000MAR: Read from word 0x8000MEM: Write value 0x3 to address 0x30000MEM: Read from word# 0x20000 requested. Processing...Goto ADDR: 0x1F
Richiedo in memoria il nuovo valoredel top dello stack
BIPUSH3
ILOADj
IADDISTORE
i
L'ALU fa semplicementepassare non modificato il valore
31 Architetture degli Elaboratori
Cycle 23Cycle 23
-----------------Start cycle 23----------------------PC=PC+1;fetch;goto 0x20PC: Put 6H: Put 0xC000ALU: 0 + B + 1 = 0x7PC: Store 7PC: Fetch byte 7MDR: Read 0x0MEM: Read value 0x0 from address 0x20000MEM: Fetch from byte# 0x7 requested. Processing...Goto ADDR: 0x20
Carico il prossimo opcode mentreattendo che il valore richiesto in memoria arrivi alla fine di questo ciclo
BIPUSH3
ILOADj
IADDISTORE
i...
32 Architetture degli Elaboratori
Cycle 24Cycle 24
-----------------Start cycle 24----------------------TOS=MDR;goto 0x2MDR: Put 0x0H: Put 0xC000ALU: 0 OR B = 0x0TOS: Store 0x0MEM: Fetch value 0x0 from address 0x7MBR: Store 0x0Goto ADDR: 0x2
Salvo il valore del top dello stackattuale in TOS e torno a Main1
BIPUSH3
ILOADj
IADDISTORE
i...
33 Architetture degli Elaboratori
Cycle 25Cycle 25
-----------------Start cycle 25----------------------PC=PC+1;fetch;goto (MBR)PC: Put 7H: Put 0xC000ALU: 0 + B + 1 = 0x8PC: Store 8PC: Fetch byte 8MEM: Fetch from byte# 0x8 requested. Processing...Goto MBR: 0x0
Parte per nuove frontiere... di microinterpretazione!!
BIPUSH3
ILOADj
IADDISTORE
i...
34 Architetture degli Elaboratori
Il microprogramma Mic-1Il microprogramma Mic-1
� Main1: microistruzione che si occupa di effettuare un salto multiplo alla parte di microprogramma che microinterpreta le varie istruzioni del livello ISA
� NOP: nessuna operazione
35 Architetture degli Elaboratori
Il microprogramma Mic-1Il microprogramma Mic-1
� IADD: pop di due parole dallo stack; push della loro somma
� ISUB: pop due parole dallo stack; push la loro differenza
� IAND: pop di due parole dallo stack; push dell'AND logico
� IOR: pop di due parole dallo stack; push dell'OR logico
36 Architetture degli Elaboratori
Il microprogramma Mic-1Il microprogramma Mic-1� DUP: copia della prima parola sullo stack e push
� POP: cancella una parola
� SWAP: scambia le due parole in cima allo stack
� BIPUSH byte: push di un byte sullo stack
37 Architetture degli Elaboratori
Il microprogramma Mic-1Il microprogramma Mic-1
� ILOAD varnum: push di una variabile locale sullo stack
� ISTORE varnum: pop una parola dallo stack; push la loro differenza
� IINC varnum const: somma una costante a una variabile locale
38 Architetture degli Elaboratori
Il microprogramma Mic-1Il microprogramma Mic-1
� WIDE: prefisso; l'istruzione seguente ha un indirizzo di 16 bit
39 Architetture degli Elaboratori
Il microprogramma Mic-1Il microprogramma Mic-1
� LDCW index: push di una costante dalla constant pool sullo stack
� Analoga allaILOAD ma:
� carica dal constant pool
� usa un offset di 16 bit
40 Architetture degli Elaboratori
Il microprogramma Mic-1Il microprogramma Mic-1� GOTO offset: branch non condizionato
L'offset e ̀relativo all'istruzione di GOTO, quindi devo prelevare tale indirizzo, il microprogrammasalta a questa microproceduraabbiamo gia ̀ordinato la lettura del prossimo byte (che sara ̀disponibile a fine di questa istruzione)
offset con segno!
41 Architetture degli Elaboratori
Il microprogramma Mic-1Il microprogramma Mic-1
� IFEQ offset: pop di una parola e branch se e ̀zero
� IFLT offset: pop di una parola e branch se e ̀negativa
passa nell'ALU senzaessere memorizzata(attiva solo l'opportunobit di controllo)
stesso di goto1
42 Architetture degli Elaboratori
Il microprogramma Mic-1Il microprogramma Mic-1
� IFICMPEQ offset: pop di due parole dallo stack; branch se sono uguali
43 Architetture degli Elaboratori
Il microprogramma Mic-1Il microprogramma Mic-1
� INVOKEVIRTUAL disp: chiama un metodo
2 byte!
44 Architetture degli Elaboratori
Dettaglio della INVOKEVIRTUALDettaglio della INVOKEVIRTUAL
...
SP
LV
objrefpar1par2
disp e ̀memorizzatosu due byte, carica ilsecondo byte, il primosara ̀disponibile allafine di questo ciclo
45 Architetture degli Elaboratori
Dettaglio della INVOKEVIRTUALDettaglio della INVOKEVIRTUAL
...
SP
LV
objrefpar1par2
In H e ̀ora presentedisp, si carica quindiil valore dallamemoria con offset disp nel constant pool
46 Architetture degli Elaboratori
Dettaglio della INVOKEVIRTUALDettaglio della INVOKEVIRTUAL
...
SP
LV
objrefpar1par2
In OPC abbiamo l'indirizzodi ritorno (l'istruzionesuccessiva al valoredi disp appena caricato
47 Architetture degli Elaboratori
Dettaglio della INVOKEVIRTUALDettaglio della INVOKEVIRTUAL
...
SP
LV
objrefpar1par2
I primi due byte delcodice del metodocontiene l'indicazionedel numero di parametriche viene caricato nel registro H (compresoobjref!), nel nostro caso 3
48 Architetture degli Elaboratori
Dettaglio della INVOKEVIRTUALDettaglio della INVOKEVIRTUAL
...
SP
LV
objrefpar1par2
I secondi due byte contengono il numero diparametri locali, siincomincia a caricare ilprimo byte
49 Architetture degli Elaboratori
Dettaglio della INVOKEVIRTUALDettaglio della INVOKEVIRTUAL
...
SP
LV
objrefpar1par2
I secondi due byte contengono il numero diparametri locali, siincomincia a caricare ilprimo byte
SP-3SP-3+1
50 Architetture degli Elaboratori
Dettaglio della INVOKEVIRTUALDettaglio della INVOKEVIRTUAL
...
SP
LV
objrefpar1par2
I secondi due byte contengono il numero diparametri locali, sicarica il secondo, quindisi pone il risultato nelregistro H, nel nostro caso 1
loc1
MAR
51 Architetture degli Elaboratori
Dettaglio della INVOKEVIRTUALDettaglio della INVOKEVIRTUAL
...
SP
LV
SP+1+1par1par2
I secondi due byte contengono il numero diparametri locali, sicarica il secondo, quindisi pone il risultato nelregistro H, nel nostro caso 1
loc1SP+1+1
MAR
MDR
52 Architetture degli Elaboratori
Dettaglio della INVOKEVIRTUALDettaglio della INVOKEVIRTUAL
...LV
linkpar1par2
Viene salvato l'indirizzodi ritorno sopra le variabililocali che era statomemorizzato su OPC
loc1ind ritorno SP
MDR
MAR
53 Architetture degli Elaboratori
Dettaglio della INVOKEVIRTUALDettaglio della INVOKEVIRTUAL
...LV
linkpar1par2
Viene salvato il basepointer del metodochiamante
loc1ind ritorno
SPMAR
LV
54 Architetture degli Elaboratori
Dettaglio della INVOKEVIRTUALDettaglio della INVOKEVIRTUAL
...LV
linkpar1par2
Si carica l'opcodesuccessivo, vienefatto ora perche ̀siadisponibile alla finedella prossima micro-istruzione per andarepoi a Main1
loc1ind ritorno
SPMAR
LV
55 Architetture degli Elaboratori
Dettaglio della INVOKEVIRTUALDettaglio della INVOKEVIRTUAL
...
LVlinkpar1par2
Viene aggiornato il base pointeralla base delnuovo recod diattivazione e si puo`procedere per lamicrointerpretazionedel codice del metodo
loc1ind ritorno
SPMAR
LV
56 Architetture degli Elaboratori
Il microprogramma Mic-1Il microprogramma Mic-1� IRETURN: ritorno da un metodo con un valore intero
57 Architetture degli Elaboratori
IRETURN: dettaglioIRETURN: dettaglio
...
LVlinkpar1par2loc1
ind ritorno
SPLV
Sul top dello stack c'e ̀ilvalore di ritorno calcolatodal metodo
valore rit.
58 Architetture degli Elaboratori
IRETURN: dettaglioIRETURN: dettaglio
...
LVlinkpar1par2loc1
ind ritorno
SP
LV
Si ripristina lo stackpointer alla base delloattuale record diattivazione e si carica l'indirizzo che puntaall'indirizzo di ritorno
valore rit.
MAR
59 Architetture degli Elaboratori
IRETURN: dettaglioIRETURN: dettaglio
...
LV
linkpar1par2loc1
ind ritorno
SP
LV
Carica l'indirizzodi ritorno in MDR
valore rit.
MARMDR
60 Architetture degli Elaboratori
IRETURN: dettaglioIRETURN: dettaglio
...
LV
linkpar1par2loc1
ind ritorno
SP
LV
Carica in PC l'indirizzodi ritorno e leggel'opcode cosi ̀puntato,legge il vecchio basepointer che si trovasopra l'indirizzo diritorno e prepara lascrittura sul top dellostack del vare di ritorno
valore rit.
MAR
61 Architetture degli Elaboratori
IRETURN: dettaglioIRETURN: dettaglio
...LV
linkpar1par2loc1
ind ritorno
SP
LV
Ripristina il vecchiovalore di LV
valore rit.
MAR
62 Architetture degli Elaboratori
IRETURN: dettaglioIRETURN: dettaglio
...LV
valore rit SP
Mette sul top dellostack il valore diritorno del metodoche era stato memorizzatosu TOS e torna quindi aMain1 (in MBR ho gia`il nuovo opcode)
MAR