34
CMPE 325 Computer Architecture II Cem Ergün Eastern Mediterranean University Assembly Language (cont)

CMPE 3 2 5 Computer Architecture II

  • Upload
    tuwa

  • View
    31

  • Download
    0

Embed Size (px)

DESCRIPTION

CMPE 3 2 5 Computer Architecture II. Cem Erg ün Eastern Med iterranean University. Assembly Language (cont). Loop Example. Consider the code where array A is an integer array with 100 elements Loop:g = g + A[i] i = i + j; if (i != h) goto Loop: g:$s0 h:$s1 i:$s2 j:$s3 A:$s4. - PowerPoint PPT Presentation

Citation preview

Page 1: CMPE  3 2 5 Computer Architecture  II

CMPE 325 Computer Architecture II

Cem ErgünEastern Mediterranean

University

Assembly Language (cont)

Page 2: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #2

Loop Example Consider the code where array A is an integer

array with 100 elementsLoop: g = g + A[i]

i = i + j;

if (i != h) goto Loop:

g: $s0h: $s1i: $s2j: $s3A: $s4

Page 3: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #3

Loop Solution Use a conditional test

Loop: add $t0, $s2, $s2 # $t0 = 2 * i

add $t0, $t0, $t0 # $t0 = 4 * i

add $t1, $t0, $s4 # $t1 = &(A[i])

lw $t2, 0($t1) # $t2 = A[i]

add $s0, $s0, $t2 # g = g + A[i]

add $s2, $s2, $s3 # i = i + j

bne $s2, $s1, Loop # goto Loop if i!=h

This sequence is known as a basic block since it has one entrance and one exit

Page 4: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #4

Loops in C Consider a very similar case with while

while (A[i] == k)i = i + j;

Use a similar loop as beforeLoop: add $t0, $s0, $s0 # $t0 = 2 * i

add $t0, $t0, $t0 # $t0 = 4 * iadd $t1, $t0, $s3 # $t1 = &(A[i])lw $t2, 0($t1) # $t2 = A[i]bne $t2, $s2, Exit # goto Exit if !

=add $s0, $s0, $s1 # i = i + jj Loop # goto Loop

Exit:

What is wrong with this approach?

Page 5: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #5

Loop Efficiency Code uses two

branches/iteration: Better structure:

Cond?

Body of loop Cond?

Body of loop

Page 6: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #6

Improved Loop Solution Remove extra branch

j Cond # goto Cond

Loop: add $s0, $s0, $s1 # i = i + j

Cond: add $t0, $s0, $s0 # $t0 = 2 * i

add $t0, $t0, $t0 # $t0 = 4 * i

add $t1, $t0, $s3 # $t1 = &(A[i])

lw $t2, 0($t1) # $t2 = A[i]

beq $t2, $s2, Loop # goto Loop if ==

Exit:

Reduced loop from 7 to 6 instructions Even small improvements important if loop executes many times

Page 7: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #7

Other Comparisons Other conditional arithmetic operators are useful

in evaluating conditional expressions using <, >, <=, >=

Conditional expressions also useful in signed vs. unsigned integers (to be discussed later)

Register is “set” to 1 when condition is met Consider the following code

if (f < g) goto Less;

Solutionslt $t0, $s0, $s1 # $t0 = 1 if $s0 < $s1bne $t0, $zero, Less # Goto Less if $t0 != 0

Page 8: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #8

MIPS ComparisonsInstruction Example Meaning Comments

set less than slt $1, $2, $3 $1 = ($2 < $3) comp less than signed

set less than imm slti $1, $2, 100 $1 = ($2 < 100) comp w/const signed

set less than uns sltu $1, $2, $3 $1 = ($2 < $3) comp < unsigned

set l.t. imm. uns sltiu $1, $2, 100 $1 = ($2 < 100) comp < const

unsigned

Page 9: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #9

MIPS Jumps & BranchesInstruction Example Meaningjump j L goto Ljump register jr $1 goto value in $1jump and link jal L goto L and set $rajump and link register jalr $1 goto $1 and set $rabranch equal beq $1, $2, L if ($1 == $s2) goto Lbranch not eq bne $1, $2, L if ($1 != $2) goto Lbranch l.t. 0 bltz $1, L if ($1 < 0) goto Lbranch l.t./eq 0 blez $1, L if ($1 <= 0) goto Lbranch g.t. 0 bgtz $1, L if ($1 > 0) goto L branch g.t./eq 0 bgez $1, L if ($1 >= 0) goto L

Page 10: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #10

Simplicity Notice that there was no branch less than

instruction for comparing two registers? The reason is that such an instruction would be too

