Les 4: De assembler en de instructies.

Vorige  keer  hebben  we  het  gehad over de adresseringsmethoden, die ik in
vogelvlucht  even doorgenomen heb.  Ik wil nog even opmerken dat we voor het
vervolg  van  de  cursus  de modes immediate data, register direct, register
indirect,   register   indirect  met  predecrement,  register  indirect  met
postincrement,  en  register indirect met offset heel vaak zullen gebruiken,
en  alle andere methoden veel minder vaak.  Wie nog wat op te halen heeft en
dus het beste daar zijn krachten op richten.

Nu  wil ik het hebben over de syntax van de assembleertaal en het format van
machinecode-instructies.  Wat moeten we ons nou voorstellen bij 'assembler',
'machinecode' en dat soort dingen?

Wat is assembler? 

Assembler, netjes assembly language, of netjes Nederlands assembleertaal, is
een  voor  mensen leesbare notatie van machinecode instructies, in ons geval
voor de 68000 microprocessor.

Een  assembler,  of  assembleerprogramma,  is een programma dat deze notatie
omzet  naar  machinecode.   Een  assembler  gebruikt als input een tekstfile
waarin de programmeur een aantal instructies heeft geschreven, en produceert
een programma dat de computer kan uitvoeren.

Een assembler is dus voor assembleertaal wat een compiler is voor C, of voor
Pascal.

Machinecode is een verzameling van getallen die ieder een bepaalde handeling
van  de  processor  eenduidig  specificeren.   Een  reeks van zulke getallen
noemen we een programma.

De  opdrachten  die  de programmeur geeft in de tekstfile die hij of zij aan
het  vertaalprogramma  voert,  kunnen  van  tweerlei  aard zijn.  Het kunnen
opdrachten  aan  de  68000  processor zijn, die in machinecode moeten worden
vertaald,  en  het  kunnen  opdrachten  aan  het  assembleerprogramma  zijn,
bijvoorbeeld  of  er  al of niet een listing moet worden gegenereerd tijdens
het  vertalen.   Deze  laatste  zal  ik  voorlopig  niet  behandelen om geen
verwarring  te  stichten;  we  komen  ze vanzelf tegen bij het programmeren.
Bovendien wisselen ze enigszins per assembleerprogramma.



         SYNTAX

De  instructies hebben een bepaalde vorm.  Om te beginnen staat er op iedere
regel van de invoer maar 1 instructie of pseudo-instructie.

( Een pseudo-instructie of pseudo-op(code) is een aanwijzing aan het 
  assembleerprogramma.)

Dit  is  ook  de  reden  dat  assemblerprogramma's  zo  enorm groot zijn als
sourcecode,  het is heel gewoon om voor een programma dat als .PRG file 1500
bytes in beslag neemt 20 K tekstfile aan de assembler te moeten voederen.

De algemene syntax is:

[<label>] <opcode>[.<size>]  [<source>,<dest>]     [; commentaar]

Onderdelen tussen haakjes mogen soms of altijd worden weggelaten.

Een label is altijd optioneel.

De opcode of pseudo-opcode is verplicht.

De size of grootte is optioneel; bij ontbreken wordt .w aangenomen.  Er zijn
ook opcodes met een vaste size waar niet van kan worden afgeweken.

Of  source  en  dest nodig zijn hangt af van de opcode.  Er zijn opcodes die
geen  argumenten  nodig  hebben,  zoals NOP, andere die er precies een nodig
hebben,  zoals  JMP  of CLR, en weer andere die er altijd twee nodig hebben,
zoals MOVE.  Twee komt het meest voor.

Een  regel die met een * sterretje begint wordt door de assembler genegeerd.
Commentaar  aan  het  eind  van  een  regel  wordt  ook door het assembleer-
programma  overgeslagen,  en hoeft niet met ; te beginnen maar dat staat wel
netter.

   Omdat  assemblerprogramma's  toch al weinig structuur van zichzelf hebben
