8. Intel IA-32 Prozessoren: Befehlsübersicht

Transkript

1 8. Intel IA-32 Prozessoren: Befehlsübersicht Ganzzahlarithmetik Kontrollstrukturen Bitmanipulation Schieben und Rotieren Meisel 1

2 8.1 Ganzzahl-Arithmetik Übersicht add adc sub sbb imul mul idiv div inc dec neg cmp Binäre Addition Binäre Addition mit Berücksichtigung von Überträgen Binäre Subtraktion Binäre Subtraktion mit Berücksichtigung von Überträgen Multiplikation von signed Integer-Werten Multiplikation von unsigned Integer-Werten Division von signed Integer-Werten Division von unsigned Integer-Werten Incrementieren Decrementieren Negieren gemäß 2-er-Komplement Vergleich zweier Integer-Operanden Meisel 2

3 8.1.2 Addition / Subtraktion / Vergleich Befehle: add %reg, %reg mem, %reg %reg, mem $imm, %reg $imm, mem sub %reg, %reg mem, %reg %reg, mem $imm, %reg $imm, mem Die Befehle setzen die Flags Z, N, C, V abhängig vom Ergebnis (0 oder 1). Reihenfolge : Ziel = Ziel Quelle Der Vergleichsoperator (cmp) führt ebenfalls eine Subtraktion aus, setzt aber im Gegensatz zur Subtraktion lediglich die Flags und verändert die Registerinhalte nicht. Beispiele: add $15, %eax [eax(0:31)] [eax(0:31)] + 15 add %bx, %ax [eax(0:15)] [eax(0:15)] + [ebx(0:15)] sub $15, %eax [eax(0:31)] [eax(0:31)] - 15 sub (%ebx), %al [eax(0:7)] [eax(0:7)] - [M([ebx])(0:7)] Meisel 3

4 8.1.3 Multiplikation von unsigned (mul) / signed Werten (imul) Befehle: mul %reg mem imul %reg mem %reg, %reg mem, %reg $imm, %reg In der ein-operanden -Form wird ein Register/Speicher mit al, ax oder eax multipliziert und das Ergebnis in ax, dx:ax oder edx:eax abgelegt. In der zwei-operanden-form muss der Datentyp des Zielregisters gleich dem des Quellregisters/-speichers sein. N, Z, C und V werden gesetzt (je nach Ergebnis 0 oder 1) Beispiele: imul %bx # [dx:ax] [ax] * [bx] imul %ecx # [edx:eax] [eax] * [ecx] imul $12,%ebx # [ebx] [ebx] * 12 imul %ecx,%ebx # [ebx] [ebx] * [ecx] imul 0x1000,%bx # [bx] [bx] * [M(0x1000)] mul %cx # [dx:ax] [cx] * [ax] mulw 0x1000 # [dx:ax] [ax] * [M(0x1000)] Meisel 4

5 8.1.4 Division von unsigned/signed Werten (div / idiv) Befehle: div %reg mem idiv %reg mem Operanden Dividend Divisor Quotient Rest max. Quot. word/byte ax reg/mem 8 al ah 255 long/word dx:ax reg/mem16 ax dx quad/long edx:eax reg/mem 32 eax edx N, Z, C und V werden gesetzt (je nach Ergebnis 0 oder 1) Beispiele: idiv %bx # [ax] [dx:ax] / [bx] idiv %ecx # [eax] [edx:eax] / [ecx] Meisel 5

6 ÜBUNG: Arithm. Ausdruck Schreiben Sie ein Programm, welches den folgenden Ausdruck berechnet: (X 2 + Y 2 )/(X-Y) - X und Y seien zwei positive Zahlen, - alle Berechnungen sollen im Word-Format ausgeführt werden, - Bereichsüberprüfungen sind nicht notwendig, - das Ergebnis soll im ax-register stehen, der Divisionsrest im dx-register. Initialisieren Sie X = 60 D und Y = 53 D. Welche Restriktionen gelten für X und Y? Meisel 6

