Machine level representation of programs
This presentation is the property of its rightful owner.
Sponsored Links
1 / 70

Machine-Level Representation of Programs Ⅱ PowerPoint PPT Presentation


  • 97 Views
  • Uploaded on
  • Presentation posted in: General

Machine-Level Representation of Programs Ⅱ. Outline. Data movement Data manipulation Control structure Suggested reading Chap 3.4, 3.5, 3.6. Indexed Addressing Mode Figure 3.3 P137. Most general form Imm ( E b , E i , s) M[Imm+ R[E b ]+ R[E i ]*s]

Download Presentation

Machine-Level Representation of Programs Ⅱ

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Machine level representation of programs

Machine-Level Representation of Programs Ⅱ


Outline

Outline

  • Data movement

  • Data manipulation

  • Control structure

  • Suggested reading

    • Chap 3.4, 3.5, 3.6


Indexed addressing mode figure 3 3 p137

Indexed Addressing Mode Figure 3.3 P137

  • Most general form

    • Imm(Eb, Ei, s)

    • M[Imm+ R[Eb]+ R[Ei]*s]

    • Constant “displacement” Imm: 1, 2, or 4 bytes

    • Base register Eb: Any of 8 integer registers

    • Index register Ei : Any, except for %esp

    • S: Scale: 1, 2, 4, or 8


Data movement figure 3 4 p139

Data Movement Figure 3.4 P139


Move instructions

Move Instructions

  • Format

    • movl src, dest

    • src and dest can only be one of the following

      • Immediate (except dest)

      • Register

      • Memory


Move instructions1

Move Instructions

  • Format

    • The only possible combinations of the (src, dest) are

      • (immediate, register)

      • (memory, register)load

      • (register, register)

      • (immediate, memory)store

      • (register, memory)store


Data movement example p139

Data Movement Example P139

movl $0x4050, %eax immediateregister

movl %ebp, %esp registerregister

movl (%edx, %ecx), %eaxmemoryregister

movl $-17, (%esp)immediatememory

movl %eax, -12(%ebp)registermemory


Data movement example p1391

Data Movement Example P139

Initial value %dh=8d %eax =98765432

  • movb %dh, %al%eax=9876548d

  • movsbl %dh, %eax%eax=ffffff8d (Move sign-extended byte)

  • movzbl %dh, %eax%eax=0000008d

    ( Move zero-extended byte)


Stack operations figure 3 5 p140

Stack operations Figure 3.5P140

Increasing

address

%esp

0x108

Stack “top”


Stack operations

Stack operations

pushl %eax

0x108

%esp

0x104

Stack “top”


Stack operations1

Stack operations

popl %edx

%esp

0x108

0x104

Stack “top”


Data movement example p141

Data Movement Example P141

int exchange(int *xp, int y)

{

int x = *xp ;/* operator * performs dereferencing */

*xp = y ;

return x ;

}

int a = 4 ;

int b = exchange(&a, 3);/* “address of” operator creates a pointer */

printf(“a = %d, b = %d\n”, a, b);


Data movement example p142

Data Movement Example P142

1 pushl %ebp

2 movl %esp, %ebp

3 movl 8(%ebp), %eax

4 movl 12(%ebp), %edx

5 movl (%eax), %ecx

6 movl %edx, (%eax)

7 movl %ecx, %eax

8 movl %ebp, %esp

9 popl %ebp

int exchange(int *xp, int y)

{

int x = *xp ;

*xp = y ;

return x ;

}

Assembly code


Data movement example

Stack

Offset

y

xp

Rtn adr

%esp

Data Movement Example


Data movement example1

Stack

Offset

Stack

12

y

Offset

8

xp

4

Rtn adr

%esp

0

Old %ebp

y

xp

Rtn adr

%esp

Data Movement Example

1 pushl %ebp


Data movement example2

Stack

Stack

Offset

Offset

12

y

12

y

8

xp

8

xp

4

Rtn adr

4

Rtn adr

%ebp

%esp

0

Old %ebp

0

Old %ebp

%esp

Data Movement Example

2 movl %esp, %ebp


Data movement example3

Stack

Offset

12

y

8

xp

4

Rtn adr

%ebp

%esp

0

Old %ebp

Data Movement Example

3 movl 8(%ebp), %eax

4 movl 12(%ebp), %edx

5 movl (%eax), %ecx

6 movl %edx, (%eax)

7 movl %ecx, %eax


Data movement example4

Stack

Offset

y

xp

Rtn adr

%esp

Data Movement Example

8 movl %ebp, %esp

9 popl %ebp


Arithmetic and logical operations figure 3 7 p144

3.5 P143

Arithmetic and Logical Operations Figure 3.7 P144


Examples for lea instruction practice problem 3 3 p143

Examples for Lea Instruction (Practice Problem 3.3 P143)

  • %eax holds x, %ecx holds y

Expression

Result

leal 6(%eax), %edx

6+x

leal (%eax, %ecx), %edx

x+y

leal (%eax, %ecx, 4), %edx

x+4*y

leal 7(%eax, %eax, 8), %edx

7+9*x

leal 0xA(, %ecx, 4), %edx

10+4*y

leal 9(%eax, %ecx, 2), %edx

9+x+2*y


Arithmetic and logical operations cont d figure 3 7 p144

Arithmetic and Logical Operations (Cont’d) Figure 3.7 P144


Arithmetic and logical operations practice problem 3 4 p145

Arithmetic and Logical Operations (Practice Problem 3.4 P145)

Instruction

Destination

Value

addl %ecx, (%eax)

0x100

0x100 (1+0xFF)

subl %edx, 4(%eax)

0x104

0xA8 (0xAB-0x3)

imull $16, (%eax, %edx, 4)

0x10C

0x110 ($16*0x11)

incl 8(%eax)

0x108

0x14 (0x13+1)

decl %ecx

%ecx

0x0 (0x1-1)

subl %edx, %eax

%eax

0xFD (0x100-0x3)


Assembly code for arithmetic expressions figure 3 8 p146

Assembly Code for Arithmetic ExpressionsFigure 3.8 P146

int arith(int x, int y, int z)

{

int t1 = x+y;

int t2 = z*48;

int t3 = t1&0xFFFF;

int t4 = t2*t3;

return t4;

}

movl 12(%ebp),%eaxGet y

movl 16(%ebp),%edx Get z

addl 8(%ebp),%eaxCompute t1=x+y

leal (%edx,%edx,2),%edx Compute 3*z

sall $4,%edxCompute t2=48*z=3*16*z

andl $0xFFFF,%eaxCompute t3=t1&FFFF

imull %eax,%edx Compute t4=t2*t3

movl %edx,%eaxSet t4 as return val


Special arithmetic operations figure 3 9 p147

Special Arithmetic OperationsFigure 3.9 P147


Examples p148

Examples P148

Initially x at %ebp+8, y at %ebp+12, their full 64-bit product as 8 bytes on top of the stack

1 movl 8(%ebp), %eax

2 imull 12(%ebp)

3 pushl %edx

4 pushl %eax

Store x/y and x%y on the stack.

1 movl 8(%ebp), %eax

2 cltd

3 idivl 12(%ebp)

4 pushl %eax

5 pushl %edx


Control

3.6 P148

Control

  • Two of the most important parts of program execution

    • Data flow (Accessing and operating data)

    • Control flow (control the sequence of operations)


Control1

Control

  • Sequential execution is default

    • The statements in C and

    • the instructions in assembly code

    • are executed in the order they appear in the program

  • Chang the control flow

    • Control constructs in C

    • Jump in assembly


Assembly programmer s view

FF

C0

%eax

%ah

%al

Addresses

BF

Stack

%edx

%dh

%dl

%ecx

%ch

%cl

Data

%ebx

%bh

%bl

80

Heap

7F

%esi

%edi

Instructions

%esp

40

DLLs

%ebp

3F

Heap

%eip

Data

%eflag

08

Text

00

Assembly Programmer’s View


Condition codes

Condition codes

  • Condition codes

    • A set of single-bit

    • Maintained in a condition code register

    • Describe attributes of the most recently arithmetic or logical operation


Condition codes1

Condition codes

  • EFLAGS

    • CF: Carry Flag

      • The most recent operation generated a carry out of the most significant bit

      • Used to detect overflow for unsigned operations

    • OF: Overflow Flag

      • The most recent operation caused a two’s complement overflow — either negative or positive