complicated and would force a longer clock cycle time

Therefore, conditionals that are not comparing against zero take at least two instructions where the first is a set and the second is a conditional branch

The MIPS assembler supports pseudoinstructions for such operators and automatically converts them to the appropriate sequence of MIPS instructions

Page 11: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #11

Pseudoinstructions Assembler expands pseudoinstructions

move $t0, $t1 # Copy $t1 to $t0

add $t0, $zero, $t1 # Actual instruction

Some pseudoinstructions need a temporary register Cannot use $t, $s, etc. since they may be in use The $at register is reserved for the assembler

blt $t0, $t1, L1 # Goto L1 if $t0 < $t1

slt $at, $t0, $t1 # Set $at = 1 if $t0 < $t1

bne $at, $zero, L1 # Goto L1 if $at != 0

Page 12: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #12

Pseudoinstructions (cont) The pseudoinstruction load immediate (li)

provides transfer of a 16-bit constant value to regli $t0, imm # Copy 16bit imm. value to $t0

addi $t0, $zero, imm # Actual instruction

Example: Write a MIPS code to load 076543210h

lui $s0, 07654 # $s0 is set to 076540000 h

addi $s0, $s0,03210 # After addition 076543210 h

Page 13: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #13

Logical Operators Bitwise operators often useful for converting &&,

||, and ! symbols into assembly Always operate unsigned (more later)

Page 14: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #14

MIPS Logical InstructionsInstruction Example Meaning Commentsand and $1, $2, $3 $1 = $2 & $3 Logical ANDor or $1, $2, $3 $1 = $2 | $3 Logical ORxor xor $1, $2, $3 $1 = $2 $3 Logical XORnor nor $1, $2, $3 $1 = ~($2 | $3) Logical NORand immediate andi $1, $2, 10 $1 = $2 & 10 Logical AND w. constantor immediate ori $1, $2, 10 $1 = $2 | 10 Logical OR w. constantxor immediate xori $1, $2, 10 $1 = ~$2 & ~10 Logical XOR w. constantshift left log sll $1, $2, 10 $1 = $2 << 10 Shift left by constantshift right log srl $1, $2, 10 $1 = $2 >> 10 Shift right by constantshift right arith sra $1, $2, 10 $1 = $2 >> 10 Shift right (sign extend) shift left log var sllv $1, $2, $3 $1 = $2 << $3 Shift left by variableshift right log var srlv $1, $2, $3 $1 = $2 >> $3 Shift right by variableshift right arith srav $1, $2, $3 $1 = $2 >> $3 Shift right arith. by varload upper imm lui $1, 40 $1 = 40 << 16 Places imm in upper 16b

Page 15: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #15

Handling Procedures Procedures are useful for decomposing

applications into smaller units Implementing procedures in assembly requires

several things to be done Space must be set aside for local variables Arguments must be passed in and return values

passed out Execution must continue after the call

Page 16: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #16

Procedure Steps1. Place parameters in a place where the

procedure can access them2. Transfer control to the procedure3. Acquire the storage resources needed for the

procedure4. Perform the desired task5. Place the result value in a place where the

calling program can access it6. Return control to the point of origin

Page 17: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #17

Stacks Stacks are a natural way to temporarily store

data for procedures (as well as call/return information) since they have a LIFO behavior

Data is pushed onto the stack to store it and popped from the stack when not longer needed

Implementation Common rules across procedures required Recent machines are set by software convention and

earlier machines by hardware instructions

Page 18: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #18

Using Stacks Stacks can grown up or down Stack grows down in MIPS Entire stack frame is pushed and popped, rather

than single elements

Page 19: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #19

Calling a Procedure To jump to a procedure, use the jal jump-and-

link instructionjal tartget # Jump and link to label

Saves the address of the next location into to register-31 and

Jumps to the specified 26-bit local word address

Page 20: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #20

jal and jr Instructions

jal Prod_Addr (J-Type) first increments the program counter

(PCPC+4), so that it points to the next location, then it stores that value into $ra (= $31).

jr $ra (R-Type) copies $ra into PC, PC$ra causes to jump back

to the stored return address.

3 Prod_Addr/4

0 31 0 0 0 8

Page 21: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #21

Who saves the register? Caller save

All values that have to be kept must besaved before a procedure is called.

Callee saveWithin the procedure all used registers are saved and afterwards restored.

Page 22: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #22

Argument Passing Convention

Return value is transferred in $v0…$v1.($v0 and $v1) corresponds to ($2 and $3)

Integer arguments up to four are passed in registers $a0 … $a3. (= $4 … $7).

