Les 3: De addressing modes en een inleiding in de syntax.

Dit  is  een beetje de zure appel van het programmeren in assembler.  Het is
makkelijk  om  in  de  war te raken.  Maar voor wie de uitleg stap voor stap
volgt is het niet moeilijk, alleen veel.

We  hebben  de  vorige  keer  gezien  dat  de 68000 processor bestaat uit 16
registers,  (8  dataregisters en 8 adresregisters) en dat hij verder toegang
heeft  tot maximaal 16 megabyte geheugen.  De inhoud van de registers en van
het geheugen kan op vele manieren door de processor worden gebruikt.  Om een
getal,  register  of  geheugenadres  te specificeren hebben we de zogenaamde
'addressing modes'.  Er zijn er een stuk of tien.  We zullen ze een voor een
bespreken, en tussendoor vast iets over de syntax van de assembler zeggen en
wat voorbeelden geven.  Dat gooit de systematiek van de inleiding een beetje
in de war maar maakt de addressing modes wel veel begrijpelijker.


1) Immediate data.

Dit  is  gewoon  een  getal  dat  door de programmeur in het programma wordt
geschreven als:

        #getal   

Bijvoorbeeld :  #17, of #$F1, (Wat tussen haakjes hetzelfde getal voorstelt)
De '#' is nodig, zoals we straks zullen zien heeft '17' een andere betekenis
dan '#17'.


2) Register direct

Ook  niet  zo  moeilijk, hierbij schrijf je gewoon de naam van het register.
dus  bijvoorbeeld  d0,  a0, a7.  De processor gebruikt dan de inhoud van het
betreffende register.

Met deze twee modes kunnen we al instructies maken:

        move.l  #$FF120233,d0

Dit betekent: zet het getal $FF120233 in register d0.

Let eens op hoe deze regel in elkaar zit.
We  zien dat we inspringen van de kantlijn, dan komt de instructie, die hier
'move'  is.  Dit is in alle programma's de meest gebruikte instructie, en we
zullen hem goed leren kennen.  Na de naam van de instructie volgt de lengte-
specificatie,  hier  '.l'  (long).  Dat wil zeggen dat de instructie alle 32
bits  van  d0  in  de  operatie  moet  betrekken.  Na het uitvoeren van deze
instructie  is  de  inhoud  van  d0  gelijk aan $FF120233.  Als we daarna de
opdracht geven:

        move.w  #$1000,d0       ; let op de '.w'

Dan  wordt  het getal $1000 in d0 gezet, maar alleen in de onderste 16 bits!
De nieuwe inhoud van d0 is dan dus $FF121000, omdat de bovenste 16 bits niet
zijn  veranderd  door de '.w' instructie.  De bronoperand is hier het getal,
de  bestemming is d0.  De notatie is zo dat de source(bron) steeds links van
de  komma staat, en de destination (bestemming) rechts, in tegenstelling tot
de  conventie  bij  veel  andere processors, zoals de 8086.  Ook de komma is
verplicht.

De syntax van de move instructie is:

[<label>]  move[.<lengte>]  <source>,<dest>      [; commentaar]

Onderdelen tussen [haakjes] mogen worden weggelaten.
In het algemeen mag een assemblerstatement in grote en kleine letters worden
geschreven,  dus move == MOVE en a0 == A0.  Als we de lengte weglaten, neemt
het  assembleerprogramma  aan  dat  we .w (word) bedoelen.  Verder is nog de
lengte  .b  (byte)  mogelijk  (als  de  bestemming  geen  adresregister is).
Bijvoorbeeld:

demo    move.b  #$FF,d0         ; zet $FF in de onderste byte van d0
        move.w  #-200,a0        ; zet -200 in a0
        move.l  #-1,a6          ; zet -1 = $FFFFFFFF in a6.

( Een eigenaardigheid van adresregisters is dat in tegenstelling tot
  dataregisters de gehele inhoud ervan  wordt beinvloed als ze destinatie
  van een  .w  bewerking zijn.  Het hoogste bit van het lage woord  wordt
  gekopieerd in alle bits van het hoge woord. Meer hierover later.)

Ook moves van register naar register zijn toegestaan.

demo2   move.w  a0,d0

kopieert de onderste helft van a0 naar de onderste helft van d0.

        move.l  d0,d6           ; prima
        move.b  d0,d1           ; prima
        move.b  d0,a1           ; dit mag NIET! waarom?

Antwoord: omdat adresregisters niet als byte te adresseren zijn.

Goed, nu we een zeker inzicht hebben verworven in de immediate data mode, de
register  direct mode, in de assembleertaal-syntax en in de move instructie,
gaan we meteen maar verder met de volgende addressing mode:

3) Register indirect.

Dit  is  een veel voorkomende manier als we gegevens uit het geheugen willen
halen.  Hij werkt alleen met adresregisters, niet met dataregisters.  Als we
als source of destination (a0) opgeven, neemt de processor niet het getal in
a0 maar het getal in het geheugenvakje waarvan het adres in a0 staat.