en  moeilijk te begrijpen zijn voor ieder ander dan de programmeur ervan, is
het  belangrijk  om  veel  aandacht  en tijd aan het commentaar te besteden.
Niet  becommentarieerde  assemblercode  is  het  best  met  'write-only'  te
beschrijven; lezen is ook voor de programmeur ervan na een paar maanden niet
meer mogelijk zonder uitgebreide studie.

   Let  ook  op  het  'wit':  een label moet voor de meeste assemblers in de
eerste  kolom  beginnen,  en  na  het  label moet minstens een spatie of tab
volgen  om  het  label te onderscheiden van de opcode.  De size wordt aan de
opcode vastgeplakt, en de operandgroep wordt weer door middel van een spatie
of  tab  van  de  opcode  gescheiden.   Als er twee operanden zijn moeten ze
worden  gescheiden  door  een  komma, en tussen de operanden mogen zich geen
spaties  bevinden.   Commentaar  moet door minstens een spatie of tab worden
gescheiden  van  de  operanden.   Labels  moeten beginnen met een letter, en
mogen  verder  wel  cijfers  bevatten.   Sommige assemblers staan nog andere
tekens  toe, maar het is zaak hiermee voorzichtig te zijn als we code willen
schrijven die liefst ongewijzigd door andere assemblers kan worden vertaald.

Om maar met onze oude vriend move te beginnen:

start   move.w  d0,d1           ; kopieer de woordinhoud van d0 naar d1

is een voorbeeld van een legale instructie.

Wat bakt zo'n assembler daar nou van bij het vertalen? 
Nou, deze instructie leidt in het programma tot de volgende code:

0011 001 000 000 000 = $3200 = 12800 decimaal.

Hoe weet ik dat? 
Opgezocht in een aantal tabelletjes in het 68000 pocketbook.

Hoe werkt het?  Nou, de eerste groep van vier bits geeft aan welke opcode we
hebben.  0011 is move.w.

 ( Omdat move zo ontzettend vaak voorkomt, is er voor iedere lengte een
   aparte opcode gebruikt. 0001 is bijvoorbeeld move.b. Andere instructies
   moeten soms opcodes delen, zo hebben cmp en eor de opcode 1011 gemeen,
   uit  verdere bits moet dan blijken welke instructie bedoeld is. )

Het  tweede  groepje  van  drie is 001, en geeft het nummer van het register
waar  het  resultaat  heen  moet.  We kunnen van 0 tot zeven tellen met drie
bits  dus  er gaat geen enkele ruimte verloren.  We weten nu alleen nog niet
of  we d1 of a1 moeten hebben, of misschien (a1) of -(a1), maar dat staat in
de  volgende groep van drie bits.  Mode 000 = data register direct, d1 wordt
het dus.

 ( Zo is 001 adresregister direct, bv. a1 
   010 adresregister indirect, of (a1),
   011 adresregister indirect met postincrement (a1)+, 
   100 adresregister indirect met predecrement -(a1) 
   etc.)

Het derde groepje van drie is 000 en geeft de mode van het
sourceregister.   Het  vierde groepje is ook 000 en geeft het nummer van het
sourceregister.

Dit patroon:

 (4 bits opcode)
 (3 bits dest reg nummer)
 (3 bits dest reg mode)
 (3 bits source reg mode )
 (3 bits source reg nummer )

komt vaak terug, soms met kleine modificaties.
Overigens  is dit niet echt belangrijk om te weten voor de programmeur, maar
ik  vond het zelf toch heel interessant en verhelderend om dit te leren.  Je
kunt  je  een praktische voorstelling maken van het werk van de assembler en
zien dat er niets magisch aan is, je zou het ook met de hand kunnen doen met
een paar bladzijden vol tabelletjes.  Dat zou ik overigens niemand aanraden,
ik  heb  het  wel  eens moeten doen voor een paar instructies, maar je maakt
bijzonder snel een vergissing...

    Wat  we  wel zien is dat een instructie voor de 68000 altijd minstens 16
