Assembler Integer-Arithmetik

Größe: px

Ab Seite anzeigen:

Download "Assembler Integer-Arithmetik"

Frauke Hermann
vor 6 Jahren
Abrufe

1 Assembler Integer-Arithmetik Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Assembler Integer-Arithmetik 1/

2 Arithmetik Zerlegung von Ausdrücken Ziel: Vereinfachung von Ausdrücken Zerlegung der Ausdrücke entsprechend der Grammatik Einführung von temporären Variablen Beispiel: y = (x + 2z)/(z sinx) t1 = 2 z ; t2 = x + t1 ; t3 = s i n ( x ) ; t4 = z t3 ; y = t2 / t4 ; Optimierung =====> t1 = 2 z ; t1 = x + t1 ; t2 = s i n ( x ) ; t2 = z t2 ; y = t1 / t2 ; Optimierung: unnötig viele temporäre Variablen vermeiden Anzahl der (schnellen) Register beschränkt Speicherzugriffe langsam Assembler Integer-Arithmetik 2/

3 Arithmetik Zerlegung von Ausdrücken Jeder Ausdruck lässt sich in Teilausdrücke zerlegen, die die Form A = (B) A = op B mit op {, +,...} A = B op C mit op {+,,, /, mod,...} A = fn(b 0, B 1,..., B N 1 ) mit fn() beliebiger Funktion haben. Assembler Integer-Arithmetik 3/

4 Arithmetik Zerlegung von Ausdrücken Zur Berechnung von A = B op C werden drei effektive Adressen benötigt: A, B und C. Kodierung von drei Adressierungsarten in einem Befehl aufwändig A = B op C kann umgeschrieben werden als A = B und A = A op C; hier werden pro Befehl nur zwei effektive Adressen benötigt (einmal A und B; einmal A und C) A = B op C kann noch weiter vereinfacht werden: ACCU = B, ACCU = ACCU op C, A = ACCU; in diesem Fall wird je Befehl nur eine effective Adresse benötigt (ACCU: Akkumulator ) Assembler Integer-Arithmetik 4/

5 Arithmetik Ein-, Zwei- und Drei-Adress-CPUs Gemäß der pro Befehl möglichen effektiven Adressen werden CPUs eingeteilt in drei Klassen: Ein-Adress-CPU: Befehle haben die Formen ACCU = A ACCU = ACCU op A A = ACCU Beispiele: z80, 6502, m68x05 Zwei-Adress-CPU: Befehle haben die Formen A = B A = A op B Beispiele: i80x86, m680x0 Drei-Adress-CPU: Befehle haben die Form A = B op C Beispiele: m88100, Sparc Assembler Integer-Arithmetik 5/

6 Arithmetik Ein-, Zwei- und Drei-Adress-CPUs Beispiel: x = y + z Drei-Adress-CPU Zwei-Adress-CPU Ein-Adress-CPU add y, z, x l o a d y # accu = y mov y, x add z # accu += z add z, x s t o r e x # x = accu Assembler Integer-Arithmetik 6/

7 Arithmetik Rechengenauigkeit Da alle Variablen im Speicher bzw. in Registern abgelegt werden, können sie nicht beliebig große (genaue) Werte annehmen (siehe TI-I). Ähnliches gilt auch für die Arithmetik: Da alle Rechenwerke einer CPU nur für eine bestimmte Anzahl von Bits ausgelegt sind, können auch hier die Werte nicht beliebig groß (genau) werden. Dies gilt generell für alle Rechner! Assembler Integer-Arithmetik 7/

8 Arithmetik Rechengenauigkeit Beispiel: mit beliebig vielen Stellen gerechnet: (2) (2) = (2) 178 (10) (10) = 383 (10) mit 8 Stellen gerechnet: (2) (2) = (1) (2) 178 (10) (10) = (256 (10) ) (10) Assembler Integer-Arithmetik 8/

9 Arithmetik Rechengenauigkeit Aufgrund der Zerlegung von Ausdrücken ergeben sich folgende Forderungen: die Werte der Eingabe aller(!) Zwischenergebnisse der Ausgabe müssen ohne Überläufe speicherbar sein alle (Teil-) Rechenschritte müssen ohne Überläufe durchführbar sein Assembler Integer-Arithmetik 9/

