1 if (a == b) 2 { 3 /* true stuff here */ 4 } 5 else 6 { 7 /* false stuff here */ 8 } 10 /* done either way (i.e., whether true.

Transcription

1

2 1 movl a, %eax 2 movl b, %ebx 3 cmpl %eax, %ebx 4 je truestuff 5 6 /* false stuff here */ 7 jmp DoneEitherWay 8 9 truestuff: 10 /* if true code here */ 1 int absdiff(int x, int y) 3 if (x<y) 4 return y-x; 5 return x-y; 6 } DoneEitherWay: 13 /* done whether true or false */ 1 if (a == b) 3 /* true stuff here */ 4 } 5 else 6 { 7 /* false stuff here */ 8 } 9 10 /* done either way (i.e., whether true 11 or false) */

3 1.section.text 2.globl max 3.type 4 max: 5 pushl %ebp 6 movl %esp, %ebp 7 movl $0, %eax 8 movl 8(%ebp), %ecx 9 movl 12(%ebp), %edx 10 cmpl %ecx, %edx 11 jge L1 12 movl %ecx, %eax 13 jmp done 14 L1: 15 movl %edx, %eax 16 done: 17 movl %ebp, %esp 18 popl %ebp 19 ret 1.section.text 2.globl max 3.type 4 max: 5 pushl %ebp 6 movl %esp, %ebp 7 movl $0, %eax 8 movl 8(%ebp), %ecx 9 movl 12(%ebp), %edx 10 cmpl %ecx, %edx 11 jge L1 12 movl %ecx, %eax 13 jmp done 14 L1: 15 movl %edx, %eax 16 done: 17 movl %ebp, %esp 18 popl %ebp 19 ret 1 int absdiff(int x, int y) 3 if (x<y) 4 return y-x; 5 return x-y; 6 } 1 int absdiff(int x, int y) 3 int rval; 4 if (x < y) 5 goto less; 6 rval = y-x; 7 goto done; 8 less: 9 rval = y - x; 10 done: 11 return rval; 12 } 1 int absdiff(int x, int y) 3 if (x<y) 4 return y-x; 5 return x-y; 6 } 1 int absdiff(int x, int y) 3 int rval; 4 if (x < y) 5 goto less; 6 rval = y-x; 7 goto done; 8 less: 9 rval = y - x; 10 done: 11 return rval; 12 } 1.file "absdiff.c" 2.text 3.globl absdiff 4.type 5 absdiff: 6 pushl %ebp 7 movl %esp, %ebp 8 subl $4, %esp 9 movl 8(%ebp), %eax 10 cmpl 12(%ebp), %eax 11 jge.l2 12 movl 8(%ebp), %edx 13 movl 12(%ebp), %eax 14 movl %eax, %ecx 15 subl %edx, %ecx 16 movl %ecx, -4(%ebp) 17 jmp.l3 18.L2: 19 movl 12(%ebp), %edx 20 movl 8(%ebp), %eax 21 movl %eax, %ecx 22 subl %edx, %ecx 23 movl %ecx, -4(%ebp) 24.L3: 25 movl -4(%ebp), %eax 26 leave 27 ret 28.size absdiff,.-absdiff 29.ident "GCC: (Ubuntu ubuntu12) 4 30.section.note.GNU-stack,"",@progbits

4 1 while (a < b) 3 /* loop body */ 4 } 1 while (a < b) 3 /* loop body */ 4 } 1 movl a, %eax 2 movl b, %ebx 3 loop_beginning: 4 cmpl %ebx, %eax 5 jge loop_ending 6 7 loop_body: 8 9 /* loop body */ jmp loop_beginning 12 loop_ending: 1.section.text 2.globl to_upper 3.type 1 int to_upper(int c) 4 to_upper: 5 pushl %ebp 3 if (c > 122 c < 97) 6 movl %esp, %ebp 4 return c; 7 xorl %eax, %eax 5 return c-32; 8 movl 8(%ebp), %eax 6 } 9 cmpl $122, %eax 10 jg done 11 cmpl $97, %eax 12 jl done 13 addl $-32, %eax 14 done: 15 movl %ebp, %esp 16 popl %ebp 17 ret

