Емулатори

Hypo mašina
• ALU je aritmetičko-logička
jedinica.
• A je 8-bitni akumulator,
registar u kome se čuva
operand i rezultat aritmetičko-
logičke operacije.
• SP je 8-bitni pokazivač steka,
pokazuje na deo memorije koji se koristi za čuvanje sadržaja steka.
• X je 8-bitni indeksni registar, koji se koristi pri indeksiranju delova
memorije koji logički formiraju nizove podataka.
• Z, P, C su jednobitni statusni indikatori (flags), koji se postavljaju na
"tačno" kada operacija uzrokuje da se u registar upiše nula, pozitivna
vrednost ili kada se desi prenos iz razreda najviše težine, respektivno.
• IR je 8-bitni registar instrukcije, u kome se drži binarna vrednost opkoda
instrukcije koja se trenutno izvršava.
• PC je 8-bitni programski brojač, koji sadrži memorijsku adresu insrukcije
koja će se izvršiti kao sledeća.
• EAR je registar efektivne adrese, koji sadrži adresu operanda kojim
manipuliše tekuća instrukcija
 Hypo mašina
• Programski model
– typedef unsigned char bytes; // veličina memorijske reči je 1 bajt
struct processor {
bytes a, sp, x, ir, pc; // procesorski registri
bool z, p, c; // indikatori statusa izvršenja operacija
};
typedef enum { running, finished, nodata, baddata, badop } status;
// stanje CPUa (tokom emulacije)
processor cpu;
bytes mem[256]; // memorija ima 256 lokacija
status ps; // stanje CPUa (tokom emulacije)

• Set instrukcija
– formati mašinskih instrukcija (1 i 2 bajta):
• 1. bajt Operacioni kod
• 2. bajt Adresno polje
– Na narednim slajdovima prikazan je instrukcijski set. Instrukcije
označene sa * utiču na indikatore P i Z, a one označene sa + utiču na C.
 Jednobajtne instrukcije
Mne C PZ Hex Opis
Jednobajtne instrukcije:
NOP     00h Nema efekta (može da se koristi da se postavi prekidna tačka)
CLA     01h Postavljanje akumulatora A na nulu
CLC +   02h Postavljanje indikatora C na nula
CLX     03h Postavljanje indeksnog registra X na nulu
CMC +   04h Komplementiranje indikatora prenosa C
INC   * 05h Uvećavanje akumulatora A za 1
DEC   * 06h Smanjivanje akumulatora A za 1
INX   * 07h Uvećavanje indeksnog registera X za 1
DEX   * 08h Smanjivanje indeksnog registra X za 1
TAX     09h Kopiranje vrednosti akumulatora A u indeksni registar X
INI   * 0Ah Vrednost akumulatora A čita se sa ulaza kao dekadni broj
INH   * 0Bh Vrednost akumulatora A čita se sa ulaza kao heksadekadni broj
INB   * 0Ch Vrednost akumulatora A čita se sa ulaza kao binarni broj
INA   * 0Dh Vrednost akumulatora A je ASCII kod znaka koji se čita sa ulaza
OTI     0Eh Ispis vrednosti akumulatora A na izlazu kao označenog celog broja
OTC     0Fh Ispis vrednosti A na izlazu kao neoznačenog dekadnog broja
OTH     10h Ispis vrednosti A na izlazu kao neoznačenog heksadekadnog broja
OTB     11h Ispis vrednosti A na izlazu kao neoznačenog binarnog broja
OTA     12h Ispis vrednosti A na izlazu kao znaka
PSH     13h Umanjuje SP za 1 i stavlja vrednost akumulatora A na stek
POP   * 14h Skidanje vrednosti sa steka u A i uvećavanje SP za 1
SHL + * 15h Pomeranje sadržaja akumulatora A jedan bit ulevo
SHR + * 16h Pomeranje sadržaja akumulatora A jedan bit udesno
RET     17h Povratak iz potprograma (povratna adresa skida se sa steka)
HLT     18h Zaustavlja izvršavanje programa
Dvobajtne instrukcije
 Dvobajtne instrukcije
CMP B + * 2Ch Poređenje sadržaja A sa sadžajem memorijske lokacije sa adresom B

CPX B + * 2Dh Poređenje sadržaja A sa sadžajem memorijske lokacije sa adresom B+X

CPI B + * 2Eh Poređenje sadržaja A sa neposrednom vrednošću B