bits  lang  is, in tegenstelling tot de 8088 familie waarbij wel instructies
van  een  byte  groot  voorkomen.   Dit  feit,  en  het feit dat pointers in
principe  altijd  32  bit  in  beslag nemen is de oorzaak dat programma's in
68000 assembler meestal wat meer ruimte innnemen dan equivalente programma's
voor   de   8086   processor.   Daar  staat  tegenover  dat  de  68000  veel
gemakkelijker  te  programmeren  is  door  de  veel universeler te gebruiken
registers  en  de  lineaire adresruimte.  Een instructie van minder dan twee
byte  kan dus niet, en de de PC mag nooit een oneven adres bevatten, evenmin
als  we  een  woord  of langwoord op een oneven adres kunnen adresseren; dit
leidt onmiddelijk tot een crash.

We  kunnen  echter  wel  meer  ruimte  dan  twee  byte nodig hebben voor een
instructie, als we adresseringen gebruiken met offset bijvoorbeeld:

        move.l  200(a0),d1
 
dan wordt dat in dit geval gedaan door het getal 200 achter de instructie te
plakken,  die  daarmee  2  bytes  langer  wordt.  De maximale lengte van een
instructie  is  dus  10  byte,  nl.   als  je  twee lange woorden extra moet
specificeren:

        move.l  #$0FFA1123,$00101024

leidt  ertoe dat zowel het adres $101024 als de waarde $FFA1123 als een lang
woord  achter  de  twee  bytes  van  de  instructie  worden  geplakt, totale
instructiegrootte  10  byte.   Dit  zijn zoals je zult begrijpen ook niet de
snelste instructies.  Over die snelheid:  de instructie

move.w d0,d1 

kost 4 kloktikken, oftewel 0.5 microseconde op een 8 Mhz 68000. 
De instructie

        move.l #$0FFA1122,$00101023

kost  28  kloktikken, ofwel 3.5 microseconde op hetzelfde systeem.  Nog niet
bepaald langzaam maar wel 7 keer langzamer dan een register-register move.

And now for something completely different:

Hands-on experience! We gaan aan de slag...

 ( Het navolgende is van toepassing voor bezitters van een Atari ST, voor 
   Amiga-bezitters en Macintoshers zijn er ook wel zulke programma's maar
   daar zul je zelf aan moeten komen vrees ik... wat je nodig hebt is een 
   monitorprogramma met assembler-instructie interpretatie-mogelijkheid. )

Nu is de tijd gekomen om eens wat te proberen met onze PD assembler.  Het is
een  programma  dat niet erg vergevensgezind is tegenover fouten en dan vaak
zonder  vorm  van  proces  crasht; doe je het echter goed dan kun je er veel
mee.    Het   is   geschreven   door  een  duitse  scholier  die  zelfs  een
programmeerwedstrijd  heeft  gewonnen  met  een muziekprogramma, gemaakt met
deze assembler.  Het is typisch eigengemaakt gereedschap:  Het kan veel maar
je  moet  het zelf goed doen.  Mag ik iedereen aanraden de handleiding enige
malen door te lezen alvorens verder te gaan?

( --- )

Goed,  we  hebben  allemaal de handleiding gelezen en er misschien veel niet
van  gesnapt, maar dat geeft niet, we weten nu tenminste waar het staat.  Nu
eens zien of we het programma aan de praat kunnen krijgen.

We klikken het programma aan en zien een melding van de auteur.  De volgende
drie  items  klikken we door met de returntoets, tot we de prompt > krijgen.
nu typen we het commando:

reg <return>