10 Arithmetik Rechengenauigkeit Beispiel (Mittelwertberechnung): z = x ; z = ( x + y ) / 2 ; z = z + y ; z = z / 2 ; Bei der Addition z = z + y; kann ein Überlauf auftreten! Assembler Integer-Arithmetik 10/

11 Arithmetik Integer Negation: x = y 8-Bit-Werte 16-Bit-Werte 32-Bit-Werte movb y, %a l negb %a l movw y, %ax negw %ax movl y, %eax n e g l %eax movb %al, x movw %ax, x movl %eax, x kürzer: 8-Bit-Werte 16-Bit-Werte 32-Bit-Werte movb y, x movw y, x movl y, x negb x negw x n e g l x Je nachdem, ob die Variablen x, y im Speicher oder in Registern liegen, ist die kürzere Version langsamer oder schneller als die längere. Assembler Integer-Arithmetik 11/

12 Arithmetik Integer Addition: x = y + z 8-Bit-Werte 16-Bit-Werte 32-Bit-Werte movb y, %a l movw y, %ax movl y, %eax addb z, %a l addw z, %ax a d d l z, %eax movb %al, x movw %ax, x movl %eax, x kürzer: 8-Bit-Werte 16-Bit-Werte 32-Bit-Werte movb y, x movw y, x movl y, x addb z, x addw z, x a d d l z, x Entsprechend: Subtraktion, Multiplikation, Division Assembler Integer-Arithmetik 12/

13 Arithmetik Carry-/Borrow-Bit Problem: Rechnungen ausserhalb der normalen Rechengenauigkeit einer CPU Beispiel aus der Schule: <= Carry 1100 <= Carry Übertrag entweder 0 oder 1 ( Carry-, Borrow -Bit) Assembler Integer-Arithmetik 13/

14 Arithmetik Carry-/Borrow-Bit Beispiel für 64-Bit-Arithmetik mit 32-Bit-Rechenoperationen: (x 1 x 0 ) = (y 1 y 0 ) + (z 1 z 0 ) bzw. (x 1 x 0 ) = (y 1 y 0 ) (z 1 z 0 ) movl y0, %eax a d d l z0, %eax movl %eax, x0 movl y1, %eax a d c l z1, %eax < Carry movl %eax, x1 movl y0, %eax s u b l z0, %eax movl %eax, x0 movl y1, %eax s b b l z1, %eax < Borrow movl %eax, x1 Assembler Integer-Arithmetik 14/

15 Arithmetik Multiplikation/Division Beispiel x = y z und x = y/z (i80x86): movl y, %eax movl y, %eax movl $0, %edx i m u l l z i d i v l z movl %eax, x movl %eax, x / %edx : U e b e r l a u f / / %edx : Rest d. D i v i s i o n Assembler Integer-Arithmetik 15/

16 Arithmetik Multiplikation/Division Besonderheiten: Multiplikation kann große Überläufe erzeugen (Carry-Bit reicht nicht!) => Extra-Register für Überlauf idiv-befehl berechnet gleichzeitig y/z und y mod z Multiplikation ist aufwändig in Hardware implementierbar (=> nur selten in Mikro-Controllern als Maschinen-Befehl implementiert) Division ist sehr(!) aufwändig in Hardware und nicht als Schaltnetz implementierbar (=> fast nie in Mikro-Controllern als Maschinen-Befehl implementiert) Assembler Integer-Arithmetik 16/

17 Arithmetik Multiplikation/Division Ersatz für fehlende/langsame Multiplikations-Befehle: 1. Beobachtung: Häufig werden nur Multiplikationen mit einem konstanten Faktor durchgeführt. Diese können auf sukzessive Additionen zurückgeführt werden. Beispiel: y = 10 x kann umgeformt werden zu y = 2 (2 2 x + x) movl x, %eax a d d l %eax, %eax movl %eax, %ebx / => %ebx = 2 x / a d d l %eax, %eax a d d l %eax, %eax / => %eax = 8 x / a d d l %ebx, %eax movl %eax, y Nicht 10-mal addieren! Assembler Integer-Arithmetik 17/