ANA B + * 2Fh Bitsko I sadržaja A sa sadržajem mem. lokacije sa adresom B
ANX B + * 30h Bitsko I sadržaja A sa sadžajem mem. lokacije sa adresom B+X
ANI B + * 31h Bitsko I sadržaja A sa neposrednom vrednošću B
ORA B + * 32h Bitsko ILI sadržaja A sa sadžajem memorijske lokacije sa adresom B

ORX B + * 33h Bitsko ILI sadržaja A sa sadžajem memorijske lokacije sa adresom B+X

ORI B + * 34h Bitsko ILI sadržaja A sa neposrednom vrednošću B

BRN B     35h Skok na adresu zadatu sa B
BZE B     36h Skok na adresu zadatu sa B ako indikator Z ima vrednost 1
BNZ B     37h Skok na adresu zadatu sa B ako indikator Z ima vrednost 0
BPZ B     38h Skok na adresu zadatu sa B ako P ima vrednost 1
BNG B     39h Skok na adresu zadatu sa B ako indikator P ima vrednost 0
BCC B     3Ah Skok na adresu zadatu sa B ako indikator C ima vrednost 0
BCS B     3Bh Skok na adresu zadatu sa B ako indikator C ima vrednost 1
JSR B     3Ch Poziv potrpograma na adresi B, uz stavljanje povratne adrese na stek
 Primjer – broj jedinica u učitanom broju

00 BEG ;Count the bits in a num

00 0A INI ; Read(A)
01 LOOP ; REPEAT
01 16 SHR ; A := A DIV 2
02 3A 0D BCC EVEN ; IF A MOD 2 # 0 THEN
04 1E 13 STA TEMP ; TEMP := A
06 19 14 LDA BITS
08 05 INC
09 1E 14 STA BITS ; BITS := BITS + 1
0B 19 13 LDA TEMP ; A := TEMP
0D 37 01 EVEN BNZ LOOP ; UNTIL A = 0
0F 19 14 LDA BITS ;
11 0E OTI ; Write(BITS)
12 18 HLT ; terminate execution
13 TEMP DS 1 ; VAR TEMP : BYTE
14 00 BITS DC 0 ; BITS : BYTE
15 END
 Zadatak 1.
Potrebno je sledeći program za hipotetičku mašinu statički rekompajlovati u x86 kod.
Pri tome, usvajamo sledeća preslikavanja:
Hipo mašina x86 kod
akumulator al
X cl
SP SP
PC IP
flegovi: C,Z,P FLAGS: C,Z, negirani S
BEG ; Count the bits in a num
LDI 127 ; A=127
LOOP ; REPEAT
SHR ; A := A DIV 2
BCC EVEN ; IF A MOD 2 # 0 THEN
STA TEMP ; TEMP := A
LDA BITS
INC
STA BITS ; BITS := BITS + 1
LDA TEMP ; A := TEMP
EVEN BNZ LOOP ; UNTIL A = 0
LDA BITS ;
OTI ; Write(BITS)
HLT ; terminate execution
TEMP DS 1 ; VAR TEMP : BYTE
BITS DC 0 ; BITS : BYTE
END
 Rešenje

• Jedna po jedna instrukcija hipo mašine se prevodi

odgovarajućom x86 instrukcijom ili nizom instrukcija.
Međutim, instrukcije se ne prevode potpuno izolovano
jedna od druge, nego je moguće izvršiti npr.
optimizaciju ažuriranja flegova.
 Rešenje
.386
.model flat, stdcall
INCLUDELIB kernel32.lib
 
STD_OUTPUT_HANDLE equ -11
GetStdHandle proto :dword
WriteConsoleA proto :dword, :dword, :dword, :dword, :dword
ExitProcess proto :dword
 
.data
temp db 0
bits db 0
 
.code
put_char PROC C znak:DWORD
push eax
push ebx
push ecx
sub esp, 4
 
INVOKE GetStdHandle, STD_OUTPUT_HANDLE
 
mov ebx, esp
mov ecx, ebp
add ecx, 8
INVOKE WriteConsoleA, eax, ecx, 1, ebx, 0
 
add esp, 4
pop ecx
pop ebx
pop eax
ret
put_char ENDP
 Rešenje