5 1.section.text 2.globl sum 3.type 4 sum: 5 pushl %ebp 6 movl %esp, %ebp 7 movl $0, %ecx 8 movl $0, %eax 9 movl 8(%ebp), %edx 10 begin: 11 cmpl 12(%ebp), %ecx 12 jge done 13 addl (%edx, %ecx, 4), %eax 14 incl %ecx 15 jmp begin 16 done: 17 movl %ebp, %esp 18 popl %ebp 19 ret 1 int rev(int A[], int len) { 2 int *p=a, 3 *q=a+len-1, 4 t1, t2; 5 6 while (p<q) { 7 t1=*p; 8 t2=*q; 9 10 *q=t1; 11 *p=t2; 12 p++; 13 q--; 14 } 15 } 1.section.text 2.globl rev_array 3.type 4 rev_array: 5 pushl %ebp 6 movl %esp, %ebp 7 pushl %ebx 8 movl 12(%ebp), %eax 9 decl %eax 10 movl 8(%ebp), %ecx 11 leal (%ecx,%eax,4), %edx 12 begin: 13 cmpl %ecx, %edx 14 jle done 15 movl (%ecx), %eax 16 movl (%edx), %ebx 17 movl %eax, (%edx) 18 movl %ebx, (%ecx) 19 addl $4, %ecx 20 addl $-4, %edx 21 jmp begin 22 done: 23 popl %ebx 24 movl %ebp, %esp 25 popl %ebp 26 ret 1.section.data 2.section.text 3.globl _start 4 _start: 5 pushl $3 #push second argument 6 pushl $2 #push first argument 7 call power #call the function 8 addl $8, %esp #move the stack pointer back 9 10 pushl %eax #save the first answer before 11 #calling the next function pushl $2 #push second argument 14 pushl $5 #push first argument 15 call power #call the function 16 addl $8, %esp #move the stack pointer back popl %ebx #The second answer is already 19 #in %eax. We saved the 20 #first answer onto the stack, 21 #so now we can just pop it 22 #out into %ebx 1.type 2 power: 3 pushl %ebp #save old base pointer 4 movl %esp, %ebp #make stack pointer the base pointer 5 subl $4, %esp #get room for our local storage 6 7 movl 8(%ebp), %ebx #put first argument in %ebx 8 movl 12(%ebp), %ecx #put second argument in %ecx 9 10 movl %ebx, -4(%ebp) #store current result power_loop_start: 13 cmpl $1, %ecx #if the power is 1, we are done 14 je end_power 15 movl -4(%ebp), %eax #move the current result into %eax 16 imull %ebx, %eax #multiply the current result by 17 #the base number 18 movl %eax, -4(%ebp) #store the current result decl %ecx #decrease the power 21 jmp power_loop_start #run for the next power addl %eax, %ebx #add them together 25 #the result is in %ebx movl $1, %eax #exit (%ebx is returned) 28 int $0x end_power: 24 movl -4(%ebp), %eax #return value goes in %eax 25 movl %ebp, %esp #restore the stack pointer 26 popl %ebp #restore the base pointer 27 ret

6 1 mov counter val into %ecx 2 lb: 3 do stuff 4 loop lb 1 /* file LoopInstrTst.s */ 2.section.data 3 msg: 4.asciz "ecx = %d\n" 5 6.section.text 7.equ LINUX_SYSCALL, 0x80 8.equ EXIT_SYSCALL, 1 9.globl _start 10 _start: 11 nop 12 movl $30, %ecx 13 loop_begin: 14 pushl %ecx 15 pushl %ecx 16 pushl $msg 17 call printf 18 addl $8, %esp 19 popl %ecx 20 loop loop_begin 21 /* loop instruction uses 22 ecx as a counter 23 don t need to decl ecx. */ movl $EXIT_SYSCALL, %eax 26 movl $0, %ebx 27 int $LINUX_SYSCALL 28 1.section.text 2.globl to_upper 3.type 1 int to_upper(int c) 4 to_upper: 5 pushl %ebp 3 if (c > 122 c < 97) 6 movl %esp, %ebp 4 return c; 7 xorl %eax, %eax 5 return c-32; 8 movl 8(%ebp), %eax 6 } 9 cmpl $122, %eax 10 jg done 11 cmpl $97, %eax 12 jl done 13 addl $-32, %eax 14 done: 15 movl %ebp, %esp 16 popl %ebp 17 ret 1.section.text 2.globl str_to_upper 3.type 1 void str_to_upper(char *str) { 4 str_to_upper: 2 char *s = str; 5 pushl %ebp 3 while (*s!= \0 ) { 6 movl %esp, %ebp 7 subl $4, %esp 4 *s = to_upper(*s); 8 movl 8(%ebp), %ecx 5 s++; 9 xorl %eax, %eax 6 } 10 begin: 7 } 11 movb (%ecx), %al 12 cmpb $0, %al 13 je done 14 movl %eax, -4(%ebp) 15 call to_upper 16 movb %al, (%ecx) 17 incl %ecx 18 jmp begin 19 done: 20 addl $4, %esp 21 movl %ebp, %esp 22 popl %ebp

