Rechnernetze und -Organisation. Teil B (30. März 2011) 2011 Michael Hutter Karl C. Posch

Transkript

1 Rechnernetz R Teil B (30. März 2011) 2011 Michael Hutter Karl C. Posch 1 Zeitplan für Teil B Mittwoch 23. März 2011 Mittwoch 30. März 2011 Mittwoch 6. April 2011 (Mittwoch 13. April 2011: Beginn Teil C) Freitag 15. April 2011: Abgabe Assignment 2 2 1

2 Two different assemblers GNU Assembler as : Uses AT&T syntax mov %ax, %bx thi we use this one NASM Assembler: Uses Intel syntax mov bx, ax Both translate t to machine code 0x6689C3 Meaning: Copy contents from AX to BX 3 Architectural elements of a CPU CPUs have an instruction set CPUs have a register set (Intel) CPUs can operate in various modes: We use: protected flat 32-bit mode AMD64 / Intel 64 Check out:

3 Flat 32-bit memory model Byte-addressable linear address space for Code Data x x+1 x+2 x+3 Stacks Adresses from 0 to x: E5 A x+4: x+8: x+12: x+16: x+20: 8B D D0 A D C3 5 8 general-purpose registers + 2 special registers EAX EBX ECX EDX accumulator, results data pointer to data in the data segment counter register data register, expands EAX in some cases, I/O pointer ESI EDI EBP ESP EIP EFLAGS source index register destination index register base pointer register stack pointer register instruction pointer, ( program counter, PC) flags (is being used implicitly) 6 3

4 32, 16, and 8 bits 32 bits EAX long oder double AX word AH Im GDB: w bedeutet auch long : AL byte x/3w examine 3 locations with 32 bits each 7 Registers and memory Registers live inside the CPU: Quick access There are always only a few registers Memory is outside the CPU: Slower access But a lot more If speed is important: Prioritise the use of registers over the use of memory 8 4

5 Addressing modes movl $9, %ebx Register mode: Copy the value 9 to register EBX movl $9, (%ebx) Indirect addressing mode: Copy the value 9 to memory location, whose address is stored in EBX movl $9, x Direct addressing mode: Copy the value 9 to memory location x Source operand is always specified in immediate mode here. 9 More addressing modes decl x(%ebx) # indexed mode: # decrement content of memory # location with address (x + EBX) decl 8(%ebx) # based mode (same as indexed): # decrement content of memory # location with address (8 + EBX) decl (%eax,%ebx,4) # scale factor: # operand address is # EAX + EBX*4 decl x(%eax,%ebx,4) # based scale factor: # operand address is # x + EAX + EBX*4 10 5

6 move kopiert von source nach dest movl source, dest dest source 11 long, word, byte movl source, dest dest source long, word, byte %eax, %ax, %ah, %al (double) 12 6

7 movl source, dest exchange dest source long, word, byte %eax, %ax, %ah, %al xchgl op1, op2 exchange 13 movl source, dest exchange dest source long, word, byte %eax, %ax, %ah, %al xchgl op1, op2 exchange Beispiele 14 7

8 Arithmetik: Addition und Subtraktion movl source, dest dest source addl source, dest dest source + dest subl source, dest dest source dest 15 movl source, dest ++, --, *, / dest source addl source, dest dest source + dest subl source, dest dest source dest (inc, dec, mul, div, ) Beispiele 16 8

9 movl source, dest Logik: AND dest source addl source, dest dest source + dest subl source, dest dest source dest andl source, dest dest source & dest 17 OR, XOR, NOT, NEG, SHL, SHR movl source, dest dest source addl source, dest dest source + dest subl source, dest dest source dest andl source, dest dest source & dest (or, xor, not, neg, shl, shr) 18 9