main: mov al,127 ; LDI 127 kod hipo mašine
lop: shr al,1 ; SHR
jnc even1 ; BCC EVEN
mov temp,al ; STA TEMP
mov al, bits ; LDA BITS
inc al ; INC
mov bits,al ; STA BITS
mov al, temp ; LDA TEMP
even1: test al,al ; prethodni mov ne menja flegove, pa mora test da ažurira Z
jnz lop ; BNZ LOOP
; prevod Write(BITS), znamo da je u pitanju jednocifren broj, inače je komplikovanije
mov dl, bits ; DL := bits (cifra za ispis)
add dl,30h ; DL := DL + 30h (u DL ide ASCII kod cifre za ispis)
push edx
call put_char ; funkcija koja će ispisati jedan znak na standardni izlaz
add esp, 4
; prevod HLT
INVOKE ExitProcess, 0
end main
 Zadatak 2.

• a) Za zadatu sekvencu koda za hipotetičku mašinu navesti

izgled ekvivalentne sekvence x86 koda, ako se prevođenje
vrši naredbu po naredbu bez optimizacije ALU indikatora.
• b) Isto to, ali sa optimizacijom ALU indikatora, da se računa
vrednost samo onih indikatora koji će biti upotrebljeni u
kodu.
LOOP1 ...
STA TEMP ; TEMP := A
LDA BITS
INC
STA BITS ; BITS := BITS + 1
LDA TEMP ; A := TEMP
BNZ LOOP1 ; UNTIL A = 0
 Rešenje
a) Koristimo preslikavanja kao u prethodnom zadatku. Želimo da se indikatori C,P i Z
hipotetičke mašine preslikaju na x86 flagove C, S (Sign) i Z. P i S imaju
komplementarno značenje, tako da pri ispitivanju u x86 kodu treba primeniti suprotan
uslov u odnosu na hipo mašinu. Dodatni problem je različit uticaj MOV instrukcija
kod x86 u odnosu na LDA kod hipo mašine:

x86

hipotetička mašina
Mnemon C PZ Hex Opis
LDA B * 19h Punjenje A sadržajem memorijske lokacije sa adresom B
STA B 1Eh Upis vrednosti akumulatora A u memorijsku lokaciju sa adresom B
INC * 05h Uvećavanje akumulatora A za 1
 Rešenje

• Prevod LDA B:
mov al, B mov al, B
jc CSET inc al
test al, al dec al
jmp KRAJ
CSET test al, al
stc
KRAJ ... loop1: ... loop1: ...
mov temp, al mov temp,al
mov al, bits mov al, bits
inc al inc al
dec al mov bits,al
inc al mov al, temp
mov bits, al test al,al
mov al, temp jnz lop
inc al
dec al
jnz loop1
 Zadatak 3.

• Potrebno je emulirati memoriju procesora koji

poseduje segmentno adresiranje. Adresa generisana
u programu Address relativna je u odnosu na početak
segmenta koji se čuva u registru BaseRegister.
Dužina segmenta čuva se u registru LimitRegister.
• Fizička memorija od adrese 0 do adrese ROMSIZE-1
je ROM, a ostatak je RAM. Napisati funkcije emulatora
za pristup memoriji. Adresiranje je na nivou jedne
memorijske reči.
 Rešenje

void WriteMemory(word Address, word Value) {

word RealAddress;
RealAddress = BaseRegister + Address;
if ((Address < LimitRegister) &&
(RealAddress > ROMSIZE)) {
Memory[RealAddress] = Value;
} else {
RaiseInterrupt(INT_SEGFAULT);
}
}
word ReadMemory(word Address) {
word RealAddress;
RealAddress = BaseRegister + Address;
if (Address < LimitRegister) {
return Memory[RealAddress];
} else {
RaiseInterrupt(INT_SEGFAULT);
return NULL;
}
}
 Zadatak 4.
Prikazati svaku promenu stanja u translacionom kešu dinamičkog rekompilatora za
dati kod hipotetičke mašine. Usvojiti mapiranja kao u zadatku 1. Početak memorije
emulirane mašine simbolički je označen sa MEM. Pretpostaviti da JIT kompajler pri
svakom pozivu obrađuje izvorišni kod do prve instrukcije skoka, ili do ranije
zapamćenog odredišta skoka.

BEG ; Count the bits in a num