7 8.2 Kontrollstrukturen Übersicht Zweck von Kontrollstrukturen: - Fortführung des Programms an anderer Stelle ohne weitere Bedingung = unbedingter Sprung - Fortführung des Programms an anderer Stelle, wenn eine bestimmte Bedingung erfüllt ist = bedingter Sprung Meisel 7

8 8.2.1 Übersicht: Unbedingte Sprungbefehle (Fortsetzung) Befehl: jmp [*]<Programm-Marke> Wirkung: Die Programmausführung wird an der angegebenen Stelle fortgesetzt. Der Programmzähler wird auf die Adresse des Sprungzieles gesetzt. Es gibt verschiedene Sprungvarianten: - Abhängig von der Sprungweite (+/- 2 7, +/- 2 15, +/ ) wird die Sprungweite mit 8 Bit (short-jump), 16 oder 32 Bit (near-jump, relative) codiert. - Durch ein * vor der Sprungmarke kann die Adresse des Sprungziels auch absolut angegeben werden (near-jump, absolute). Beispiele: jmp Lab1 # relative jump (short/near)... Lab1: mov$1, %eax jmp *Lab1... Lab1: mov$1, %eax # absolute jump (near) Meisel 8

9 8.2.1 Übersicht: Bedingte Sprungbefehle (Fortsetzung) Befehle: jcc.x [*]<Programm-Marke> Wirkung: Bedingte Sprünge erlauben die Verzweigung der Programmausführung in Abhängigkeit von Bedingungen (Condition-Codes). Es gibt eine Vielzahl von bedingten Sprungbefehlen, die sich durch die Buchstabenkombination cc in obigem Befehlscode unterscheiden. Sprungvarianten wie bei jmp Meisel 9

10 8.2.1 Übersicht: Bedingte Sprungbefehle (Fortsetzung) Sprungbefehl Bedeutung Verzweigt,wenn jcc Branch on Test einzelner Condition-Bits jnc Carry Clear C = 0 jc Carry Set C = 1 jne Not Equal Z = 0 je Equal Z = 1 jno Overflow Clear V = 0 jo Overflow Set V = 1 jns Plus N = 0 js Minus N = 1 Test mehrer Condition-Bits (signed / unsigned-operationen) jg Greater Z or (N xor V) = 0 jl Less N xor V = 1 jge Greater or Equal N xor V = 0 jle Less or Equal Z or (N xor V) = 1 ja Above C or Z = 0 jbe Below or Equal C or Z = Meisel 10

11 8.2.2 Anwendung bedingter Sprungbefehle Sehr häufig (aber nicht zwingend) werden Sprungbefehle in Verbindung mit dem Compare-Befehl verwendet. cmp S,D ; Setzen der Condition-Codes gemäss des ; Ergebnisses der Operation [D] [S] jcc Marke ; Verzweigt, wenn cc gilt Sprungbefehle können aber auch in Verbindung mit anderen Befehlen verwendet werden, sofern diese Auswirkungen auf die verwendeten Flags haben (Verschiebebefehle, log. Befehle, Schiebe- und Rotationsbefehle,. ) Meisel 11

12 ANMERKUNG Muß bei Vergleichen zwischen signed und unsigned unterschieden werden? JA!! Beispiel: 4-bit-Zahl unsigned Interpretation: 1111 B > 0111 B (15 D > 7 D ) signed Interpretation: 1111 B < 0111 B (-1 D < 7 D ) Meisel 12

13 8.2.3 Bedingte Sprungbefehle für unsigned-vergleiche mit cmp cmp Op1, Op2 ;geht dem Sprungbefehl voraus Sprungbefehl Sprung, wenn oder anders Bcc gilt gesagt jc (carry set) Op2 - Op1 < 0 Op2 < Op1 jbe (below or equal) Op2 - Op1 <= 0 Op2 <= Op1 jz (equal, d.h. if zero) Op2 - Op1 = 0 Op2 = Op1 jnz (not equal, d.h. in not zero) Op2 - Op1 <> 0 Op2 <> Op1 jnc (carry clear) Op2 - Op1 >= 0 Op2 >= Op1 ja (above) Op2 - Op1 > 0 Op2 > Op Meisel 13