Voorbeeld:  Stel in a0 staat het getal 1000.  In het geheugen staat op adres
1000 de bytewaarde $FF.  Schrijven we nu de instructie:

        move.b  (a0),d0 

Dan leest de processor die byte $FF en zet hem in d0.  Het wordt nu hopelijk
duidelijk waarom de a-registers adresregisters genoemd worden.

Nog  een  voorbeeld:  stel op adres 1000 staat een byte met waarde $FF en op
adres 1001 staat een byte met waarde $12.  a0 bevat de waarde 1000.

         move.w  (a0),d1

leidt  er  dan  toe  dat de onderste helft van d1 de waarde $FF12 bevat.  De
waarden  op  adres 1000 en 1001, en in a0, blijven onveranderd.  stel dat op
1002 en 1003 de waarden $26 en $38 staan, dan bevat d2 na de instructie

        move.l  (a0),d2

de waarde $FF122638.

Er  schuilt  een addertje onder het gras:  als we een woord of langwoord uit
het  geheugen  willen lezen of ernaartoe willen schrijven mag dat alleen als
we  een even getal in het adresregister hebben.  Als dus a0 1001 bevat en we
geven de opdracht

        move.w  (a0),d0 

dan  leidt  dat  tot  3 bommetjes c.q.  een guru meditatie...  De instructie
move.b (a0),d0 mag echter wel.

Dit  is  misschien het moment om even uit te weiden over adressering van het
geheugen.  Als a0 weer de waarde 1000 bevat, dan lees je met de instructie

        move.b  (a0),d0

1 byte uit het geheugen, op de plaats 1000.

       move.w   (a0),d0

haalt  2  bytes  op,  van  de plaatsen 1000 en 1001.  De byte op plaats 1000
wordt  de  meest significante van het onderste woord in d0.  De byte op 1001
wordt dus gekopieerd naar de laagste byte van d0.

      move.l   (a0),d0

haalt  4  bytes op, van de geheugenplaatsen 1000,1001,1002,1003.  En de byte
in  plaats 1000 wordt gekopieerd naar de hoogste byte in d0, de byte in 1003
naar de laagste.

( Verder tast de move net zo min als alle andere instructies de inhoud 
  van de source aan; het is niet echt een 'move' operatie maar meer een
  'copy' maar waarom ze dat dan niet zo genoemd hebben zou je aan Motorola 
  moeten vragen... )
De volgende methode is verwant aan de vorige: 


4) register indirect met postincrement.

Deze  methode  is heel handig als we snel een reeks waarden uit het geheugen
willen  lezen,  vergelijken of schrijven.  We schrijven:  (an)+ waarbij n in
[0..7]  Het  werkt  bijna  net  als  (an)  maar het verschil is dat NADAT de
betrokken   geheugenplaats   is  gelezen  of  geschreven  het  adresregister
automatisch  wordt  opgehoogd  met het aantal bytes dat de instructiegrootte
aangaf.   Voorbeeld:  stel dat a3 de waarde 1000 bevat, en de bytes op adres
1000  en verder zijn nog steeds $FF,$12,$26,$38, dan is het resultaat van de
volgende instructie:

        move.w  (a3)+,d0

dat  d0  $FF12  bevat in de onderste 16 bits, en a3 bevat nu het getal 1002.
Dus  eerst  wordt  de  waarde  op  het adres waarnaar a3 verwijst gehaald en
daarna wordt a3 opgehoogd met het aantal bytes dat gelezen of geschreven is.
Hadden we geschreven:

        move.b  (a3)+,d0        ; een byte grootte instructie dus,

dan  had  d0 $FF bevat in de onderste byte, en a3 na de instructie 1001.  Op
dezelfde  manier  had  na een .l instructie a3 1004 bevat.  De waarde in het
adresregister wijst dus steeds voorbij de geheugenplaatsen die we net hebben
gehad, en naar de plaats waar we misschien verder willen gaan.

Deze addressing mode heeft nog een verwant:


5) register indirect met predecrement.

We schrijven: -(an)
Wat  gebeurt  er:   VOORDAT  de  waarde  uit  het  geheugen wordt gelezen of
geschreven   wordt  eerst  het  a-register  met  het  aantal  bytes  van  de
instructiegrootte  verminderd.   Als  dus a0 1004 bevat en de bytes op adres
1000  en  verder  nog  steeds  $FF,$12,$26,$38 zijn, is het resultaat van de
instructie:

        move.l  -(a0),d5

dat d5 de waarde $FF122638 bevat en a0 de waarde 1000.  Merk op dat de (an)+
en  -(an)  methode  erg  op elkaar lijken, met het verschil dat bij de (an)+
methode  het adresregister NA de toegang tot het geheugen wordt veranderd en
bij de -(an) methode VOOR de toegang tot het geheugen.

( Er is een register dat vrijwel altijd op deze twee manieren wordt 
  gebruikt, met afwisselend postincrement en predecrement, nl a7, 
  oftewel de stackpointer.
        move.l  a0,-(a7)        ; en 
        move.l  (a7)+,a0        ; 
  heffen elkaar exact op. Ga dit na! )

6) register indirect met offset.