Condition codes2

Condition codes

  • EFLAGS

    • ZF: Zero Flag

      • The most recent operation yielded zero

    • SF: Sign Flag

      • The most recent operation yielded a negative value


Setting conditional codes

Setting Conditional Codes

  • Implicit SettingBy Arithmetic Operations

    addl Src,Dest

    C analog: t = a+b

    • CF set if carry out from most significant bit

      • Used to detect unsigned overflow

    • ZF set if t == 0

    • SF set if t < 0

    • OF set if two’s complement overflow

      (a>0 && b>0 && t<0) || (a<0 && b<0 && t>=0)


Conditional code

Conditional Code

  • lea instruction

    • has no effect on condition codes

  • Xorl instruction

    • The carry and overflow flags are set to 0

  • Shift instruction

    • carry flag is set to the last bit shifted out

    • Overflow flag is set to 0


Setting conditional codes1

Setting Conditional Codes

  • Explicit Setting by Compare Instruction

    cmpl Src2,Src1

    • cmpl b,a like computing a-bwithout setting destination

    • CF set if carry out from most significant bit

      • Used for unsigned comparisons

    • ZF set if a == b

    • SF set if (a-b) < 0

    • OF set if two’s complement overflow

      (a>0 && b<0 && (a-b)<0) ||

      (a<0 && b>0 && (a-b)>0)


Setting conditional codes2

Setting Conditional Codes

  • Explicit Setting by Test instruction

    testl Src2,Src1

    • Sets condition codes based on value of Src1&Src2

      • Useful to have one of the operands be a mask

    • testl b,a like computing a&b without setting destination

    • ZF set when a&b == 0

    • SF set when a&b < 0


Accessing conditional codes

Accessing Conditional Codes

  • The condition codes cannot be read directly

  • One of the most common methods of accessing them is

    • setting an integer register based on some combination of condition codes

    • Set commands


Accessing conditional codes1

Accessing Conditional Codes

  • after each set command is executed

    • A single byte to 0 or to 1 is obtained

  • The descriptions of the different set commands apply to the case

    • where a comparison instruction has been executed


Accessing conditional codes figure 3 10 p150

Accessing Conditional CodesFigure 3.10 P150


Accessing conditional codes2

Accessing Conditional Codes

  • The destination operand is either

    • one of the eight single-byte register elements or

    • a memory location where the single byte is to be stored

  • To generate a 32-bit result

    • we must also clear the high-order 24 bits


Accessing conditional codes p151

Accessing Conditional Codes P151

Initially a is in %edx, b is in %eax

1 cmpl %eax, %edx

#compare a:b

2 setl %al

#set low order by to 0 or 1

3 movzbl %al, %eax

#set remaining bytes of %eax to 0


Jump instructions p152

Jump Instructions P152

  • Under normal execution

    • instructions follow each other in the order they are listed

  • A jump instruction can cause

    • the execution to switch to a completely new position in the program.

  • Label

    • Jump destinations


Jump instructions p1521

Jump Instructions P152

1 xorl %eax, %eax Set %eax to 0

2 jmp .L1Goto .L1

3 movl (%eax), %edx Null pointer dereference

4 .L1:

5 popl %edx


Unconditional jump p153

Unconditional jump P153

  • Jumps unconditionally

  • Direct jump: jmp label

    • jmp .L

  • Indirect jump: jmp *Operand

    • jmp *%eax

    • jmp *(%eax)


Conditional jump

Conditional jump

  • Either jump or continue executing at the next instruction in the code sequence

    • Depending on some combination of the condition codes

  • All direct jump


Jump instructions p154

Jump Instructions P154

1 jle .L4

2 .p2align 4,,7align next instruction to multiple of 8

3 .L5:

  • movl %edx, %eax

  • sarl $1, %eax ;Arithmetic right shift

  • subl %eax, %edx

  • testl %edx, %edx

  • jg .L5

    9 .L4:

    10movl %edx, %eax


Jump instructions

Jump Instructions

  • PC-relative

    • Jump target is an offset relative to the address of the instruction just followed jump (pointed by PC)

  • Absolute address

    • Jump target is an absolute address


Example for jump p154

Example for Jump P154

1 8: 7e 11jle1b<silly+0x1b>

2 a: 8d b6 00 00 00 00lea0x0(%esi), %esi

3 10: 89 d0movl %edx, %eax dest1:

412: c1 f8 01sarl $1, %eax

515: 29 c2subl %eax, %edx

617: 85 d2testl %edx, %edx

  • 19: 7f f5jg 10<silly+0x10>

  • 1b: 89 d0movl %edx, %eax dest2:

    dest1: 11+a = 1b 11+10

    dest2: 1b+f5(-b) =10 F5=-11=0X(-b)


Example for jump p155

Example for Jump P155

1 80483c8: 7e 11jle80483db<silly+0x1b>

2 80483ca: 8d b6 00 00 00 00lea0x0(%esi), %esi

3 80483d0: 89 d0movl %edx, %eax dest1:

480483d2: c1 f8 01sarl $1, %eax

580483d5: 29 c2subl %eax, %edx

680483d7: 85 d2testl %edx, %edx

  • 80483d9: 7f f5jg 80483d0<silly+0x10>

  • 80483db: 89 d0movl %edx, %eax dest2:

    11+a = 1b => 11+ca=db

    1b+f5(-b) =10 => db+f5(-b)=d0


Translating conditional branches p157

Translating Conditional Branches P157

t = test-expr ;

if ( t )

goto true ;

else-statement

goto done

true:

then-statement

done:

if ( test-expr )

then-statement

else

else-statement


Translating conditional branches p156

  • int absdiff(int x, int y)

  • {

  • if (x < y)

  • return y – x;

  • else

  • return x – y;

  • }

  • int gotodiff(int x, int y)

  • {

  • int rval ;

  • if (x < y)

  • goto less

  • rval = x – y ;

  • goto done;

  • less:

  • rval = y – x;

  • done:

  • return rval;

  • }

Translating Conditional Branches P156


Jump instructions p156

Jump Instructions P156

  • movl 8(%ebp), %edx get x

  • movl 12(%ebp), %eax get y

  • cmpl %eax, %edx cal x - y

  • jl .L3 if x < y goto less

  • subl %eax, %edx compute x – y (subl: des-src)

  • movl %edx, %eax set return val

  • jmp .L5 goto done

  • .L3:less:

  • subl %edx, %eax compute y – x (subl: des-src)

  • .L5:done: Begin Completion code


Do while translation p158

Do-while Translation P158

do

body-statement

while (test-expr)

loop:

body-statement

t = test-expr;

if ( t )

goto loop ;


Do while translation p159

Do-while Translation P159

int fib_dw(int n)

{

int i = 0;

int val = 0 ;

int nval = 1 ;

do {

int t = val + nval ;

val = nval ;

nval = t ;

i++;

} while ( i<n) ;

return val ;

}


Do while translation p1591

Do-while Translation P159

.L6:

lea (%ebx, %edx), %eax

movl %edx, %ebx

movl %eax, %edx

incl %ecx

cmpl %esi, %ecx

jl .L6

movl %ebx, %eax

lea: %ebx+%edx => %eax


While loop translation p161

While Loop Translation P161

while (test-expr)

body-statement

loop:if ( !test-expr)

t = test-expr goto done;

if ( !t )do

goto done; body-statement

body-statementwhile(test-expr)

goto loop; done:

done:


While loop translation p162

While Loop Translation P162

int fib_w(int n)

{

int i=1;

int val=1;

int nval=1;

while ( i<n ) {

int t=val+nval ;

val = nval ;

nval = t ;

i = i+1;

}

return val ;

}

int fib_w_got0(int n)

{

int val=1;

int nval=1;

int nmi, t ;

if ( val >= n )

goto done ;

nmi = n-1;

loop:

t=val+nval ;

val = nval ;

nval = t ;

nmi--;

if ( nmi )

goto loop

done:

return val

}


While loop translation p1621

Register usage

Register

Variable

Initially

%edx

nmi

n-1

%ebx

val

1

%ecx

nval

1

