Assembler programmering (instruktionssekvens)
Hej, jag har lite svårt för att förstå hur jag skall lösa följande instruktionssekvens. 
Hittills har jag kommit såhär långt:
SP = F0
F0-2 --> X, då blir X = EE (LEAX)
F0-1 = EF (PSHX)
X-> M(SP)
EF - 1 = EE (PSHA)
A-> M(SP)
EE + 1 -> EF (LEAX)
EF - 1 -> EE (PSHX)
X-> M(SP)
M(0+EE) - > EE (LDSP, 0 ,X)
M(SP)->A (PULA)
EE+1->EF
M(SP)->X (PULX)
EF+1 -> F0
Min fråga är då om jag har tänkt rätt? Jag har inget sätt att verifiera detta så vill mest veta ifall jag tänkt rätt eller fel i min beräkning
Jag ser att man pushar tre gånger och poppar två gånger, så stackpekaren borde vara en enhet ifrån där man började (0xF0), men jag vet inte hur stora orden är (1, 2 eller 4 bytes) och inte åt vilket håll stacken växer. Vad är det för processor?
Det verkar vara den här: http://www.cse.chalmers.se/edu/year/2014/course/EDA216/FlisProcessorHandbok-A4.pdf
Jag kan inte den processorn. Förslagsvis gör du en tabell med en kolumn för instruktionen och en kolumn för varje register (och ev minnet om det behövs). Då är risken liten att man gör fel.
Laguna skrev:Jag ser att man pushar tre gånger och poppar två gånger, så stackpekaren borde vara en enhet ifrån där man började (0xF0), men jag vet inte hur stora orden är (1, 2 eller 4 bytes) och inte åt vilket håll stacken växer. Vad är det för processor?
Processorn som vi använder är den som @programmeraren länka till (FLIS processor),
Stacken växer upp/ner beroende på vilken instruktion vi utför. Men PUL kommando lägger till på toppen av stacken och PSH minskar från stacken (minskar från toppen).
Är det en generell regel då att man kan kolla på antal gånger man pushar för att se vart man hamnar?
Utan att ha gått igenom programmet i detalj så ser det spontant ut som att det är ett med flit tillkrånglat sätt att manipulera stackpekaren. Jag skulle göra en tabell med en kolumn per register och aktuella minnesadresser och stega igenom., typ som du gjort men mindre risk tappa bort något värde.
Programmeraren skrev:Utan att ha gått igenom programmet i detalj så ser det spontant ut som att det är ett med flit tillkrånglat sätt att manipulera stackpekaren. Jag skulle göra en tabell med en kolumn per register och aktuella minnesadresser och stega igenom., typ som du gjort men mindre risk tappa bort något värde.
Hur vet jag vilken adress F0 börjar på? Vi har bara den informationen som angetts i bilden.
Första raden sätter SP till F0, Dvs stackpekaren pekar på minnesaddress F0. I uppgiften är det mest till för att du måste veta vad SP är från början för att kunna veta vad den är efter alla instruktionerna.
Programmeraren skrev:Första raden sätter SP till F0, Dvs stackpekaren pekar på minnesaddress F0. I uppgiften är det mest till för att du måste veta vad SP är från början för att kunna veta vad den är efter alla instruktionerna.
Förstår inte riktigt, om vi börjar på F0 som minnesadress vilken data startar vi på då? Måste väl veta vilket värde start adressen har för att kunna navigera med instruktionerna?
Menar du PC? Program Counter? Den går framåt av sig själv genom instruktionerna och ändras bara vid jump och liknande.
SP sätts till FO, det betyder bara att nästa push kommer att lagra på den adressen (återigen, man måste läsa vad varje instruktion gör för att veta exakt hur det påverkar, kan vara så att SP räknas upp/ner för/efter vid push/pull eller tvärtom, samma princip men skiljer mellan olika processorer).
SP är ett register som pekar på en minnesadress. Gör du push kommer värdet lagras på adressen och SP ändras att peka nästa plats ovanpå stacken (eftersom jag inte läst in mig på FLIS vet jag inte om stacken växer uppåt eller nedåt i minnet men principen är densamma oavsett).
Har du gjort en tabell med kolumner för alla register och de minnesceller som används (de kan du lägga till vartefter de dyker upp, t ex M(FO)). Jag tror att det kommer göra det enkelt att gå igenom koden och hålla koll på registervärdena och stackens minne.
Sä här menar jag att tabellen kan se ut:
