Assembler - Adressierungsarten

Transkript

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

2 Adressierungsarten Einführung Beispiel (C, C++, Java): i n t a, b, c [ 1 0 ] ; s t r u c t { char y ; i n t x ; i n t p } d, e, f [ 5 ] ;... = 1 3 ;... = a ;... = b ;... = c [ i ] ;... = d. x ;... = e >x ;... = f [ i ]. x ;... und Kombinationen davon: c [ f [ e >x ]. y ] =... ; f [ b ]. p =... ; a =... ; b =... ; c [ i ] =... ; d. x =... ; e >x =... ; f [ i ]. x =... ; Assembler - Adressierungsarten 2/

3 Adressierungsarten effektive Adresse Bei vielen Adressierungsarten wird eine sogenannte effektive Adresse dynamisch zur Laufzeit berechnet. Gründe (Beispiele): Basisadresse einer Datenstruktur fest, Index variabel (z.b. beim Array-Zugriff) Basisadresse einer Datenstruktur variabel, Displacement bekannt (z.b. beim Zugriff über Pointer auf Records) Assembler - Adressierungsarten 3/

4 Adressierungsarten effektive Adresse Beispiel: Zugriff auf Array-Elemente: short i n t i ; // A d r e s s e 8 short i n t f [ 5 ] ; // A d r e s s e 14 f [ i ] = 3 00; Adresse von i bekannt (8) Adresse von f bekannt (14) Größe der Elemente von f bekannt (2) Adresse(f [i]) = Adresse(f ) + i 2 Assembler - Adressierungsarten 4/

5 Adressierungsarten effektive Adresse Beispiel: Zugriff auf Record-Elemente über Pointer: s t r u c t r e c { short i n t x ; long i n t i ; short i n t y ; short i n t z ; } ; s t r u c t r e c p ; // A d r e s s e 8 s t r u c t r e c s ; // A d r e s s e 14 p >y = 9 ; Adresse von p bekannt (8) Displacement von s.y bezüglich s bekannt (6) Adresse(p > y) = p + 6 Assembler - Adressierungsarten 5/

6 Adressierungsarten Bei der Ausführung von Befehlen mit Parametern (z.b. Addition zweier Werte) sind folgende Punkte sind zu unterscheiden: wo stehen die eigentlichen Parameter (im Befehl, im Register oder im Speicher) wo stehen die Informationen, wie man an die Parameter kommt (i.a. sind diese Informationen Teil des Befehls) wie berechnet sich die effektive Adresse (wenn die Parameter im Speicher stehen) Assembler - Adressierungsarten 6/

7 Adressierungsarten Überblick Register Immediate Operand Direct (Absolute) Address Register Indirect Register Indirect with Index Register Indirect with Displacement / PC-relative Register Indirect with Index and Displacement Memory Indirect Register Indirect with Pre-/Post-Decrement Register Indirect with Pre-/Post-Increment... Assembler - Adressierungsarten 7/

8 Adressierungsarten Register Register-Name bzw. -Nummer ist Bestandteil des Befehls Operand liegt im Register Syntax-Beispiele (i80x86): movl %eax,... movb..., %a l Verwendung: Schreiben bzw. Lesen von in Registern gespeicherten Variablen r e g i s t e r short i n t r ; / r l i e g t im R e g i s t e r %ax / r e g i s t e r short i n t s ; / s l i e g t im R e g i s t e r %bx / r = s ; ergibt compiliert: movw %bx, %ax Assembler - Adressierungsarten 8/

9 Adressierungsarten Immediate Operand Operand ist Bestandteil des Befehls Syntax-Beispiele (i80x86): movl $14,... movl $0x14,... movb $ a,... Verwendung: Zuweisung von Konstanten an Variablen r e g i s t e r long i n t x ; / x l i e g t im R e g i s t e r %edx / x = 1 4 ; ergibt compiliert: movl $14, %edx Assembler - Adressierungsarten 9/