10 Programmflusskontrolle jmp label jump zuerst: testl op1, op1 EFLAGS wird beeinflusst cmpl op1, op2 Vergleiche (EFLAGS danach: je label jump if equal jne label jump if not equal jz label jump if zero jnz label jump if not zero jge label jump if greater or equal 19 Call und Return call label ESP ESP 4; mem[esp] EIP; EIP label; ret EIP mem[esp] ESP ESP

11 Push und Pop pushl source ESP ESP 4; mem[esp] source (push und pushl sind identisch) (pushb gibt es nicht) popl dest dest mem[esp] ESP ESP Load Effective Address leal source, dest dest Adresse von source Beispiele: leal label, %eax EAX label leal 4(%esp), %ecx ECX ESP+4 leal (%eax, %ebx), %ecx ECX EAX + EBX 22 11

12 Beispiele mit LEA 23 MOVZ: Move Zero Extended movzbw source, dest movzbl source, dest byte to word: Nur das niederwertige Byte von dest wird verändert byte to long: Nur das niederwertige Byte von dest wird verändert movzwl source, dest word to long: Nur das niederwertige Word von dest wird verändert 24 12

13 pushl %ebp movl %esp, %ebp subl $8, %esp ENTER und LEAVE Currently not used, since this instruction is too slow enter 8, 0 Prologue movl %ebp, %esp popl %ebp leave Epilogue 25 main1.c add.c Unterprogrammaufruf 26 13

14 gcc S main1.c main1_0.s Unterprogrammaufruf 27 main1_0.s add_1.s Return 28 14

15 main1_0.s add_1.s Return 29 main1_0.s add_1.s Return 30 15

16 main1_0.s add_1.s Return 31 main1_0.s add_1.s Return 32 16

17 What happens call label: push return address Decrease contents of stack pointer ESP by 4 Store current contents of program counter on stack, i.e. on memory location pointed to by register ESP Load program counter with the symbolic address (= label). ret: pop return address Load program counter with value from memory location pointed to by ESP Increase contents of ESP by 4 33 What if Return without Call The CPU does not know about this. There is always something on the stack. CPU will interpret this memory word as return address. If you are lucky, this jump leads to an address to which the operating system will not let your program go. and the operating system will flag a segmentation fault

18 The stack Stack is a memory section Stack is organised last in first out Typical operations for stack: Push & Pop CPU has a special register for operations on stack: Stack Pointer (ESP) ESP points to Top of Stack Usually stack grows from higher addresses to lower addresses Stack has NO fence; wherever ESP points, there is the Top of Stack ; even if no stack is used at all! 35 Watch out! When you pop a value from stack, the value is NOT removed from the stack; only the contents of ESP will be changed; nothing is taken from stack, but just copied

19 main000.s: So wäre es am einfachsten 37 main000.s: So wäre es am einfachsten Wir beginnen (wie immer) beim Label main

20 main000.s: So wäre es am einfachsten Wir beginnen (wie immer) beim Label main. Im ersten Befehl von main springen wir zum Label sub. 39 main000.s: So wäre es am einfachsten Wir beginnen (wie immer) beim Label main. Im ersten Befehl von main springen wir zum Label sub. Der Befehl call merkt sich die Rücksprungadresse am Stack

21 main000.s: So wäre es am einfachsten Wir beginnen (wie immer) beim Label main. Im ersten Befehl von main springen wir zum Label sub. Der Befehl call merkt sich die Rücksprungadresse am Stack. Der einzige Befehl des Unterprogramms sub ist ret. 41 main000.s: So wäre es am einfachsten Wir beginnen (wie immer) beim Label main. Im ersten Befehl von main springen wir zum Label sub. Der Befehl call merkt sich die Rücksprungadresse am Stack. Der einzige Befehl des Unterprogramms sub ist ret. ret holt sich die Rücksprungadresse vom Stack und macht nach dem Call-Befehl weiter

22 main000.s: So wäre es am einfachsten Wir beginnen (wie immer) beim Label main. Im ersten Befehl von main springen wir zum Label sub. Der Befehl call merkt sich die Rücksprungadresse am Stack. Der einzige Befehl des Unterprogramms sub ist ret. ret holt sich die Rücksprungadresse vom Stack und macht nach dem Call-Befehl weiter. (Dort steht wieder ein ret -Befehl.) 43 as a main000.s (Assemblierung) Maschinenprogramm mit 3 Befehlen 44 22

23 as a main000.s Maschinenprogramm mit 3 Befehlen x: x+4: X+8: x x+1 x+2 x+3 E C3 C3 Im Hauptspeicher 45 main00.s: Für das Debuggen fügen wir noch ein Label after_call call ein. Wir verändern damit das Maschinenprogramm nicht! 46 23

24 as a main00.s: Hier der Beweis Das Maschinenprogramm hat sich nicht verändert. 47 gcc g o main00 main00.s Assemblierung von main00.s (mit inkludierter Debug-Information für GDB) Assemblieren, GDB starten, Breakpoint setzen, Run. Wir befinden uns beim Label main, also ganz am Anfang

25 GDB-Session 49 GDB-Session info registers eip: Welcher Wert steht im Program Counter (Instruction Pointer) 50 25

26 info registers eip: Welcher Wert steht im Program Counter (Instruction Pointer) GDB-Session An dieser Adresse beginnt der Code: Das Label main steht also symbolisch für die Adresse 0x GDB-Session Was steht denn dort im Speicher 52 26

27 GDB-Session Was steht denn dort im Speicher Tatsächlich: Hier finden wir das Programm: 0x : E x : 00 C3 C3 90 0x C: Beachte die Reihenfolge! (Little Endian) 53 Welcher Wert steht im Stack Pointer GDB-Session 54 27

28 Welcher Wert steht im Stack Pointer GDB-Session Der Stack Pointer zeigt auf die Speicheradresse 0xbfc428ac 55 Welche Werte befinden sich denn derzeit ganz oben am Stack GDB-Session 56 28

29 Welche Werte befinden sich denn derzeit ganz oben am Stack GDB-Session Der Stack: Top of Stack 0xbfc428ac: b7 dd xbfc428b0: xbfc428b4: bf c GDB-Session step instruction Wir exekutieren eine Instruktion: Das ist call sub

30 GDB-Session step instruction Wir exekutieren eine Instruktion: Das ist call sub. Jetzt sind wir beim Label sub, also im Unterprogramm. tepoga Dort steht der Befehl ret. Im Assembler-Listing ist das die Zeile 10. Auch das wird angezeigt. 59 Welcher Wert steht denn jetzt im Instruction Pointer GDB-Session 60 30

31 Welcher Wert steht denn jetzt im Instruction Pointer GDB-Session Jetzt sind wir beim Label sub, also im Unterprogramm. Dort steht der Befehl ret. Im Assembler-Listing ist das die Zeile 10. Auch das wird angezeigt. 61 Welcher Wert steht denn jetzt im Instruction Pointer GDB-Session Wir sind also jetzt hier im Programm: Jetzt sind wir beim Label sub, also im Unterprogramm. Dort steht der Befehl ret. Im Assembler-Listing ist das die Zeile 10. Auch das wird angezeigt. 0x : E x : 00 C3 C3 90 0x C:

32 Welcher Wert steht denn jetzt im Stack Pointer GDB-Session 63 Welcher Wert steht denn jetzt im Stack Pointer GDB-Session Der Befehl call sub hat die Rücksprungadresse auf den Stack gepusht. Damit ist der Stack um 4 Bytes Gewachsen. Tatsächlich. Der Wert im Stack Pointer ist jetzt um 4 weniger als vorhin

33 Welche 12 Bytes finden wir denn jetzt ab Top of Stack GDB-Session 65 Welche 12 Bytes finden wir denn jetzt ab Top of Stack Top of Stack Der Stack: GDB-Session 0xbfc428a8: xbfc428ac: b7 dd xbfc428b0: xbfc428b4: bf c

34 Welche 12 Bytes finden wir denn jetzt ab Top of Stack Top of Stack Der Stack: GDB-Session 0xbfc428a8: xbfc428ac: b7 dd xbfc428b0: xbfc428b4: bf c Tatsächlich: Am Top of Stack finden wir jetzt die Rücksprungadresse. 0x : E x : 00 C3 C3 90 0x C: Wir exekutieren die einzige Instruktion des Unterprogramms: ret. GDB-Session 68 34

35 Wir exekutieren die einzige Instruktion des Unterprogramms: ret. GDB-Session Damit sind wir beim Label after_call angekommen. Also vom Unterprogramm sub zurück gekehrt. 69 Welcher Wert befindet sich denn nun im Instruction Pointer GDB-Session 70 35

36 Welcher Wert befindet sich denn nun im Instruction Pointer Wir sind wie nicht anders erwartet jetzt beim Label after_call. Also bei dieser Instruktion ret. Die Rücksprungadresse wurde also mit dem vorigen Befehl ret vom Stack zurück geholt. GDB-Session 0x : E x : 00 C3 C3 90 0x C: Sehen wir uns nochmals den Stack an. Auf welcher Adresse befindet sich denn der Top of Stack jetzt GDB-Session 72 36

37 Sehen wir uns nochmals den Stack an. Auf welcher Adresse befindet sich denn der Top of Stack jetzt GDB-Session ESP hat den Wert 0xbfc428ac. 73 examine 3 words Starting with address 0xbfc428a: ( w bedeutet im GDB 32-Bit) GDB-Session ESP hat den Wert 0xbfc428ac

38 examine 3 words starting with address 0xbfc428a: ( w bedeutet im GDB 32-Bit) Top of Stack Der Stack: GDB-Session 0xbfc428a8: xbfc428ac: b7 dd xbfc428b0: xbfc428b4: bf c ESP hat den Wert 0xbfc428ac. 75 examine 3 words starting with address 0xbfc428a: ( w bedeutet im GDB 32-Bit) Der vorige Rücksprungwert befindet sich noch immer im Speicher; er gehört Top of jedoch Stack nicht mehr zum Stack dazu. Der Stack: GDB-Session 0xbfc428a8: xbfc428ac: b7 dd xbfc428b0: xbfc428b4: bf c ESP hat den Wert 0xbfc428ac

39 Parameterübergabe: parameters000.s Vor dem Aufruf einer Funktion werden deren aktuelle Parameter auf den Stack gepusht. Nach der Rückkehr muss man am Stack aufräumen. 77 Parameterübergabe: parameters000.s In der Funktion selbst holen wir uns die aktuellen Parameter vom Stack

40 Jetzt mit printf : parameter00.s add2 printf Das Resultat wird in EAX übergeben. 79 gcc parameters00.s Versuch: Weglassen der Aufräumarbeiten! Was passiert 80 40

41 Was ist, wenn Funktionen Register brauchen Wer sichert und restauriert Das ist eine Frage der Konvention: Entweder das aufrufende Programm oder das aufgerufene. Doch eines ist klar: Die Werte werden am Stack gesichert und von dort wieder restauriert. 81 Und wo leben die lokalen Variablen einer Funktion Du ahnst es schon: Ebenfalls am Stack

42 main3.c Parameterübergabe 83 main3.c add3.c 84 42

43 gcc S main3.c main3.s Und hier geht es noch weiter 85 gcc S main3.c Und hier geht es noch weiter main3.s Den Wert der symbolischen Adressen b b und a a vom Speicher in EAX und EDX moven. Dann die Werte von EAX und EDX auf den Stack pushen und call von add. Schließlich den in EAX übergebenen Rückgabewert auf die symbolische Adresse c kopieren

44 gcc S add3.c add3.s Welche Rolle spielt EBP 87 Der Stack-Frame und der Base-Pointer Der Inhalt des Registers ESP definiert den Top of Stack. In EBP merken wir uns gleich nach jedem Funktionsaufruf die Adresse des Beginns des sogenannten Stack-Frame der soeben aufgerufenen Funktion. Dazu müssen wir vorher den alten Wert des EBP auf den Stack pushen. Wir haben also in jeder Funktion einen Referenzpunkt im Speicher. Mit diesem Wert in EBP können wir mit konstantem Offset auf übergebene Parameter oder auch auf lokale Variable dieser Funktion zugreifen. Vor dem Return-Befehl müssen wir dann den alten Wert in EBP restaurieren. Das ist ja der Beginn des Stack-Frame der aufrufenden Funktion. Die braucht diesen ja gleich wieder

45 gcc S add3.c add3.s 89 gcc S add3.c add3.s Sichere den alten Wert im Base-Pointer am Stack

46 gcc S add3.c add3.s Sichere den alten Wert im Base-Pointer am Stack. Definiere den neuen Base-Pointer-Wert für diese Funktion. 91 gcc S add3.c add3.s Sichere den alten Wert im Base-Pointer am Stack. Definiere den neuen Base-Pointer-Wert für diese Funktion. Jetzt können wir mit Konstantem Offset vom Wert in EBP auf die übergebenen Parameter zugreifen

47 gcc S add3.c add3.s Zum Schluss müssen wir vor der Rückkehr zur aufrufenden Funktion den alten Wert im Base Pointer resaurieren. 93 Und hier geht es noch weiter Der Stack in diesem Beispiel: Der Stack wächst nach oben hin zu kleineren Adressen. EBP EBP-Wert von main ESP 94 47

48 Und hier geht es noch weiter Der Stack in diesem Beispiel: Der Stack wächst nach oben hin zu kleineren Adressen. EBP Dar rüber reden wir später EBP-Wert von main ESP 95 Und hier geht es noch weiter Der Stack in diesem Beispiel: Der Stack wächst nach oben hin zu kleineren Adressen. EBP Dar rüber reden wir später EBP-Wert von main ESP 96 48

49 Und hier geht es noch weiter Der Stack in diesem Beispiel: Der Stack wächst nach oben hin zu kleineren Adressen. EBP Dar rüber reden wir später EBP-Wert von main Parameter b ESP 97 Der Stack in diesem Beispiel Der Stack wächst nach oben hin zu kleineren Adressen. Dar rüber reden wir später EBP EBP-Wert von main Parameter a Parameter b ESP 98 49

50 Und hier geht es noch weiter Der Stack in diesem Beispiel Der Stack wächst nach oben hin zu kleineren Adressen. EBP Dar rüber reden wir später EBP-Wert von main Rücksprungadresse Parameter a Parameter b ESP 99 Der Stack in diesem Beispiel Der Stack wächst nach oben hin zu kleineren Adressen. EBP-Wert von main Rücksprungadresse Parameter a Parameter b EBP EBP-Wert von main ESP

51 Der Stack in diesem Beispiel Der Stack wächst nach oben hin zu kleineren Adressen. EBP-Wert von main Rücksprungadresse Parameter a Parameter b EBP EBP-Wert von add ESP 101 Der Stack in diesem Beispiel Der Stack wächst nach oben hin zu kleineren Adressen. EBP-Wert von main Rücksprungadresse Parameter a Parameter b EBP EBP-Wert von add ESP

52 Der Stack in diesem Beispiel Der Stack wächst nach oben hin zu kleineren Adressen. EBP-Wert von main Rücksprungadresse Parameter a Parameter b EBP EBP-Wert von add ESP 103 Der Stack in diesem Beispiel Der Stack wächst nach oben hin zu kleineren Adressen. EBP-Wert von main Rücksprungadresse Parameter a Parameter b EBP EBP-Wert von main ESP

53 Der Stack in diesem Beispiel Der Stack wächst nach oben hin zu kleineren Adressen. Wert-Wert von main Rücksprungadresse Parameter a Parameter b EBP ESP 105 Der Stack in diesem Beispiel Der Stack wächst nach oben hin zu kleineren Adressen. Doch hier geht es noch weiter Dar rüber reden wir später Wert-Wert von main Rücksprungadresse Parameter a Parameter b ESP

54 Der Stack in diesem Beispiel Der Stack wächst nach oben hin zu kleineren Adressen. Doch hier geht es noch weiter Wert-Wert von main Rücksprungadresse Parameter a Parameter b ESP 107 Zurück zu main0.c:

55 main0.c main0.s 109 main0.s: Fast nur Prolog und Epilog Prolog Epilog

56 main0.s: main ist auch nur eine Funktion. Unmittelbar bevor die erste Instruktion von main ausgeführt wird, liegt also ganz oben am Stack die Rücksprungadresse. 111 main0.s: main ist auch nur eine Funktion. Unmittelbar bevor die erste Instruktion von main ausgeführt wird, liegt also ganz oben am Stack die Rücksprungadresse. Load Effective Address: ECX kriegt den Wert ESP + 4. Wir sichern also ESP+4 in ECX

57 main0.s: main ist auch nur eine Funktion. Unmittelbar bevor die erste Instruktion von main ausgeführt wird, liegt also ganz oben am Stack die Rücksprungadresse. Load Effective Address: ECX kriegt den Wert ESP + 4. Wir sichern also ESP+4 in ECX. Jetzt setzen wir den Wert in ESP auf die nächst kleinere 16-Byte-Grenze. Damit beginnt der Stack-Frame von main nicht irgendwo, sondern auf einer runden Adresse. 113 main0.s: Der Stack-Pointer zeigt also jetzt auf eine Adresse, welche im niederwertigen Byte 0x00 hat

58 main0.s: Der Stack-Pointer zeigt also jetzt auf eine Adresse, welche im niederwertigen Byte 0x00 hat. Das Datum auf der Adresse (ECX 4) ist genau die Rücksprungadresse von vorhin. Diese pushen wir jetzt auf den Stack. 115 main0.s: Der Stack-Pointer zeigt also jetzt auf eine Adresse, welche im niederwertigen Byte 0x00 hat. Das Datum auf der Adresse (ECX 4) ist genau die Rücksprungadresse von vorhin. Diese pushen wir jetzt auf den Stack. Und jetzt geht es normal Weiter: Zuerst den Base-Pointer- Wert der aufrufenden Funktion am Stack sichern

59 main0.s: Der Stack-Pointer zeigt also jetzt auf eine Adresse, welche im niederwertigen Byte 0x00 hat. Das Datum auf der Adresse (ECX 4) ist genau die Rücksprungadresse von vorhin. Diese pushen wir jetzt auf den Stack. Und jetzt geht es normal Weiter: Zuerst den Base-Pointer- Wert der aufrufenden Funktion am Stack sichern. Dann einen neuen Stack-Frame beginnen: In EBP ist jetzt also der Base-Pointer-Wert von main. 117 main0.s: Und dann noch den Wert Von ECX am Stack sichern. Den brauchen wir am Ende Von main ja wieder, um den Stack zurück zu bauen

60 main0.s: Und dann noch den Wert Von ECX am Stack sichern. Den brauchen wir am Ende Von main ja wieder, um den Stack zurück zu bauen. Das war der Prolog der Funktion main. Jetzt kommt der Kern von main. Dieser besteht hier ja lediglich aus return 0. Es besteht die Konvention, einfache Return-Werte im Register EAX zu übergeben. So auch hier. 119 main0.s: Und dann noch den Wert Von ECX am Stack sichern. Den brauchen wir am Ende Von main ja wieder, um den Stack zurück zu bauen. Das war der Prolog der Funktion main. Jetzt kommt der Kern von main. Dieser besteht hier ja lediglich aus return 0. Es besteht die Konvention, einfache Return-Werte im Register EAX zu übergeben. So auch hier. Jetzt kommt der Epilog von main

61 main0.s: Es geht jetzt verkehrt herum: Wir restaurieren den Wert von ECX. 121 main0.s: Es geht jetzt verkehrt herum: Wir restaurieren den Wert von ECX. Diesen Wert haben wir ja vor der Exekution des Kerns von main auf den Stack gepusht

62 main0.s: Es geht jetzt verkehrt herum: Wir restaurieren den Wert von ECX. Diesen Wert haben wir ja vor der Exekution des Kerns von main auf den Stack gepusht. Dann restaurieren wir den Base-Pointer-Wert der aufrufenden Funktion. 123 main0.s: Es geht jetzt verkehrt herum: Wir restaurieren den Wert von ECX. Diesen Wert haben wir ja vor der Exekution des Kerns von main auf den Stack gepusht. Dann restaurieren wir den Base-Pointer-Wert der aufrufenden Funktion. Auch diesen haben wir zuvor auf den Stack gepusht

63 main0.s: Schließlich setzen wir den Wert von ESP auf den ursprünglichen Wert; 125 main0.s: Schließlich setzen wir den Wert von ESP auf den ursprünglichen Wert; Das ist also der Wert, den ESP vor dem AND-Befehl gehabt hat. Mit dem AND- Befehl haben wir ESP ja so manipuliert, dass ESP auf eine runde Adresse gezeigt hat

64 main0.s: Schließlich setzen wir den Wert von ESP auf den ursprünglichen Wert; Das ist also der Wert, den ESP vor dem AND-Befehl gehabt hat. Mit dem AND- Befehl haben wir ESP ja so manipuliert, dass ESP auf eine runde Adresse gezeigt hat. Davor haben wir ja den Original-ESP-Wert in ECX gesichert. 127 main0.s: Schließlich setzen wir den Wert von ESP auf den ursprünglichen Wert; Das ist also der Wert, den ESP vor dem AND-Befehl gehabt hat. Mit dem AND- Befehl haben wir ESP ja so manipuliert, dass ESP auf eine runde Adresse gezeigt hat. Davor haben wir ja den Original-ESP-Wert in ECX gesichert. Und Return

65 Call by reference: main4.c 129 main4.c add4.c

66 gcc o main4 main4.c add4.c 131 Vergleich: main3.c versus main4.c main3.c: Call by value main4.c: Call by reference

67 Vergleich: main3.s versus main4.s main3.c: Call by value main4.c: Call by reference main3.s: main4.s: 133 add3.c versus add4.c

68 add3.c versus add4.c add3.s add4.s 135 Lokale Variable: main5.c

69 main5.c und add5.c 137 main4.s main5.s Die globale Variable c ist im Datensegment und deren Startadresse heißt symbolisch c Die lokale Variable c lebt am Stack auf Adresse EBP

70 add5.c 139 gcc- S add5.c add5.s

71 gcc- S add5.c add5.s Platz am Stack machen 141 gcc- S add5.c add5.s Platz am Stack machen Übergebene Parameter vom Stack nach EDX und EAX holen

72 gcc- S add5.c add5.s Platz am Stack machen: Übergebene Parameter vom Stack nach EDX und EAX holen Addition: Summe in EAX 143 gcc- S add5.c add5.s Platz am Stack machen: Übergebene Parameter vom Stack nach EDX und EAX holen Addition: Summe in EAX Summe auf den Stack ( result )

73 gcc- S add5.c add5.s Platz am Stack machen: Übergebene Parameter vom Stack nach EDX und EAX holen Addition: Summe in EAX Summe auf den Stack ( result ) Return: result nach EAX 145 gcc- S add5.c add5.s Platz am Stack machen: Übergebene Parameter vom Stack nach EDX und EAX holen Addition: Summe in EAX Summe auf den Stack ( result ) Return: result nach EAX und leave

74 Wo leben Daten Lokale Variable: (brauchen in der ausführbaren Datei keinen Platz) am Stack Uninitialisierte Variable: (brauchen in der ausführbaren Datei keinen Platz).comm Initialisierte Variable: (brauchen in der ausführbaren Datei Platz) Initialisierte Konstante: (brauchen in der ausführbaren Datei Platz).data.section.rodata 147 Beispiel main6.c

75 main6.s 149 a = 2; main6.s c = a + b; printf( )