********************************************************
     ****        Olika addresseringss{tt p} 68000      ****
     ****            av Mike Westwood 880420           ****       
    ********************************************************

Om man t.ex. skriver:

 move.w #$20000,D0

S} {r det inte speciellt sv}rt att hajja. Allt den g|r e att den
tar siffran #$20000 ( $=hexadecimalt, %=bin{rt ) och flyttar den till
register D0. Om man nu skulle missa att skriva # f|re siffran $20000
s} tolkar datorn detta som om att du vill flytta talet i adress
$20000 till D0 ist{llet f|r sj{lva siffran $20000. Skilnaden i att om 
man skriver .w (word) eller .l (longword)  efter move {r att vid .w 
s} ber|rs bara dom 16 f|rsta bitarna (0-15) i D0 och d} kan man inte 
flytta tal till D0 som {r st|rre {n 16 bit,st|rsta talet d} blir 2 
upph|jt till 16, eller 2^16. Om man har har .l efter s} blir st|rsta 
talet givetvis 2^32. Det var det f|rsta adresserings{ttet,och det heter
Data register direct, p} Engelska.
  

N{sta adresseringss{tt {r Address register direct. Ex.

 move.l #$50000,A0

Och {r n{stan precis som f|rrg}ende men med skilnaden att man inte 
 kan flytta bytes, och att man flyttar till adressregister.
  



Det tredje adresserings s{ttet heter Address register indirect. Det 
kan man skriva som s}:

 move.l #$1000,(A1)

Det betyder att processorn flyttar talet #$1000 dit A1 pekar,det i
sin tur betyder att om talet $50000 finns i A1 s} flyttas talet $1000
till adress $50000. Allts} m{ste den adressen som man vill flytta
$1000 till finnas i register A1.
 
 
 

Fj{rde s{ttet heter s} mycket som:Address register indirect with 
post-increment. Inte s} sv}rt som det l}ter! Ett ex. f|rst:

 move.l #$1000,(A1)+

Om vi antar att talet $50000 finns i A1 s} tar datorn helt enkelt och 
flyttar talet $1000 till adress $50000 f|rst och sedan |kar den 
register A1 med ett long word,som ju {r 4 bytes, alts} kommer A1 att 
inneh}lla $50004 efter att man k|rt denna instruktion.
  



N{sta s{tt heter: Address Register Indirect with Pre-decrement.
Som vanlig ett ex. f|rst.
 move.l #$1000,-(A1)
 move.w #$1000,-(A1)
Om vi nu antar att talet fr}n d{r ovan finns i A1,dvs. $50004.
D} h{nder det bara att datorn f|rst minskar A1 med ett long word
s} att A1 inneh}ller $50000,sedan flyttar den $1000 till adress $50000.
I det andra ex. s} st}r det ju .w efter move och detta betyder
att den bara minskar med 2 bytes som ju ett .w {r. Allts} blir
A1 $50002, som den flyttar $1000 till.  
  


Address Register Indirect Addressing with Displacement (puuuh) heter
n{sta s{tt.

 move.l 8(A1),D0

Om vi antar att i A1 finns $50000. D} flyttar datorn talet som finns 
i A1+8 till D0. Allts} i detta fall det talet som finns i adress
$50008 flyttas till D0.
  



Address Register Indirect Addressing with index {r ett mycket anv{ndbart
adresserinss{tt.
  move.l 4(A1,D1.w),D0           eller
  move.l (A1,D1.w),D0              eller
  move.l (A1,A2.l),D0
eller n}gon kombination av dessa. Man kan t.ex. skriva 

 move.l 50(A1,A2.l),D0.

Om vi nu antar att i register A1 finns $50000 och i D1 $4,s} tar den 
f|rsta formen helt enkelt och flyttar det talet som finns i 
adressen som man f}r n{r man l{gger ihop 4+A1+D1 och flyttar till D0.
Alts} i detta fallet flyttas talet som finns i adress 4+$50000+4
som ju {r $50008 till D0.

 
 

Det var n{stan alla adresserins{tt som finns,iallafall dom viktigaste.
Man kan givetvis anv{nda dessa adresserinss{tt med andra instruktioner
{n move. exempelvis:

 or.w 50(a4,a1.w),d5
 lea 34(a1),a1
 add.l #42,(a1)+
 
 osv.....