1 /* file cpuid2.s */ 4.asciz "The processor Vendor ID is %s \n" 5.section.bss. 6.lcomm buffer, section.text. 8.globl _start.

Transcription

1

2 1 /* file cpuid2.s */ 2.section.data 3 output: 4.asciz "The processor Vendor ID is %s \n" 5.section.bss 6.lcomm buffer, 12 7.section.text 8.globl _start 9 _start: 10 movl $0, %eax 11 cpuid 12 movl $buffer, %edi 13 movl %ebx, (%edi) 14 movl %edx, 4(%edi) 15 movl %ecx, 8(%edi) 16 pushl $buffer 17 pushl $output 18 call printf 19 addl $8, %esp 20 pushl $0 21 call exit 1 /* file cpuid.s */ 2.section.data 3 output: 4.ascii "The processor Vendor ID is xxxxxxxxxxxx \n" 5.section.text 6.globl _start 7 _start: 8 movl $0, %eax 9 cpuid 10 movl $output, %edi 11 movl %ebx, 28(%edi) 12 movl %edx, 32(%edi) 13 movl %ecx, 36(%edi) 14 movl $4, %eax 15 movl $1, %ebx 16 movl $output, %ecx 17 movl $42, %edx 18 int $0x80 19 movl $1, %eax 20 movl $0, %ebx 21 int $0x80

3

4

5 int x, y; int x, y;... movl %ebx, %eax... movl %ebx, %eax x=y; x=y; int x, y;... x=y;

6 int x = 0x ; char y = 0xFF;... movl $0x7FFFFFFF, %eax movb $0x6, %al x=y; C declaration intel data type GAS suffix, e.g., for movx instruction x86-32 size (bytes) char byte b 1 short word w 2 int double word l 4 unsigned double word l 4 long int double word l 4 unsigned long double word l 4 char * double word l 4 float single precision s 4 double double precision l 8 long double extended precision t 10/12 x=35; movl $35, %eax

7 1.section.rodata 2 print_str: 3.string "x=0x%x\n" 4.text 5.globl main 6.type 7 main: 8 pushl %ebp 9 movl %esp, %ebp 10 movl $0x , %eax 11 movl $print_str, %ecx 12 pushl %eax 13 pushl %ecx 14 call printf 15 addl $8, %esp 16 movl $0, %eax 17 leave 18 ret 1.section.rodata 2 print_str: 3.string "x=0x%x\n" 4.text 5.globl main 6.type 7 main: 8 pushl %ebp 9 movl %esp, %ebp 10 movl $0x , %eax 11 movb $0xFF, %al 12 movl $print_str, %ecx 13 pushl %eax 14 pushl %ecx 15 call printf 16 addl $8, %esp 17 movl $0, %eax 18 leave 19 ret movl movb $0x7FFFFFFF, %eax $0x6, %al 1.section.rodata 2 print_str: 3.string "x=0x%x\n" 4.text 5.globl main 6.type 7 main: 8 pushl %ebp 9 movl %esp, %ebp 10 movl $0x , %eax 11 movl $print_str, %ecx 12 pushl %eax 13 pushl %ecx 14 call printf 15 addl $8, %esp 16 movl $0, %eax 17 leave 18 ret 1.section.rodata 2 print_str: 3.string "x=0x%x\n" 4.text 5.globl main 6.type 7 main: 8 pushl %ebp 9 movl %esp, %ebp 10 movl $0x , %eax 11 movb $0xFF, %al 12 movl $print_str, %ecx 13 pushl %eax 14 pushl %ecx 15 call printf 16 addl $8, %esp 17 movl $0, %eax 18 leave 19 ret

8 1.section.rodata 2 print_str: 3.string "x=0x%x\n" 4.text 5.globl main 6.type 7 main: 8 pushl %ebp 9 movl %esp, %ebp 10 movl $0x , %eax 11 movb $0xFF, %dl 12 movzbl %dl, %eax 13 movl $print_str, %ecx 14 pushl %eax 15 pushl %ecx 16 call printf 17 addl $8, %esp 18 movl $0, %eax 19 leave 20 ret 21.size main,.-main 1.section.rodata 2 print_str: 3.string "x=0x%x\n" 4.text 5.globl main 6.type 7 main: 8 pushl %ebp 9 movl %esp, %ebp 10 movl $0x , %eax 11 movb $0xFF, %dl 12 movzbl %dl, %eax 13 movl $print_str, %ecx 14 pushl %eax 15 pushl %ecx 16 call printf 17 addl $8, %esp 18 movl $0, %eax 19 leave 20 ret 21.size main,.-main

9 var addr ip 1000 cp 1000 cp ip cp+x 1000+x ip+x 1000+x*sizeof(int) src dst assembly example C equiv imm reg movl $0x52, %eax x=0x52; imm mem movl $0x52, (%eax) *p=0x52; reg reg movl %ebx, %eax a=b; reg mem movl %eax, (%ebx) *p=x; mem reg movl (%eax), %ebx x=*p; mem mem can t be done *p=*q;