10 Adressierungsarten Immediate Operand Anmerkung: Viele Prozessoren (besonders RISC-CPUs) verwenden zur Kodierung der Befehle jeweils gleichlange Byte-Folgen (z.b. m88100: jeder Befehl ist genau 4 Bytes lang). Aber: unmöglich, z.b. einen movl 0x , %eax-befehl (allein Konstante ist 4 Byte lang) in 4 Bytes zu kodieren. Abhilfe: Aufteilen des Befehls in zwei Teil-Befehle: statt einem Befehl zwei Befehle s e t h i $0x1234, %eax movl $0x , %eax s e t l o $0x5678, %eax Assembler - Adressierungsarten 10/

11 Adressierungsarten Direct (Absolute) Address effektive Adresse ist Bestandteil des Befehls Operand liegt im Speicher Syntax-Beispiele (i80x86): movl 1236,... movb..., 4345 Hinweis: Statt der Adressen werden häufig lieber symbolische Werte geschrieben. Z.B.: movl varx,... movb..., f l a g Die symbolischen Werte müssen jedoch auf irgendeine Weise definiert werden (z.b. durch define- oder equ-anweisungen). Definition im Folgenden aus Platzgründen häufig weggelassen. Assembler - Adressierungsarten 11/

12 Adressierungsarten Direct (Absolute) Address Verwendung: Schreiben bzw. Lesen von im Speicher abgelegten Variablen char c ; / c hat A d r e s s e 1245 / char d ; / d hat A d r e s s e 1246 / c = A ; d = c ; ergibt compiliert: movb $65, 1245 movb 1245, 1246 oder (lesbarer) #d e f i n e c 1245 #d e f i n e d 1246 movb $ A, movb c, d c Assembler - Adressierungsarten 12/

13 Adressierungsarten Register Indirect Register-Name/-Nummer ist Bestandteil des Befehls Register enthält effektive Adresse Operand liegt im Speicher Syntax-Beispiele (i80x86): movl (%ebx ),... movb..., (%ebp ) Assembler - Adressierungsarten 13/

14 Adressierungsarten Register Indirect Verwendung: z.b. Schreiben bzw. Lesen von Variablen über Pointer, die in Registern liegen. r e g i s t e r short i n t p ; / p l i e g t im R e g i s t e r %edx short i n t x ; / x hat d i e A d r e s s e 1456 / p = &x ; p = 1 4 ; x = p ; ergibt compiliert: movl $1456, %edx movw $14, (%edx ) movw (%edx ), 1456 Assembler - Adressierungsarten 14/

15 Adressierungsarten Register Indirect with Index Register-Namen/-Nummern sowie Scale-Faktor sind Bestandteile des Befehls Register A enthält Anfangsadresse des Objektes ( Startadresse, Basisadresse ) Register B enthält Index effektive Adresse berechnet sich als Adresse = Basisadresse + Index ScaleFaktor Operand liegt im Speicher Syntax-Beispiele (i80x86): movl (%ebx, %ecx, 4 ),... movb..., (%ebp, %edi, 8) Assembler - Adressierungsarten 15/

16 Adressierungsarten Register Indirect with Index Verwendung: Schreiben bzw. Lesen von Array-Elementen short i n t f [ ] ; / f hat d i e A d r e s s e 1246 / r e g i s t e r short i n t p ; / p l i e g t im R e g i s t e r %ebx r e g i s t e r short i n t i ; / i l i e g t im R e g i s t e r %ecx p = &f [ 0 ] ; p [ i ] = 5 0 ; f [ 1 ] = p [ i ] ; ergibt compiliert: movl $1246, %ebx movw $50, (%ebx, %ecx, 2) movw (%ebx, %ecx, 2 ), 1248 Assembler - Adressierungsarten 16/

17 Adressierungsarten Register Indirect with Displacement Register-Name/-Nummer sowie Displacement sind Bestandteile des Befehls Register enthält Basisadresse effektive Adresse berechnet sich als Adresse = Basisadresse + Displacement Operand liegt im Speicher Syntax-Beispiele (i80x86): movl 4(%ebp ),... movb..., 17(% e s i ) Assembler - Adressierungsarten 17/

