Programmering av Motorola TSIU02 Datorteknik

Transkript

1 Programmering av Motorola TSIU02 Datorteknik Michael Josefsson Version 1.2

2

3 Innehåll 1 Inledning Datormodell Tutor-kortet Data- och adressregister Dataregister Exempel Exempel Registerbredd och variabla operandstorlekar Åttabitarsoperand. Byte Exempel Sextonbitarsoperand. Word Exempel Trettiotvåbitarsoperand. Longword Exempel Adressregister Exempel Övriga register 17 4 Instruktioner, adresseringsmoder och hopp Flytta data Aritmetiska operationer Logiska operationer Exempel Skiftinstruktioner Adresseringsmoder Register direkt Omedelbar Exempel Absolut Exempel Villkorliga hopp Exempel Exempel Relativa och icke-relativa hopp Exempel

4 Innehåll 5 Ytterligare adresseringsmoder 29 Exempel Indexerad (Motorola: Register Indirect) Indexerad med förskjutning Indexerad med postinkrement Indexering med predekrement Exempelprogram Exempel Subrutiner 33 Exempel Stacken räddar data Parameteröverföring via returstacken Något att fundera över Avbrott Inledning Exempel Multipla avbrott, NMI Pollning Avbrott på Avbrott eller pollning?

5 1 Inledning Ingen processor är exakt den andra lik. Det förekommer skillnader beroende på vad syftet med processorn är, men även bakomliggande filosofier och tillgänglig produktionsmetod inverkar på slutprodukten. Vi ska i kursen använda en avancerad processor: Denna processor är från sent 1970-tal och var mycket avancerad för sin tid. Med sina transistorer (faktiskt!) var den en representant för den mest avancerade produktionsmetodiken man hade. Det var vid denna tid inte möjligt att klämma in fler transistorer på en kiselbricka med någon större framgång 1. Även om processorn i sig är av äldre modell är den utmärkt för undervisningsändamål. Den innehåller många avancerade funktioner som återfinns i dagens processor men är samtidigt tillräckligt enkel för att man ska kunna förstå den i detalj. Förstår vi hur denna processor ser ut och fungerar är ingen annan processor obegriplig för oss. Även om detaljer kan avvika inte så lite mellan olika processormodeller är det stora programoch dataflödet ungefär lika oavsett det gäller en liten, enkel eller stor, komplicerad processor. Processorn har ättlingar än idag. Dels sitter den enklare varianten fortfarande i många inbyggda system, exempelvis laserskrivare m.m. Dels har Motorola utvecklat nyare processorfamiljer med direkta rötter i processorn. En av dessa är den spridda ColdFire-familjen. 1.1 Datormodell För att förstå vilka delar en dator måste bestå av ska vi först presentera en enkel datormodell. Det är viktigt att förstå datorns huvuddrag och hur databehandlingen går till för att uppskatta de olika delarna. Alltså, vår datormodell: 1 I produktionsmiljön gäller ju att det inte får förekomma för många icke-fungerande chip. Då brakar tillverkningskostanderna i höjden med dyrare enhetspris som resultat och kanske en vikande försäljning. 5

6 1 Inledning Den här datormodellen tjänar till att presentera det generella förloppet i ett datorsystem. Vi förstår att en del komponenter är nödvändiga. Det finns en programräknare som pekar ut adressen till nästa instruktion, ett instruktionsregister där instruktionen hamnar efter inläsning och en ackumulator där själva databehandlingen sker. Det finns dessutom in/ut-enheter för att kunna kommunicera med omvärlden. Vi märker snart att det även behövs minne för att lagra program och/eller data och det minnet kan befinna sig internt i processorn eller externt i processorns närhet. Redan nu kan vi kanske förstå att det är lyckosamt att ha åtminstone en del minne internt i processorn för att inte behöva prata med ett yttre minne ideligen. Uppgiften att konstruera en e ektiv och ändamålsenlig uppsättning instruktioner och en lämplig datorhårdvara är svår. Det är därför med stor glädje vi ser att flera tillverkare redan gjort det jobbet åt oss. Det återstår för oss att förstå deras datormodell och instruktioner, något som brukar kallas datorns arkitektur. 1.2 Tutor-kortet Alla laborationer i kursen utförs på det s k Tutorkortet. Det är en en komplett liten dator med processorn som centralenhet. Innan laborationerna börjar måste vi förstå hur kortet fungerar och speciellt hur man programmerar processorn att utföra det vi begär av den. Vi börjar med en kort genomgång av kortets beståndsdelar i huvudsak: PROM (Programmable Read Only Memory). Läsminne. En sorts minne som man bara kan läsa ifrån. För att kunna skriva i minnet måste man använda en speciell programmeringsutrustning. Här används minnet för att innehålla ett fast program. Det är detta program som är tutorkortets beteende. T ex är det programmet i PROM som skriver TUTOR 1.3> vid spänningspåslag. RAM Random Acccess Memory). Läs- och skrivminne. Här kan processorn både läsa och skriva och det är hit vi kan skriva våra egna program. Processorn kan 6

7 1.2 Tutor-kortet också använda RAM-arean för att mellanlagra resultat. Tutorsystemet använder delar av RAM:et men större delen är tillgängligt för oss. Processor som utför de instruktioner vi förser den med. Processorn kan hämta instruktioner från både RAM och PROM. I/O (Input-Output). In-/utenheter för att vi ska kunna kommunicera med tutorkortet. I/O kan finnas i olika varianter. På tutorkortet finns två sorter: dels en parallellport (kretsen 6821) och en serieport (kretsen 6850). Serieporten ser vi inte mycket av men den används hela tiden för att skicka våra textkommandon till kortet. Även kortets utgående text till vår skärm går över denna port. Parallellporten kommer vi däremot att använda flitigt. Porten innehåller i huvudsak två utgångar, vardera om 8 bitar. Dessa bitar kan styras individuellt som ingång eller utgång. Vi kommer senare att studera kretsen 6821 i detalj. Dessutom tillkommer diverse klister -komponenter ex vis TTL-kretsar för minnesavkodning och klockpulsgenerator för processorn. Det är minnesavkodningen som avgör om RAM, PROM eller I/O adresseras. Vi kommer även studera minnesavkodningen mer i detalj senare. 7

8 1 Inledning 8

