Post on 23-Jul-2020
transcript
CS33 Intro to Computer Systems XI–1 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
CS 33Machine Programming (3)
CS33 Intro to Computer Systems XI–2 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Not a Quiz …
What value ends up in %ecx?
movl $1000,%eax
movl $1,%ebx
movl 2(%eax,%ebx,4),%ecx
a) 0x02030405b) 0x05040302c) 0x06070809d) 0x09080706
0x070x060x050x040x030x020x010x001000:
1001:1002:1003:1004:1005:1006:1007:
0x090x081008:
1009:
Hint:
%eax
CS33 Intro to Computer Systems XI–3 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
%rsp
x86-64 General-Purpose Registers
– Extend existing registers to 64 bits. Add 8 new ones.– No special purpose for %ebp/%rbp
%eax
%ebx
%ecx
%edx
%esi
%edi
%esp
%ebp
%r8d
%r9d
%r10d
%r11d
%r12d
%r13d
%r14d
%r15d
%r8
%r9
%r10
%r11
%r12
%r13
%r14
%r15
%rax
%rbx
%rcx
%rdx
%rsi
%rdi
%rbp
a1
a2
a3
a4
a5a6
CS33 Intro to Computer Systems XI–4 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
32-bit Instructions on x86-64
• addl 4(%rdx), %eax– memory address must be 64 bits– operands (in this case) are 32-bit
» result goes into %eax• lower half of %rax• upper half is filled with zeroes
CS33 Intro to Computer Systems XI–5 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Bytes
• Each register has a byte version– e.g., %r10: %r10b
• Needed for byte instructions– movb (%rax, %rsi), %r10b– sets only the low byte in %r10
» other seven bytes are unchanged
• Alternatives– movzbq (%rax, %rsi), %r10
» copies byte to low byte of %r10» zeroes go to higher bytes
– movsbq (%rax, %rsi), %r10» copies byte to low byte of %r10» sign is extended to all higher bits
CS33 Intro to Computer Systems XI–6 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
32-bit code for swap
void swap(int *xp, int *yp) {
int t0 = *xp;int t1 = *yp;*xp = t1;*yp = t0;
} Body
SetUp
Finish
swap:pushl %ebpmovl %esp,%ebppushl %ebx
movl 8(%ebp), %edxmovl 12(%ebp), %ecxmovl (%edx), %ebxmovl (%ecx), %eaxmovl %eax, (%edx)movl %ebx, (%ecx)
popl %ebxpopl %ebpret
CS33 Intro to Computer Systems XI–7 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
64-bit code for swap
• Arguments passed in registers– first (xp) in %rdi, second (yp) in %rsi– 64-bit pointers
• No stack operations required• 32-bit data
– data held in registers %eax and %edx– movl operation
void swap(int *xp, int *yp) {
int t0 = *xp;int t1 = *yp;*xp = t1;*yp = t0;
}
Body
SetUp
Finish
swap:
movl (%rdi), %edxmovl (%rsi), %eaxmovl %eax, (%rdi)movl %edx, (%rsi)
ret
CS33 Intro to Computer Systems XI–8 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
64-bit code for long int swap
• 64-bit data– data held in registers %rax and %rdx– movq operation
» “q” stands for quad-word
void swap(long *xp, long *yp) {
long t0 = *xp;long t1 = *yp;*xp = t1;*yp = t0;
}
Body
SetUp
Finish
swap_l:
movq (%rdi), %rdxmovq (%rsi), %raxmovq %rax, (%rdi)movq %rdx, (%rsi)
ret
CS33 Intro to Computer Systems XI–9 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
text
text
binary
binary
Compiler (gcc -S)
Assembler (as)
Linker (ld)
C program (p1.c p2.c)
Asm program (p1.s p2.s)
Object program (p1.o p2.o)
Executable program (p)
Static libraries (.a)
Turning C into Object Code– Code in files p1.c p2.c– Compile with command: gcc –O1 p1.c p2.c -o p
» use basic optimizations (-O1)» put resulting binary in file p
CS33 Intro to Computer Systems XI–10 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Example
int sum(int a, int b) {return(a+b);
}
CS33 Intro to Computer Systems XI–11 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Code for sum0x401040 <sum>:
0x550x890xe50x8b0x450x0c0x030x450x080x5d0xc3
Object Code
• Assembler– translates .s into .o– binary encoding of each instruction– nearly-complete image of executable
code– missing linkages between code in
different files• Linker
– resolves references between files– combines with static run-time
libraries» e.g., code for printf
– some libraries are dynamically linked» linking occurs when program begins
execution
• Total of 11 bytes• Each instruction:
1, 2, or 3 bytes• Starts at address 0x401040
CS33 Intro to Computer Systems XI–12 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Instruction Format
CS33 Intro to Computer Systems XI–13 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Disassembled
Disassembling Object Code
• Disassemblerobjdump -d <file>
– useful tool for examining object code– analyzes bit pattern of series of instructions– produces approximate rendition of assembly code– can be run on either executable or object (.o) file
080483c4 <sum>:80483c4: 55 push %ebp80483c5: 89 e5 mov %esp,%ebp80483c7: 8b 45 0c mov 0xc(%ebp),%eax80483ca: 03 45 08 add 0x8(%ebp),%eax80483cd: 5d pop %ebp80483ce: c3 ret
CS33 Intro to Computer Systems XI–14 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Disassembled
Dump of assembler code for function sum:0x080483c4 <sum+0>: push %ebp0x080483c5 <sum+1>: mov %esp,%ebp0x080483c7 <sum+3>: mov 0xc(%ebp),%eax0x080483ca <sum+6>: add 0x8(%ebp),%eax0x080483cd <sum+9>: pop %ebp0x080483ce <sum+10>: ret
Alternate Disassembly
• Within gdb debuggergdb <file>disassemble sum
– disassemble procedurex/11xb sum
– examine the 11 bytes starting at sum
Object0x401040:
0x550x890xe50x8b0x450x0c0x030x450x080x5d0xc3
CS33 Intro to Computer Systems XI–15 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
How Many Instructions are There?• We cover ~30• Implemented by Intel:
– 80 in original 8086 architecture
– 7 added with 80186– 17 added with 80286– 33 added with 386– 6 added with 486– 6 added with Pentium– 1 added with Pentium MMX– 4 added with Pentium Pro– 8 added with SSE– 8 added with SSE2– 2 added with SSE3– 14 added with x86-64– 10 added with VT-x– 2 added with SSE4a
• Total: 198• Doesn’t count:
– floating-point instructions» ~100
– SIMD instructions» lots
– AMD-added instructions– undocumented instructions
CS33 Intro to Computer Systems XI–16 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Some Arithmetic Operations
• Two-operand instructions:Format Computation
addl Src,Dest Dest = Dest + Srcsubl Src,Dest Dest = Dest - Srcimull Src,Dest Dest = Dest * Srcsall Src,Dest Dest = Dest << Src Also called shllsarl Src,Dest Dest = Dest >> Src Arithmeticshrl Src,Dest Dest = Dest >> Src Logicalxorl Src,Dest Dest = Dest ^ Srcandl Src,Dest Dest = Dest & Srcorl Src,Dest Dest = Dest | Src
– watch out for argument order!– no distinction between signed and unsigned int (why?)
CS33 Intro to Computer Systems XI–17 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Some Arithmetic Operations
• One-operand Instructionsincl Dest = Dest + 1decl Dest = Dest - 1negl Dest = - Destnotl Dest = ~Dest
• See book for more instructions
CS33 Intro to Computer Systems XI–18 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Arithmetic Expression Example
int arith(int x, int y, int z){
int t1 = x+y;int t2 = z+t1;int t3 = x+4;int t4 = y * 48; int t5 = t3 + t4;int rval = t2 * t5;return rval;
}
arith:leal (%rdi,%rsi), %eaxaddl %edx, %eaxleal (%rsi,%rsi,2), %edxsall $4, %edxleal 4(%rdi,%rdx), %ecximull %ecx, %eaxret
CS33 Intro to Computer Systems XI–19 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Understanding arith
leal (%rdi,%rsi), %eaxaddl %edx, %eaxleal (%rsi,%rsi,2), %edxsall $4, %edxleal 4(%rdi,%rdx), %ecximull %ecx, %eaxret
int arith(int x, int y, int z){
int t1 = x+y;int t2 = z+t1;int t3 = x+4;int t4 = y * 48; int t5 = t3 + t4;int rval = t2 * t5;return rval;
}
%rsi
%rdi
y
x
%rdx z
CS33 Intro to Computer Systems XI–20 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Understanding arithint arith(int x, int y, int z){
int t1 = x+y;int t2 = z+t1;int t3 = x+4;int t4 = y * 48; int t5 = t3 + t4;int rval = t2 * t5;return rval;
}
leal (%rdi,%rsi), %eax # eax = x+y (t1)addl %edx, %eax # eax = t1+z (t2)leal (%rsi,%rsi,2), %edx # edx = 3*y (t4)sall $4, %edx # edx = t4*16 (t4)leal 4(%rdi,%rdx), %ecx # ecx = x+4+t4 (t5)imull %ecx, %eax # eax *= t5 (rval)ret
%rsi
%rdi
y
x
%rdx z
CS33 Intro to Computer Systems XI–21 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Observations about arithint arith(int x, int y, int z){
int t1 = x+y;int t2 = z+t1;int t3 = x+4;int t4 = y * 48; int t5 = t3 + t4;int rval = t2 * t5;return rval;
}
leal (%rdi,%rsi), %eax # eax = x+y (t1)addl %edx, %eax # eax = t1+z (t2)leal (%rsi,%rsi,2), %edx # edx = 3*y (t4)sall $4, %edx # edx = t4*16 (t4)leal 4(%rdi,%rdx), %ecx # ecx = x+4+t4 (t5)imull %ecx, %eax # eax *= t5 (rval)ret
• Instructions in different order from C code
• Some expressions might require multiple instructions
• Some instructions might cover multiple expressions
CS33 Intro to Computer Systems XI–22 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Another Example
int logical(int x, int y){
int t1 = x^y;int t2 = t1 >> 17;int mask = (1<<13) - 7;int rval = t2 & mask;return rval;
}
xorl %esi, %edi # edi = x^y (t1)sarl $17, %edi # edi = t1>>17 (t2)movl %edi, %eax # eax = ediandl $8185, %eax # eax = t2 & mask (rval)
213 = 8192, 213 – 7 = 8185
CS33 Intro to Computer Systems XI–23 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Quiz 1
• What is the final value in %ecx?
xorl %ecx, %ecx
incl %ecx
sall %cl, %ecx # %cl is the low byte of %ecx
addl %ecx, %ecx
a) 2b) 4c) 8d) indeterminate
CS33 Intro to Computer Systems XI–24 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Processor State (x86-64, Partial)
%rsp
%eax
%ebx
%ecx
%edx
%esi
%edi
%esp
%ebp
%r8d
%r9d
%r10d
%r11d
%r12d
%r13d
%r14d
%r15d
%r8
%r9
%r10
%r11
%r12
%r13
%r14
%r15
%rax
%rbx
%rcx
%rdx
%rsi
%rdi
%rbp
%rip CF ZF SF OFcondition codes
a1a2a3a4
a5a6
CS33 Intro to Computer Systems XI–25 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Condition Codes (Implicit Setting)
• Single-bit registersCF carry flag (for unsigned) SF sign flag (for signed)ZF zero flag OF overflow flag (for signed)
• Implicitly set (think of it as side effect) by arithmetic operationsexample: addl/addq Src,Dest ↔ t = a+bCF set if carry out from most significant bit or borrow (unsigned overflow)ZF set if t == 0SF set if t < 0 (as signed)OF set if two’s-complement (signed) overflow(a>0 && b>0 && t<0) || (a<0 && b<0 && t>=0)
• Not set by lea instruction
CS33 Intro to Computer Systems XI–26 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Condition Codes (Explicit Setting: Compare)
• Explicit setting by compare instructioncmpl/cmpq src2, src1
compares src1:src2cmpl b,a like computing a-b without setting destination
CF set if carry out from most significant bit or borrow (used for unsigned comparisons)ZF set if a == bSF set if (a-b) < 0 (as signed)OF set if two’s-complement (signed) overflow(a>0 && b<0 && (a-b)<0) || (a<0 && b>0 && (a-b)>0)
CS33 Intro to Computer Systems XI–27 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Condition Codes (Explicit Setting: Test)
• Explicit setting by test instructiontestl/testq src2, src1testl b,a like computing a&b without setting destination
– sets condition codes based on value of Src1 & Src2– useful to have one of the operands be a mask
ZF set when a&b == 0SF set when a&b < 0
CS33 Intro to Computer Systems XI–28 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Reading Condition Codes
• SetX instructions– set single byte based on combinations of condition codes
SetX Condition Descriptionsete Equal / Zerosetne Not Equal / Not Zerosets Negativesetns Nonnegativesetg Greater (Signed)setge Greater or Equal (Signed)setl Less (Signed)setle Less or Equal (Signed)seta Above (unsigned)setb Below (unsigned)
ZF~ZFSF~SF
~(SF^OF)&~ZF~(SF^OF)
(SF^OF)(SF^OF)|ZF~CF&~ZFCF
CS33 Intro to Computer Systems XI–29 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
cmpl %esi, %edi # compare x : ysetg %al # %al = x > ymovzbl %al, %eax # zero rest of %eax/%rax
Reading Condition Codes (Cont.)• SetX instructions:
– set single byte based on combination of condition codes
• Uses byte registers– does not alter remaining 7 bytes– typically use movzbl to finish job
int gt (int x, int y){
return x > y;}
Body
%al%ah%eax%rax
CS33 Intro to Computer Systems XI–30 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Jumping
• jX instructions– Jump to different part of code depending on condition codes
jX Condition Descriptionjmp 1 Unconditionalje ZF Equal / Zerojne ~ZF Not Equal / Not Zerojs SF Negativejns ~SF Nonnegativejg ~(SF^OF)&~ZF Greater (Signed)jge ~(SF^OF) Greater or Equal (Signed)jl (SF^OF) Less (Signed)jle (SF^OF)|ZF Less or Equal (Signed)ja ~CF&~ZF Above (unsigned)jb CF Below (unsigned)
CS33 Intro to Computer Systems XI–31 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Conditional-Branch Example
int absdiff(int x, int y){
int result;if (x > y) {
result = x-y;} else {
result = y-x;}return result;
}
absdiff:movl %esi, %eaxcmpl %esi, %edijle .L6subl %eax, %edimovl %edi, %eaxjmp .L7
.L6:subl %edi, %eax
.L7:ret
Body1
Body2b
Body2a
x in %edi
y in %esi
CS33 Intro to Computer Systems XI–32 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Conditional-Branch Example (Cont.)int goto_ad(int x, int y){
int result;if (x <= y) goto Else;result = x-y;goto Exit;
Else:result = y-x;
Exit:return result;
}
• C allows “goto” as means of transferring control– closer to machine-level
programming style• Generally considered bad
coding style
absdiff:movl %esi, %eaxcmpl %esi, %edijle .L6subl %eax, %edimovl %edi, %eaxjmp .L7
.L6:subl %edi, %eax
.L7:ret
Body1
Body2b
Body2a
CS33 Intro to Computer Systems XI–33 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
C Codeval = Test ? Then_Expr : Else_Expr;
Goto Versionnt = !Test;if (nt) goto Else;val = Then_Expr;goto Done;
Else:val = Else_Expr;
Done:. . .
General Conditional-ExpressionTranslation
– Test is expression returning integer== 0 interpreted as false≠ 0 interpreted as true
– Create separate code regions for then & else expressions
– Execute appropriate one
val = x>y ? x-y : y-x;
CS33 Intro to Computer Systems XI–34 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
C Codeint pcount_do(unsigned x) {
int result = 0;do {
result += x & 0x1;x >>= 1;
} while (x);return result;
}
Goto Versionint pcount_do(unsigned x){
int result = 0;loop:
result += x & 0x1;x >>= 1;if (x)
goto loop;return result;
}
“Do-While” Loop Example
• Count number of 1’s in argument x (“popcount”)• Use conditional branch either to continue looping or
to exit loop
CS33 Intro to Computer Systems XI–35 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Goto Version“Do-While” Loop Compilation
Registers:%edi x%eax result
movl $0, %eax # result = 0.L2: # loop:
movl %edi, %ecxandl $1, %ecx # t = x & 1addl %ecx, %eax # result += tshrl %edi # x >>= 1jne .L2 # if !0, goto loop
int pcount_do(unsigned x) {int result = 0;
loop:result += x & 0x1;x >>= 1;if (x)
goto loop;return result;
}
CS33 Intro to Computer Systems XI–36 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
C Codedo Bodywhile (Test);
Goto Versionloop:Bodyif (Test)goto loop
General “Do-While” Translation
• Body:
• Test returns integer= 0 interpreted as false≠ 0 interpreted as true
{Statement1;Statement2;
…Statementn;
}
CS33 Intro to Computer Systems XI–37 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
C Code Goto Version
“While” Loop Example
• Is this code equivalent to the do-while version?– must jump out of loop if test fails
int pcount_while(unsigned x) {int result = 0;while (x) {
result += x & 0x1;x >>= 1;
}return result;
}
int pcount_do(unsigned x) {int result = 0;if (!x) goto done;
loop:result += x & 0x1;x >>= 1;if (x)
goto loop;done:
return result;}
CS33 Intro to Computer Systems XI–38 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
While versionwhile (Test)
Body
Do-While Versionif (!Test) goto done;
doBodywhile(Test);
done:
General “While” Translation
Goto Versionif (!Test)goto done;
loop:Bodyif (Test)goto loop;
done:
CS33 Intro to Computer Systems XI–39 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
C Code
“For” Loop Example
• Is this code equivalent to other versions?
#define WSIZE 8*sizeof(int)int pcount_for(unsigned x) {
int i;int result = 0;for (i = 0; i < WSIZE; i++) {
unsigned mask = 1 << i;result += (x & mask) != 0;
}return result;
}
CS33 Intro to Computer Systems XI–40 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
“For” Loop Form
for (Init; Test; Update )
Body
General Form
for (i = 0; i < WSIZE; i++) {unsigned mask = 1 << i;result += (x & mask) != 0;
}
i = 0
i < WSIZE
i++
{unsigned mask = 1 << i;result += (x & mask) != 0;
}
Init
Test
Update
Body
CS33 Intro to Computer Systems XI–41 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
“For” Loop à While Loop
for (Init; Test; Update )
Body
For Version
Init;
while (Test ) {
Body
Update;}
While Version
CS33 Intro to Computer Systems XI–42 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
“For” Loop à … à Goto
for (Init; Test; Update )
Body
For Version
Init;
while (Test ) {
Body
Update;
}
While Version
Init;if (!Test)
goto done;loop:
BodyUpdateif (Test)
goto loop;done:
Init;if (!Test)
goto done;do
BodyUpdate
while(Test);done:
CS33 Intro to Computer Systems XI–43 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
C Code
“For” Loop Conversion Example
Initial test can be optimized away
#define WSIZE 8*sizeof(int)int pcount_for(unsigned x) {
int i;int result = 0;for (i = 0; i < WSIZE; i++) {
unsigned mask = 1 << i;result += (x & mask) != 0;
}return result;
}
Goto Versionint pcount_for_gt(unsigned x) {
int i;int result = 0;i = 0;if (!(i < WSIZE))
goto done;loop:{
unsigned mask = 1 << i;result += (x & mask) != 0;
}i++;if (i < WSIZE)
goto loop;done:return result;
}
Init
!Test
Body
UpdateTest
CS33 Intro to Computer Systems XI–44 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Switch-StatementExample
• Multiple case labels– here: 5 & 6
• Fall-through cases– here: 2
• Missing cases– here: 4
long switch_eg(long x, long y, long z) {long w = 1;switch(x) {case 1:
w = y*z;break;
case 2:w = y/z;/* Fall Through */
case 3:w += z;break;
case 5:case 6:
w -= z;break;
default:w = 2;
}return w;
}
CS33 Intro to Computer Systems XI–45 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Jump-Table Structure
Code Block 0Targ0:
Code Block 1Targ1:
Code Block 2Targ2:
Code Block n–1Targn-1:
•••
Targ0
Targ1
Targ2
Targn-1
•••
jtab:
target = JTab[x];goto *target;
switch(x) {case val_0:
Block 0case val_1:
Block 1• • •
case val_n-1:Block n–1
}
Switch Form
Approximate Translation
Jump TableJump Targets
CS33 Intro to Computer Systems XI–46 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Switch-Statement Example (x86-64)
Setup:
long switch_eg(long x, long y, long z){
long w = 1;switch(x) {
. . .}return w;
}
switch_eg:... # Setupmovq %rdx, %rcx # %rcx = zcmpq $6, %rdi # Compare x:6ja .L8 # If unsigned > goto defaultjmp *.L7(,%rdi,8) # Goto *JTab[x]
What range of values is covered by the default case?
Note that w not initialized here
CS33 Intro to Computer Systems XI–47 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Switch-Statement Examplelong switch_eg(long x, long y, long z){
long w = 1;switch(x) {
. . .}return w;
}
Indirect jump
Jump table
Setup:switch_eg:
... # Setupmovq %rdx, %rcx # %rcx = zcmpq $6, %rdi # Compare x:6ja .L8 # If unsigned > goto defaultjmp *.L7(,%rdi,8) # Goto *JTab[x]
.section .rodata.align 4
.L7:.quad .L8 # x = 0.quad .L3 # x = 1.quad .L4 # x = 2.quad .L9 # x = 3.quad .L8 # x = 4.quad .L6 # x = 5.quad .L6 # x = 6
CS33 Intro to Computer Systems XI–48 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Assembly-Setup Explanation
• Table structure– each target requires 8 bytes– base address at .L7
• Jumpingdirect: jmp .L8– jump target is denoted by label .L8
indirect: jmp *.L7(,%rdi,8)– start of jump table: .L7– must scale by factor of 8 (labels have 8 bytes on x86-64)– fetch target from effective address .L7 + rdi*8
» only for 0 ≤ x ≤ 6
Jump table.section .rodata.align 4
.L7:.quad .L8 # x = 0.quad .L3 # x = 1.quad .L4 # x = 2.quad .L9 # x = 3.quad .L8 # x = 4.quad .L6 # x = 5.quad .L6 # x = 6
CS33 Intro to Computer Systems XI–49 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
.section .rodata.align 4
.L7:.quad .L8 # x = 0.quad .L3 # x = 1.quad .L4 # x = 2.quad .L9 # x = 3.quad .L8 # x = 4.quad .L6 # x = 5.quad .L6 # x = 6
Jump TableJump table
switch(x) {case 1: // .L3
w = y*z;break;
case 2: // .L4w = y/z;/* Fall Through */
case 3: // .L9w += z;break;
case 5:case 6: // .L6
w -= z;break;
default: // .L8w = 2;
}
CS33 Intro to Computer Systems XI–50 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Code Blocks (Partial).L3: # x == 1
movl %rsi, %rax # yimulq %rdx, %rax # w = y*zret
.L6: # x == 5, x == 6movl $1, %eax # w = 1subq %rdx, %rax # w -= zret
.L8: # Defaultmovl $2, %eax # w = 2ret
switch(x) {case 1: // .L3
w = y*z;break;
. . .case 5: // .L6case 6: // .L6
w -= z;break;
default: // .L8w = 2;
}
CS33 Intro to Computer Systems XI–51 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Handling Fall-Through
long w = 1;. . .
switch(x) {. . .
case 2:w = y/z;/* Fall Through */
case 3:w += z;break;
. . .}
case 2:w = y/z;goto merge;
case 3:w = 1;
merge:w += z;
CS33 Intro to Computer Systems XI–52 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Code Blocks (Rest).L4: # x == 2
movq %rsi, %raxmovq %rsi, %rdxsarq $63, %rdxidivq %rcx # w = y+zjmp .L5
.L9: # x == 3movl $1, %eax # w = 1
.L5: # merge:addq %rcx, %rax # w += zret
switch(x) {. . .case 2: // .L4
w = y/z;/* Fall Through */
case 3: // .L9w += z;break;
. . .}
CS33 Intro to Computer Systems XI–53 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
idivq
rdx rax06364127
idivq rcx063
divisor
rdx rax063063
dividend
quotientremainder
CS33 Intro to Computer Systems XI–54 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
x86-64 Object Code
• Setup– label .L8 becomes address 0x4004e5– label .L7 becomes address 0x4005c0
00000000004004ac <switch_eg>:. . .4004b3: 77 30 ja 4004e5 <switch_eg+0x39>4004b5: ff 24 fd c0 05 40 00 jmpq *0x4005c0(,%rdi,8)
switch_eg:. . .ja .L8 # If unsigned > goto defaultjmp *.L7(,%rdi,8) # Goto *JTab[x]
Assembly code
Disassembled object code
CS33 Intro to Computer Systems XI–55 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
x86-64 Object Code (cont.)• Jump table
– doesn’t show up in disassembled code– can inspect using gdbgdb switch(gdb) x/7xg 0x4005c0
» examine 7 hexadecimal format “giant” words (8-bytes each)» use command “help x” to get format documentation
0x4005c0: 0x00000000004004e5 0x00000000004004bc0x4005d0: 0x00000000004004c4 0x00000000004004d30x4005e0: 0x00000000004004e5 0x00000000004004dc0x4005f0: 0x00000000004004dc
CS33 Intro to Computer Systems XI–56 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
x86-64 Object Code (cont.)• Deciphering jump table
0x4005c0: 0x00000000004004e5 0x00000000004004bc0x4005d0: 0x00000000004004c4 0x00000000004004d30x4005e0: 0x00000000004004e5 0x00000000004004dc0x4005f0: 0x00000000004004dc
Address Value x0x4005c0 0x4004e5 00x4005c8 0x4004bc 10x4005d0 0x4004c4 20x4005d8 0x4004d3 30x4005e0 0x4004e5 40x4005e8 0x4004dc 50x4005f0 0x4004dc 6
CS33 Intro to Computer Systems XI–57 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Disassembled Targets(gdb) disassemble 0x4004bc,0x4004ebDump of assembler code from 0x4004bc to 0x4004eb
0x00000000004004bc <switch_eg+16>: mov %rsi,%rax0x00000000004004bf <switch_eg+19>: imul %rdx,%rax0x00000000004004c3 <switch_eg+23>: retq0x00000000004004c4 <switch_eg+24>: mov %rsi,%rax0x00000000004004c7 <switch_eg+27>: mov %rsi,%rdx0x00000000004004ca <switch_eg+30>: sar $0x3f,%rdx0x00000000004004ce <switch_eg+34>: idiv %rcx0x00000000004004d1 <switch_eg+37>: jmp 0x4004d8 <switch_eg+44>0x00000000004004d3 <switch_eg+39>: mov $0x1,%eax0x00000000004004d8 <switch_eg+44>: add %rcx,%rax0x00000000004004db <switch_eg+47>: retq0x00000000004004dc <switch_eg+48>: mov $0x1,%eax0x00000000004004e1 <switch_eg+53>: sub %rdx,%rax0x00000000004004e4 <switch_eg+56>: retq0x00000000004004e5 <switch_eg+57>: mov $0x2,%eax0x00000000004004ea <switch_eg+62>: retq
CS33 Intro to Computer Systems XI–58 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Matching Disassembled Targets0x00000000004004bc: mov %rsi,%rax0x00000000004004bf: imul %rdx,%rax0x00000000004004c3: retq0x00000000004004c4: mov %rsi,%rax0x00000000004004c7: mov %rsi,%rdx0x00000000004004ca: sar $0x3f,%rdx0x00000000004004ce: idiv %rcx0x00000000004004d1: jmp 0x4004d8 0x00000000004004d3: mov $0x1,%eax0x00000000004004d8: add %rcx,%rax0x00000000004004db: retq0x00000000004004dc: mov $0x1,%eax0x00000000004004e1: sub %rdx,%rax0x00000000004004e4: retq0x00000000004004e5: mov $0x2,%eax0x00000000004004ea: retq
Value x0x4004e5 00x4004bc 10x4004c4 20x4004d3 30x4004e5 40x4004dc 50x4004dc 6
CS33 Intro to Computer Systems XI–59 Copyright © 2019 Thomas W. Doeppner. All rights reserved.
Quiz 3What C code would you compile to get the following assembler code?
movq $0, %rax.L2:
movq %rax, a(,%rax,8)addq $1, %raxcmpq $10, %raxjne .L2ret
long a[10];void func() {
long i;for (i=0; i<10; i++)
a[i]= 1;}
a
long a[10];void func() {
long i=0;while (i<10)
a[i]= i++;}
b
long a[10];void func() {
long i=0;switch (i) {
case 0:a[i] = 0;break;
default:a[i] = 10
}}
c