MEM+0 LDI 127 ; A=127
MEM+2 LOOP ; REPEAT
MEM+2 SHR ; A := A DIV 2
MEM+3 BCC EVEN ; IF A MOD 2 # 0 THEN
MEM+5 STA TEMP ; TEMP := A
MEM+7 LDA BITS
MEM+9 INC
MEM+10 STA BITS ; BITS := BITS + 1
MEM+12 LDA TEMP ; A := TEMP
MEM+14 EVEN BNZ LOOP ; UNTIL A = 0
MEM+16 LDA BITS ;
MEM+18 OTI ; Write(BITS)
MEM+19 HLT ; terminate execution
MEM+20 TEMP DS 1 ; VAR TEMP : BYTE
MEM+21 BITS DC 0 ; BITS : BYTE
END
 Algoritam rada JIT emulatora
• int (*dyncode)(CPU *cpu);
 
do {
entrypoint = JIT_translate(cpu->PC);
dyncode = (int(*)(CPU*)) entrypoint
status = (*dyncode)(cpu)
} while (isNotEnd(status));

• Svaki put kada se pozove JIT_translate, vrši se prevođenje koda počev od

zadate adrese, zaključno sa prvom instrukcijom za kontrolu toka ili zaključno
sa instrukcijom neposredno pre adrese koja već postoji u translacionom
kešu.

• Pre izvršavanja svakog prevedenog bloka koda neophodno je restaurirati

kontekst emuliranog programa.

• Nakon izvršavanja svakog bloka koda dodaje se kod koji obezbeđuje čuvanje
konteksta emuliranog programa i skok na deo emulatora za preusmeravanje
na izvršavanje narednog bloka, a po potrebi i prethodno prevođenje istog.
 Pomoćna funkcija BranchHelper

• BranchHelper: (samo opis funkcije, mora biti realizovana u

x86 asm kodu)
– ako je CX jednako -1, skida okvir sa vrha steka i vraća se u
glavnu petlju, vraćajući status za kraj emulacije.
– poziva tcache_lookup() da mapira CX u adresu u kešu (blkN)
– ako je poziv uspešan, koristeći povratnu adresu na steku menja se
instrukcija lea cx, MEM+N u jmp blkN i kontrola prenosi na blkN
– U suprotnom (odredište nije u trans. cacheu)
• 3.1. sa steka se skida okvir BranchHelper funkcije, čime na vrhu
steka ostaje okvir kojim je pozvan prethodno izvršeni blok koda.
U tom okviru zapisana povratna adresa je adresa glavne petlje
emulatora.
• 3.2. stanje sačuvano u globalnim promjenljivim čuva u CPU
strukturi prosleđenoj pri pozivu prevedenog bloka iz glavne
petlje emulatora
• 3.3. izlazi se iz funkcije, čime se kontrola vraća u glavnu petlju
emulatora, vraćajući status kojim govori da emulacija još nije
završena.
 Rešenje (postavka)

BEG ; Count the bits in a num

MEM+0 LDI 127 ; A=127
MEM+2 LOOP ; REPEAT
MEM+2 SHR ; A := A DIV 2
MEM+3 BCC EVEN ; IF A MOD 2 # 0 THEN
MEM+5 STA TEMP ; TEMP := A
MEM+7 LDA BITS
MEM+9 INC
MEM+10 STA BITS ; BITS := BITS + 1
MEM+12 LDA TEMP ; A := TEMP
MEM+14 EVEN BNZ LOOP ; UNTIL A = 0
MEM+16 LDA BITS ;
MEM+18 OTI ; Write(BITS)
MEM+19 HLT ; terminate execution
MEM+20 TEMP DS 1 ; VAR TEMP : BYTE
MEM+21 BITS DC 0 ; BITS : BYTE
END
 Rešenje
Inicijalno stanje
Translacioni keš je prazan
Izvorišna adresa Adresa u kešu
MEM+0 -

Prva iteracija JIT algoritma -- poziv JIT_translate() za MEM+0 saveflags db 0

Sekvenca koda hipo mašine: saveal db 0
MEM+0
MEM+2 LOOP
LDI 127 ; A=127
; REPEAT savex db 0
MEM+2
MEM+3
SHR
BCC EVEN
; A := A DIV 2
; IF A MOD 2 # 0 THEN
savepc dw 0

blk0: mov al,127 ; LDI 127 kod hipo mašine