9 2 Data- och adressregister Vi kommer under kursen att kunna konstatera att mycket av databehandlingen i en traditionell processor går åt till att placera datat i en ackumulator för att kunna utföra operationer på det. En traditionell processor ser ungefär ut som den arkitektur vi hittills sett: En programräknare, en ackumulator, osv 1. Med begreppet programmerarmodell menas den bild av processorns resurser programmeraren behöver. I programmerarmodellen ingår ofta bara de register processorn består av. En mer komplett programmerarmodell innehåller dock också processorns instruktions- och dataformat samt ingående instruktioner. 2.1 Dataregister För är programmerarmodellen utökad jämfört med modelldatorn. I modelldatorn var ackumulatorn en tydlig flaskhals då allt bara kunde hända där. Det är i ackumulatorn bland annat alla aritmetiska operationer sker och alla data måste först flyttas dit innan operationen kan äga rum. Dessutom måste förstås resultatet av operationen flyttas från ackumulatorn innan en ny operation, på nya operander, tar plats där. Allt flyttandet av data tar en massa tid och utför inget egentligt jobb i sig. Det vore mycket bättre om man kunde e ektivisera processorn så att den möjliggör mer vettigt jobb och mindre flyttande av operander konstruktörerna hade naturligtvis det här klart för sig och utökade den traditionella arkitekturen med sammanlagt åtta ackumulatorer! 1 Faktum är att 90% av alla processorer som tillverkas idag ser ut ungefär som den. Det finns variationer i instruktionsuppsättningen förstås, men den sortens processorer med s.k. ackumulatorarkitektur är den förhärskande. 9

10 2 Data- och adressregister Dessa åtta dataregister, D0 D7, är sinsemellan lika och var och en av dem fungerar som en ackumulator. Med åtta ackumulatorer kan man antagligen låta ett resultat ligga kvar där det beräknades medan ett annat resultat beräknas i någon av de sju övriga ackumulatorerna. Rimligen minskar detta mängden onödigt flyttande av data inom processorn. Två exempel visar på hur man flyttar data inom dessa register: Exempel Flytta konstanten $23 till D2. Brukar kallas att ladda D2 med $23. Exempel Flytta innehållet i register D2 till register D7. Lägg märke till hur instruktionen pekar ut varifrån operanden läses, vilken operation som skall utföras och slutligen pekar ut vart resultatet skall lämnas. I det sista fallet läser vi från D2, och gör en flyttning (MOVE) till D7. Ordet flyttning är egentligen missvisande eftersom det aldrig flyttas något utan bara kopieras. Innehållet i D2 ovan påverkas inte av läsningen. 2.2 Registerbredd och variabla operandstorlekar Vi har inte nämnt det än, men dataregistren är arbetsbesparande inte bara för att de är åtta stycken, varje register är dessutom hela 32 bitar brett. Detta innebär att stora tal kan hanteras innan registret slår i taket. I kan tal upp till = hanteras i varje ackumulator! Men om man nu inte har så stora tal att det verkligen behövs 32-bitars bredd på registren, hur gör man då? Enklast är naturligtvis att inte bry sig utan att alltid använda 10

11 2.2 Registerbredd och variabla operandstorlekar hela ordbredden, antingen det behövs eller inte. Detta lösning är dock lång ifrån optimal eftersom det i många fall tar längre tid att stuva runt 32-bitars tal i processorn än till exempel 8-bitars tal. Dessutom är många av en processors standarduppgifter 2 inte alls beroende av så stora tal och då är det förstås slöseri att använda ett helt 32-bitars ord med bara några få bitars nyttolast. Det är lika svårt att lära gamla hundar sitta som att lära om gamla programmerare. Alltså måste man tillfredsställa de som fortfarande ville tänka i åttabitarsbanor. I sanningens namn finns det fördelar med att inte använda större registerbredd än vad uppgiften kräver. För den sakens skull införde man inte mindre än tre olika möjliga operandstorlekar för dessa dataregister: 8, 16 och 32 bitar (byte, word, longword) Åttabitarsoperand. Byte. Den minsta operandstorleken dataregistren kan hantera är åtta bitar. Då kan bara de åtta lägsta bitarna i ett register eller minnescell refereras. De övriga 24 bitarna kan man inte nå. Exempel D0 innehåller en si ra i sin lägsta byte. Översätt denna si ra till dess ASCIIrepresentation och placera resultatet i D1. 2 Till en av standarduppgifterna hör att hantera text. Bokstäver brukar representeras med det sjueller åttabitars värde det har i den s.k. ASCII-tabellen. ASCII-tabellen finns bilagd i labhandledningen. 11

12 2 Data- och adressregister Märk hur man, i varje instruktion, talar om vilken operandstorlek man avser att använda. Det är mycket viktigt att inte glömma att specificera detta. En väsentlig del av alla programmeringsfel på är just att man glömt ange vilken del av registret man använder Sextonbitarsoperand. Word. Den operandtyp som underförstås om man inte anger något annat är WORD, dvs 16 bitar. För tydlighets skull brukar man ändå ange denna med.w. På samma sätt som i fallet med byte-operand är det bara de lägsta bitarna av registret man kan komma åt, i detta fall de sexton lägsta bitarna. En begränsning om 16 bitar innebär att ett tal kan vara mellan 0 och Exempel Adressen $102 innehåller ett sextonbitarstal i sina två lägsta byte. Invertera alla bitar i (ett-komplementera) talet. Det finns flera sätt att lösa detta på. Samtliga förlitar sig på en logisk operation av något slag. För att göra det enkelt för oss använder vi instruktionen NOT. Försök själv dela upp inverteringen i två åttabitars inverteringar. Är det någon poäng att göra det? 12

13 2.3 Adressregister Trettiotvåbitarsoperand. Longword. Den största operandstorleken processorn stödjer är fulla registerbredden på 32 bitar. I praktiken är det sällan nödvändigt med så brett register, men behöver man det är det förstås bra att ha. Vi kommer antagligen oftast använda denna operandstorlek för att på ett enkelt sätt ladda konstanter till register samt ange adresser. Exempel D3 innehåller gammal information. Radera denna! Med operandstorleken longword kan vi rensa registret helt och hållet i en enda instruktion. Det kan vara förnuftigt att på detta sätt rensa ett register innan man använder det. Speciellt om man tänker använda en annan operandstorlek senare kan man nu vara säker på att det inte ligger något skräp kvar. Är man noggrann behöver man förstås inte rensa mer än den del av registret man har för avsikt att använda, men det visar sig att man ofta göra någon modifiering av sitt program och då är det lätt hänt att man glömmer kompensera för ändrade operandstorlekar. Laddar man med.l så går man säker från just detta problem. 2.3 Adressregister För att peka ut en adress i ett yttre minne till exempel måste adressen befinna sig i ett av åtta adressregister. Dataregistren kan inte användas till detta. Adressregistren är speciella då de: 13

