MC68020: Expected result A7 indirect with post increment

Sven S. OP #3037043
Lesenswert?
• ▲
▼ 
Ich bin gerade beim Testen eines eigenen Emulators für den Motorola 
MC68020. Als "Referenz" dient mir der Musashi Emulator. Bei folgendem 
Befehl verhalten sich beide Emulatoren unterschiedlich, aber ich bin mir 
nicht sicher, welches Ergebnis der Realität entspricht.
1
moves.b a7, (a7)+

In a7 steht testweise 0xFFFF0008. Mein Emulator schreibt auf Adresse 
0xFFFF0008 den Wert 0x08, während Musashi den Wert 0x0A schreibt. Ich 
tendiere ja dazu einem ausgereiften Emulator gegen einem neu 
geschriebenen Recht zu geben, aber eigentlich ist mein Verständnis, daß 
hier der Wert von A7 auf die von A7 adressierte Speicherstelle zu 
schreiben ist und danach der Wert von A7 zu incrementieren ist (und 
nicht der incrementierte Wert zu schreiben).
Aber wie verhält sich der MC68020 tatsächlich? Möglich wäre ja auch, daß 
direkt nach dem Lesen aus A7 incrementiert wird (also post increment 
nach Lesen von A7 und nicht nach Befehlsabarbeitung) und damit dann 
tatsächlich A7+2 geschrieben werden würde. Oder anders ausgedrückt: wann 
wird incrementiert? Nach Lesen von A7 oder nach Abarbeitung des Befehls?
Vielen Dank für die Hilfe schon mal!
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Bernd K. #3037082
Lesenswert?
• ▲
▼ 
Hallo Sven,
ich habe früher sehr viele Jahre mit dem 68020 in Assembler programmiert 
- VMEbus usw. Leider habe ich keine Maschine mehr zur Verfügung um das 
an einem lebenden Objekt zu verifizieren.
Nach meinem Verständnis ist das eindeutig ein postincrement, d.h. A7 
wird NACH dem byte transfer erhöht.
Gruß
Bernd
Antwort Zitieren Bearbeiten Löschen Beitrag melden
holm Gast #3037163
Lesenswert?
• ▲
▼ 
Wenn Ihr mir dem Mschinencode mal aufschreibt und ein 68010 oder ein 
68332 diesen Befehlt auch unterstützt, kann ich evtl mal nachgucken was 
der macht.

Ich habe nur den fbug oder den CPU32Bug auf den ollen Platinen.. (KatCe)

Gruß,

Holm
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Micha Gast #3037203
Lesenswert?
• ▲
▼ 
Eigendlich sollte ja Sven recht haben, aber wenn man hier schaut:
http://bitsavers.informatik.uni-stuttgart.de/pdf/motorola/68000/CPU32_Reference_Manual_Rev1_Dec90.pdf
und zwar S.164 (acrobat-reader-zählung)

ich zitiere mal:
1
                    NOTE:

2
For either of the two following examples, which use the same address register as both source and destination, the value stored is undefined. The current implementations of the MC68010, CPU32 and MC68020 store the incremented or decremented value od An.

3


4
            MOVES.x An,(An)+

5
            MOVES.x An,-(An)


scheint also doch der Musashi Emulator recht zu haben
Gruss Micha
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Sven S. OP #3037213
Lesenswert?
• ▲
▼ 
Hallo alle zusammen und vielen Dank für die Rückmeldungen. Ihr seid 
super.
Der Maschinencode ist:
1
0E1F F800

Und der 68010 kennt den Befehl bereits.
Zur Frage, ob der Befehl Sinn macht: Der Code ist bei einem 
automatischen Test rausgepurzelt, der verschiedene Kombinationen 
gegeneinander ausprobiert. Der Befehl ist gültig und ich wäre gern so 
akkurat wie möglich. Und ich denke die Frage, wann jetzt genau 
incrementiert wird, ist noch für andere opCodes relevant. Daher der 
Versuch das zu klären. Vielen Dank für eure Hilfe! Und es wäre super, 
wenn sich das am real target verifizieren ließe :-)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Arc N. #3037217
Lesenswert?
• ▲
▼ 
Sven S. schrieb:
> Aber wie verhält sich der MC68020 tatsächlich? Möglich wäre ja auch, daß
> direkt nach dem Lesen aus A7 incrementiert wird (also post increment
> nach Lesen von A7 und nicht nach Befehlsabarbeitung) und damit dann
> tatsächlich A7+2 geschrieben werden würde. Oder anders ausgedrückt: wann
> wird incrementiert? Nach Lesen von A7 oder nach Abarbeitung des Befehls?
> Vielen Dank für die Hilfe schon mal!