shr al,1 ; SHR
jnc even1 ; BCC EVEN Izvorišna adresa Adresa u kešu
lahf ; mov flags into AH MEM+0 blk0
mov saveflags, ah ; save flags to memory MEM+5 -
mov saveal, al ; save al to memory MEM+14 -
mov savex, cl ; save x to memory
lea cx, MEM+5 ; izvorna adresa na koju se prenosi kontrola toka
call BrancHelper ; neće biti vraćanja na mesto iza call
even1:
lahf ; mov flags into AH
mov saveflags, ah ; save flags to memory
mov saveal, al ; save al to memory
mov savex, cl ; save x to memory
lea cx, MEM+14 ; izvorna adresa na koju se prenosi kontrola toka
call BranchHelper ; neće biti vraćanja na mesto iza call
 Rešenje (postavka)

BEG ; Count the bits in a num

MEM+0 LDI 127 ; A=127
MEM+2 LOOP ; REPEAT
MEM+2 SHR ; A := A DIV 2
MEM+3 BCC EVEN ; IF A MOD 2 # 0 THEN
MEM+5 STA TEMP ; TEMP := A
MEM+7 LDA BITS
MEM+9 INC
MEM+10 STA BITS ; BITS := BITS + 1
MEM+12 LDA TEMP ; A := TEMP
MEM+14 EVEN BNZ LOOP ; UNTIL A = 0
MEM+16 LDA BITS ;
MEM+18 OTI ; Write(BITS)
MEM+19 HLT ; terminate execution
MEM+20 TEMP DS 1 ; VAR TEMP : BYTE
MEM+21 BITS DC 0 ; BITS : BYTE
END
 Rešenje
MEM+5 STA TEMP ; TEMP := A
MEM+7 LDA BITS
MEM+9 INC
MEM+10 STA BITS ; BITS := BITS + 1
MEM+12 LDA TEMP ; A := TEMP

blk5: mov al, saveal ; restauracija al, flegovi i x ne moraju jer se

; ne koriste u ovom bloku
mov MEM+20,al ; STA TEMP
mov al, MEM+21 ; LDA BITS
inc al ; INC
mov MEM+21,al ; STA BITS
mov al, MEM+20 ; LDA TEMP
test al,al ; ažuriranje Z flega, ostali se ne koriste dalje
; pa se zato ne rekonstruišu svi flegovi (C)
lahf ; mov flags into AH
mov saveflags, ah ; save flags to memory
mov saveal, al ; save al to memory
mov savex, cl ; save x to memory
lea cx, MEM+14
call BranchHelper
Izvorišna adresa Adresa u kešu
MEM+0 blk0
MEM+5 blk5
MEM+14 -
 Rešenje (postavka)

BEG ; Count the bits in a num

MEM+0 LDI 127 ; A=127
MEM+2 LOOP ; REPEAT
MEM+2 SHR ; A := A DIV 2
MEM+3 BCC EVEN ; IF A MOD 2 # 0 THEN
MEM+5 STA TEMP ; TEMP := A
MEM+7 LDA BITS
MEM+9 INC
MEM+10 STA BITS ; BITS := BITS + 1
MEM+12 LDA TEMP ; A := TEMP
MEM+14 EVEN BNZ LOOP ; UNTIL A = 0
MEM+16 LDA BITS ;
MEM+18 OTI ; Write(BITS)
MEM+19 HLT ; terminate execution
MEM+20 TEMP DS 1 ; VAR TEMP : BYTE
MEM+21 BITS DC 0 ; BITS : BYTE
END
 Rešenje
MEM+14 EVEN BNZ LOOP ; UNTIL A = 0

blk14: mov al, saveal ; restauracija al (moglo bi i bez ove instrukcije

jer
; se akumulator ne koristi u ovom bloku)
mov ah, saveflags ; restauracija flegova
sahf ; mov flags[7:0], ah
jnz lop ; BNZ LOOP ; ne mora čuvanje, ništa nije
menjano
lea cx, MEM+16 ; kontekst u ovom bloku nije menjan, pa ga nije
call BranchHelper ; potrebno ponovo čuvati
lop: lea cx, MEM+2
call BranchHelper

Izvorišna adresa Adresa u kešu

MEM+0 blk0
MEM+2 -
MEM+5 blk5
MEM+14 blk14
MEM+16 -
 Rešenje (postavka)

BEG ; Count the bits in a num

