Upload
candace-downer
View
216
Download
0
Embed Size (px)
Citation preview
CMPE 325 Computer Architecture II
Cem ErgünEastern Mediterranean
University
Assembly Language (cont)
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
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
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?
CMPE 325 CH #3 Slide #5
Loop Efficiency Code uses two
branches/iteration: Better structure:
Cond?
Body of loop Cond?
Body of loop
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
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
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
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
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
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
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
CMPE 325 CH #3 Slide #13
Logical Operators Bitwise operators often useful for converting &&,
||, and ! symbols into assembly Always operate unsigned (more later)
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
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
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
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
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
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
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
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.
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
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 .
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.
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;}
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
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.
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
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; }
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.
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
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.
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
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