14 8.2.4 Bedingte Sprungbefehle für signed-vergleiche mit cmp cmp Op1, Op2 ;geht dem Sprungbefehl voraus Sprungbefehl Sprung wenn oder anders Bcc gilt gesagt jl (less than) Op2 - Op1 < 0 Op2 < Op1 jle (less or equal) Op2 - Op1 <= 0 Op2 <= Op1 je Op2 - Op1 = 0 Op2 = Op1 jne Op2 - Op1 <> 0 Op2 <> Op1 jge (greater or equal) Op2 - Op1 >= 0 Op2 >= Op1 jg (greater than) Op2 - Op1 > 0 Op2 > Op Meisel 14

15 kleiner Exkurs zur strukturierten Programmierung (s. Kap ff.) Meisel 15

16 8.2.5 Implementierung einfacher Verzweigungen if (Bedingung) then Anweisungsfolge 1 else Anweisungsfolge 2 endif ja Bedingung nein Anweisungs- Anweisungsendif folge 1 folge 2 Implementierungsschema 1 Implementierungsschema 2 (direkte Bed-Auswertung) (negierte Bed-Auswertung) if-nn: then-nn: else-nn: endif-nn: Auswertung der Bedg. J bed then-nn JMP else-nn Anweisungsfolge 1 JMP endif-nn Anweisungsfolge 2 if-nn: then-nn: else-nn: endif-nn: Auswertung der Bedg. J not bed else-nn Anweisungsfolge 1 JMP endif-nn Anweisungsfolge Meisel 16

17 BEISPIEL: einfache Verzweigung A < B J X:= B X:= A if (A < B) then X:= B else X:= A end-if A:.word 13 B:.word 55 X:.word 1 mov A, %ax # if (A < B) if_01: cmp B, %ax # (A B) >= 0? jge else_01 # Sprung, wenn A >= B # A < B then_01: mov B, %ax mov %ax, X # X := B jmp endif_01 # A >= B else_01: mov A, %ax mov %ax, X # X := A endif_01: Meisel 17

18 8.2.6 Implementierung von Schleifen while (Laufbedingung) do Anweisungsfolge endwhile Laufbedingung Anweisungsfolge repeat Anweisungsfolge until (Abbruchbedingung) Anweisungsfolge Abbruchbedingung while-nn: do-nn: endwhile-nn: Auswertung der Bedg. J bed do-nn JMP endwhile-nn Anweisungsfolge JMP while-nn repeat-nn: until-nn: endrepeat-nn: Anweisungsfolge Auswertung der Bedg. J bed endrep-nn JMP repeat-nn Meisel 18

19 8.2.7 Implementierung von Zählschleifen for lfv:= Startwert step Schrittwert until Endwert do Anweisungsfolge enddo for-nn: until-nn: do-nn: Laufvariable auf Startwert setzen Laufvariable auf Endwert testen J lfv >= Endwert enddo-nn Anweisungsfolge step-nn: enddo-nn: Laufvariable um Schrittwert erhöhen JMP until-nn Meisel 19

20 BEISPIEL: Implementierung von Zählschleifen for lfv:= 1 step 1 until 10 do sum:= sum+1 enddo lfv:= 1 lfv >= 10 false sum:= sum+1 lfv:= lfv+1 true for_01: # --- INITIALISIERUNG mov $1, %ax # [ax] lfv mov $10, %bx # [bx] Endw until_01: # --- PRÜFUNG DER ABBRUCHBEDINGUNG --- cmp %bx, %ax # (lfv Endw.) >= 0? jge enddo_01 # Sprung wenn lfv >= Endw do_01: # --- ANWEISUNGSFOLGE add $1, %cx # sum=sum + 1 step_01: # --- INCREMENT DER LAUFVARIABLEN add $1, %ax # lfv = lfv + 1 jmp until_01 enddo_nn: Meisel 20