18 Arithmetik Multiplikation/Division Ersatz für fehlende/langsame Multiplikations-Befehle: 2. Beobachtung: Häufig werden Multiplikationen/Divisionen mit konstanten 2-er-Potenzen durchgeführt Beispiel: Multiplikation mit 2er-Potenz: y = x 2 5 y N+4...y 2 y 1 y 0 (2) = x N 1...x 2 x 1 x (2) (entspricht dem Anhängen der entsprechenden Anzahl von Nullen) Beispiel: Division durch 2er-Potenz (mit Abrundung): y = x/2 5 y N 6...y 2 y 1 y 0 = x N 1...x 7 x 6 x 5 (2) (entspricht dem Löschen der entsprechenden Anzahl von Ziffern) Assembler Integer-Arithmetik 18/

19 Arithmetik Shift-Befehle arithmetic shift left (sal): übergebene vorzeichenbehaftete Binär-Zahl wird um eine Stelle nach links verschoben (entspricht Multiplikation mit 2) arithmetic shift right (sar): übergebene vorzeichenbehaftete Binär-Zahl wird um eine Stelle nach rechts verschoben (entspricht Division durch 2 mit Abrunden) (logical) shift left (shl): übergebene vorzeichenlose Binär-Zahl wird um eine Stelle nach links verschoben (entspricht Multiplikation mit 2) (logical) shift right (shr): übergebene vorzeichenlose Binär-Zahl wird um eine Stelle nach rechts verschoben (entspricht Division durch 2 mit Abrunden) Es existieren z.t. Befehle, Werte um mehrere Stellen zu verschieben. Assembler Integer-Arithmetik 19/

20 Arithmetik Shift-Befehle Beispiel: salw $3, %ax shrw $4, %ax shlw $6, %ax sarw $3, %ax / %ax = / / %ax = / / %ax = / / %ax = / / %ax = / Assembler Integer-Arithmetik 20/

21 Arithmetik And, Or, Xor, Not Für die Verarbeitung Bool scher Werte existieren die Bool schen Operationen and, or, xor und not. Es werden N Bits (N {8, 16, 32,...}) parallel verarbeitet: and: x N 1...x 1 x 0 = y N 1...y 1 y 0 and z N 1...z 1 z 0 x N 1...x 1 x 0 = (y N 1 and z N 1 )...(y 1 and z 1 )(y 0 and z 0 ) or: x N 1...x 1 x 0 = y N 1...y 1 y 0 or z N 1...z 1 z 0 x N 1...x 1 x 0 = (y N 1 or z N 1 )...(y 1 or z 1 )(y 0 or z 0 ) xor: x N 1...x 1 x 0 = y N 1...y 1 y 0 xor z N 1...z 1 z 0 x N 1...x 1 x 0 = (y N 1 xor z N 1 )...(y 1 xor z 1 )(y 0 xor z 0 ) not: x N 1...x 1 x 0 = not y N 1...y 1 y 0 x N 1...x 1 x 0 = (not y N 1 )...(not y 1 )(not y 0 ) Assembler Integer-Arithmetik 21/

22 Arithmetik And, Or, Xor, Not Beispiel: movw $0x1234, %ax andw $0xf61c, %ax / %ax hat j e t z t den Wert 0 x1214 / movl $0x , %eax o r l $0x , %eax / %eax hat j e t z t den Wert 0 x / movb $0x24, %a l xorb $ 0 x f f, %a l / %a l hat j e t z t den Wert 0 xdb / movl $ , %eax n o t l %eax / %eax hat j e t z t den Wert 0 xedcba987 / Assembler Integer-Arithmetik 22/

23 Arithmetik Hinweise Zur Beschleunigung/Verkürzung der Programme gibt es für sehr häufig vorkommende Ausdrücke Extra-Maschinenbefehle: Beispiele: a d d l $1, x subw $1, y => movl $0, %eax i n c l x decw y x o r l %eax, %eax Assembler Integer-Arithmetik 23/

Ähnliche Dokumente

Assembler - Adressierungsarten

Assembler - Adressierungsarten Dr.-Ing. Volkmar Sieh Department Informatik 3: Rechnerarchitektur Friedrich-Alexander-Universität Erlangen-Nürnberg SS 2008 Assembler - Adressierungsarten 1/31 2008-04-01