14 2 Data- och adressregister dels inte hanterar byteoperander.b och, dels behandlas som om de innehöll tvåkomplementstal. Detta får till e ekt att, om inte full (dvs 32-bitars) adress används, betraktar processorn adressen som ett tvåkomplementstal och teckenutvidgar denna omedelbart till ett 32-bitars tal: Registervärde (adressregister, 32 bitar) Efter teckenutvidgning Syns utåt på kretsen (adress) Registervärde (adressregister, 32 bitar) Efter teckenutvidgning Syns utåt från kretsen (adress) Med assembler kan man alltså bli förvånad om adressregistret använts med ordlängden.w: MOVE.L MOVE.W #0,A3 #8000,A3 ger A3 med innehållet $FFFF8000 på grund av teckenutvidgningen i den andra raden. Av denna anledning är LEA (Load E ective Adress) en lämplig instruktion för att ladda adressregister. Då sker ingen automatiskt teckenutvidgning. LEA finns bara i varianten.l. 14

15 2.3 Adressregister Exempel Vilken är skillnaden mellan dessa två olika sätt att initiera A0? MOVE.W #$9800,A0 LEA.L $9800,A0 MOVE.B (A0),D0 MOVE.B (A0),D0 : : : : FEL RÄTT 15

16 2 Data- och adressregister 16

17 3 Övriga register Visserligen är det i data- och adressregistren processorns egentliga jobb utförs men två andra register är minst lika viktiga för att processorn skall kunna utföra sitt arbete: Programräknaren och statusregistret. Programräknaren, PC, innehåller adressen till den instruktion som utförs för tillfället. När programmet körs kommer programräknaren att ökas på allteftersom. Om man gör ett hopp i programmet är det som händer att programräknaren laddats med ett nytt värde. Statusregistret, SR, innehåller i sin lägre byte information om den senaste instruktionens resultat. Speciellt intresserade är vi av de lägre bitarna Z, N, C och V. Dessa sätts (ett- eller noll-ställs) av flera instruktioner. Flaggorna återspeglar samtliga aritmetiska resultat från den aritmetisk logiska enheten (ALU). Villkorliga hopp använder dessa flaggor för att avgöra om hopp skall ske eller inte. Flaggorna är på detta sätt ett sätt för en instruktion att meddela sig till nästa instruktion. För att summera egenskaperna hos registren i har vi alltså: 1 Ingenjörerna på Motorola var framsynta vid konstruktionen av Den skulle ju vara flaggskeppet i deras produktlinje. Och den var faktiskt så bra att den levde kvar, frodades, växte och blev med tiden både 68010, 68020, och Där de senare var 32-bitars processorer tankarna lever kvar än i dag i vad Motorola kallar CPU32, ett byggblock som är grundstenen i deras nya uppsättning processorer bl a Coldfire 2. Samtliga versioner har i huvudsak samma programmerarmodell och ett program skrivet för kan köras på en Coldfire om så skulle önskas. Omvändningen gäller dock inte ett program för kan använda nya instruktioner som den råa inte förstår. 17

18 3 Övriga register 8 dataregister à 32 bitar 8 adressregister à 32 bitar 1 programräknare, PC 1 statusregister à 16 bitar Operandstorleken byte kan bara användas i dataregistren medan word och long kan användas överallt. Processorns register, data- och adressregister, programräknare osv, brukar kallas processorn programmerarmodell. Det är den bild av processorns innanmäte man behöver för att asseblerprogrammera den. 18

19 4 Instruktioner, adresseringsmoder och hopp Innan vi bo rjar programmera kretsen pa allvar ma ste vi studera de instruktioner vi kan anva nda. Programmet byggs upp av instruktioner som utfo rs i sekvens. Det finns ocksa instruktioner som bryter sekvensen, s k hoppinstruktioner. Som tur a r beho ver vi inte anva nda alla dessa instruktioner. De vanligast anva nda a r kanske ett tjugotal av dessa. Man ser att instruktionerna so nderfaller i fem olika grupper: Instruktioner som flyttar data (ex vis MOVE) Aritmetiska instruktioner (ex vis ADD, SUB, MUL) Hoppinstruktioner (JMP, BRA, JSR) Logiska instruktioner (ASL, ROR m fl) I/O (MOVEP) 19

20 4 Instruktioner, adresseringsmoder och hopp 4.1 Flytta data Instruktionen för att flytta data har vi redan använt, MOVE Aritmetiska operationer Bland de aritmetiska instruktionerna har vi trä at på ADD. Naturligtvis finns en motsvarande SUB för subtraktion och dessutom de ovanligare MUL och DIV för multiplikation respektive division Logiska operationer Av logiska operationer har vi redan använt NOT,för att invertera alla bitar i ett register. Övriga är vanliga booleska operationer utförda på registerinnehåll. Sålunda återfinns AND, OR, NOT och EOR (för xor) bland dessa. Sedan digitaltekniken vet vi vad dessa booleska operatorer gör, det som skiljer nu är att de opererar på hela register: 3 Exempel Använd instruktionen AND för att skilja ut de lägsta tre bitarna ur byten på adress $ MOVE ersätter två vanliga instruktioner man hittar i andra processorer. Vanligen finns en instruktion för att ladda ett register ( load ) och en annan för att kopiera registervärdet till yttre minnet ( store ). 2 De båda sista finns dessutom i två varianter vardera eftersom multiplikation och division ser något olika ut beroende på talens som skall multipliceras är teckenlösa eller inte (2-komplement underförstås vid tal med tecken). 3 Med hänsyn till använd operandstorlek som vanligt förstås. 20

21 4.4 Skiftinstruktioner 4.4 Skiftinstruktioner Ett mellanting mellan de aritmetiska och logiska operationerna, men som brukar räknas till de senare, är skiftinstruktionerna. Det finns egentligen fyra skiftinstruktioner men då två av dem sammanfaller behöver vi bara lära oss tre, två högerskift och ett vänsterskift: ASR Arithmetic Shift Right, Aritmetiskt högerskift. LSR Logical Shift Right, Logiskt högerskift. ASL Arithmetic Shift Leftt, Aritmetiskt vänsterskift = Logiskt vänsterskift. Vi ser att de båda vänsterskiften ser likadana ut. 4.5 Adresseringsmoder För att kunna använda processorns fulla styrka måste man behärska dess adresseringsmoder. Med adresseringsmoder menas de olika sätt man som assemblerprogrammerare kan använda sig av för att lokalisera de data man behöver. ADD-instruktionen följer assemblersyntaxen (taget direkt ur Motorolas dokumentation) 21