Bei movem gibt es einen Unterschied: Bsp.: movem.l a0-a3, -(a0) 68k 
schreibt a0 unverändert, >68020 schreibt den dekrementierten Wert
Beim normalen move wird "After the operand address is used, it is 
incremented by one, two, or four depending on the size of the operand: 
byte, word, or long word, respectively"
Einzige Ausnahme afaik: A7/Stack, wird immer min. um 2 de/inkrementiert.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Holm T. Gast #3038413
Lesenswert?
• ▲
▼ 
Möglicherweise stelle ich mich ein wenig prasslig an, aber ich habe es 
mal probiert auf einem 68010 mit Motorola FBUG Monitor:

1
MOTOROLA> as 1000

2
$00001000 4E71            nop               ?                              

3
$00001002 4E71            nop               ?                              

4
$00001004 0E1F F800       moves.b       A7,(A7)+    ?                      

5
$00001008 4E71            nop               ?                              

6
$0000100A 4E71            nop               ?                              

7
$0000100C 4E71            nop               ?  .

8
MOTOROLA> br 1002

9
Break Point:

10
$00001002:&0

11


12
MOTOROLA> br 1008

13
Break Point:

14
$00001002:&0

15
$00001008:&0

16


17
MOTOROLA> go 1000

18
Breakpoint at $00001002

19


20
PC   =$00001002   SR   =$00002700   USP  =$00001B00   

21
SSP  =$00002000   VBR  =$00000000   SFC  =$00000003   DFC  =$00000000   

22


23
D0   =$00000000   D1   =$00000000   D2   =$00000000   D3   =$00000000   

24
D4   =$00000000   D5   =$00000000   D6   =$00000000   D7   =$00000000   

25


26
A0   =$00000000   A1   =$00000000   A2   =$00000000   A3   =$00000000   

27
A4   =$00000000   A5   =$00000000   A6   =$00000000   A7   =$00002000   

28


29
$00001002 4E71            nop                   ?  

30


31
MOTOROLA> g

32
Breakpoint at $00001002

33


34
PC   =$00001002   SR   =$00002700   USP  =$00001B00   

35
SSP  =$00002000   VBR  =$00000000   SFC  =$00000003   DFC  =$00000000   

36


37
D0   =$00000000   D1   =$00000000   D2   =$00000000   D3   =$00000000   

38
D4   =$00000000   D5   =$00000000   D6   =$00000000   D7   =$00000000   

39


40
A0   =$00000000   A1   =$00000000   A2   =$00000000   A3   =$00000000   

41
A4   =$00000000   A5   =$00000000   A6   =$00000000   A7   =$00002000   

42


43
$00001002 4E71            nop                   ?  

44


45
MOTOROLA> go 1004

46
Breakpoint at $00001008

47


48
PC   =$00001008   SR   =$00002700   USP  =$00001B00   

49
SSP  =$00002002   VBR  =$00000000   SFC  =$00000003   DFC  =$00000000   

50


51
D0   =$00000000   D1   =$00000000   D2   =$00000000   D3   =$00000000   

52
D4   =$00000000   D5   =$00000000   D6   =$00000000   D7   =$00000000   

53


54
A0   =$00000000   A1   =$00000000   A2   =$00000000   A3   =$00000000   

55
A4   =$00000000   A5   =$00000000   A6   =$00000000   A7   =$00002002   

56


57
$00001008 4E71            nop                   ?  

58


59
MOTOROLA> md 2000

60
$00002000:  $0010  $6444  $4744  $5544  $5404  $4444 

61
$0000200C:  $C544  $5444  $4544  $444C  $4045  $4505  

62
$00002018:  $4544  $4504  $4545  $6441  $5744  $5554

63
$00002024:  $4554  $5544  $554C  $4554  $4500  $5508  

64
$00002030:  $4405  $C490  $5505  $C440  $4544  $5D40  

65
$0000203C:  $5641  $5404  $4547  $4401  $5540  $44C4  

66
$00002048:  $5DD0  $4505  $4545  $5404  $4504  $5500  

67
$00002054:  $9554  $5444  $6544  $5DC4  $D554  $5444  

68


69


70
MOTOROLA>


Ich kann mir nicht erklären was die 0010 bei 2000 im Speicher zu suchen 
hat. Eine 2000 hätte ich ja für plausibel gehalten, aber A7 ist doch 
irgendwie auch der Stackpointer? Ich habe über die Dinger so gut wie 
Alles vergessen.

Gruß,

Holm
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren