Docstoc

Introduction to Computer Systems

Document Sample
Introduction to Computer Systems Powered By Docstoc
					Machine-Level Representation of
         Programs Ⅱ




                                  1
Outline


• Data movement
• Data manipulation
• Control structure
• Suggested reading
  – Chap 3.4, 3.5, 3.6




                         2
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


                                                    3
Data Movement           Figure 3.4 P139

Instruction    Effect                 Description
movl    S, D   D¬S                    Move double word

movw    S, D   D¬S                    Move word

movb    S, D   D¬S                    Move byte

movsbl S, D    D ¬ SignedExtend( S)   Move sign-extended byte

movzbl S, D    D ¬ ZeroExtend(S)      Move zero-extended byte

pushl   S      R[%esp] ¬ R[%esp]-4    Push
               M[R[%esp]] ¬ S
popl    D      D ¬ M[R[%esp]]         Pop
               R[%esp] ¬ R[%esp]+4
                                                          4
Move Instructions


• Format
  – movl src, dest
  – src and dest can only be one of the following
     • Immediate (except dest)
     • Register
     • Memory



                                                    5
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


                                                   6
Data Movement Example P139

movl   $0x4050, %eax        immediate   register
movl   %ebp, %esp           register    register
movl   (%edx, %ecx), %eax   memory      register
movl   $-17, (%esp)         immediate   memory
movl   %eax, -12(%ebp)      register    memory




                                              7
Data Movement Example   P139


Initial value %dh=8d    %eax =98765432

1 movb     %dh, %al      %eax=9876548d
2 movsbl %dh, %eax       %eax=ffffff8d
  (Move sign-extended byte)
3 movzbl %dh, %eax       %eax=0000008d
   ( Move zero-extended byte)



                                         8
Stack operations   Figure 3.5 P140


%eax   0x123
%edx   0
%esp   0x108                Increasing
                             address




                     %esp         0x108
                                          Stack “top”


                                                    9
Stack operations

%eax   0x123
%edx   0
%esp   0x104

pushl %eax

                         0x108
                   %es   0x104   0x123
                   p             Stack “top”


                                          10
Stack operations

%eax   0x123
%edx   0x123
%esp   0x104

popl %edx

                   %es   0x108
                   p     0x104    0x123

                                 Stack “top”

                                               11
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);
                                                                     12
Data Movement Example           P142
                               1 pushl %ebp
int exchange(int *xp, int y)
                               2 movl %esp, %ebp
{
    int x = *xp ;              3 movl 8(%ebp), %eax
                               4 movl 12(%ebp), %edx
    *xp = y ;                  5 movl (%eax), %ecx
    return x ;                 6 movl %edx,     (%eax)
}
                               7 movl %ecx, %eax
                               8 movl %ebp, %esp
                               9 popl %ebp
                                                     13
                                Assembly code
Data Movement Example


                        •
                        •      Stack
            Offset      •



                       y

                       xp

                     Rtn adr    %esp




                                       14
Data Movement Example

1 pushl     %ebp


               •                          •
               •      Stack               •      Stack
   Offset      •              Offset      •



              y                  12      y

              xp                  8      xp

            Rtn adr    %esp       4    Rtn adr
                                  0 Old %ebp      %esp
                                                    15
Data Movement Example

2 movl        %esp, %ebp


                 •                            •
                 •      Stack                 •      Stack
    Offset       •                Offset      •



         12     y                    12      y
         8      xp                    8      xp
         4    Rtn adr                 4    Rtn adr
                                                      %ebp
         0 Old %ebp        %esp       0 Old %ebp
                                                      %esp
                                                        16
Data Movement Example

3 movl   8(%ebp), %eax
4 movl   12(%ebp), %edx                 •
5 movl   (%eax), %ecx                   •      Stack
                            Offset      •
6 movl   %edx,     (%eax)
7 movl   %ecx,     %eax
                               12      y
                                8      xp
                                4    Rtn adr
                                                %ebp
                                0 Old %ebp
                                                %esp


                                                  17
Data Movement Example

8 movl   %ebp, %esp
                                    •
9 popl   %ebp                       •      Stack
                        Offset      •



                                   y

                                   xp

                                 Rtn adr    %esp




                                               18
3.5 P143
Arithmetic and Logical Operations   Figure 3.7 P144


Instruction   Effect     Description
leal   S, D   D ¬ &S     Load effective address
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
                                              19
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
                                            20
Arithmetic and Logical Operations (Cont’d)
Figure 3.7 P144


Instruction       Effect       Description
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
sarl    k, D      D ¬ D >> k   Arithmetic right shift
shrl    k, D      D ¬ D >> k   Logical right shift

                                                  21
Arithmetic and Logical Operations (Practice
Problem 3.4 P145)

Address     Value              Register    Value
 0x100      0xFF                 %eax      0x100
 0x104      0xAB                 %ecx        0x1
 0x108      0x13                 %edx        0x3
 0x10C      0x11

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)   22
Assembly Code for Arithmetic Expressions
Figure 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),%eax        Get y
 movl 16(%ebp),%edx        Get z
 addl 8(%ebp),%eax         Compute t1=x+y
 leal (%edx,%edx,2),%edx   Compute 3*z
 sall $4,%edx              Compute t2=48*z=3*16*z
 andl $0xFFFF,%eax         Compute t3=t1&FFFF
 imull %eax,%edx           Compute t4=t2*t3
 movl %edx,%eax            Set t4 as return val     23
Special Arithmetic Operations
Figure 3.9 P147

imull S R[%edx]:R[%eax] ¬S*R[%eax]             Signed full multiply
mull      R[%edx]:R[%eax] ¬S*R[%eax]           Unsigned full multiply
S
Cltd      R[%edx]:R[%eax] ¬                    Convert to quad word
          SignExtend(R[%eax])
idivl S   R[%edx] ¬ R[%edx]:R[%eax] mod S (余   Signed divide
          数)
          R[%eax] ¬ R[%edx]:R[%eax] ¸ S (商)
divl S    R[%edx] ¬R[%edx]:R[%eax] mod S       Unsigned divide
          R[%eax] ¬ R[%edx]:R[%eax] ¸ S




                                                                 24
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
                                                25
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)




                                                   26
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

                                                    27
Assembly Programmer’s View

                                      FF
  %eax     %ah   %al   Addresses
  %edx     %dh   %dl

  %ecx     %ch   %cl                  C0
                                      BF   Stack
  %ebx     %bh   %bl     Data
  %esi
                                      80
  %edi                                7F
                       Instructions
  %esp
                                           Heap
  %ebp                                     DLLs
                                      40
                                      3F
  %eip                                     Heap
                                           Data
  %eflag                                   Text
                                      08
                                                   28
                                      00
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




                                               29
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

                                                  30
Condition codes


• EFLAGS
  – ZF: Zero Flag
     • The most recent operation yielded zero
  – SF: Sign Flag
     • The most recent operation yielded a negative
      value



                                                 31
Setting Conditional Codes

• Implicit Setting By 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)



                                                    32
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




                                                    33
Setting Conditional Codes

• Explicit Setting by Compare Instruction
  cmpl Src2,Src1
  – cmpl b,a like computing a-b without 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)

                                                34
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

                                                      35
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


                                                36
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




                                                37
Accessing Conditional Codes
Figure 3.10         P150
Instruction Synonym    Effect         Set Condition
Sete       Setz        ZF             Equal/zero
Setne      Setnz       ~ZF            Not equal/not zero
Sets                   SF             Negative
Setns                  ~SF            Nonnegative
Setl       Setnge      SF^OF          Less
Setle      Setng       (SF^OF)|ZF     Less or Equal
Setg       Setnle      ~(SF^OF)&~ZF   Greater
Setge      Setnl       ~(SF^OF)       Greater or Equal
Seta       Setnbe      ~CF&~ZF        Above
Setae      Setnb       ~CF            Above or equal
Setb       Setnae      CF             Below
Setbe      Setna       CF|ZF          Below or equal
                                                           38
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




                                                  39
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

                                         40
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



                                                   41
Jump Instructions    P152


1 xorl   %eax, %eax         Set %eax to 0
2 jmp    .L1                Goto .L1
3 movl    (%eax), %edx      Null pointer dereference
4 .L1:
5 popl   %edx




                                                  42
Unconditional jump   P153


• Jumps unconditionally
• Direct jump: jmp label
  – jmp .L

• Indirect jump: jmp *Operand
  – jmp *%eax
  – jmp *(%eax)


                                43
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




                                                 44