10 x y x y %eax %edx %ecx %ebx %esi %edi %esp %ebp yp xp 12 %ebp 0 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx x11c 0x118 0x114 0x110 0x10c 0x108 0x100 %eax %edx %ecx %ebx %esi %edi %esp %ebp yp xp 12 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx 8 4 %ebp 0-4 0x11c 0x118 0x114 0x110 0x10c 0x108 0x100 void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } swap: pushl %ebp movl %esp,%ebp pushl %ebx movl 12(%ebp),%ecx movl 8(%ebp),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } %ecx yp %edx xp %eax t1 %ebx t yp xp ebp ebx %ebp movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx

11 x y x y %eax %edx %ecx %ebx %esi %edi %esp %ebp yp xp %ebp 0-4 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx 0x11c 0x118 0x114 0x110 0x10c 0x108 0x100 %eax %edx %ecx %ebx %esi %edi %esp %ebp yp xp %ebp 0-4 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx 0x11c 0x118 0x114 0x110 0x10c 0x108 0x100 x y x y %eax %edx %ecx %ebx %esi %edi %esp %ebp yp xp %ebp 0-4 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx 0x11c 0x118 0x114 0x110 0x10c 0x108 0x100 %eax %edx %ecx %ebx %esi %edi %esp %ebp 456 yp xp %ebp 0-4 movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx 0x11c 0x118 0x114 0x110 0x10c 0x108 0x100

12 %eax %edx %ecx %ebx %esi %edi %esp %ebp yp xp %ebp movl 12(%ebp),%ecx # ecx = yp movl 8(%ebp),%edx # edx = xp movl (%ecx),%eax # eax = *yp (t1) movl (%edx),%ebx # ebx = *xp (t0) movl %eax,(%edx) # *xp = eax movl %ebx,(%ecx) # *yp = ebx x y 0x11c 0x118 0x114 0x110 0x10c 0x108 0x100 assembly exp resulting address x(%eax) %eax+x (%eax, %ebx) %eax+%ebx x(%eax, %ebx) x+%eax+%ebx (,%eax,s) (%eax*s) x(,%eax,s) x+(%eax*s) (%eax,%ebx,s) %eax+(%ebx*s) x(%eax,%ebx,s) x+%eax+(%ebx*s)

13 operand value %eax?? $0x108? (%eax)? 4(%eax)? 9(%eax,%edx)? 260(%ecx,%edx)? 0xFC(,%ecx,4)? (%eax,%edx,4)? address 0x100 0x108 0x10C register %eax %ecx %edx value 0xFF 0xAB 0x13 0x11 value 0x100 0x1 0x3 operand value comment %eax 0x100 register 0xAB absolute address $0x108 0x108 immediate (%eax) 0xFF addr 0x100 4(%eax) 0xAB addr 9(%eax,%edx) 0x11 addr 0x10C 260(%ecx,%edx) 0x13 addr 0x108 0xFC(,%ecx,4) 0xFF addr 0x100 (%eax,%edx,4) 0x11 addr 0x10C address 0x100 0x108 0x10C register %eax %ecx %edx value 0xFF 0xAB 0x13 0x11 value 0x100 0x1 0x3 type form operand value name immediate $imm imm immediate register E a R[E a ] register memory imm M[imm] absolute memory (E a ) M[R[E a ]] indirect memory imm(e b ) M[imm+R[E b ]] base+displacement memory (E b,e i ) M[R[E b ]+R[E i ]] indexed memory imm(e b,e i ) M[imm+R[E b ]+R[E i ]] indexed memory (,E i,s) M[R[E i ]*s] scaled indexed memory imm(,e i,s) M[imm+R[E i ]*s] scaled indexed memory (E b,e i,s) M[R[E b ]+R[E i ]*s] scaled indexed memory imm(e b,e i,s) M[imm+R[E b ]+R[E i ]*s] scaled indexed

14 expression leal 6(%eax), %edx leal (%eax,%ecx), %edx leal (%eax,%ecx, 4), %edx leal 7(%eax,%eax,8), %edx leal 0xA(,%ecx,4), %edx leal 9(%eax,%ecx,2), %edx result expression result leal 6(%eax), %edx 6+x leal (%eax,%ecx), %edx x+y leal (%eax,%ecx, 4), %edx x+4y leal 7(%eax,%eax,8), %edx 7+x+8x=7+9x leal 0xA(,%ecx,4), %edx 0xA+4y=10+4y leal 9(%eax,%ecx,2), %edx 9+x+2y %eax %ecx 0x1000 0xA %eax %ecx 0x1000 0xA %eax+%ecx*4 = 0x *4 = 0x = 0x1000+0x28 = 0x1028

15 instruction effect description incl D D D + 1 increment decl D D D 1 decrement negl D D D negate notl D D D complement addl S, D D D + S add subl S, D D D S subtract imull S, D D D S multiply xorl S, D D D S exclusive or orl S, D D D S or andl S, D D D&S and sall k, D D D << k left shift shll k, D D D << k left shift (same as sall) sarl k, D D D >> k shift right arithmetic shrl k, D D D >> k shift right logical

16 1 #include <stdlib.h> 2 3 #define BUF_LEN int main(void) { 6 int x; 7 char *buff; if ((buff = (char*)malloc(buf_len))==null) { 12 fprintf(stderr, "error allocating space. quitting\n"); 13 return 1; 14 } return 0; 18 } 1 class Junk { 2 int x; 3 String s; 4 } 5 6 public class WhereAllocated { 7 public static void main(string args[]) { 8 final int LEN = 1024; 9 int x; 10 Junk j = new Junk(); 11 int A[] = new int[len]; for (int i=0; i<a.length; i++) { /* do something with A[] */ } 20 } 21 }

17

18

19

20

21 parameter location local var 2-8(%ebp) local var 1-4(%ebp) old %ebp (%ebp) return addr 4(%ebp) param 1 8(%ebp) param 2 12(%ebp) param n 4n+4(%ebp) parameter location old %ebp (%ebp) return addr 4(%ebp) param 1 8(%ebp) param 2 12(%ebp) param n 4n+4(%ebp)

22 void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } swap: pushl %ebp movl %esp,%ebp pushl %ebx movl 12(%ebp),%ecx movl 8(%ebp),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret 1.text 2.globl sumtwomine 3.type 4 sumtwomine: 5 pushl %ebp 6 movl %esp, %ebp 7 movl 12(%ebp), %eax 8 movl 8(%ebp), %edx 9 addl %edx, %eax 10 popl %ebp 11 ret type fname: pushl %ebp movl %esp, %ebp /* add space for local vars if */ /* necessary by subtracting */ /* from %esp */... /* if you ve added space for */ /* local vars, free the space */ /* by adding to %esp */ movl popl ret %ebp, %esp %ebp

23 1.text 2.globl sumtwomine 3.type 4 sumtwomine: 5 pushl %ebp 6 movl %esp, %ebp 7 movl 12(%ebp), %eax 8 movl 8(%ebp), %edx 9 addl %edx, %eax 10 popl %ebp 11 ret 1.text 2.globl sumtwo 3.type 4 sumtwo: 5 pushl %ebp 6 movl %esp, %ebp 7 movl 12(%ebp), %eax 8 movl 8(%ebp), %edx 9 leal (%edx,%eax), %eax 10 popl %ebp 11 ret

24

25 void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } swap: pushl %ebp movl %esp,%ebp pushl %ebx movl 12(%ebp),%ecx movl 8(%ebp),%edx movl (%ecx),%eax movl (%edx),%ebx movl %eax,(%edx) movl %ebx,(%ecx) movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret 1.section.text 2.globl _start 3.globl factorial #this is unneeded unless we want to share 4 #this function among other programs 5 _start: 6 pushl $4 #The factorial takes one argument - the 7 #number we want a factorial of. So, it 8 #gets pushed 9 call factorial #run the factorial function 10 addl $4, %esp #Scrubs the parameter that was pushed on 11 #the stack 12 movl %eax, %ebx #factorial returns the answer in %eax, but 13 #we want it in %ebx to send it as our exit 14 #status 15 movl $1, %eax #call the kernel s exit function 16 int $0x80

26 1.type 2 factorial: 3 pushl %ebp #standard function stuff - we have to 4 #restore %ebp to its prior state before 5 #returning, so we have to push it 6 movl %esp, %ebp #This is because we don t want to modify 7 #the stack pointer, so we use %ebp. 8 9 movl 8(%ebp), %eax #This moves the first argument to %eax 10 #4(%ebp) holds the return address, and 11 #8(%ebp) holds the first parameter 12 cmpl $1, %eax #If the number is 1, that is our base 13 #case, and we simply return (1 is 14 #already in %eax as the return value) 15 je end_factorial 16 decl %eax #otherwise, decrease the value 17 pushl %eax #push it for our call to factorial 18 call factorial #call factorial 19 movl 8(%ebp), %ebx #%eax has the return value, so we 20 #reload our parameter into %ebx 21 imull %ebx, %eax #multiply that by the result of the 22 #last call to factorial (in %eax) 23 #the answer is stored in %eax, which 24 #is good since that s where return 25 #values go. 26 end_factorial: 27 movl %ebp, %esp #standard function return stuff - we 28 popl %ebp #have to restore %ebp and %esp to where 29 #they were before the function started 30 ret #return from the function (this pops the 31 #return value, too)