Any higher data structure is passed by a pointer. If there are more than 4 parameters,

first four parameters are passed in registers, the others are transferred in the stack

Page 23: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #23

Register Saving Conventions

Save the registers saved-registers s0…s7, arguments a0 … a3, and system registers $gp, $sp, $fp and $ra

before they are corrupted in a call. Restore them before the start of calling

code .

Page 24: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #24

Procedure Coding Example

The C code for swap procedure is:swap(int v[ ], int k){ int temp; temp = v[k]; v[k] = v[k+1]; v[k+1] = temp;}

Code it in MIPS Assembly.

Page 25: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #25

Coding Example -swap Allocate registers to procedure variables.

swap(int v[], int k) two arguments • pointer v[ ] in $a0 , integer k in $a1.• $t0, $t1, … for temp. values and addresses

Write MIPS code for the procedure body.sll $t1, $a1, 2 # $t1 k 4add $t1, $a0, $t1 # $t1 v+(k 4)lw $t0, 0($t1) # $t0 = v[k]lw $t2, 4($t1) # $t2 = v[k+1]sw $t2, 0($t1) # v[k] $t2 ( =

v[k+1] )sw $t0, 4($t1) # v[k+1] $t0 (= v[k] )

Nothing to save since only temp.regs corrupted. none of {$s0…$s7, $a0 …$a3, $sp, $ra} is corrupted

swap(int v[ ], int k){ int temp; temp = v[k]; v[k] = v[k+1]; v[k+1] = temp;}

Page 26: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #26

Swap in Final Form Final form of the procedure

swap:

sll $t1, $a1, 2 # $t1 k 4

add $t1, $a0, $t1 # $t1 v+(k 4)

lw $t0, 0($t1) # $t0 = v[k]

lw $t2, 4($t1) # $t2 = v[k+1]

sw $t2, 0($t1) # v[k] $t2 ( = v[k+1] )

sw $t0, 4($t1) # v[k+1] $t0 (= v[k] )

jr $ra

Label to call the procedure

return to caller code

Page 27: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #27

Nested Calls A call in another call corrupts $ra.

$ra must be saved on the stack before the second call

and then restored after the return from the inner call.

Page 28: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #28

Nested Stacks The stack grows and shrinks downward

A:A

CALL B

B: AB

CALL C ABC

C:

RET

RET

AB

A

Page 29: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #29

Coding Example: Procedures

Assume x[ ] starts from 10000 and y[ ] starts from 20000. Code the following program in MIPS Assembler

starting main from address 300, and f from 400.

Main pocedure. . . . .j=5 f(j,x);x[3]+=5;. . . . .

f procedurevoid f(int j, int x[]){ if (j= =7) x[2]=6*x[1]–x[0]; else g(y); }

g procedureint g(int y[]){ int i; for (i=2;i<12;i++) y[i]*=2; y[2] – = 4; }

Page 30: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #30

Coding Example –Main Body

Code for MainMain: ...

li $a0,5li $a1,10000jal flw $t0,12($a1) # $t0 x[3]addi $t0,$t0,5 # $10 x[3] + 5sw $t0,12($a1) # x[3] x[3] + 5…

Main pocedure. . . . .j=5 f(j,x);x[3]+=5;. . . . .

allocate registers• two arguments in f(), use $a0, $a1

one argument in g() use $a0• j and x are saved variables• in g(), i is local, temporary variable. • address calculations in temp.registers.

Page 31: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #31

Coding Example -Procedure f()

li $t0,7 # if (j !=7 )bne $a0, $t0, Else # go to Else.li $t1, 6 # $t1 6, lw $t2, 4($a1) # $t2 x[1]mult $t2, $t1 # LO 6 x[1]mflo $t2 # $t2 6 x[1]lw $t1, 0($a1) # $t1 x[0] sub $t1, $t2, $t1 # $t1 6x[1] – x[0]; sw $t1, 8($a1) # x[2] 6x[1] – x[0]; j ExitIf

Else:li $a0, 20000jal g

ExitIf:

f procedurevoid f(int j, int x[]){ if (j= =7) x[2]=6*x[1]–x[0]; else g(y); }

$a0 is corrupted

$ra is corrupted

Callee savesthe registers

Callee restoresthe registers

jr $ra

return of procedure f()

2-words = 8 bytes

f:

label of procedure

addi $sp,$sp, -8 sw $a0, 0($sp) sw $ra, 4($sp)

lw $a0, 0($sp) lw $ra, 4($sp) addi $sp,$sp, 8

Page 32: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #32

Coding Example – Procedure g()