Jump Instructions          P154

1 jle .L4
2 .p2align 4,,7  align next instruction to multiple of 8
3 .L5:
4 movl %edx, %eax
5 sarl $1, %eax          ;Arithmetic right shift
6 subl %eax, %edx
7 testl %edx, %edx
8 jg    .L5
9 .L4:
10 movl %edx, %eax

                                                      45
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




                                                   46
Example for Jump           P154

1   8: 7e 11               jle     1b<silly+0x1b>
2   a: 8d b6 00 00 00 00   lea     0x0(%esi), %esi
3   10: 89 d0              movl    %edx, %eax      dest1:
4   12: c1 f8 01           sarl    $1, %eax
5   15: 29 c2              subl    %eax, %edx
6   17: 85 d2              testl   %edx, %edx
7   19: 7f f5              jg      10<silly+0x10>
8   1b: 89 d0              movl    %edx, %eax      dest2:

dest1: 11+a = 1b              11+10
dest2: 1b+f5(-b) =10          F5=-11=0X(-b)
                                                       47
Example for Jump                 P155

1    80483c8:     7e 11                   jle   80483db<silly+0x1b>
2    80483ca:     8d b6 00 00 00 00       lea   0x0(%esi), %esi
3    80483d0:   89 d0                     movl %edx, %eax dest1:
4    80483d2:   c1 f8 01                  sarl  $1, %eax
5    80483d5:   29 c2                     subl  %eax, %edx
6    80483d7:   85 d2                     testl %edx, %edx
7    80483d9:   7f f5                     jg    80483d0<silly+0x10>
8    80483db:   89 d0                     movl %edx, %eax      dest2:

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




                                                                 48
Translating Conditional Branches        P157

                                 t = test-expr ;
if ( test-expr )
                                 if ( t )
       then-statement
                                            goto true ;
else
                                 else-statement
       else-statement
                                 goto done
                         true:
                                 then-statement
                         done:                      49
Translating Conditional Branches                P156

•    int absdiff(int x, int y)   •    int gotodiff(int x, int y)
•   {                            •   {
•       if (x < y)               •       int rval ;
•           return y – x;        •       if (x < y)
•       else                     •          goto less
•           return x – y;        •       rval = x – y ;
•   }                            •       goto done;
                                 •    less:
                                 •          rval = y – x;
                                 •     done:
                                 •          return rval;
                                                             50
                                 •   }
    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
                                                         51
Do-while Translation   P158

do
 body-statement
while (test-expr)

loop:
  body-statement
  t = test-expr;
  if ( t )
       goto loop ;


                              52
Do-while Translation         P159

int fib_dw(int n)              register   value   initially
{                              %ecx       i       0
    int i = 0;
                               %esi       n       n
    int val = 0 ;
    int nval = 1 ;             %ebx       val     0
                               %edx       nval    1
    do {
                               %eax       t       -
      int t = val + nval ;
      val = nval ;
      nval = t ;
      i++;
    } while ( i<n) ;
    return val ;
}

                                                        53
Do-while Translation           P159

.L6:
   lea    (%ebx, %edx), %eax   lea: %ebx+%edx => %eax
   movl   %edx, %ebx
   movl   %eax, %edx
   incl   %ecx
   cmpl   %esi, %ecx
   jl     .L6                    register   value   initially
   movl   %ebx, %eax             %ecx       i       0
                                 %esi       n       n
                                 %ebx       val     0
                                 %edx       nval    1
                                 %eax       t       -
                                                            54
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-statement           while(test-expr)
  goto loop;             done:
done:
                                                 55
While Loop Translation          P162

int fib_w(int n)            int fib_w_got0(int n)
                            {
{                               int val=1;
   int i=1;                     int nval=1;
   int val=1;                   int nmi, t ;
   int nval=1;                 if ( val >= n )
                                       goto done ;
                               nmi = n-1;
    while ( i<n ) {
         int t=val+nval ;   loop:
         val = nval ;          t=val+nval ;
                               val = nval ;
         nval = t ;            nval = t ;
          i = i+1;             nmi--;
                               if ( nmi )
    }                                 goto loop
    return val ;            done:
}                              return val
                            }

                                                     56
While Loop Translation                P162

       Register usage             •      movl 8(%ebp), %eax
                                  •      movl $1, %ebx