22 4 Instruktioner, adresseringsmoder och hopp Här betyder <ea> e ektiv adress. Som vi snart kommer se finns det flera sätt att ange var ett data är beläget. Vi har använt omedelbar 4 adressering (för konstanten ovan) och absolut adressering (för att peka ut data på adressen $3000). Det syntaxen ovan i praktiken betyder är att åtminstone ett dataregister (D0-D7) måste ingå i instruktionen. Man kan alltså inte ADD A0,A5 men ADD A0,D3 och ADD D3,A5 är tillåtna. Processorn har hart när alla förekommande adresseringsmoder. För att programmera e ektivt är det viktigt att känna till dem Register direkt Register direkt, eller bara direkt adressering, är adresseringsmoden då enbart processorns interna register används. MOVE.B D1,D Omedelbar Med omedelbar adressering menas att den operanden anges i form av en konstant. På processorn innebär detta att # måste föregå operanden. MOVE.W #$FACE,D3 Som vi vet sedan förra exemplet är det hexadecimala talet ett tal och inte en adress. # talar om att det som följer är ett tal och $ att talet är skrivet i hexadecimal form. 4 Vid omedelbar adressering anges argumentet direkt i instruktionen: MOVE.B #4,D0, medan i direkt adressering argumentet är i ett register: MOVE.B D1,D0 22

23 4.5 Adresseringsmoder Exempel Det är viktigt att inte blanda ihop $ och # Assmbler Betydelse MOVE.B #10,D3 D3 :=0x0A MOVE.B #$10,D3 D3 :=0x10 MOVE.B 10,D3 D3 :=M(0x0A) Absolut Med absolut adressering menas moden då man anger den e ektiva adressen direkt med dess adress. MOVE.B $F0, D0 Dessa tre adresseringsmoder är de mest grundläggande. Ofta klarar man flera programmeringsuppgifter med dessa enbart. Som framgått handlar dessa moder om att peka ut data i minnet eller i register samt förse programmet med konstanter. Exempel Operanderna A och B består vardera av 16 bitar och finns lagrade på adresserna $8014 respektive $8016. Beräkna summan av dem, dividera med två och placera resultatet på adress $9000. Vi använder absolut adressering för att peka ut operanderna och även för att peka ut resultatet. 23

24 4 Instruktioner, adresseringsmoder och hopp Ett möjligt sätt är den direkta approachen: Uppgiften kan också lösas så här: Övning: Vilka adresseringsmoder används i varje rad i programmen? Spelar det någon roll om talen är tvåkomplementskodade eller inte? 4.6 Villkorliga hopp Hittills har vi inte kunnat utföra hopp i vår programkod. Alla program har bara kunnat rinna uppifrån och ned. Med hopp kan programkörningen avslutas på en programrad och påbörjas någon helt annanstans. Det finns två sorters hopp villkorliga och ovillkorliga. Som man förstår av namnet kommer de ovillkorliga hoppen att alltid hoppa medan de villkorliga måste fatta ett beslut om hoppet ska gå igenom eller inte. För att välja mellan olika alternativ kommer vi se att flaggorna i statusregistret spelar en central roll. Vi börjar med ett programexempel där ett villkorligt hopp måste göras och tar detaljerna efteråt. Exempel I minnescellerna $1100 och $1101 finns två +va tal, placera det största talet i cellen $1102. Vi börjar för tydlighets skull med en registerplan, vi ritar upp verkligheten som vi ser den. 24

25 4.6 Villkorliga hopp Med dessa förberedelser kan programmet skrivas: Här använde vi CMP-instruktionen för första gången. CMP-instruktionen jämför två tal genom att subtrahera det ena från det andra och kasta bort resultatet. Det enda som finns kvar efter jämförelsen är subtraktionens resultat i flaggorna i statusregistret SR. Om resultatet var noll, d v s D0 och D1 var lika stora sätts Z-flaggan, annars nollställs den. Om resultatet var negativt, d v s om D1 var större än D0 sätts N-flaggan, annars nollställs den. Och slutligen, om resultat var positivt, d v s D0 var större än D1 är både N- och Z-flaggan nollställda. Nästföljande instruktion BHI, Branch if Higher, tittar på flaggorna och utför hoppet om villkoret är uppfyllt. Villkoret if higher används på tvåkomplementskodade tal för att jämför om det ena är större än det andra. För icke-tvåkomplementskodade tal finns inte möjligheten att ett tal är negativt varför andra villkor också finns att tillgripa vid jämförelser (cc = condition code dvs hoppvilkor.): CMP.x B,A Bcc adress 25

26 4 Instruktioner, adresseringsmoder och hopp Hopp om +va tal 2 komplement A>B BHI BGT A B BCC BGE A<B BCS BLT AappleB BLS BLE Ett vanligt fall är då man räknar ner en variabel, eller ett register, och vill hoppa då operanden blivit noll eller hoppa så länge operanden är skild från noll. Efter SUBinstruktionen kan man då använda följande tabell för att hitta ett lämpligt villkor: SUB.B #1,A Bcc adress Villkor Mnemonic A = 0 BEQ (Z=1?) A6=0 BNE (Z=0?) 0 appleaapple127 BPL (N=0?) -128 applea<0 BMI (N=1?) Varför +127 och 128 ovan? Det största värde en tvåkomplements byte kan innehålla är = 127. Det minsta värde en tvåkomplements byte kan innehålla är 2 7 = 128. För word är detta = respektive 2 15 = o s v. Förkortningarna står för något av HIgher, GreaTer, Carry Clear, Greater or Equal, Carry Set, Less Than, Low or Same, Less or Equal, EQual, Not Equal, PLus eller MInus. Lägg märke till hur användningen av kommentarer (efter ; ) ökar läsbarheten för programmet väsentligt. Ett exempel på hur SUB-instruktionen kan användas kommer här: Exempel Beräkna summan X255 och lagra resultatet i $ = Den här uppgiften är lite mer komplicerad. Rita gärna en registerplan om du tycker det underlättar. Vi beslutar att tilldela registren enligt D0 = varvräknaren, D1 = summan. 26