7 1.type 2.globl strlen 3 4 strlen: 5 pushl %ebp 6 movl %esp, %ebp 7 8 /* use eax as counter */ 9 movl $0, %eax /* %edi now contains the address of the string */ 12 movl 8(%ebp), %edi 13 loop_beginning: 14 /* have we found the null character? */ 15 cmpb $0, (%edi) 16 je exit 17 /* increment counter */ 18 incl %eax 19 /* increment pointer */ 20 incl %edi 21 jmp loop_beginning 22 exit: 23 movl %ebp, %esp 24 popl %ebp 25 ret 1.type 2.globl strlen2 3 4 strlen2: 5 pushl %ebp 6 movl %esp, %ebp 7 8 /* %eax now contains the address 9 of the begining of the string */ 10 movl 8(%ebp), %eax 11 loop_beginning: 12 /* have we found the null character? */ 13 cmpb $0, (%eax) 14 je exit 15 /* increment counter */ 16 incl %eax 17 jmp loop_beginning 18 exit: 19 /* length = address of end of str 20 stored in eax - address of beginning 21 of the string stored in 8(%ebp) */ 22 subl 8(%ebp), %eax 23 movl %ebp, %esp 24 popl %ebp 25 ret 1 /* file LoopInstrTst.s */ 2.section.data 3 msg: 4.asciz "ecx = %d\n" 5 6.section.text 7.equ LINUX_SYSCALL, 0x80 8.equ EXIT_SYSCALL, 1 9.globl _start 10 _start: 11 nop 12 movl $30, %ecx 13 loop_begin: 14 pushl %ecx 15 pushl %ecx 16 pushl $msg 17 call printf 18 addl $8, %esp 19 popl %ecx 20 loop loop_begin 21 /* loop instruction uses 22 ecx as a counter 23 don t need to decl ecx. */ movl $EXIT_SYSCALL, %eax 26 movl $0, %ebx 27 int $LINUX_SYSCALL 28

8 cmpl Y, X je jump if they were equal jg jump if the 2nd was greater than the first jge jump if the 2nd was greater or equal than the first jl jump if the 2nd was less than the first jle jump if the 2nd was less than or equal to the first CF carry flag ZF zero flag SF sign flag OF overflow flag o o o o o

9 instruction synonym effect set condition sete D setz D ZF equal/zero setne D setnz D ZF not equal/not zero sets D D SF negative setns D D SF non-negative setg D setnle D (SF OF) & ZF greater (signed >) setge D setnl D (SF OF) greater or equal (signed >=) setl D setnge D SF OF less (signed <) setle D setng D (SF OF) ZF less or equal (signed <=) seta D setnbe D CF & ZF above (unsigned >) setae D setnb D CF above or equal (unsigned >=) setb D setnae D CF below (unsigned <) setbe D setna D CF ZF below or equal (unsigned (<=) instruction synonym jump condition description jmp label 1 direct jump jmp *operand 1 indirect jump je label jz ZF equal/zero jne label jnz ZF not equal/zero js label SF negative jns label SF non-negative jg label jnle (SF OF) & ZF greater (signed >) jge label jnl (SF OF) greater or equal (signed >=) jl label jnge SF OF less (signed <) jle label jng (SF OF) ZF less or equal (signed (<=) ja label jnbe CF & ZF above (unsigned >) jae label jnb CF above or equal (unsigned >=) jb label jnae CF below (unsigned <) jbe label jna CF ZF below or equal (unsigned <=) add sub,xor test cmp testx A,BA&B cmpx A,BB-A

10 cmpl %ebx,%eax jl %eax < %ebx %ebx < %eax 1 /* from Programming from the Ground Up */ 2.section.data 3 4 data_items: #These are the data items 5.long 3,67,34,222,45,75,54,34,44,33,22,11,66,0 6 7.section.text 8 9.globl _start 10 _start: 11 movl $0, %edi # move 0 into the index register 12 movl data_items(,%edi,4), %eax # load the first byte of data 13 movl %eax, %ebx # since this is the first item, %eax is 14 # the biggest start_loop: # start loop 17 cmpl $0, %eax # check to see if we ve hit the end 18 je loop_exit 19 incl %edi # load next value 20 movl data_items(,%edi,4), %eax 21 cmpl %ebx, %eax # compare values 22 jle start_loop # jump to loop beginning if the new 23 # one isn t bigger 24 movl %eax, %ebx # move the value as the largest 25 jmp start_loop # jump to loop beginning loop_exit: 28 # %ebx is the status code for the exit system call 29 # and it already has the maximum number 30 movl $1, %eax #1 is the exit() syscall 31 int $0x80 1 /* file altb.s */ 2.text 3 4.equ LINUX_SYSCALL, 0x80 5.equ EXIT_SYSCALL, globl _start 8 _start: 9 nop 10 movl $10, %eax 11 movl $20, %ebx 12 cmpl %ebx, %eax 13 setl %al 14 movzbl %al, %eax movl %eax, %ebx 17 movl $EXIT_SYSCALL, %eax 18 int $LINUX_SYSCALL 19

11 1 /* file SimpleArr.s */ 2.data 3 msg1: 4.asciz "A[%d]=%d\n" 5 msg2: 6.asciz "Done.\n" 7 8.text 9.globl _start 10.equ SIZE, _start: 12 pushl %ebp 13 movl %esp, %ebp /* add space on stack for 16 array of 10 ints */ 17 subl $40, %esp 18 leal (%esp), %ebx 19 movl $0, %edi 20 init_loop_beginning: 21 movl %edi, (%ebx, %edi, 4) 22 incl %edi 23 cmpl $SIZE, %edi 24 jl init_loop_beginning 25 movl $0, %edi 26 print_loop_beginning: 27 pushl %edi 28 pushl (%ebx, %edi, 4) 29 pushl $msg1 30 call printf 31 addl $12, %esp 32 incl %edi 33 cmpl $SIZE, %edi 34 jl print_loop_beginning pushl $msg2 37 call printf 38 addl $4, %esp /* we re exiting anyway, 41 but it can t hurt */ 42 movl %ebp, %esp 43 popl %ebp movl $1, %eax 46 movl $0, %ebx 47 int $0x80 1 #include <stdio.h> 2 3 #define NUMROWS 4 4 #define NUMCOLS int main(int argc, char **argv) 7 { 8 int A[NUMROWS][NUMCOLS], i, j; 9 10 printf("\n "); 11 for (i=0; i<numrows; i++) { 12 for (j=0; j<numcols; j++) 13 printf("%p ", (void*)&a[i][j]); 14 printf("\n "); 15 } return 0; 18 } 1 #include <stdio.h> 2 3 #define LEN 5 4 typedef struct { 5 char s[10]; 6 int i; 7 float f; 8 } junk; 9 10 int main(int argc, char **argv) 11 { 12 int i; 13 int inta[len]; 14 char chara[len]; 15 junk junka[len]; printf("inta[]\n"); 18 for (i=0; i<len; i++) 19 printf("%p ", (void*)&inta[i]); printf("\nchara[]\n"); 22 for (i=0; i<len; i++) 23 printf("%p ", (void*)&chara[i]); printf("\njunka[]\n"); 26 for (i=0; i<len; i++) 27 printf("%p ", (void*)&junka[i]); inta[0] inta[1] inta[2] inta[3] inta[4] 0xbffff4c8 0xbffff4cc 0xbffff4d0 0xbffff4d4 0xbffff4d8 chara[0] chara[1] chara[2] chara[3] chara[4] 0xbffff4c3 0xbffff4c4 0xbffff4c5 0xbffff4c6 0xbffff4c7 junka[0] junka[1] junka[2] junka[3] junka[4] 0xbffff45c 0xbffff470 0xbffff484 0xbffff498 0xbffff4ac printf("\n"); 30 return 0; 31 }

12 1 #include "car.h" 2 #include <stdio.h> 3 4 void printcar(car *c) 5 { 6 printf("make:%s\n", c->make); 7 printf("model:%s\n", c->model); 8 printf("year:%d\n", c->year); 9 printf("city MPG:%d\n", c->cmpg); 10 printf("highway MPG:%d\n", c->hmpg); 11 } void printcarlong(car *c) 14 { 15 printf("make[%p]:%s\n", (void*)&(c->make), c->make); 16 printf("model[%p]:%s\n", (void*)&(c->model), c->model); 17 printf("year[%p]:%d\n", (void*)&(c->year), c->year); 18 printf("city MPG[%p]:%d\n", (void*)&(c->cmpg), c->cmpg); 19 printf("highway MPG[%p]:%d\n", (void*)&(c->hmpg), c->hmpg); 20 } 1 #include "car.h" 2 3 int main(int argc, char **argv) 4 { 5 car c1 = {"Toyota", "Prius", 2004, 35, 50}; 6 car c2 = {"Ford", "Expedition", 2004, 8, 18}; 7 8 printcarlong(&c1); 9 printcarlong(&c2); 10 return 0; 11 } 12 0xbffff438 0xbffff43c 0xbffff440 0xbffff444 0xbffff448 0xbffff44c 0xbffff450 0xbffff454 0xbffff458 0xbffff45c 0xbffff460 0xbffff464 1 /* car.h */ 2 3 #ifndef CAR_H 4 #define CAR_H 5 6 typedef struct { 7 char make[15]; 8 char model[15]; 9 int year; 10 int cmpg; /* city MPG */ 11 int hmpg; /* highway MPG */ 12 } car; void printcar(car*); 15 void printcarlong(car*); #endif

13 1 make[0xbffff4b4]:toyota 2 model[0xbffff4c3]:prius 3 year[0xbffff4d4]: city MPG[0xbffff4d8]:35 5 highway MPG[0xbffff4dc]:50 6 make[0xbffff488]:ford 7 model[0xbffff497]:expedition 8 year[0xbffff4a8]: city MPG[0xbffff4ac]:8 10 highway MPG[0xbffff4b0]:18

14 size type lowest bits of address 1 char no restrictions 2 short lowest bit=0 2 4 int, float, pointer lowest two bits= double Windows - lowest 3 bits=000 2 Linux - lowest 2 bits=00 2

15 arch void somecfunc( ) { asm( assembly here ); /* OR */ asm ( assembly here ); } 1 /* file sizeoftst.c */ 2 #include <stdio.h> 3 4 typedef struct { 5 int x; 6 char c[5]; 7 } foo; 8 9 typedef struct { 10 int x; 11 char c; 12 } goo; 13 int main(int argc, char **argv) 14 { 15 foo F[10]; 16 goo G[10]; printf("sizeof foo = %lu\n", 19 sizeof(f[0])); 20 printf("sizeof F[] = %lu\n", 21 sizeof(f)); 22 printf("sizeof goo = %lu\n", 23 sizeof(g[0])); 24 printf("sizeof G[] = %lu\n", 25 sizeof(g)); 26 return 0; 27 } 1 /* file sizeoftst.c */ 2 #include <stdio.h> 3 4 typedef struct { 5 int x; 6 char c[5]; 7 } foo; 8 9 typedef struct { 10 int x; 11 char c; 12 } goo;

16 1 unsigned char c = ch; 2 3 if (c == \n ) 4 putchar( \r ); /* \n -> \r\n */ 5 6 /* int $0x10 is known to have bugs involving touching registers 7 it shouldn t. Be extra conservative... */ 8 asm volatile("pushal; pushw %%ds; int $0x10; popw %%ds; popal" 9 : : "b" (0x0007), "c" (0x0001), "a" (0x0e00 ch));

17 char description r use any general purpose register a %eax, %ax, or %al b %ebx, %bx, or %bl c %ecx, %cx, or %cl d %edx, %dx, or %dl S %esi D %edi m use memory, not a register 0, 1,..., 9 use some variable that you ve defined earlier in some list, e.g. asm( addl %0, %0 : a (var) : 0 (var)). In this case 0 refers to the first variable, var, in the output list.

18 char *getcpuid() { int func=0, bx, cx, dx; } char *cpuidstr; if ((cpuidstr = (char*)calloc(cpuid_strlen, 1))==NULL) return NULL; asm("cpuid" :"=b" (bx), "=c" (cx), "=d" (dx) : "a" (func)); memcpy(cpuidstr, &bx, 4); memcpy(&cpuidstr[4], &dx, 4); memcpy(&cpuidstr[8], &cx, 4); cpuidstr[cpuid_strlen-1]= \0 ; return cpuidstr; 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