Logical and decision operations
This presentation is the property of its rightful owner.
Sponsored Links
1 / 18

Logical and Decision Operations PowerPoint PPT Presentation


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

Logical and Decision Operations. Chapter 2. Logical operations. Shift left Example: sll $t2,$so,4 Reg t2 = $so << 4 Shift right Example: srl $t2,$so,4 Reg t2 = $so >> 4 Bit-wise AND Example: and $t0,$t1, $t2 Reg t0 = reg t1 & reg t2 Bit-wise OR Example: or $t0,$t1,$t2

Download Presentation

Logical and Decision Operations

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


Logical and decision operations

Logical and Decision Operations

Chapter 2


Logical operations

Logical operations

  • Shift left

    • Example: sll $t2,$so,4

    • Reg t2 = $so << 4

  • Shift right

    • Example: srl $t2,$so,4

    • Reg t2 = $so >> 4

  • Bit-wise AND

    • Example: and $t0,$t1, $t2

    • Reg t0 = reg t1 & reg t2

  • Bit-wise OR

    • Example: or $t0,$t1,$t2

    • Reg $t0 = $t1 | $t2


Instructions for selection if else

Instructions for Selection (if..else)

  • If (i == j) then f = g + h; else f = g – h;

    bne $s3,$s4, else

    add $s0,$s1,$s2

    j done

    else: sub $s0,$s1,$s2

    done:


Instructions for iteration while

Instructions for Iteration (while)

  • while (save[i] == k)

  • i = i + 1;

    Let i be in reg $s3

    Let k be in reg $s5

    Let $t1 have the address of Save array element

    Loop: sll $t1,$s3,2

    add $t1,$t1$s6

    lw $t0,0($t1)

    bne $t0,$s5,Exit

    addi $s3,$s3,1

    j Loop


Compiling c procedures

Compiling C procedures

int leaf_example (int g, int h, int i, int j)

{ int f;

f = (g + h) – (i + j);

return f;

}

How do you pass the parameters? How does compiler transport the parameters?


Passing parameters arguments

Passing Parameters/arguments

Special registers for arguments: a0, a1, a2, a3

Save temp register on the stack

Perform operations

And return value

Restore values stored on the stack

Jump back to return address


Steps in execution of a procedure

Steps in Execution of a Procedure

  • Place parameters in a place where procedures can access them

  • Transfer control to the procedure

  • Acquire the storage resources needed for the procedure

  • Perform the desired task

  • Place the result value in a place where the calling program can access it

  • Return control to the point of origin, since a procedure can be called from several points in a program


Register mapping ahah

Register Mapping – Ahah!

R0 (r0) = 00000000

R1 (at) = 00000000

R2 (v0) = 00000000

R3 (v1) = 00000000

R4 (a0) = 00000000

R5 (a1) = 00000000

R6 (a2) = 00000000

R7 (a3) = 00000000

R8 (t0) = 00000000

R9 (t1) = 00000000

R10 (t2) = 00000000

R11 (t3) = 00000000

R12 (t4) = 00000000

R13 (t5) = 00000000

R14 (t6) = 00000000

R15 (t7) = 00000000

R16 (s0) = 00000000

R17 (s1) = 00000000

R18 (s2) = 00000000

R19 (s3) = 00000000

R20 (s4) = 00000000

R21 (s5) = 00000000

R22 (s6) = 00000000

R23 (s7) = 00000000

R24 (t8) = 00000000

R25 (t9) = 00000000

R26 (k0) = 00000000

R27 (k1) = 00000000

R28 (gp) = 10008000

R29 (sp) = 7fffeffc

R30 (s8) = 00000000

R31 (ra) = 00000000


Procedure call conventions

Procedure Call Conventions

  • $a0-$a3 : four argument registers in which to pass parameters

  • $vo-$v1: two value registers in which to return values

  • $ra: one return address register to return to point of origin of the call

  • MIPS assembly language also has a special instruction jal (jump and link) that saves the return address in $ra before transferring control to the procedure.

    • Eg: jal ProcedureAddress

  • Another instruction “jr” transfers control back to the called location.

    • Eg. jr $ra


Using the stack automatic storage

Using the Stack “automatic storage”

  • Automatic store for “workspace” and temporary registers.

  • Use the stack:

  • Use the stack pointer to access stack;

  • Remember stack operates on LIFO

  • Also note that $ZERO is a convenience register that stores the value 0 (check your green sheet attached to your textbook)

  • Now we are ready to translate the procedure:


Translating the procedure

Translating the procedure

int leaf_example (int g, int h, int i, int j)

{ int f;

f = (g + h) – (i + j);

return f;

}

  • Parameters g, h, i, j will be stored in argument registers: $a0,$a1,$a2,$a3 before the call

  • Once inside we plan to use $s0, $t0, $t1; so we need save their values on the stack;

  • Then use them to compute (g+h), (i+j) and f


Mips code

MIPS code

addi $sp,$sp,-12 # make room on the stack

sw $t1,8($sp) # save the temp registers

sw $t0,4($sp)

sw $so,o($sp)

add $to,$ao,$a1 # t0  g + h

add $t1,$a2,$a3 # t1  i + j

sub $so,$t0,$t1 # f = t0 – t1

add $v0,$so,$zero # returns f ($vo = $s0 + 0)

lw $s0,0(sp) # restore saved values into temp registers from stack

lw $t0,4(sp)

lw $t1,8(sp)

addi $sp,$sp,12

jr $ra # jump back to the return address


Allocating space on stack

Allocating Space on Stack

  • Stack is used to save and restore registers when calling a procedure

  • It may also be used to store return address

  • It may be used to store arguments

  • It may be used to store local arrays and data

  • The segment of the stack containing a procedure’s saved registers and local variables is called “procedure frame” or “activation record”

  • A frame pointer ($fp) points to first word of the frame of a procedure.


Stack and frame pointers

Stack and frame pointers

before

after

during

fp

fp

sp

sp

fp

Saved arguments

Saved return addr

Saved regs

.

Locals arrays

& structures

sp


Delayed branches

Delayed Branches

Branch:

Execute

Inst Fetch

Dcd & Op Fetch

execute successor

even if branch taken!

Dcd & Op Fetch

Execute

Inst Fetch

Inst Fetch

Then branch target

or continue

Single delay slot

impacts the critical path

  • add r3, r1, r2

  • sub r4, r4, 1

  • bzr4, LL

  • NOP

  • ...

  • LL: add rd, ...

    • Compiler can fill a single delay slot with a useful instruction 50% of the time.

      • try to move down from above jump

      • move up from target, if safe


    Delayed branches1

    Delayed Branches

    • li r3, #7

    • sub r4, r4, 1

    • bzr4, LL

    • subir6, r6, 2

  • LL:sltr1, r3, r5

    • li r3, #7

    • sub r4, r4, 1

    • bzr4, LL

    • nop

  • LL:sltr1, r3, r5

  • subir6, r6, 2

    compiler


    Branch and pipelines

    Branch and Pipelines

    Time

    • li r3, #7

    execute

    • sub r4, r4, 1

    ifetch

    execute

    • bzr4, LL

    ifetch

    execute

    Branch

    • subi r6, r6, 2

    Delay Slot

    ifetch

    execute

    LL:sltr1, r3, r5

    ifetch

    execute

    Branch Target

    By the end of Branch instruction, the CPU knows whether or not

    the branch will take place.

    However, it will have fetched the next instruction by then,

    regardless of whether or not a branch will be taken.

    Why not execute it?


    Putting it all together

    Putting it all together

    • Sort procedure

      void sort (int v[], int n)

      {

      int i, j;

      for (i = 0; i < n; i = i+1) { // outer loop

      for (j = i - 1; j >= 0 && v[j] > v[j+1]; j = j-1){

      swap(v, j); }

      } }

      See fig. 2.34, 2.36

      Hwk 2: 2.15 : due date: 2/6/2009, submit online.


  • Login