27 4.7 Relativa och icke-relativa hopp Villkorsinstruktionen BNE testar Z-flaggan för att avgöra om föregående instruktion (SUB.W) räknat ner registret till noll eller inte. Övning: Prova att göra om uppgiften men räkna från 0! 255 istället för att ladda räknaren med 255 från början. Vilken fördel eller nackdel medför detta? 4.7 Relativa och icke-relativa hopp För att göra vår beskrivning av hopp komplett måste vi reda ut skillnaden mellan relativa och icke-relativa hopp. Vi börjar med det register i processorn som hoppen påverkar: PC, Program Counter, programräknaren. Programräknaren pekar i normalfallet den adress i programminnet där nästa instruktion ligger. När processorn gjort klart en instruktion ökas PC på ett steg och processorn plockar sedan in den instruktionen osv. För att åstadkomma hopp måste vi alltså kunna påverka programräknaren så att nästa instruktion tas från någon annan plats i minnet än den automatiskt uträknade. Det finns två sorter av de rena hoppinstruktionerna JMP, jump, och BRA, branch. Skillnaden mellan dem är att i JMP anger argumentet, hoppadressen, i sin fulla längd (icke-relativt, absolut hopp) medan BRA:s argument anger hur långt från där vi står nu vi skall hoppa, (relativt hopp). 27

28 4 Instruktioner, adresseringsmoder och hopp I och med att vi själva väljer en hoppadress måste vi först försäkra oss om att en instruktion finns dit vi vill hoppa, och dessutom att instruktionen börjar precis dit vi dirigerat programexekveringen. Vi kan lätt hoppa mitt in i en instruktion om vi är oförsiktiga. Gör inte det! Programmet kommer att spåra ur och vi måste börja om från börja igen. Exempel Hoppa från $1000 till $1200 dels med JMP och dels med BRA! Både JMP och BRA kan också hoppa bakåt. För BRA betyder det att argumentet är ett negativt tal ty detta tal adderas till nuvarande värdet hos PC. I och med att a +( b) = a b kommer programräknaren minskas. Uppenbarligen förväntar sig BRA att o set:en är tvåkomplementskodad. Det visar sig att de villkorliga hoppen alltid är relativa, d v s hoppets destination fås genom att addera en o set till den nuvarande instruktionens adress. I och med att programräknaren, PC, pekar på nuvarande instruktion handlar det om att addera ett värde till PC eller inte. Om hoppet skall tas sker additionen, i övriga fall kommer programräknarens värde att automatiskt peka ut nästa instruktion. 28

29 5 Ytterligare adresseringsmoder Efter ett tags programmerande märker man att de hittills presenterade adresseringsmoderna kan ge komplicerade konstruktioner för att peka ut rätt data. Exempel Med en sträng menas en följd av tecken i minnet. Ofta, men inte nödvändigtvis, är en sträng ett stycke läsbar text och ofta markeras strängens slut med värdet 0 1. Hur kan man traversera en sträng, d v s hur pekar man ut varje bokstav i tur och ordning? Lösningen är att ha ett register som pekare. Eftersom våra adressregister är de enda register vi har, som kan peka i minnet, är ett sådant naturligt att använda. När väl datat är utpekat kan det sedan läsas in i ett dataregister. Exemplet visar att det är önskvärt med åtminstone en ytterligare adresseringsmod. En där man kan låta innehållet i ett register, eller innehållet i en minnesposition för den delen, peka ut den önskade adressen. På så sätt kan man lätt öka registerinnehållet med ett lämpligt värde för att peka ut nästa element. Det visar sig att Indexerad Adressering är lösningen. 1 I ascii kallad nul-tecknet. 29

30 5 Ytterligare adresseringsmoder Indexerad (Motorola: Register Indirect) ADD.W (A3),D0 För gäller att endast adressregistren kan användas som indexregister. Å andra sidan kan alla adressregister användas till detta. 2 Dessutom, och det är kanske inte helt uppenbart, används alltid hela adressregistret för att peka ut data. Man kan ladda det word -vis men det kommer alltid att användas long -vis Indexerad med förskjutning Indexerad med förskjutning använder ett indexregister men också en konstant förskjutning relativt detta. Den e ektiva adressen fås genom att addera konstanten till indexregistrets innehåll. Vid en första anblick är detta väsentligen samma som föregående. Det finns dock ett typfall där denna adresseringsmod är motiverad: tabelluppslagning. Om man låter konstanten vara adressen till tabellens början kan man indexera in i tabellen med början i indexet 0. ADD.W 2(A3),D Indexerad med postinkrement När man använder indexerad adressering enligt ovan och speciellt i det beskrivna fallet med strängar är det ofta nödvändigt att indexera sig fram till nästa element. 2 Ofta är dock registret A7 upptaget för den s k stackpekaren. Vi kommer till denna senare. 30

31 Naturligtvis kan det göras manuellt, t ex med instruktionen ADD.L #1,A3 eller liknande. Emellertid är detta en så vanlig företeelse att en speciell adresseringsmod framtagits för detta. Adresseringsmoden Indexerad med postinkrement utför två saker: Först används indexerad adressering som vanligt och som avslutning av instruktionen utförs sedan en addition av en konstant till adressregistret. Konstantens värde fås ur den använda ordlängden, så att ordlängden.b ökar på 1,.W ökar 2 och.l 4. CLR.W (A3)+ I en del fall vill man inte öka på indexet utan istället minska det. För detta finns adresseringsmoden Indexerad med predekrement. Den fungerar på liknande sätt som moden ovan men räknar ner istället. Dessutom sker denna nedräkning innan indexeringen sker Indexering med predekrement CLR.W -(A3) Lägg märke till att åtminstone i det bara finns predekrement och postinkrement inte preinkrement eller postdekrement. Räkna upp efter eller räkna ner innan Exempelprogram Som exempel på att den sista adresseringsmoden är mycket praktisk och eliminerar behovet av separata nedräkningsinstruktioner. Vi använder den i exemplet nedan. 31

32 5 Ytterligare adresseringsmoder Exempel Nollställ minnescellerna från adressen $800 till och med $1234! En alternativlösning är: Varför är en varning utfärdad i sista fallet? Det finns några ytterligare adresseringsmoder hos Detta är mest en e ekt av att processorn är konstruerad att vara ovanligt komplett. Med de hittills beskrivna adresseringsmoderna kan man programmera godtyckligt komplicerade program. Vi skulle även kunna nöjt oss utan postinkrement- och predekrementmoderna men de är så användbara att det vore synd att inte känna till dem. 32

33 6 Subrutiner Ofta behöver man göra en uppgift flera gånger i ett program. Det kan till exempel handla om att läsa av en tangent, tända en lysdiod, göra en speciellt krånglig beräkning, vänta en bestämd tid och så vidare. Som vi hittills lärt oss är enda möjligheten att göra dessa uppgifter att programmera dem på de ställen där de behövs i programmet. Det innebär att alla de programrader uppgiften kräver måste klistras in i programmet där de behövs. Visst vore det praktiskt att bara ha programraderna för uppgiften på ett ställe och sedan bara referera till dem varje gång de behöver göras? Vi kan ju redan nu göra detta genom att lägga den önskade programrutinen på någon plats i minnet och sedan hoppa (med JMP adress eller BRA adress ) till detta ställe från huvudprogrammet. Det är inga som helst problem att göra detta hopp till rutinen och sedan låta rutinen hoppa tillbaka till huvudprogrammet med ett avslutande JMP eller BRA. Men det blir omedelbart problem om rutinen ska anropas från flera olika ställen i huvudprogrammet. Då måste ju också återhoppen ske till olika ställen. Men våra instruktioner JMP och BRA hoppar bara till ett ställe, adressen är fast. Här krävs uppenbarligen en ny mekanism. De vanliga hoppen duger inte eftersom de inte har någon aning varifrån hoppen skedde. Det är här subrutiner kommer väl till pass. 33

34 6 Subrutiner Vi förstår att en de instruktioner som orsakar ett subrutinanrop måste uppfylla tre villkor: Programflödet måste styras över till subrutinen. En återhoppsadress måste sparas. Återhoppsadressen måste vara första programraden efter anropet. Subrutinen måste, efter förättat värv, kunna hoppa till återhoppsadressen. Subrutiner är rutiner i ett program som kan anropas från vart som helst i programmet och som sedan återhoppar till raden precis efter där anropet skedde. Subrutinerna måste alltså ha ett minne som gör att de minns vart de skall hoppa när de är klara. Med subrutiner vinner man framförallt minskad total programstorlek minskad programkomplexitet p g a bättre programstruktur. För att använda några programrader som en subrutin måste de anropas med antingen instruktionen JSR (Jump SubRoutine) eller BSR (Branch SubRoutine). Dessa instruktioner fungerar precis som JMP och BRA med den skillnaden att de samtidigt lagrar undan adressen till nästföljande instruktion på en stack. Stacken är i verkligheten ett stycke minne dit man pekar med en stackpekare. På processorn pekar stackpekaren (registret A7 används för detta) ut första lediga plats på stacken. Stacken är lite egendomlig i och med att den växer mot mindre adresser. Det är rätt vanligt bland processorer att stacken växer nedåt på detta sätt. Nu är detta inte något egentligt problem för oss eftersom vi i allmänhet inte märker något av det. De instruktioner som automatiskt använder sig av stacken tar hänsyn till det. För att genomföra återhoppet duger nu inte ett vanligt hopp våra vanliga hopp har ju ingen aning om vad som finns på stacken, de vet ju inte ens om att det finns 34

35 en stack utan instruktionen RTS, (ReTurn from Subroutine) måste användas. RTS genomför återhoppet till den adress som ligger på stacken. Genom att den senaste subrutinen skall återhoppa till den senast ditlagda adressen på stacken o s v kommer stacken alltid att vara parad med rätt subrutinåterhopp. Det kan vara intressant att fundera på svaren till dessa frågor: Vad händer om en subrutin avslutas med JMP istället för RTS? Vad händer om en subrutin avslutas med BSR istället för RTS? Vad händer om JMP används för att hoppa till en korrekt avslutad subrutin? Det är enkelt att använda subrutiner och de förenklar programmeringen i och med att det är lättare att hålla en vettig struktur på sitt program. Använd dem ofta. Det finns tre saker att tänka på: Hopp till subrutin görs med JSR eller BSR Subrutinen måste avslutas med RTS Adressregistret A7 är stackpekare, använd inte A7 till något annat. Exempel Skriv en subrutin som beräknar udda paritet av byten i D1! Med udda paritet menas att summan av alla 1-or i det binära talet skall vara udda. Om ett åttabitarstal förses med paritet är denna oftast den mest signifikanta biten (Pxxxxxxx), så även här. Subrutinen skall alltså räkna antalet 1-or i de 7 lägre bitarna. Och om antalet är jämnt sätta paritetsbiten, P, till 1 annars till 0. Talet ska inte förstöras, och rutinen får använda enbart D1. 35

36 6 Subrutiner Lösningen till det här problemet hängde mycket på rotationsinstruktionen ROR: Och skiftinstruktionen LSR: Lägg märke till hur sista raden gjorde att detta program kan ansropas som en subrutin: Instruktionen RTS. Detta gör att den måste anropas med JSR eller BSR. För subrutiner på har konstruktörerna valt följande konvention (SP är stackpekaren): Instruktion Innebörd JSR addr SP := SP 1,M(SP):= PC + 1,PC := addr RTS PC := M(SP),SP := SP +1 Vi ser att detta stämmer med adresseringsmoderna predekrement och postinkrement. Återigen: I processorn är registret A7 stackpekarregister. Använd inte A7 till något annat. Som programmerare behöver jag inte röra stackpekaren, allt sköts transparent och automatiskt av instruktionerna JSR och RTS. 36

37 6.0.1 Stacken räddar data Subrutinen i exemplet är programmerad och klar att anropas från flera ställen i den övriga programkoden. För att göra detta så smärtfritt som möjligt vore det bra om subrutinen inte förstör innehållet i de register huvudprogrammet använde. Vi ser i rutinen av dataregistren D0, D1 och D2 används. D1 används för att överföra byten till rutinen och också innehålla resultatet vid återhopp. Men huvudprogrammet kanske använde de övriga registren och blir nog förvånad om subrutinen har ändrat i dem. Vi måste alltså se till att subrutinen inte förändrar innehållet i andra register än det huvudprogrammet förväntar sig. Det enklaste sättet att spara undan innehållet i D0 och D2 är att vid början av subrutinen lägga dessa på stacken för att som sista moment i rutinen plocka tillbaka dem i de ursprungliga registren. 1 Det anropande programmet hoppar till subrutinen med ett JSR, som vanligt, och ser till att D1 förses med rätt värde innan: Och subrutinen inleds och avslutas med programrader som sparar undan och återställer de register rutinen använder: 1 Vi kan i och för sig låta huvudprogrammet spara undan registren men det är enklare att överlåta detta till subrutinen. Den vet ju själv exakt vilka register den använder, vilket kanske inte huvudprogrammet har helt klart för sig. 37