21 ÜBUNG: Zeichen zählen Gegeben sei ein String, der mit einer 0 abgeschlossen ist. Es ist ein Assemblerprogramm zu schreiben, welches die Anzahl der a in diesem String zählt. Gehen Sie wie folgt vor: 1. Pseudocode des Programms erstellen. 2. Assemblerprogramm erstellen. Register eax soll als Zeichenzähler verwendet werden Meisel 21

22 ÜBUNG: Stringmanipulation Es soll ein Assemblerprogramm geschrieben werden, mit dem ein String wie folgt bearbeitet wird: 1. Alle Zahlen sollen durch eine 1 ersetzt werden. 2. Alle anderen Zeichen sollen durch eine 0 ersetzt werden. Beispiel: Aus abb12xauo99 soll werden: Meisel 22

23 8.3 Bitmanipulation Logische Bitoperationen AND, OR, XOR AND = Ergebnis ist 1, wenn beide Operanden 1 sind. OR = Ergebnis ist 1, sobald mindestens einer der beiden Operanden 1 ist. XOR = Ergebnis ist 1, wenn genau einer der beiden Operanden 1 ist. Op AND OR XOR Op Erg Meisel 23

24 8.3.2 Anwendungsbeispiele Programmierung von Ein-/Ausgabe-Karten/Bausteinen/Geräten Relaiskarten Digital-I/O-Karten Schrittmotorkarten ADC-Karten (Analog-Digitalwandler) Interruptcontroller Signalverarbeitung/Bildverarbeitung Invertieren Graustufenreduktion Überlagerung von Bild und Grafik Zufallszahlenerzeugung Datensicherung (CRC-Check) Verschlüsselung Meisel 24

25 8.3.3 Befehle zur Bitmanipulation Die IA-32-Prozessoren verfügen über folgende logische Instruktionen and src,dst ; dst:= src AND dst - bitweises logisches UND or src,dst ; dst:= src OR dst - bitweises inklusive ODER xor src,dst ; dst:= src XOR dst - bitweises exklusive ODER not dst ; dst:= NOT dst - bitweises Negieren Meisel 25

26 8.3.4 Typische Problemstellungen und ihre Lösung Extraktion von Bitfeldern Logische Operationen werden z.b. verwendet, um Bitfelder zu extrahieren Beispiel: Übertragen der relevanten Bits (11-8) des Speicherwortes P und der relevanten Bits (6-0) des Speicherwortes Q an die entsprechenden Bitpositionen im Speicherwort T P Q T mov P,%ax ; Transport von P nach ax and $0b ,%ax ; alle Bits löschen, ausser Bits 8-11 mov Q,%bx ; Transport von Q nach bx and $0x007F,%bx ; alle Bits löschen, ausser Bit (6-0) or %bx,%ax ; Kombiniert die Bitfelder in ax mov %ax,t ; Transport von ax nach T Meisel 26

27 Setzen von Bits Beispiel: Setzen des Bit 10 in ax oder auch or $0x0400,%ax or $0b , %ax ax ax Meisel 27

28 Löschen von Bits Beispiel: Löschen des Bit 10 in %ax oder auch and $0xFBFF,%ax and $0b , %ax ax ax Meisel 28

29 Negieren von Bits Beispiel: Negieren des Bit 10 in %ax (toggeln = umschalten) xor $0x0400,%ax oder auch xor $0b , %ax ax ax bzw. ax ax Meisel 29

30 Übung: Bitoperationen (1) Ein auf Adresse 0x8000 liegendes Speicherwort soll wie folgt verändert werden: Die Bits 0-3 sollen gesetzt werden, die Bits 5-9 sollen gelöscht werden und die Bits sollen umgeschaltet werden. Schreiben Sie ein Assemblerprogramm Meisel 30

31 Übung: Bitoperationen (2) a) Schreiben Sie in Unterprogramm "TestBitPattern", mit folgendem Verhalten: [%bl] = 1, wenn genau Bit 0, 3 und 7 von Register %al gesetzt sind, = 0 sonst. b) Schreiben Sie in Unterprogramm "PatternTester", mit folgendem Verhalten: [%al] = 1, wenn [%bl] und [%cl] an denjenigen Bitstellen übereinstimmt (0- und 1-Übereinstimmung) die in [%dl] mit 1 markiert sind. = 0 sonst Meisel 31