MEM+0 LDI 127 ; A=127
MEM+2 LOOP ; REPEAT
MEM+2 SHR ; A := A DIV 2
MEM+3 BCC EVEN ; IF A MOD 2 # 0 THEN
MEM+5 STA TEMP ; TEMP := A
MEM+7 LDA BITS
MEM+9 INC
MEM+10 STA BITS ; BITS := BITS + 1
MEM+12 LDA TEMP ; A := TEMP
MEM+14 EVEN BNZ LOOP ; UNTIL A = 0
MEM+16 LDA BITS ;
MEM+18 OTI ; Write(BITS)
MEM+19 HLT ; terminate execution
MEM+20 TEMP DS 1 ; VAR TEMP : BYTE
MEM+21 BITS DC 0 ; BITS : BYTE
END
 Rešenje
MEM+2 LOOP ; REPEAT
MEM+2 SHR ; A := A DIV 2
MEM+3 BCC EVEN ; IF A MOD 2 # 0 THEN

blk2: mov al, saveal ; restauracija al, flegovi ne moraju

shr al,1 ; SHR
jnc even1 ; BCC EVEN
lahf ; mov flags into AH
mov saveflags, ah ; save flags to memory
mov saveal, al ; save al to memory
jmp blk5 ; već imamo prevedeno odredište skoka
even1:
lahf ; mov flags into AH
mov saveflags, ah ; save flags to memory
mov saveal, al ; save al to memory
jmp blk14 ; već imamo prevedeno odredište skoka

Izvorišna adresa Adresa u kešu

MEM+0 blk0
MEM+2 blk2
MEM+5 blk5
MEM+14 blk14
MEM+16 -
 Rešenje
Skok na blk5

Kada se pozove BranchHelper, dolazi do izmjene, tako da se sledeći put umjesto poziva
BranchHelper-a direktno skoči na odredišni blok koji je već preveden.

blk5: mov al, saveal ; restauracija al, flegovi ne moraju

mov MEM+20,al ; STA TEMP
mov al, MEM+21 ; LDA BITS
inc al ; INC
mov MEM+21,al ; STA BITS
mov al, MEM+20 ; LDA TEMP
test al,al ; ažuriranje Z flega
lahf ; mov flags into AH
mov saveflags, ah ; save flags to memory
mov saveal, al ; save al to memory
jmp blk14 ; OVDE JE PROMENJENO, zna se gde se skače
 Rešenje

Skok na blk14.

Kada se na kraju bloka pozove BranchHelper, dolazi do prepravke, tako da se

umjesto poziva BranchHelper-a, sledeći put direktno skače na odredišni blok.

blk14: mov al, saveal ; restauracija al

mov ah, saveflags ; restauracija flegova
sahf ; mov flags[7:0], ah
jnz lop ; BNZ LOOP ; ne mora čuvanje, ništa nije
menjano
lea cx, MEM+16
call BranchHelper
lop: jmp blk2 ; OVDE JE PROMENJENO, zna se gde se skače
 Rešenje

• Više puta će se izvršiti segment koda od blk2 do blk14 bez vraćanja u

glavnu petlju emulatora, sve dok se ne istisnu svi bitovi iz akumulatora, tj.
uslov jnz lop ne bude zadovoljeno.
MEM+16 LDA BITS ;
MEM+18 OTI ; Write(BITS)
MEM+19 HLT ; terminate execution

blk16: ; nije potrebna restauracija al niti flags

mov dl, MEM+21 ; DL := bits (cifra za ispis)
add dl,30h ; DL := DL + 30h (u DL ide ASCII kod cifre za ispis)
push EDX
call put_char ; funkcija iz zadatka 1.
add ESP, 4
; prevod HLT
mov CX, -1
Izvorišna adresa Adresa u kešu
call BranchHelper
MEM+0 blk0
MEM+2 blk2
MEM+5 blk5
MEM+14 blk14
MEM+16 blk16
 Rešenje

• Optimizacije?
• Delimična restauracija konteksta u skladu sa potrebama
bloka
• Čuvanje i restauracija konteksta
– Pamtiti dve ulazne tačke u svaki blok, jednu sa
restauracijom konteksta, drugu bez
– Kada se blokovi uvezuju direktno, izbeći i čuvanje i
restauraciju konteksta
• Prepravljanje poziva BranchHelper-a na direktan skok
– Prepravljanje za prethodni blok izvesti iz glavne petlje
emulatora (neophodno sačuvati adresu na kojoj se vrši
prepravka, pre izlaska iz BranchHelper-a)