38 6 Subrutiner Vem ska spara undan registren? Det finns två alternativ: huvudprogrammet, eller subrutinen. Det är ju huvudprogrammets data så det ligger onekligen i dess intresse att spara dom, men eftersom subrutinen själv bäst vet exakt vad som ska sparas undan brukar man överlämna detta åt den senare. Man kan i princip välja vilket sätt som helst men det är renare att låta subrutinen ta hand om det. Vad händer om subrutinen modifieras så att även D3 påverkas? Det är synd och strängt taget onödigt att behöva ändra på alla ställen i huvudprogrammet anropet förekommer. Bättre är att ändra i subrutinen, det blir ju färre ändringar så. Det är naturligtvis möjligt att spara undan samtliga processorregister men det tar så mycket tid att det i allmänhet är oattraktivt. Processorn har dock ett speciellt format av MOVE-instruktionen för detta, exempelvis MOVEM.W D0-D7/A0-A6,-(A7), som lagrar registren D0 D7 och A0 A6 på stacken Parameteröverföring via returstacken Ett annat vanligt sätt att använda stacken är för parameteröverföring, d v s, i exemplet ovan, låta huvudprogrammet lagra värdet på stacken. Subrutinen vet sedan att dess argument finns att hämta på stacken: 38

39 6.0.3 Något att fundera över Stackhanteringen kan utnyttjas på flera olika sätt, för syften den kanske inte är avsedd för. Vad händer till exempel egentligen i dessa programsnuttar? MOVE.L MOVE.L MOVE.L MOVE.L D0,-(A7) D2,-(A7) (A7)+,D0 (A7)+,D2 Och detta: MOVE.L MOVE.L RTS #$8000,D0 D0,-(A7) ADD.L #4,A7 eller t.o.m. ADD.L #4,(A7) 39

40 6 Subrutiner 40

41 7 Avbrott 7.1 Inledning Vi har sett hur ett program kan få saker utförda i subrutiner som programmet anropar. Med instruktionen JSR kan vi i programmet anropa andra programsnuttar för att få beräkningar utförda och sedan hoppa tillbaka med RTS för att fortsätta som om inget hade hänt. Med avbrott kan en yttre enhet signalera till processorn att det är dags att hoppa till en särskild subrutin, en avbrottsrutin. Det låter kanske förvånande, men vi människor gör så hela tiden. Ett typexempel är telefonen: Vi går inte runt och provlyssnar i luren för att höra om någon råkar ringa just då. Vi är mer praktiskaoch har försett telefonen med en ringsignal så kan den själv kalla på uppmärksamhet när det behövs. Ett typiskt avbrott. När vi pratat klart fortsätter vi med vad vi nu höll på med. I stort sett på samma sätt går det till i en processor! Vi betraktar först avbrott i allmänhet innan de specifika egenskaperna studeras. Exempel En yttre enhet kan behöva snabb service, till exempel om en tangent på tangentbordet blivit nedtryckt eller om sekundpulsen från den yttre klockan kommer. Detta är en utmärkt situation för en avbrottsrutin. Det kritiska är att enheten vill bli betjänad snabbt. Om den inte är så känslig kanske man kan avstå från att använda avbrott och istället låta programmet, polla, d v s vid vissa programrader titta efter om en tangent blivit nedtryckt. 41

42 7 Avbrott Tangentbordet lägger ut den nedtryckta tangentens binära värde på INenheten och påkallar sedan uppmärksamhet genom att dra i avbrottssignalen. Processorn kollar just innan den påbörjar varje ny instruktion om någon ryckt i avbrottstsnöret. Om så är fallet väljer den bort nästa instruktion för ögonblicket och gör ett subrutinanrop (som sparar återhoppsadressen på stacken i vanlig ordning) till avbrottsrutinen istället. Avbrottsrutinen läser i sin tur in tecknet från tangentbordet, lagrar värdet i minnescellen för senaste tangent och hoppar sedan tillbaka till huvudprogrammet. Ett avbrott ser ut och fungerar som ett subrutinanrop med en viktig skillnad: Avbrottsrutinen måste avslutas med en speciell instruktion RTE, Re- Turn from Exception. 1 Precis som vid vanliga subrutiner lagras återhoppsadressen på stacken men eftersom ett avbrott kommer som en blixt från klar himmel måste avbrottsrutinen se till att alla register den använder återlämnas oförvanskade då avbrottsrutinen är färdig. Dessutom kan man vara säker på att statusflaggorna i SR-registret ändras av avbrottsrutinen och för att förenkla för programmeraren sparar processorn automatiskt också detta register på stacken. Man ser att återhoppsadressen lagras först och statusflaggorna sedan. Detta är ytterligare en orsak till att använda RTE för återhoppet från avbrottsrutinen. Om RTS användes skulle den ta det som lades till stacken senast (d v s SR) och tolka det som en returadress! Multipla avbrott, NMI Under pågående avbrottsrutin får inte ett nytt avbrott inträ a. Den s k avbrottsflaggan sätts för att hindra ytterligare avbrott. Då återhoppet sker måste denna nollställas igen och även detta är en uppgift för RTE. 1 Där exception är den engelska termen för undantag. Avbrott, interrupt, är en del av processorns undantagshantering. 42

43 7.1 Inledning Varför får inte nytt avbrott inträ a? Betänk vad som händer vid subrutinanrop. Stacken används för att lagra återhoppsadesserna. Om avbrottet sker tusen gånger per sekund kommer stacken att fyllas med åtskilliga tusen returadresser varje sekund! Om ytterligare avbrott inte förhindras kommer vi att fylla upp stacken på nolltid. Det finns inget inbyggt stopp i stacken utan den växer och växer tills den skrivit över något annat. Vad händer om två avbrott kommer (nästan) samtidigt till processorn? Processorn kan bara tjäna en herre åt gången, så det senare avbrottet får stå och vänta. Om det senare avbrottet är allvarligare strömmen håller på att försvinna, det är brådis att spara undan data innan hela processorn dyker kan vi helt enkelt inte vänta, avbrottet måste igenom. Av den anledningen brukar det finnas ett ytterligare avbrott som man inte kan maska bort genom att manipulera avbrottsvippan. Det kallas NMI (Non maskable interrupt) och är ett avbrott som trumfar alla andra avbrott processorn har. Sammanfattningsvis händer alltså detta vid avbrott: 1. Yttre enhet signalerar avbrott. 2. Pågående instruktion i processorn slutförs. 3. PC och SR sparas på stacken. 4. Förhindra ytterligare avbrott genom att sätta avbrottsflaggan. 5. Hoppa till avbrottsrutin (motsvarar ett JSR men ingår i avbrottsmekanismen och utförs inte som separat instruktion). När programflödet styrts över till avbrottsrutinen måste denna: 1. Spara processorns inre tillstånd, d.v.s. innehållet i processorregistren eller åtminstone de register som används i avbrottsrutinen. 2. Köra själva avbrottsprogrammet. 3. Hoppa ur avbrottsrutinen med den speciella returinstruktionen RTE, ReTurn from Exception som, bland annat, automatiskt återställer avbrottsflaggan Pollning Om flera yttre enheter kan påkalla avbrott, d v s likt på bussar och spårvagnar, att alla kan dra i linan för att stanna bussen, måste processorn på något sätt kunna avgöra vem det var som önskade uppmärksamhet. Enklast är om avbrottsrutinen går runt och frågar enheterna i tur och ordning (pollning igen, men nu vet processorn att den fått ett avbrott). Olika delar av avbrottsrutinen kan då användas till att serva olika interrupt. Pollning används som begrepp i två fall: Antingen som alternativ till avbrott eller som tillvägagångssätt för att efter att avbrott inträ at avgöra vem som skapade avbrottet. 43

