why we shouldn t use assembly compilers generate pre8y fast, efficient code tedious, easy to screw up not portable

Transcription

1 chapter 3 part 1 1

2 why we shouldn t use assembly compilers generate pre8y fast, efficient code tedious, easy to screw up not portable 2

3 why you shouldn t use assembly and for that ma8er, why for a lot of things you shouldn t be using C either Corbató's Law: "The number of lines of code a programmer can write in a fixed period of 9me is the same independent of the language used."

4 why we re doing assembly here learn how the machine works possibly faster code. one scenario: write in C profiler tweak the assembly for parts the profiler shows what if no compiler? processor features not easily accessed by higher- level language 4

5 the point we re not trying to prepare you for a job doing assembly programming it s about learning how computers work 5

6 how look at the assembly generated by GCC write some of our own assembly from scratch 6

7 7

8 warning: GCC and Cygwin no difference up unpl now be8er use GCC on Linux with this stuff 8

9 instrucpon set set of of operapons that a processor supports examples load x bytes from this address into register y add what s in register i to what s in register j primipve stuff usually takes lots of these primipve ops to do something really useful 9

10 Other instrucpon sets IA32, Intel64 (x86-64 or x64), IA64 SPARC ARM PowerPC MIPS Alpha JVM we re using: IA32 not easiest, but popular focusing on GCC output on Linux 10

11 some terminology x86 name for the chips IA32 the name of the instrucpon set IA = Intel Architecture note difference between: architecture: what you need to know to program assembly - - instrucpon set, registers microarchitecture: implementa9on e.g., IA32 on non- Intel chips (e.g. AMD) 11

12 GAS assembler used by GCC differences with NASM AT&T syntax be careful when reading the Intel manuals operand order! 12

13 Looking GCC assembly output gcc S another possibly helpful switch: - fverbose- asm 13

14 some tools compiler GCC assembler as aka gas linker ld debugger gdb disassembler - objdump profiler - gprof 14

15 Some History: Why should we care? Important things to take away from the history lesson in the chapter: Moore s law EvoluPon of register names Backward compatability: Goal: run progs compiled for earlier versions of chip But: old baggage support features that new OS, compilers rarely use 15

16 Some History name date transistors notes K 16-bit processor. DOS. 1MB address space. DOS allows 640K K Windows K 32-bit registers. Flat addressing. Can run a Unix OS M Pentium M /MMX M instructions helpful for multimedia processing PentiumPro M conditional move instructions Pentium III M Pentium IV M Core 2 Duo M i M 16

17 In parallel. IA64 chips. name date transistors Itanium M Itanium M Itanium 2 Dual-Core B 17

18 from wikipedia 18

19 famous quote If automobiles had followed the same development cycle as the computer, a Rolls- Royce would today cost $100, get a million miles per gallon, and explode once a year, killing everyone inside. Robert X. Cringely 19

