Programmiermodell - Moderne Prozessorarchitekturen: Prinzipien und ihre Realisierungen - page 45

zessoren zu beschreiben. Die Programmbeispiele in diesem Buch sollten dennoch
verständlich sein, da sie jeweils in Kommentaren, in Fußnoten oder im Text erläutert
werden. In einigen Fällen wird auf eine Beschreibung der Funktionsweise von
Befehlen auch verzichtet, wenn nämlich die verwendeten Mnemone selbstdokumen-
tierend sind. Zum Beispiel kennzeichnet das Mnemon „add“ den Befehl „addiere“,
das Mnemon „sub“ den Befehl „subtrahiere“.

Die Assemblerschreibweise der Befehle unterschiedlicher Prozessoren variiert
meist in Details, wie z.B. der Groß- und Kleinschreibung oder der Reihenfolge, mit
der die Operanden und das Ergebnis angegeben werden. In Programmbeispielen, die
nicht auf einen konkreten Prozessor bezogen sind, sei deshalb festgelegt, dass die
Befehle klein zu schreiben und das Ergebnis jeweils vor den Operanden anzugeben
ist (ähnlich wie in vielen Hochsprachen). Für die Adressierungsarten kommen dabei
die in Tabelle 1.2 (auf Seite 28) aufgelisteten Schreibweisen zur Anwendung.

Tabelle 1.8. Auswahl an Assemblerbefehlen zu unterschiedlichen Prozessoren

Prozessor
(Hersteller)

Assemblerbefehle

ColdFire MFC5206
(Motorola)

move.l d2, d1 // 32 Bit Registerzuweisung: d1 = d2

sub.l #100, d1 // 32 Bit Subtraktion: d1 = d1 - 100

add (100), d1 // 16 Bit Addition: d1 = d1 + mem [100]

beq loop // Bedingter Sprung: if (zero) goto loop

Itanium 2
(Intel, HP)

mov r1 = r2 // 64 Bit Registerzuweisung: r1 = r2

add r1 = -100, r1 // 64 Bit Subtraktion: r1 = r1 - 100

ld4 r1 = [r2] // 32 Bit Ladeoperation: r1 = mem [r2]

(p1) br loop // Bedingter Sprung: if (p1) goto loop

i8051
(Intel, Siemens)

MOV R1 , A // 8 Bit Registerzuweisung: R1 = A

ADD A , #-100 // 8 Bit Subtraktion: A = A - 100

ADD A , 100 // 8 Bit Addition: A = A + mem [100]

JZ loop // Bedingter Sprung: if (zero) goto loop

Nemesis
(TU Berlin)

or r1 , 0, r2 // 32 Bit Registerzuweisung: r1 = r2

sub.cr0 r1 , r1, 100 // 32 Bit Subtraktion: r1 = r1 - 100

lduh r1 , [100] // 16 Bit Ladeoperation: r1 = mem [100]

beq.cr0 loop // Bedingter Sprung: if (cr0.zero) goto loop

Pentium 4
(Intel)
Athlon64
(AMD)

mov eax , ebx // 32 Bit Registerzuweisung: eax = ebx

sub eax , 100 // 32 Bit Subtraktion: eax = eax - 100

add ax , word ptr [100] // 16 Bit Addition: ax = ax + mem [100]

je loop // Bedingter Sprung: if (zero) goto loop

PowerPC 970
(IBM)
PowerPC MPC750
(Motorola)

mr r1 , r2 // 32 Bit Registerzuweisung: r1 = r2

subi. a

r1 , r1, 100 // 32 Bit Subtraktion: r1 = r1 - 100

lhz r1 , 100 (r0) // 16 Bit Ladeoperation: r1 = mem [100]

beq cr0, loop // Bedingter Sprung: if (cr0.zero) goto loop

Transputer T9000
(Inmos)

ldl 1 // 32 Bit Zuweisung: A = workspace [1]

sub // 32 Bit Subtraktion: A = B - A

ldnl 100 // 32 Bit Ladeoperation: A = mem [100]

cj loop // Bedingter Sprung: if (A != 0) goto loop

mov b UltraSPARC IIIi

(Sun)

%g2, %g1 // 32 Bit Registerzuweisung: %g2 = %g1

subcc %g1, 100, %g1 // 32 Bit Subtraktion: %g1 = %g1 - 100

lduw [100], %g1 // 16 Bit Ladeoperation: %g1 = mem [100]

be loop // Bedingter Sprung: if (zero) goto loop

a. Der Befehl wird durch eine Addition r1 = (-100) + r1 nachgebildet.

b. Der Befehl wird vom Assembler durch ein Oder nachgebildet (or %g1, 0, %g2).