en we zien het volgende:

 D0=$00000000  A0=$00000000
 D1=$00000000  A1=$00000000
 D2=$00000000  A2=$00000000
 D3=$00000000  A3=$00000000
 D4=$00000000  A4=$00000000
 D5=$00000000  A5=$00000000
 D6=$00000000  A6=$00000000
 D7=$00000000  A7=$00000000

SR: T-S--III---XNZVC
    0000000000000000

Leuk he?

Wat  we hier zien is de opbouw en de toestand van de 68000!  Jullie zien dat
ik  het  niet  allemaal maar verzonnen heb.  Het programma heeft netjes alle
registers en vlaggen voor ons op nul gezet.

We  zien  dat  er  inderdaad 8 dataregisters d0-d7 en 8 adresregisters a0-a7
zijn.  We zien de vlaggen XNZVC, die allemaal op nul staan.

Verder  zien  we  een  paar dingetjes die ik heb overgeslagen:  de tracemode
vlag T, de supervisor mode vlag S, en de drie interrupt level bits III, waar
we  het nog niet over hebben gehad, en die we voorlopig zullen vergeten.  Nu
kunnen  we  eens  proberen  om  een  paar  instructies direct uit te voeren.
Hiervoor  heeft  de  assembler  een  interpret-mode,  als  we een !  voor de
instructie  typen  wordt hij vertaald en uitgevoerd, en de resultaten kunnen
we  met  reg  weer  bekijken.   Het  is  logisch  dat we op deze manier geen
pc-relatieve  adresseringen  kunnen  gebruiken  en  ook geen sprongen kunnen
maken.  Ook van de stackpointer, register a7, moeten we afblijven.

typ in:

!move.l #$12348678,d0 <return>

Het uitroepteken is nodig en geeft aan dat we een instructie gaan
interpreteren.

daarna typen we weer: 

reg <return>

en  we  zien,  dat  d0 inderdaad de waarde $12348678 heeft gekregen.  verder
zien we dat a7 opeens niet meer nul is, maar dat is een gevolg van het lopen
van  het programma, dat heeft niets met ons te maken.  Ook de interruptlevel
bitjes negeren we even.

Nog een proberen?

!move.b d0,d1
reg

en we zien dat de onderste byte van d1 de waarde $78 krijgt.

!move.w d0,a0
reg

Nu zien we iets dat we misschien al weer vergeten waren:

 a0 bevat niet $00008678 maar $FFFF8678,

omdat  bij  woordadressering  van  een  adresregister het hoogste bit van de
source wordt gebruikt om het sourcegetal tot 32 bits uit te breiden.  Dat is
altijd zo, en het is belangrijk dit te onthouden.

Inmiddels  zullen  we  ons al wel eens vertypt hebben.  Geeft niets, als het
programma crasht gewoon weer starten en opnieuw beginnen.

Nu een vuile:

!move.b d0,a0

crash!  byte adressering van adresregisters niet toegestaan, remember?

experimenteer  zelf  nog  eens  wat,  en  bedenk  dat  het  lastig  is om de
adresseringen  (a0),  -(a0),  (a0)+, d(a0) te gebruiken als a0 niet naar een
bestaande en toegankelijke geheugenplaats wijst.....

Geheugenplaatsen  onder  $800  zijn in de Atari beschermd door het operating
system en mogen niet worden gelezen of beschreven.  Maar met

!move.l #$810,a0

kun  je  een  geldig  adres  in a0 laden, en de adressing modes (an), -(an),
(an)+, d(an) uitproberen, en voor zover ik het heb getest zonder onmiddelijk
te  crashen.  Bedenk wel dat er toch veranderingen kunnen zijn opgetreden in
het systeem, zodat je na je experimenten beter even kunt resetten.

Nogmaals:  van de stackpointer a7 moet je afblijven, dat geeft bommen.

Dat  was het dan weer voor wat betreft deze les.  Volgende keer:  ons eerste
programma,  om  de  smaak een beetje te pakken te krijgen, en daarna gaan we
systematisch aan de slag met alle instructies.