32 8.4 Rotations- und Verschiebeoperationen Übersicht Rotations- und Verschiebeoperationen manipulieren den Inhalt einer Speichereinheit durch Verschieben des Bitmusters um einige Stellen nach links oder rechts. Dazu stehen bei den IA-32-Prozessoren folgende Instruktionen zur Verfügung. Rotate left rol count,dst Rotate right ror count,dst Rotate through carry left rcl count,dst Rotate through carry right rcr count,dst Logical Shift left shl count,dst Logical Shift right shr count,dst Arithmetik Shift left sal count,dst Arithmetik Shift right sar count,dst Meisel 32

33 8.4.2 Rotation (auch: zyklisches Schieben) Von einer Rotation wird gesprochen, wenn beim Verschieben kein Bit verloren geht. Die maximale Schiebewert beträgt 31. ror $imm, %reg $imm, mem %cl, %reg %cl, mem rol $imm, %reg $imm, mem %cl, %reg %cl, mem ror C C rol Beispiel: ror $3, %ax # [ax] um 3 Bit nach rechts rotieren mov $15, %cl rol %cl, %ax # [ax] um 15 Bit nach links rotieren Meisel 33

34 8.4.3 Rotation über beliebig große Bitfelder Um eine Rotation über mehr als 32 Bit zu ermöglichen, stehen die Instruktionen rcr und rcl zur Verfügung (rotate through carry). rcr $imm, %reg $imm, mem %cl, %reg %cl, mem rcl $imm, %reg $imm, mem %cl, %reg %cl, mem C rcl Beispiel: Rotation eines an der Adresse Mem stehenden 24-Bit-Wortes um 1 bit rclb $1, Mem+2 # um eine Stelle nach links, carry übernehmen rclb $1, Mem+1 # um eine Stelle nach links, carry übernehmen rclb $1, Mem+0 # um eine Stelle nach links, carry übernehmen Meisel 34

35 8.4.4 Logisches Schieben Ein logischer Shift ist eine Verschiebeoperation, wobei in die freiwerdenden Bitpositionen eine 0 nachgeschoben wird. Bits, die herausgeschoben werden, werden in das Carry-Bit geschoben. shr $imm, %reg $imm, mem %cl, %reg %cl, mem shl $imm, %reg $imm, mem %cl, %reg %cl, mem 0 C C 0 shr shl Beispiel: shr $3, %ax # [ax] um 3 Bit nach rechts schieben mov $15, %cl shl %cl, %ax # [ax} um 15 Bit nach links schieben Meisel 35

36 8.4.5 Arithmetisches Schieben Ein arithmetischer Shift ist eine Verschiebeoperation auf einem Bitmuster in der 2-er-Komplement-Darstellung (vorzeichenrichtige Erweiterung). Eine Verschiebeoperation nach links um 1 Bit entspricht der Multiplikation mit 2 und eine Verschiebeoperation nach rechts um 1 Bit entspricht der Division mit 2 sar $imm, %reg $imm, mem %cl, %reg %cl, mem sal $imm, %reg $imm, mem %cl, %reg %cl, mem sar C C sal 0 Beispiel: sar $3, %ax # [ax] durch 8 dividieren mov $4, %cl sal %cl, %ax # [ax] mit 16 multiplizieren Meisel 36

37 Übung: Schieben und Rotieren a) Schreiben Sie in Unterprogramm "XOR_07", mit folgendem Verhalten: [%bl] = 1, wenn Bit 0 und Bit 7 von Register %al ungleich sind, = 0, wenn Bit 0 und Bit 7 von Register %al gleich sind. b) Schreiben Sie in Unterprogramm "RotateLower5", mit folgendem Verhalten: - Bei jedem Aufruf des Unterprogramms sollen die Bits 0..4 von %al um eine Bitstelle linksherum rotieren. - Die vorderen Bits 5..7 sollen dabei unverändert bleiben Meisel 37