1. מבנה מחשב תרגול 4 מבנה התוכנית

2. 2 Introduction When we wrote: ‘int n = 10’; the compiler allocated the variable’s memory address and labeled it ‘n’. In Assembly, we’ll do it ourselves. Our program is comprised of 3 parts:  Data Segment  Text (=Code) Segment  Stack Segment

3. 3 The Data Segment.data - start of data part of the code. We can give each data item a label, for future reference, by writing: my_label: Later the assembler will exchange the labels with actual memory addresses. Every line must start with a ‘tab’.

4. 4 The Data Segment We must specify the type of each data item, e.g. byte, word, double. For instance: counter:.word 15 In memory, it will look like: 00001111 00000000 The compiler will translate ’15’ to binary. Remember “word” = 16 bit countercounter+1

5. 5 The Data Segment Example:.data vec:.word12089, -89, 130 avi:.word72 So ‘vec’ is actually an array of words. Each item should be read as word, else it would have a different meaning.

6. 6 The Data Segment Another Example:.data alice:.byte3, 5,10, -7 bob:.byte9, 20 In the memory it will be stored sequentially: 00000011 00000101 00001010 11111001 00001001 00010100 alice alice+1 alice+2 alice+3 bob bob+1

7. 7 The Data Segment Each variable type can store a signed or an unsigned value. Therefore, byte, for example can store a value in the range: -128 – 255. For simply allocating memory space we can use:.space10*4 for example (10*4 clearer syntax for 10 variables of size 4 - rather than 40).

8. 8 The Data Segment.section.rodata means that from this point until.data or.text this section contains only read-only data. Const, Global, permanent string data.

9. 9 The Text Segment.text – start of the text part of the code. for instance:.text addl$20, %eax …

10. 10 The Stack Segment We’ll use a stack, rather different then the “common” one. We can read and write data anywhere on the stack. But, for each procedure / function, we’ll add space in the stack in a LIFO manner. The Stack Pointer (%esp) is a register pointing to the head of the stack.

11. 11 The Stack Segment For example:.text addl$-64, %esp …(the procedure itself) addl$64, %esp

12. 12 The Stack Segment Why did we add -64 (and not 64)? Data Segment Text Segment Reserved for OS Initial %esp PC New %esp Stack Segment 0x00000000 0x00400000 0x10000000 0x7fffffff New %ebp

13. 13 The Stack Segment The Frame Pointer (%ebp) is used to store the contents of the stack pointer at the beginning of the procedure. So if we’ll make an error managing the SP, we can recover its value, as it was when the procedure started.

14. 14 Registers * Must be saved (pushed) in the stack before changing them, and restored when the program\function ends. ** Do not count on them !!!,Don’t put any valuable information in them if you are going to call a function from outside your program (like: printf,scanf etc..) Register NamesizeUse %al, %cl, %dl8bLoad to the lower 8 bits of these registers** %ah, %ch, %dh8bLoad to bits 8-15 in these registers** %bl, %bh8bLoad the lower 8 bits and bits 8-15 of this register* %ax, %cx, %dx16bLoad to the lower 16 bits of these registers** %bx16bLoad to the lower 16 bits of this register* %ecx, %edx32bCaller save registers = Temporary registers** %eax32bReturn value** %ebx, %esi, %edi32bCallee save registers = Save registers* %esp32bContains the stack pointer %ebp32bContains the frame pointer

15. 15 Program Structure.data l:…#all global data. ….section.rodata k:…#all RO data such as string formats for printf..text#the beginning of the code.globlmain#defining the label “main” as the starting point..typemain, @function#defining “main” as function. main: pushl%ebp#saving the old frame pointer. movl%esp,%ebp#creating the new frame pointer. …#saving callee-save registers if needed …#The program code …#restoring callee-save registers if needed movl%ebp,%esp#restoring the old stack pointer. popl%ebp#restoring the old frame pointer. ret#returning to the function that called us.

16. 16 Stack Frame Structure The stack is used for: passing arguments storing return information saving registers local storage