Brief Assembly Refresher Learn AT&T syntax 1 last time - PowerPoint PPT Presentation

Brief Assembly Refresher Learn AT&T syntax 1

last time ❑ processors ↔ memory, I/O devices ❑ processor: send addresses (or memory values) ❑ memory: reply with stores value or retrieves at address. ❑ endianness: ❑ little = least address is least significant little endian: 0x1234 : 0x34 at address x + 0 ❑ : 0x12 at address x + 0 ❑ big endian: 0x1234 ❑ object files and linking ❑ relocations: “fill in the blank” with final addresses symbol table: location of labels within file like main ❑ We will review in more detail. 2

Overview/ Learning Goals • Generally understand the compilation pipeline • Learn how to read and write AT&T syntax assembly • Review x86 registers and condition codes . • Be able to translate from C to AT&T syntax assembly

compilation pipeline main.c (C code) compile main.s (assembly) main.o main.exe (object file) linking (executable) assemble (machine code) (machine code) 5

what’s in those files? hello.c #include <stdio.h> int main (void) { puts ( "Hello, World!" ); return 0; } 7

compilationpipeline main.c main.c: • #include <stdio.h> (C code) • int main (void) { • puts ( "Hello, World!\n" ); compile • } main.s puts.o (assembly) (object file) main.o (object main.exe file) (machine linking (executable) assemble code) (machine code) 5

what’s in those files? hello.c hello.s #include <stdio.h> .text int main (void) { main: sub $8, %rsp puts ( "Hello, World!" ); mov $.Lstr, %rdi return 0; call puts } xor %eax, %eax add $8, %rsp ret .data "Hello, ␣ World!" .Lstr: .string 7

compilationpipeline main.c main.c: • #include <stdio.h> (C code) • int main (void) { • puts ( "Hello, World!\n" ); compile • } main.s puts.o (assembly) (object file) main.o (object main.exe file) (machine linking (executable) assemble code) (machine code) 5

what’s in those files? hello.c hello.s #include <stdio.h> .text int main (void) { main: sub $8, %rsp puts ( "Hello, World!" ); mov $.Lstr, %rdi return 0; call puts } xor %eax, %eax add $8, %rsp ret hello.o text (code) segment: .data 48 83 EC 08 BF 00 00 00 00 E8 00 00 "Hello, ␣ World!" .Lstr: .string 00 00 31 C0 48 83 C4 08 C3 data segment: + stdio.o 48 65 6C 6C 6F 2C 20 57 6F 72 6C 00 relocations : take 0s at and replace with text, byte 6 ( ) data segment, byte 0 address of puts text, byte 10 ( ) symboltable : main text byte 0 7

what’s in those files? hello.c hello.s #include <stdio.h> .text int main (void) { main: sub $8, %rsp mov puts ( "Hello, World!" ); return 0; $.Lstr, %rdi } call puts xor %eax, %eax add $8, %rsp hello.o ret text (code) segment: .data 48 83 EC 08 BF 00 00 00 00 E8 00 00 .Lstr: .string "Hello, ␣ World!" 00 00 31 C0 48 83 C4 08 C3 data segment: 48 65 6C 6C 6F 2C 20 57 6F 72 6C 00 relocations : take 0s at and replace with text, byte 6 ( ) data segment, byte 0 address of puts text, byte 10 ( ) symboltable : main text byte 0 7

0xc = 12 Unwind section is for exception handling

what’s in those files? hello.c hello.s #include <stdio.h> .text int main (void) { main: sub $8, %rsp mov puts ( "Hello, World!" ); return 0; $.Lstr, %rdi } call puts xor %eax, %eax add $8, %rsp hello.o ret text (code) segment: .data 48 83 EC 08 BF 00 00 00 00 E8 00 00 .Lstr: .string "Hello, ␣ World!" 00 00 31 C0 48 83 C4 08 C3 data segment: + stdio.o 48 65 6C 6C 6F 2C 20 57 6F 72 6C 00 hello.exe relocations : take 0s at and replace with (actually binary, but shown as hexadecimal) … text, byte 6 ( ) data segment, byte 0 48 83 EC 08 BF A7 02 04 00 address of puts text, byte 10 ( ) E8 08 4A 04 00 31 C0 48 symboltable : C3 … 83 C4 08 …(code from stdio.o) … main text byte 0 48 65 6C 6C 6F 2C 20 57 6F … 72 6C 00 …(data from stdio.o) … 7

compilation commands ⇒ gcc -S file.c file.s (assembly) compile: ⇒ assemble: gcc -c file.s file.o (object file) ⇒ gcc -o file file.o file (executable) link: ⇒ gcc -c file.c file.o c+a: ⇒ gcc -o file file.c file c+a+l: … 6