g() procedurevoid g(int y[]) { int i; for (i=2;i<12;i++)

y[i]*=2; y[2] – = 4; }

g: li $t0, 2 # $10= i 2 for loopLoop:

slti $t1, $t0, 12 # if ( i < 12) then $t11 beq $t1,$0, ExitF # if ($t1=0) exit for-loop.sll $t2, $t0, 2 # $t2 4 iadd $t2, $a0, $t2 # $t2 y[] + 4 ilw $t3, 0($t2) # $t3 y[i]add $t3, $t3,$t3 # $t3 2 y[i]sw $t3, 0($t2) # y[i] 2 y[i]addi $t0, $t0, 1 # $t0 = i i+1j Loop # loop again

ExitF: # end of for looplw $t3, 8($a0) # $t3 y[2]addi $t3, $t3,–4 # $t3 y[2] – 4sw $t3, 8($a0) # y[2] y[2] – 4

jr $31

Only temporary registers are used

No registers need to be saved.

Page 33: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #33

Decimal Coding of a Program• coding starts from memory address 300ten.

addressmemory word contents (instruction fields)

assembly with pseudocode

assembly without pseudocodeopc rs rt rd sa fn

300: 8 0 4 5 li $a0,5 add $4,$0,5304: 8 0 5 10000 li $a1,10000 add $5,$0,10000308: 3 100 jal f jal f312: 35 5 8 12 lw $t0,12($a1) lw $8,12($5)316: 8 8 8 5 addi $t0,$t0,5 addi $8,$8,5320: 43 5 8 12 sw $t0,12($a1) sw $8,12($5)…. … … … … … …

F: 400: 8 29 29 –8 addi $sp,$sp,–8 addi $29,$29,–8404: 43 29 4 0 sw $a0,0($sp) sw $4,0($29)408: 43 29 31 20 sw $ra,4($sp) sw $31,4($29)412: 8 0 8 7 li $t0,7 addi $8,7416: 5 4 8 8 bne $4,$t0,Else bne $4,$8,Else420: 8 0 9 6 li $t1,6 addi $9,$0,6 424: 35 5 10 4 lw $t2,4($a1) lw $10,4($5)428: 0 10 9 0 0 35 mult $t2,$t1 mult $10,$9432: 0 0 0 10 0 18 mflo $t2 mflo $10436: 35 5 9 0 lw $t1,0($a1) lw $9,0($5)440: 0 10 9 9 0 34 sub $t1,$t2,$t1 sub $9,$10,$9444: 43 5 9 8 sw $t1,8($a1) sw $9,8($5)448: 2 115 j ExitIf j ExitIf

Else: 452: 8 0 4 20000 li $a0,20000 addi $4,$0,20000456: 3 119 jal G jal G

ExitIf: 460: 35 29 4 0 lw $a0,0($sp) lw $4,0($29)464: 35 29 31 4 lw $ra,4($sp) lw $31,4($29)468: 8 29 29 8 addi $sp,$sp,8 addi $29,$29,24472: 0 31 0 0 0 8 jr $ra jr $31

100= 400/4

8= (392–360)/4

115= 460/4

119= 476/4

Page 34: CMPE  3 2 5 Computer Architecture  II

CMPE 325 CH #3 Slide #34

Decimal Coding of a Program-2• continuation of coding

addressmemory word contents (instruction fields) assembly with

pseudocodeassembly without

pseudocodeopc rs rt rd sa fn

g: 476: 8 0 8 2 li $t0,2 addi $8,$0, 2Loop: 480: 10 8 9 12 slti $t1,$t0,12 slti $9,$8,12

484: 4 0 9 7 beq $t1,$0, ExitF beq $9,$0, ExitF488: 0 0 8 10 2 0 sll $t2,$t0,2 sll $10,$8,2492: 0 10 4 10 0 32 add $t2,$t2,$a0 add $t2,$t2,$4496: 35 12 11 0 lw $t3,0($t2) lw $11,0($10)500: 0 11 11 11 0 32 add $t3,$t3,$t3 add $11,$11,$11504: 43 10 11 0 sw $t3,0($t2) sw $11,0($10)508: 8 8 8 1 addi $t0,$t0,1 addi $8,$8,1512: 2 120 j Loop j Loop

ExitF: 516: 35 4 13 8 lw $t3, 8($a0) lw $11, 8($4)520: 8 11 11 –4 addi $t3,$t3,–4 addi $11,$11,–4524: 43 4 11 8 sw $t3, 8($a0) sw $11, 8($4)528: 0 31 0 0 0 8 jr $ra jr $31

... .. .. .. .. .. .. ... ...

7 =(516-488)/4

120 =480/4