Voor  wie  de  vorige  modes  doorheeft  zal  dit niet te moeilijk zijn.  We
schrijven:   d(an) , waarbij d een getal van maximaal 16 bits groot mag zijn
en  n  natuurlijk  mag  varieren  van  0  tm  7.   Als a0 1000 bevat, is het
resultaat van de instructie

        move.w  2(a0),d2

dat d2 $2638 bevat in zijn onderste 16 bits, en a0 nog steeds 1000.
 d wordt door de processor opgevat als een getal met teken, dus als
 d == $FFFE is de offset -2.

7) register indirect met offset en displacement.

Van  hetzelfde  laken een pak, alleen komt er nu nog een ander register bij.
We schrijven:

        d(an,Ri[.<size>])

Voor  de  berekening  van  het  effectieve  adres wordt nu de inhoud van het
adresregister  opgeteld  bij  die  van  het indexregister Ri ( Dit mag ieder
adres-  of  dataregister zijn) en daarbij weer de displacement d, die in dit
geval  maar  1  byte  groot  mag  zijn.   <Size>  mag  .w  of .l zijn.  Deze
adresseermethode  is vrij zeldzaam in zelfgeschreven assembler- programma's,
ik  heb  hem  tenminste  nog  nooit gebruikt omdat ik altijd met eenvoudiger
methoden ben uitgekomen.  Voor adresseringen in een array is het wel handig.
Voorbeeld:

        move.w  $56(a0,d1.w),d2

Bedenk zelf wat deze instructie doet.


8) Absoluut adresseren:
We geven een adres op waar de processor zijn data vandaan moet lezen.

        move.l  1000,d0

laadt de waarde op adres 1000 in d0. (dus de bytes op 1000,1001,1002,1003)

Een veel voorkomende vergissing is dat je schrijft 1000 als je #1000
bedoelt. Dat kan soms lang zoeken zijn.

( Deze methode wordt eigenlijk zelden gebruikt, omdat je nooit weet waar
  het bedrijfssysteem van de computer je programma neerzet als je het
  uitvoert. Het kan overal in het geheugen terechtkomen. Je kunt dus niet
  zomaar je gegevens op vaste locaties gaan neerpoten, want dan schrijf je
  misschien over andere programma's heen of je vernietigt variabelen van 
  het bedrijfssysteem. Je moet een stukje geheugen zien te vinden waarvan
  je zeker weet dat je erin mag schrijven zonder kwaad te doen. Meestal 
  vraag je dat aan het operating system, dat je dan een vrij gebied wijst.
  Dan zet je het beginadres van dat gebied in een adresregister
  en adresseert het gebied met de indirecte modes die we hebben gezien. )

Van  deze  instructie  bestaan  eigenlijk twee vormen, een korte, die een ds
gebruikt  dat  kan liggen tussen $0000 en $FFFF, en een lange vorm die ieder
adres  kan  gebruiken.   Bij  gebruik van een kort adres waarvan bit 15 1 is
wordt  het volledige adres gevormd door er enen voor te zetten, zodat met de
korte vorm de hoogste en de laagste 32 K byte van het geheugen kunnen worden
geadresseerd.  Hier is natuurlijk altijd het operating system gelokaliseerd,
om zoveel mogelijk profijt van deze ruimtebesparing te kunnen trekken.  Voor
ons gebruikers is alleen de lange vorm van belang.

9) PC-relatief.

We adresseren ten opzichte van de waarde van de program counter.

        move.w  -300(pc),d0

laadt  het woord dat driehonderd bytes voor de huidige waarde van de program
counter  staat  in  de  onderste  helft  van  d0.  Dit mag alleen bij source
operands,  maw naar een op deze manier geadresseerde locatie mag niet worden
geschreven,  om  redenen  die  we  later  uit  zullen  leggen.  Wordt vooral
gebruikt om naar adressen te springen, zelden om variabelen of constanten te
lezen.  Kan ook nog met offsetregister worden gebruikt:


pc-relatief met index en displacement

        move.w  120(PC,d2.w),d0

laadt  de  waarde  op het adres, verkregen door de pc en de onderste 16 bits
van d2 bij 120 op te tellen, in d0.

Ook een beetje een exoot.

 ( Men zou kunnen denken dat deze 2 adresseringen het voor de programmeur 
   nodig maken om te weten hoe lang alle instructies zijn, om uit te kunnen
   tellen hoe groot de gewenste displacement is. Dat zou wel kunnen, maar
   meestal laten we het assembleerprogramma dat werk doen en adresseren we
   met labels, zodat we ons over de grootte van de offset niet het hoofd
   hoeven te breken. )

Dat  was  het  dan weer voor wat betreft deze les.  Ik wil nog even opmerken
dat  alle  offsets  gewoon  als het getal of als label worden genoteerd, dus
niet  met  het  #  teken  ervoor.   Dus  10(a0)  of  varA(a0)  (als varA een
getalswaarde  heeft),  en  NIET  #10(a0) of #varA(a0).  Alleen bij immediate
data wordt # gebruikt, dus #10 of #varA.  Over die labels later meer.