While Loop Translation P162

  • movl 8(%ebp), %eax

  • movl $1, %ebx

  • movl $1, %ecx

  • cmpl %eax, ebx

  • jge .L9

  • lea –1(%eax), %edx

  • .L10:

  • lea (%ecx, %ebx), %eax

  • movl %ecx, %ebx

  • movl %eax, %ecx

  • decl %edx

  • jnz .L10

  • .L9:


For loop translation p164

For Loop Translation P164

for ( init-expr, test-expr, update-expr)

body-statement

init-expr

while ( test-expr) {

body-statement

update-expr

}


For loop translation p165

For Loop Translation P165

int fib_f(int n)

{

int i;

int val=1;

int nval=1;

for ( i=1; i<n; i++ ) {

int t = val + nval ;

val = nval ; nval = t ;

}

return val ;

}


Switch statements p167

Switch statements P167

int switch_eg(int x)

{

int result = x ;

switch ( x ) {

case 100:

result *= 13 ;

break ;

case 102:

result += 10 ;

/* fall through */

case 103

result += 11;

break ;

case 104:

case 106:

result *= result ;

break ;

default:

result = 0 ;

}

return result ;

}


Switch construct

Switch Construct

  • Properties of Switch Construct

    • Integer testing

    • Multiple outcomes (may be a large number)

    • Improve the readability of the source code


Switch statements

Switch Statements

int switch_eg(int x)

{

int result = x ;

switch ( x ) {

case 100:

result *= 13 ;

break ;

case 102:

result += 10 ;

/* fall through */

case 103

result += 11;

break ;

case 104: case 106:

result *= result ;

break ;

default:

result = 0 ;

}

return result ;

}

Multiple cases

Integer testing


Switch form

Switch Form

switch(op) {

case val_0:

Block 0

case val_1:

Block 1

• • •

case val_n-1:

Blockn–1

}


Jump table

Jump Table

  • Efficient implementation

  • Avoid long sequence of if-else statement

  • Criteria

    • the number of cases and the sparsity of the case value


Jump table implementation

Targ0:

Code Block

0

jtab:

Targ0

Targ1

Targ2

Targ1:

Code Block

1

Targn-1

Targ2:

Code Block

2

Targn-1:

Code Block

n–1

Jump Table Implementation

Jump Table

Jump Targets

Approx. Translation

target = JTab[op];

goto *target;


Switch statements1

Switch Statements

int switch_eg(int x)

{

int result = x ;

switch ( x ) {

case 100:

result *= 13 ;

break ;

case 102:

result += 10 ;

/* fall through */

case 103

result += 11;

break ;

case 104: case 106:

result *= result ;

break ;

default:

result = 0 ;

}

return result ;

}

Multiple cases

Integer testing


Jump table implementation p167

Jump Table Implementation P167

code jt[7] = {loc_a, loc_def, loc_b, loc_c, loc_d, loc_def, loc_d};

int switch_eg_goto ( int x)

{

unsigned xi = x-100;

int result = x ;

if ( xi >6 )

goto loc_def ;

goto jt[xi];

loc_a:

result *= 13 ;

goto done ;

loc_b:

result += 10 ;

loc_c:

result +=11;

goto done ;

loc_d:

result *= result ;

goto done ;

loc_def:

result = 0 ;

done:

return result ;

}


Jump table implementation p168

Jump Table Implementation P168

  • lea –100(%edx), %eax

  • cmpl $6, %eax

  • ja. L9

  • jmp *.L10(, %eax, 4)

  • .L4:

  • leal ( %edx, %edx, 2), %eax

  • leal (%edx, %eax, 4), %edx

  • jmp .L3

  • .L5:

  • addl $10, %edx


Jump table implementation1

Jump Table Implementation

  • .L6:

  • addl $11, %edx

  • jmp .L3

  • .L8:

  • imull %edx, %edx

  • jmp .L3

  • .L9:

  • xorl %edx, %edx

  • .L3:

  • movl %edx, %eax


Jump table p169

Jump Table P169

  • .section .rodata

  • .align 4

  • .L10:

  • .long .L4case 100: loc_a

  • .long .L9case 101: loc_def

  • .long .L5case 102: loc_b

  • .long .L6case 103: loc_c

  • .long .L8case 104: loc_d

  • .long .L9case 105: loc_def

  • .long .L8case 106: loc_d


  • Login