Register   Variable   Initially
                                  •      movl $1, %ecx
%edx       nmi        n-1         •      cmpl %eax, ebx
%ebx       val        1           •      jge .L9
%ecx       nval       1           •      lea –1(%eax), %edx
                                  •    .L10:
                                  •      lea (%ecx, %ebx), %eax
                                  •      movl %ecx, %ebx
                                  •      movl %eax, %ecx
                                  •      decl %edx
                                  •      jnz .L10
                                  •    .L9:

                                                              57
For Loop Translation     P164

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

init-expr
while ( test-expr) {
      body-statement
      update-expr
}



                                           58
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 ;
}
                                        59
Switch statements            P167

int switch_eg(int x)                    case 103
{                                           result += 11;
   int result = x ;                         break ;
   switch ( x ) {                       case 104:
   case 100:                            case 106:
        result *= 13 ;                      result *= result ;
        break ;                             break ;
   case 102:                            default:
        result += 10 ;                      result = 0 ;
        /* fall through */              }
                                        return result ;
                                    }
                                                             60
Switch Construct

• Properties of Switch Construct
  – Integer testing
  – Multiple outcomes (may be a large number)
  – Improve the readability of the source code




                                                 61
Switch Statements
                                                         M
                                                           ul
                                                             tip
 int switch_eg(int x)               case 103               le
                                                              ca




                     In tin
 {                                      result += 11;            se




                       teg g
                                                                    s


                        tes
                                        break ;



                           er
   int result = x ;
   switch ( x ) {                   case 104: case 106:
                                        result *= result ;
   case 100:
                                        break ;
        result *= 13 ;
                                    default:
        break ;                         result = 0 ;
   case 102:                        }
        result += 10 ;              return result ;
        /* fall through */      }
                                                                   62
Switch Form

switch(op) {
  case val_0:
    Block 0
  case val_1:
    Block 1
    • • •
  case val_n-1:
    Block n–1
}
                  63
Jump Table

• Efficient implementation
• Avoid long sequence of if-else statement
• Criteria
  – the number of cases and the sparsity of the case
    value




                                                 64
 Jump Table Implementation

        Jump Table             Jump Targets
jtab:      Targ0          Targ0:   Code Block
           Targ1                       0
           Targ2          Targ1:   Code Block
             •                         1
             •
             •            Targ2:   Code Block
                                       2
          Targn-1
                                       •
                                       •
  Approx. Translation                  •
  target = JTab[op];    Targn-1:   Code Block
  goto *target;                       n–1

                                                65
Switch Statements
                                                         M
                                                           ul
                                                             tip
 int switch_eg(int x)               case 103               le
                                                              ca




                     In tin
 {                                      result += 11;            se




                       teg g
                                                                    s


                        tes
                                        break ;



                           er
   int result = x ;
   switch ( x ) {                   case 104: case 106:
                                        result *= result ;
   case 100:
                                        break ;
        result *= 13 ;
                                    default:
        break ;                         result = 0 ;
   case 102:                        }
        result += 10 ;              return result ;
        /* fall through */      }
                                                                   66
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)                loc_b:
 {                                             result += 10 ;
    unsigned xi = x-100;                    loc_c:
    int result = x ;                           result +=11;
    if ( xi >6 )                               goto done ;
           goto loc_def ;                   loc_d:
    goto jt[xi];                               result *= result ;
                                               goto done ;
loc_a:                                      loc_def:
   result *= 13 ;                              result = 0 ;
   goto done ;                              done:
                                               return result ;
                                            }                         67
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
                                            68
Jump Table Implementation

11.   .L6:
12.      addl $11, %edx
13.      jmp .L3
14.   .L8:
15.      imull %edx, %edx
16.      jmp .L3
17.   .L9:
18.      xorl %edx, %edx
19.   .L3:
20.      movl %edx, %eax
                            69
Jump Table         P169

•   .section .rodata
•   .align 4
•   .L10:
•       .long .L4         case 100: loc_a
•       .long .L9         case 101: loc_def
•       .long .L5         case 102: loc_b
•       .long .L6         case 103: loc_c
•       .long .L8         case 104: loc_d
•       .long .L9         case 105: loc_def
•       .long .L8         case 106: loc_d
                                              70

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:0
posted:10/23/2013
language:Unknown
pages:70