20 From Intel (h8p://download.intel.com/pressroom/kits/corei7/images/nehalem_die_callout.jpg) 20

21 aside: goals then and now big goal then: cram as much processing power on a chip possible big goal now: cram as much processing power on a chip possible BUT don t use so much power some environments: keep the chip small think cell phone 21

22 How bad is your electric bill? Company Servers Electricity Cost ebay 16K MWh $3.7M Akamai 40K MWh $10M Rackspace 50K MWh $12M Microsoft >200K > MWh > 36M Google >500K > MWh >38M USA (2006) 10.9M MWh $4.5B MIT campus MWh $62M from, CuIng the Electric Bill for Internet- Scale Systems, Qureshi et al, CCR

23 8086 Register Example general purpose register 8 general purpose 23

24 386 registers 24

25 64- bit general purpose registers 25

26 26

27 Registers: General purpose PC (EIP IA32, RIP x86-64) CondiPon codes 27

28 32- bit Register File 28

29 general purpose registers register EAX EBX ECX EDX ESI EDI ESP EBP common use accumulator, return pointer to items in data segment loop control I/O pointer src ptr for string ops dst ptr for string ops stack pointer base pointer 29

30 64- bit Register File 30

31 but wait, there s more in x

32 data types in Intel- speak name byte word doubleword quadword double quadword size 1 byte 2 bytes 4 bytes 8 bytes 16 bytes so a word isn t a word? 32

33 simplest funcpon ever 1 int sum() 2 { 3 int x=30; 4 int y=57; 5 int z=39; 6 7 return x+y+z; 8 } 33

34 gcc output of sum funcpon 1.text 2.globl _sum 3 _sum: 4 pushl %ebp # 5 movl %esp, %ebp #, 6 subl $24, %esp #, 7 movl $30, -20(%ebp) #, x 8 movl $57, -16(%ebp) #, y 9 movl $39, -12(%ebp) #, z 10 movl -16(%ebp), %eax # y, y 11 addl -20(%ebp), %eax # x, D addl -12(%ebp), %eax # z, D leave 14 ret 34

35 simplest funcpon ever 1 int sum() 2 { 3 int x=30; 4 int y=57; 5 int z=39; 6 7 return x+y+z; 8 } 1.text 2.globl _sum 3 _sum: 4 pushl %ebp 5 movl %esp, %ebp 6 subl $24, %esp 7 movl $30, -20(%ebp) 8 movl $57, -16(%ebp) 9 movl $39, -12(%ebp) 10 movl -16(%ebp), %eax 11 addl -20(%ebp), %eax 12 addl -12(%ebp), %eax 13 leave 14 ret 35

36 let s try a full program 1 /* file summain.c */ 2 int main(void) 3 { 4 int x=30; 5 int y=57; 6 int z=39; 7 8 return x+y+z; 9 } 36

37 its assembly output 1 /* file summain.s */ 2.text 3.globl _main 4 _main: 5 pushl %ebp 6 movl %esp, %ebp 7 subl $24, %esp 8 movl $30, -20(%ebp) 9 movl $57, -16(%ebp) 10 movl $39, -12(%ebp) 11 movl -16(%ebp), %eax 12 addl -20(%ebp), %eax 13 addl -12(%ebp), %eax 14 leave 15 ret 16.subsections_via_symbols 37

38 same code on SPARC 1.section ".text" 2.align 4 3.global main 4.type main,#function 5.proc 04 6 main: 7!#PROLOGUE# 0 8 save %sp, -128, %sp 9!#PROLOGUE# 1 10 mov 30, %o0 11 st %o0, [%fp-20] 12 mov 57, %o0 13 st %o0, [%fp-24] 14 mov 39, %o0 15 st %o0, [%fp-28] 16 ld [%fp-20], %o0 17 ld [%fp-24], %o1 18 add %o0, %o1, %o0 19 ld [%fp-28], %o1 20 add %o0, %o1, %o0 21 mov %o0, %i0 22 b.ll2 23 nop 24.LL2: 25 ret 26 restore 27.LLfe1: 28.size main,.llfe1-main 29.ident "GCC: (GNU) (release)" 38

39 most of the same on ARM 1 sum: args = 0, pretend = 0, frame = 16 frame_needed = 1, uses_anonymous_args = 0 link register save eliminated. 5 push {r7} 6 sub sp, sp, #20 7 add r7, sp, #0 8 mov r3, #30 9 str r3, [r7, #12] 10 mov r3, #57 11 str r3, [r7, #8] 12 mov r3, #39 13 str r3, [r7, #4] 14 ldr r2, [r7, #12] 15 ldr r3, [r7, #8] 16 adds r2, r2, r3 17 ldr r3, [r7, #4] 18 adds r3, r2, r3 19 mov r0, r3 20 add r7, r7, #20 21 mov sp, r7 22 pop {r7} 23 bx lr 39

40 what to do with it assembling: as - o summain.o summain.s linking: ld - o sum summain.o 40

41 What s going on Assembler - -.s to.o binary encoding of each instrucpon connecpons missing for code in different files Linker references between files stapc linker copies library code into binary dynamic linker linkage when program is run 41

42 42

43 understand what s in each 43

44 opposite direcpon? 44

45 disassembly objdump d filename produces assembly from binary file works for.o file or full executable 45

46 1 /* file AnotherSimpleSum.s */ 2.section.text 3.globl _start 4 _start: 5 /* pushl %ebp */ 6 /* movl %esp, %ebp */ 7 movl $14, %ebx 8 addl $29, %ebx 9 addl $10, %ebx movl $1, %eax 12 int $0x80 1 sum: file format elf32-i386 2 disassembly example.s file disassembled binary 3 4 Disassembly of section.text: <_start>: : bb 0e mov $0xe,%ebx : 83 c3 1d add $0x1d,%ebx c: 83 c3 0a add $0xa,%ebx f: b mov $0x1,%eax : cd 80 int $0x80 46

47 another look at disassembled binary 1 sum: file format elf32-i Disassembly of section.text: <_start>: : bb 0e mov $0xe,%ebx : 83 c3 1d add $0x1d,%ebx c: 83 c3 0a add $0xa,%ebx f: b mov $0x1,%eax : cd 80 int $0x80 let addresses of the instrucpons center opcode + operands some instrucpons longer than others: more frequently used instrucpons shorter opcodes some operapons take more operands 47

48 what can we disassemble? any executable disassembler interprets bytes as assembly src no source code required 48

49 aside: can do this in GDB too disas disassembles current funcpon disas sum disassemble the sum funcpon disas addr disassemble funcpon at addr disas ad 1 ad 2 disas between addr ad 1, ad 2 49

50 very excipng program 1 #include <unistd.h> 2 3 int main(int argc, char **argv) 4 { 5 _exit(17); 6 } 50

51 very excipng program 1 #include <unistd.h> 2 3 int main(int argc, char **argv) 4 { 5 _exit(17); 6 } can see the exit value in the shell by doing: echo $? 51

52 assembly equivalent 1 /* file exitonly.s 2 only slightly modified from Programming from the Ground Up. 3 */ 4.section.data 5.section.text 6.globl _start 7 _start: 8 movl $1, %eax /* this is the linux kernel command */ 9 /* number (system call) for exiting */ 10 /* a program */ 11 movl $0, %ebx /* this is the status number we will */ 12 /* return to the operating system. */ 13 /* Change this around and it will */ 14 /* return different things to */ 15 /* echo $? */ 16 int $0x80 /* this wakes up the kernel to run */ 17 /* the exit command */ 52

53 syscalls how we get services from the OS important idea more next semester 53

54 what happens during a syscall? 1. interrupt pin goes high during current instrucpon 2. control to interrupt handler 3. interrupt handler runs 4. handler returns to next instrucpon 54

55 what are the syscalls in my OS? in Linux, man syscalls seems to work on the Fedora boxes in the lab but not my Ubuntu machine unistd.h lists them: #define NR_restart_syscall 0 #define NR_exit 1 #define NR_fork 2 #define NR_read 3 #define NR_write 4 #define NR_open 5 #define NR_close 6 #define NR_waitpid 7 #define NR_creat 8 #define NR_link 9 #define NR_unlink 10 #define NR_execve 11 #define NR_chdir 12 #define NR_time 13 #define NR_mknod 14 #define NR_chmod

56 Another syscall example. 1 #include <stdio.h> 2 3 void print_question_printf(); 4 5 int main(void) 6 { 7 print_question_printf(); 8 return 0; 9 } void print_question_printf() { 12 char *str = "Who lives in a pineapple under the sea?\n"; printf("%s", str); 15 } 56

57 same thing using write system call 1 #include <unistd.h> 2 #include <string.h> 3 4 void print_question_write(); 5 6 int main(void) 7 { 8 print_question_write(); 9 return 0; 10 } void print_question_write() { 13 char *str = "Who lives in a pineapple under the sea?\n"; write(stdout_fileno, str, 40); 16 } 57

58 Almost the same 1.equ STDOUT, 1 2.equ MSG_LEN, 40 3.equ WRITE_SYSCALL, section.data 6 str: 7.ascii "Who lives in a pineapple under the sea?\n" 8 9.section.text 10.globl _start 11 _start: 12 /* write */ 13 movl $WRITE_SYSCALL, %eax 14 movl $STDOUT, %ebx 15 movl $str, %ecx 16 movl $MSG_LEN, %edx 17 int $0x /* exit */ 20 movl $1, %eax 21 movl $0, %ebx 22 int $0x80 58

59 C Library and system calls What s the relaponship between the funcpons in the C Library and system calls exported by an OS? Tool: strace strace program runs program and prints the system calls executed 59

60 strace on the write version execve("./print_question_write", ["./print_question_write"], [/* 39 vars */]) = 0 brk(0) = 0xcc write(1, "Who lives in a pineapple under t"..., 40Who lives in a pineapple under t ) =

61 strace on the prinx version execve("./print_question_printf", ["./print_question_printf"], [/* 39 vars */]) = brk(0) = 0x1d write(1, "Who lives in a pineapple under t"..., 40Who lives in a pineapple under t ) = 40 61

62 So what does strace tell us? What does strace tell us about the relaponship between the C library funcpon calls and syscalls provided by Linux (or any other OS)? 62

63 binary compapbility Linux runs on my Intel desktop Windows runs on my Intel desktop Why can t I take my Windows binaries and run them on Linux and vice versa? 63

64 for now: old program as template 1 /* file exitonly.s 2 only slightly modified from Programming from the Ground Up. 3 */ 4.section.data 5.section.text 6.globl _start 7 _start: 8 movl $1, %eax /* this is the linux kernel command */ 9 /* number (system call) for exiting */ 10 /* a program */ 11 movl $0, %ebx /* this is the status number we will */ 12 /* return to the operating system. */ 13 /* Change this around and it will */ 14 /* return different things to */ 15 /* echo $? */ 16 int $0x80 /* this wakes up the kernel to run */ 17 /* the exit command */ 64

65 another simple program 1.section.data 2.section.text 3.globl _start 4 _start: 5 movl $20, %ebx /* %ebx=20 */ 6 addl $30, %ebx /* %ebx+=30 */ 7 movl $1, %eax /* exit syscall number */ 8 int $0x80 /* this wakes up the kernel to run */ 9 /* the exit command */ 65