exercise (1) Visit Kahoot.it hello.exe hello.o (actually binary, but shown as hexadecimal) … text 48 83 EC 08 BF A7 02 04 00 (code) segment: E8 08 4A 04 00 31 C0 48 48 83 EC 08 BF 00 00 00 00 E8 00 00 83 C4 08 C3 … 00 00 31 C0 48 83 C4 08 C3 …(code from stdio.o) … data segment: 48 65 6C 6C 6F 2C 20 57 6F 48 65 6C 6C 6F 2C 20 57 6F 72 6C 00 … 72 6C 00 relocations : …(data from stdio.o) … take 0s at and replacewith text, byte 6 ( ) data segment, byte 0 text, byte 10 ( ) address of puts symboltable : hello.s main text byte 0 .text main: sub $8, %rsp mov $.Lstr, %rdi Which files contain the me memo mory address of call puts xor %eax, %eax “Hello World” ? add $8, %rsp ret A. main.s (assembly) B. main.o (object) .data .Lstr: .string “Hello , ␣ World” C. main.exe (executable) E. something else 9

exercise (2). Kahoot.it main.c: #include <stdio.h> 1 void sayHello (void) { 2 puts ( "Hello, World!" ); 3 } 4 int main (void) { 5 sayHello (); 6 } 7 Which files contain the literal ASCII string of Hello, World! ? A. main.s (assembly) D. A, B and C B. main.o (object) C. main.exe (executable) 10

Relocation types • machine code doesn’t always use direct addresses • The address is sometime computed relative example relative to the program counter • “call function 4303 bytes later” • linker needs to compute “4303” • extra field on relocation list 11

dynamic linking (very briefly) dynamic linking — don e wh en application is loaded idea: don’t have N copies of printf other type of linking: static ( gcc -static ) Copy of print code ls.exe ecmacs.exe Share the code 12

View a list of dynamic libraries that get loaded at run time ldd /bin/ls. (linux) $ ldd /bin/ls linux-vdso.so.1 => (0x00007ffcca9d8000) libselinux.so.1 => /lib/x86_64-linux- Shared gnu/libselinux.so.1 (0x00007f851756f000) Object file libc.so.6 => /lib/x86_64-linux- gnu/libc.so.6 (0x00007f85171a5000) libpcre.so.3 => /lib/x86_64-linux-gnu/libpcre.so.3 (0x00007f8516f35000) libdl.so.2 => /lib/x86_64-linux- gnu/libdl.so.2 (0x00007f8516d31000) /lib64/ld-linux-x86-64.so.2 (0x00007f8517791000) libpthread.so.0 => /lib/x86_64-linux- gnu/libpthread.so.0 (0x00007f8516b14000) 13

Great so now does the program get laid out in memory?

Memory These bytes correspond to instructions hello.exe (actually binary, but shown as hexadecimal) … 48 83 EC 08 BF A7 02 04 00 E8 08 4A 04 00 31 C0 48 C3 … 83 C4 08 …(code from stdio.o) … 48 65 6C 6C 6F 2C 20 57 6F … 72 6C 00 …(data from stdio.o) …

Great I get how program get turned into binary. But I need a quick assembly refresh so that I can start reading assembly code again. hello.s Let’s start by reviewing .text main: registers and the syntax sub $8, %rsp mov $.Lstr, %rdi call puts xor %eax, %eax Does the RDI register add $8, %rsp ret represent .data "Hello, ␣ World!" .Lstr: .string

Reminder of registers CPU

Key Registers Review Callee-saved registers (AKA non-volatile registers) are used to hold long-lived values that should be preserved across calls

Key Registers Review Memory Stack 0x0 http://flint.cs.yale.edu/cs421/papers/x86-asm/asm.html

AT&T syntax vs Intel Syntax AT&T syntax Intel Syntax movq $42, (%rbx) mov QWORD PTR [rbx], 42 We will be using AT&T effect (pseudo-C): memory[rbx] <- 42 syntax in this class destination last

Key Points for AT&T syntax • registers start with %

Key Points for AT&T syntax • () s represent value in memory %rbx rbx 000000000000FF (%rbx) x0FF

Key Points for AT&T syntax • constants start with $ 0 0 0000 1 1 0001 2 2 0010 3 3 0011 4 4 0100 5 5 0101 6 6 0110 $42 0000000000002A 7 7 0111 8 8 1000 9 9 1001 16^1, 16^0 A 10 1010 B 11 1011 C 12 1100 2*16 + 1*10(A) = 42 D 13 1101 E 14 1110 F 15 1111

AT&T syntax example (1) value 42 in hex movq $42, (%rbx) 0000000000002A ← // memory[rbx] 42 destination last rbx 000000000000FF () s represent value in memory 0000000000002A x0FF constants start with $ registers start with % 16

AT&T syntax example (1) suffix Meaning movq $42, (%rbx) b “Byte”: 1 byte ← // memory[rbx] 42 w “Word”: 2 bytes q (‘quad’) indicates length (8 bytes) l l : 4; w : 2; b : 1 “Long”: 4 bytes sometimes can beomitted q “Quad”: 8 bytes (4 words) 000000000000002A rbx b w l

Other was to compute addresses AT&T syntax: $42 = 0x 2A movq $42, 10(%rbx,%rcx,4) rbx+rcx*4+10 rbx 00000000000001 1+2*4+10 = 19 rcx 00000000000002 19 = 0x13 0x13 0000000000002A

AT&T versus Intel syntax (2) AT&T syntax: movq $42, 100(%rbx,%rcx,4) Intel syntax: mov QWORD PTR [rbx+rcx*4+100], 42 effect (pseudo-C): memory[rbx + rcx * 4 + 100] <- 42 17