18 Adressierungsarten Register Indirect with Displacement Bemerkungen: wird für das Register der Instruction-Pointer/Program-Counter verwendet, spricht man auch von PC-relativer -Adressierung statt der Bezeichnung Displacement wird auch häufig die Bezeichnung Offset verwendet Assembler - Adressierungsarten 18/

19 Adressierungsarten Register Indirect with Displacement Verwendung: Schreiben bzw. Lesen von Record-Elementen über Pointer s t r u c t r e c { long i n t x ; char c ; short i n t s ; } ; s t r u c t r e c r ; / r hat d i e A d r e s s e 3456 / r e g i s t e r s t r u c t r e c p ; / p l i e g t im R e g i s t e r %eax p = &r ; p >c = A ; r. s = p >s ; ergibt compiliert: movl $3456, %eax movb $ A, 4(%eax ) movw 6(%eax ), 3462 / = ; mit Alignment / Assembler - Adressierungsarten 19/

20 Adressierungsarten Register Indirect with Index and Displacement Register-Name/-Nummer, Scale-Faktor sowie Displacement sind Bestandteile des Befehls Register A enthält Basisadresse Register B enthält Index effektive Adresse berechnet sich als Adresse = Basisadresse + Index ScaleFaktor + Displacement Operand liegt im Speicher Syntax-Beispiele (i80x86): movw 4(%ebp, %eax, 8 ),... movl..., 16(%edx, %ebx, 4) Assembler - Adressierungsarten 20/

21 Adressierungsarten Register Indirect with Index and Displacement Verwendung: Schreiben bzw. Lesen von Record-Elementen eines Arrays s t r u c t r e c { long i n t x ; char c ; short i n t s ; } ; s t r u c t r e c f [ ] ; / f hat d i e A d r e s s e 452 / r e g i s t e r s t r u c t r e c p ; / p l i e g t im R e g i s t e r %ecx r e g i s t e r long i n t i ; / i l i e g t im R e g i s t e r %eax p = &f [ 0 ] ; p [ i ]. c = A ; f [ 2 ]. s = p [ i ]. s ; ergibt compiliert: movl $452, %ecx movb $ A, 4(%ecx, %eax, 8) movw 6(%ecx, %eax, 8 ), 474 / = ; mit Alignm Assembler - Adressierungsarten 21/

22 Adressierungsarten Memory Indirect Speicheradresse ist Bestandteil des Befehls effektive Adresse ist der Inhalt der angegebenen Speicherzelle Operand liegt im Speicher Syntax-Beispiele: movl ( 2 4 ),... movb..., (465) Assembler - Adressierungsarten 22/

23 Adressierungsarten Memory Indirect Verwendung: Schreiben bzw. Lesen von Variablen über Pointer, die im Speicher liegen short i n t x ; / x hat d i e A d r e s s e 340 / short i n t p ; / p hat d i e A d r e s s e 342 / p = &x ; p = 4 5 ; x = p ; ergibt compiliert: movl $340, 342 movw 45, (342) movw ( ), 340 Assembler - Adressierungsarten 23/

24 Adressierungsarten Register Indirect with Pre-/Post-Increment/Decrement Register-Name/Nummer sowie die Größe des Operanden sind Bestandteile des Befehls Register enthält effektive Adresse Operand liegt im Speicher vor/nach dem Zugriff auf den Operanden wird Registerinhalt inkrementiert/dekrementiert (um die Größe des Operanden) Syntax-Beispiele (i80x86): movw (%esp ),... movb +(%eax ),... movl..., (%ebp)+ movw..., (%ecx) Assembler - Adressierungsarten 24/

25 Adressierungsarten Register Indirect with Pre-/Post-Increment/Decrement Verwendung: Push und Pop von Werten auf dem Stack (später) s t r u c t r e c { long i n t x ; short i n t y ; char c ; } ; s t r u c t r e c a ; / a hat d i e A d r e s s e 1232 / s t r u c t r e c b ; / b hat d i e A d r e s s e 344 / a = b ; ergibt compiliert: movl $1232, %eax movl $344, %ebx movl (%ebx )+, (%eax)+ movw (%ebx )+, (%eax)+ movb (%ebx )+, (%eax)+ Assembler - Adressierungsarten 25/