44 7 Avbrott 7.2 Avbrott på Processorn har ett avancerat avbrottssystem. Förutom det vanliga externa avbrottet som vi diskuterat tidigare kan både processorn och programmet som körs orsaka avbrott. Man brukar skilja på två sorters avbrott: Vanligt (yttre) avbrott, interrupt. Detta är ett hårdvarustyrt avbrott initierat av yttre enhet och syftar oftast till att betjäna denna enhet. Inre avbrott, trap. Initieras av processorn eller programmet som körs. Används ofta för olika typer av felhantering (till exempel för att signalera division med noll), men kan även användas för att anropa andra typer av rutiner. I laborationerna använder vi TRAP 14 för att avsluta assemblerprogrammet. Tillsammans kallas dessa för undantag (exception). För styrs nästan all undantagshantering av ett antal avbrottsvektorer: 44

45

46 7 Avbrott I tabellen ser vi att DIV-instruktionen har ett eget inre avbrott en TRAP om division med noll föreligger. Om processorn finner att kod ligger på udda adress kommer Trap Illegal Instruction att utföras. De yttre avbrotten är dessutom prioriterade genom att själv kan hålla reda på åtta interruptnivåer. Den yttre enheten begär avbrott genom att lägga sin interruptprioritet, 1 7, som ett binärt värde på processorns insignaler IPL0, IPL1ochIPL2(IPL<0:2>). Om IPL = 0 innebär detta att ingen yttre enhet har begärt avbrott. Processorn (programmet) avgör vilken nivå av av brott som ska tillåtas genom den s k interruptmasken, i statusregistret, SR: Om I 2 I 1 I 0 =<100> dvs IPL=4 (Interrupt Privilege Level) kommer avbrott med nivåerna 0 till och med 4 att stoppas och alltså inte hanteras av processorn. En yttre enhet måste nu ha minst interruptnivå 5 för att inte ignoreras. IPL6 trumfar IPL5 osv.ipl7 innebär att inga avbrott kommer att betjänas förutom NMI enligt ovan som alltid slår igenom. Det är till och med så att ett avbrott på nivå 7 kan avbryta ett pågående avbrott på samma nivå Avbrott eller pollning? Så när ska man använda interrupt för en yttre enhet? Här kommer två fall att fundera över: 1. Först kan jag inte undvika telefonanalogin: Vilken interruptprioritet har telefonen? Rätt hög, eftersom jag avbryter det jag gör för tillfället och rusar iväg för att svara. Men är jag i duschen har jag höjt min interruptmask så att ett telefonabvrott inte slår igenom. Det är i varje 46

47 7.2 Avbrott på fall helt klart att det rör sig om ett avbrott och inte det andra sättet att lösa det hela: pollning, dvs att man då och då går en sväng förbi telefonen och kollar om det är någon i andra änden. 2. I min gamla ZX Spectrum (à la 1982) användes avbrott på ett sätt som underlättade för programmeraren. Tangentbordet avlästes samtidigt med ett klockavbrott 50 gånger per sekund och den tangent som då var nedtryckt om någon sparades i en minnescell och i en annan cell meddelades om en ny tangent hade blivit nedtryckt. När ett program som kördes skulle kolla tangentbordet behövde den inte gå igenom hela tangetbordsavläsningsrutinen själv utan kunde direkt kolla minnescellen om någon ny kommit in. Mycket praktiskt. Det var ju också en fördel att datorn gjorde detta åt mig så att jag aldrig behövde bry mig om hur tangenbordsavkodning gjordes. På det här sätt kunde man vara säker på att man inte missade någon tangent vilket skulle kunna hända om man bara läste tangentbordet när man behövde. En tangentnedtryckning är bara ungefär 50 millisekunder lång som kortast och om programmet återkom till tangentbegäran mer sällan kunde man missa en nedtryckning. Men ibland kan det räcka med pollning och då finns det ingen anledning att krångla till det med avbrott. 47

48 7 Avbrott 48

49 Förtydliganden M68000 (gäller även och TUTOR) De register som pekar ut adresser är internt 32 bitar långa men alla dessa bitar syns inte utåt. På är till exempel endast bitarna A1-A23 tillgängliga utåt. Detta medför att det, vid ordlängden.w, är nödvändigt att hålla ordning på samtliga utgående bitar i en adress. Speciellt är det viktigt att se till att de adressbitar som med automatik läggs ut från processorn, dvs de som man inte själv programmerat om ordländen.w används, är lika med 0. Enklast åstadkommer man detta genom att initiera adressregistret med 0, à la CLR.L A3 2, eller att direkt ladda detta register à la MOVE.L #$800,A3. Om inte full, dvs 32-bitars, adress används betraktar processorn adressen som ett tvåkomplementstal och teckenutvidgar denna till ett 32- bitars tal innan det görs tillgängligt utanför processorn om adressregistret använts med ordlängden.w: Registervärde (32 bitar) Efter teckenutvidgning Syns utåt på kretsen Registervärde (32 bitar) Efter teckenutvidgning Syns utåt på kretsen Om adressregistret använts med ordlängden.l sker ingen automatisk teckenutvidgning: Registervärde (32 bitar) Syns utåt på kretsen Som e ektiv adress <ea> i databladen räknas samtliga metoder att ange en operand. Dvs i vårt fall adressmoderna Dn, An, (An), (An)+, -(An), d(an) och så vidare. 2 Ehrm, vid närmare koll av vilka adresseringsmoder CLR kan hantera visar det sig att just adressregistren inte ingår, men vi förstår principen. 49