26 Adressierungsarten m68x05 tax / Reg. > Reg. / txa l d a #12 / Immediate Operand > Reg. / l d x #34 l d a 1234 / D i r e c t Address > Reg. / l d x 5678 s t a 1234 / Reg. > D i r e c t Address / s t x 5678 l d a, x / Reg. I n d i r e c t > Reg. / l d x, x s t a, x / Reg. > Reg. I n d i r e c t / s t x, x l d a 12, x / Reg. I n d i r e c t with Displacement > Re l d x 34, x s t a 56, x / Reg. > Reg. I n d i r e c t with Displaceme s t x 78, x Assembler - Adressierungsarten 26/

27 Adressierungsarten Hinweise nicht alle CPUs können alle Adressierungsarten (insbesondere viele Einschränkungen bei RISC-CPUs und kleinen Mikro-Controllern) nicht alle Adressierungsarten sind mit allen Registern möglich (z.b. ist der Instruction Pointer nicht als Basis- oder Index-Register erlaubt) nicht alle Kombinationen von Adressierungsarten (Ziel und Quelle) sind möglich (z.b. erlauben viele CPUs movl 1232, 432 nicht) es existieren i.a. Einschränkungen für die möglichen Werte bzw. die Größe von Scale-Faktor und Displacement (z.b. kann der Scale-Faktor nur 1, 2, 4 oder 8 betragen; Displacement häufig < 256) Assembler - Adressierungsarten 27/

28 Adressierungsarten Hinweise Zum Teil werden Befehle und Adressierungsarten (z.b. aus historischen Gründen) anders geschrieben. Beispiele (i80x86): statt movl %eax, (%esp ) movl (%esp )+, %eax wird verwendet p u s h l %eax p o p l %eax movl %e f l a g s, (%esp ) movl (%esp )+, %e f l a g s p u s h f l p o p f l movl $1234, %e i p jmp 1234 movl (%esp )+, %e i p r e t Assembler - Adressierungsarten 28/

29 Adressierungsarten lea-befehl Nicht alle Programmier-Konstrukte zum Zugriff auf Variablen innerhalb von (verschachtelten) Arrays und Records sind direkt umsetzbar. Z.B.: char f [ 1 0 ] [ 1 0 ] ; i n t i, j ; f [ i ] [ j ] =... ; Adresse(f [i][j]) wäre im Beispiel Adresse(f ) + i 10 + j. Dafür existiert keine Adressierungsart (bei den meisten Prozessoren). In diesen Fällen muss die Adresse explizit berechnet werden lea-befehl explizite Arithmetik (später) Assembler - Adressierungsarten 29/

30 Adressierungsarten lea-befehl s t r u c t r e c { short i n t v a l u e ; char name [ 6 ] ; } ; s t r u c t r e c r ; / r hat d i e A d r e s s e 432 / r e g i s t e r s t r u c t r e c p ; / p l i e g t im R e g i s t e r %eax r e g i s t e r long i n t i ; / i l i e g t im R e g i s t e r %ebx p = &r ; p >name [ i ] = A ; ist equivalent zu r e g i s t e r char n ; / n l i e g t im R e g i s t e r %ecx p = &r ; n = &p >name [ 0 ] ; n [ i ] = A ; ergibt compiliert movl $432, %eax l e a 2(%eax ), %ecx movb $ A, (%ecx, %ebx, 1) ; Assembler - Adressierungsarten 30/

31 Adressierungsarten Hinweise Ersatz für fehlende Adressierungsarten: movl , %eax movl ( ), %eax movl $ , %eax movl (%eax ), %eax movl $ , %eax movl (%eax ), %eax movl (%eax ), %eax movl 8(%eax,%ebx,1),% eax l e a l 8(%eax ), %eax movl (%eax,%ebx,1),% eax Weitere Adressierungsarten können über Arithmetik-Befehle nachgebildet werden. Assembler - Adressierungsarten 31/