1. Assembly Language
Chapter 3

2. Chapter 3 Assembly Languages
Computer Languages
High-level languages
Java, Python, C, ASP, HTML, …
Low-level languages
Assembly language: symbolic representation of machine instructions.
Assembler: a compiler which translates from an assembly language to a machine language.
Machine languages
Chapter 3 Assembly Languages

3. Components of a computer: More detail
processor
memory
registers
ALU
data
program
Instruction register
Program counter
data
address
Control units
Chapter 3 Assembly Languages

4. Levels of descriptions of computer systems
computer architecture begins at the instruction set.
An instruction set is what a programmer at the lowest level sees of a processor
one instruction set with different level of performance for many models, based on the implementation of a control unit via “microprogram”.
Present day processor designs converge, their instruction sets become more similar than different.
Applications
Operating systems
Instruction set
Functional units
Finite state machine
Logic gates
Electronics
Chapter 3 Assembly Languages

5. Chapter 3 Assembly Languages
Registers
Name Reg. No. Usage
$zero 0 hardwired 0
$v0-$v return value and expression evaluation
$a0-$a arguments
$t0-$t temporary values
$s0-$s saved values
$t8-$t more temporary values
$gp global pointer
$sp stack pointer
$fp frame pointer
$ra return address
Chapter 3 Assembly Languages

6. Chapter 3 Assembly Languages
MIPS operands
Name
Example
Comments
32 registers
$0, $1, $2,..., $31
Fast location for data. In MIPS, data must be in registers to perform arithmetic.
memory words
Memory[0], Memory[4],..., Memory[ ]
Accessed only by data transfer instructions. MIPS uses byte addresses, so sequential words differ by 4. Memory holds data structures, such as arrays, and spilled registers, such as those saved on procedure calls
Chapter 3 Assembly Languages

7. MIPS Assembly Instructions: Arithmetic
Example
Meaning
Comments
add
add $rd,$rs,$rt
$rd = $rs + $rt
3 operands; data in registers
subtract
sub $rd,$rs,$rt
$rd = $rs - $rt
add unsigned
addu $rd,$rs,$rt
subtract unsigned
subu $rd,$rs,$rt
add immediate
addi $rd,$rs, 100
$rd = $rs + 100
3 operands; data in registers and a constant
Chapter 3 Assembly Languages

8. MIPS Assembly Instructions: Data Transfer
Example
Meaning
Comments
load word
lw $rt, 10($rs)
$rt = Memory[$rs+10]
Data from memory to register
store word
sw $rt, 10($rs)
Memory[$rs+10] = $rt
Data from register to memory
Chapter 3 Assembly Languages

9. MIPS Assembly Instructions: Logical
Example
Meaning
Comments
and
and $rd,$rs,$rt
$rd = $rd & $rt
3 register operands; bitwise operation or
or $rd,$rs,$rt
$rd = $rd | $rt
nor
nor $rd,$rs,$rt
$rd = ~($rd & $rt)
and immediate
andi $rt,$rs,10
$rt = $rs & 10
bitwise operation with constant
or immediate
ori $rt,$rs,10
$rt = $rs | 10
shift left logical
sll $rd,$rt,10
$rd = $rt << 10
Shift left/right by constant
shift right logical
srl $rd,$rt,10
$rd = $rt >> 10
Chapter 3 Assembly Languages

10. MIPS Assembly Instructions
Example
Meaning
Comments
jump
j 10000
goto 10000
Jump to target addr.
jump register
j $31
goto $31
For switch, procedure return
jump and link
jal 1000
$31 = PC+4 ; go to 1000
For procedure call
Chapter 3 Assembly Languages

11. MIPS Assembly Instructions: Conditionals
Example
Meaning
Comments
branch on =
beq $rs,$rt,100
if ($rs == $rt)
go to PC+4+100
Equal test; PC relative branch
branch on not =
bne $rs,$rt,100
if ($rs != $rt)
Not equal test; PC relative branch
set on <
slt $rd,$rs,$rt
if ($rs < $rt) $rd = 1;
else $rd = 0
Compare <; 2’s complement
set < immediate
slti $rt,$rs,100
if ($rs < 100) $rt = 1;
else $rt = 0
Compare < constant; 2’s complement
set < unsigned
sltu $rd,$rs,$rt
Compare <; natural number
set < immediate unsigned
sltiu $rt,$rs,100
($rs < 100) $rt = 1;
Compare < constant; natural number
Chapter 3 Assembly Languages

12. Chapter 3 Assembly Languages
Example
x = y+z+5;
w = z-y;
lw $t0, 18($zero) # load y
lw $t1, 22($zero) # load z
add $t2, $t0, $t1 # y+z
addi $t2, $t2, # (y+z)+5
sw $t2, 14($zero) # store x
sub $t3, $t1, $t2 # z-y
sw $t3, 10($zero) # store w
if (a<b) a++;
else b++;
lw $t0, 50($zero) # load a
lw $t1, 54($zero) # load b
slt $t2, $t0, $t1 # a<b
beq $t2, $zero, else # if
addi $t0, $t0, 1 # a++
sw $t0, 50($zero) # store a
else:
addi $t1, $t1, 1 # b++
sw $t1, 54($zero) # store b w x y z a b
Chapter 3 Assembly Languages

13. Basic instruction formats
R- format op rs rt rd
Shamt
funct
I- format Op rs rt
Const/addr
J- format
Op code
address
Chapter 3 Assembly Languages

14. Instruction Representation: Examples
Format Op rs rt rd
Shamt
funct
Const/addr
add $rs,$rt,$rd R 00
reg 20 NA
sub $rs,$rt,$rd 22
addi $rs,$rt, 100 I 08
const
j 10000 J 02
addr
beq $rs,$rt, 1000 04
Chapter 3 Assembly Languages

15. Instruction Representation: Examples
Format Op rs rt rd
Shamt
funct
Const/addr
add $rs,$rt,$rd R 00
reg 20 NA
add $t0, $t1, $t2 op rs rt rd
Shamt
funct 9 5
Chapter 3 Assembly Languages

16. Instruction Representation: Examples
Format Op rs rt rd
Shamt
funct
Const/addr
sub $rs,$rt,$rd R 00
reg 22 NA
sub $s0, $s1, $s2 op rs rt rd
Shamt
funct 1 9
Chapter 3 Assembly Languages

17. Instruction Representation: Examples
Format Op rs rt rd
Shamt
funct
Const/addr
addi $rs,$rt, 100 I 08
reg NA
const
addi $s0, $s1, 100 op rs rt
Const/addr 2 1
C A C
Chapter 3 Assembly Languages

18. Instruction Representation: Examples
Format Op rs rt rd
Shamt
funct
Const/addr
j 10000 J 02 NA
addr
j 10000 op
Const/addr
Chapter 3 Assembly Languages

19. Instruction Representation: Examples
Format Op rs rt rd
Shamt
funct
Const/addr
beq $rs,$rt, 1000 I 04
reg NA
const
beq $s0, $s1, 100 op rs rt
Const/addr 1
C A C
Chapter 3 Assembly Languages

20. Chapter 3 Assembly Languages
MIPS Simulator
Chapter 3 Assembly Languages

21. Case/ Switch statement
switch (i)
{ case 0: i++; break;
case 1: j++; break;
case 4: k++; }
Jump (address) table
Table storing addresses of different cases
3010
2010
k=0
3014
2045
k=1
3018
2077
k=2
301C
k=3
3020
2085
k=4
Chapter 3 Assembly Languages

22. Case statement and jr instruction
switch (i)
{ case 0:
i++;
break;
case 1:
j++;
case 4:
k++; }
# variable i is in $t1, const 5 is in $t0
# start addr of jump table (e.g. 3010) is in $s0
blt $t1, $zero, out
bge $t1, $t0, out
# multiply i by 4 for word size
sll $t1, $t1, 2
# find entry in the jump table
add $t1, $t1, $s0
# load addr in jump table to $t2
lw $t2, 0($t1)
jr $t2
L2010: …
j out
L20485:
out:
Chapter 3 Assembly Languages

23. Chapter 3 Assembly Languages
Procedure calls
Steps to Execute procedure
place parameters in a place where procedure can access them
transfer control to the procedure
acquire the storage needed for the procedure
perform the desired task
place the result value in a place where the calling program can access it
return to the control point of origin
Chapter 3 Assembly Languages

24. Memory allocation for programs
$sp
Stack
Heap
(dynamic data)
Static data
Code
(text segment)
Reserved
$fp
$gp pc
Chapter 3 Assembly Languages

25. Chapter 3 Assembly Languages
Registers
$a0-$a3
four argument registers in which to pass parameters
$v0-$v1
two value registers in which to return values
$ra
one return address register to return to the point of origin
Chapter 3 Assembly Languages

26. Chapter 3 Assembly Languages
jal jump and link
jumps to an address and simultaneously saves the address of the following instruction in register $ra
jal ProcedureAddress
jal puts PC + 4 in $ra
to return, after completion of the procedure:
jr $ra
calling program (caller) puts parameter values in $a0-$a3
callee performs calculations and places result in $v0-$v1
Chapter 3 Assembly Languages

27. Chapter 3 Assembly Languages
Call sequence
Put arguments in $a0-$a3
The rest of the arguments (if exist) are placed in the frame or activation record
Allocate a frame in stack (update $sp)
Save values of $s0-$s7, $fp, $ra in the frame
Update $fp
Execute jal instruction
Chapter 3 Assembly Languages

28. Chapter 3 Assembly Languages
Return sequence
Put the return value in $v0
Restore registers $s0-$s7
Restore $fp
Pop the frame from stack
Execute jr $ra
Chapter 3 Assembly Languages

29. Chapter 3 Assembly Languages
Example 1
int leaf_example (int g, int h, int i, int j)
{ int f;
f = (g + h) - (i + j); return f; }
leaf example:
addi $sp, $sp, -12 #adjust stack to make room for 3 items
sw $t1, 8($sp) #save register $t1 for use afterwards
sw $t0, 4($sp) #save register $t0 for use afterwards
sw $s0, 0($sp) #save register $s0 for use afterwards
add $t0, $a0, $a1 #register $t0 contains g + h
add $t1, $a2, $a3 #register $t1 contains i + j
sub $s0, $t0, $t1 #f = $t0 - $t1, which is (g+h)-(i+j)
add $v0, $s0, $zero #returns f ($v0 = $s0 + 0)
lw $s0, 0($sp) #restore register $s0 for caller
lw $t0, 4($sp) #restore register $t0 for caller
lw $t1, 8($sp) #restore register $t1 for caller
addi $sp, $sp, 12 #adjust stack to delete 3 items
jr $ra #jump back to calling routing
Chapter 3 Assembly Languages

30. Chapter 3 Assembly Languages
Example 2
int fact (int n)
{ if (n<2) return(1); else return(n*fact(n-1); }
fact:
addi $sp, $sp, -8 #adjust stack to make room for 2 items
sw $ra, 4($sp) #save the return address
sw $a0, 0($sp) #save the argument n
slti $t0, $a0, 2 #test for n<2
beq $t0, $zero, L1 #if n>=2 goto L1
addi $sp, $sp, 8 #adjust stack to delete 2 items
addi $v0, $zero, 1 #else return 1
jr $ra #jump back to calling routing
L1:
addi $a0, $a0, -1 #if n>=1 calculate n-1
jal fact #call fact with n-1
lw $a0, 0($sp) #return from jal, restore argument
lw $ra, 4($sp) #restore return address
mul $v0, $a0, $v0 # return n* fact(n-1)
Chapter 3 Assembly Languages

31. Chapter 3 Assembly Languages
int fact (int n)
{ if (n<2) return(1);
else return(n*fact(n-1); }
… fact(2);
Execution example
fact:
addi $sp, $sp, -8
sw $ra, 4($sp)
sw $a0, 0($sp)
slti $t0, $a0, 2
beq $t0, $zero, L1
addi $sp, $sp, 8
addi $v0, $zero, 1
jr $ra
L1:
addi $a0, $a0, -1
jal fact
lw $a0, 0($sp)
lw $ra, 4($sp)
mul $v0, $a0, $v0
Push
frame
Call fact (2) addi $a0, $zero, 2
(03A0) jal fact
$a0 2
n<2
ret 1 1
stack
03A4 ($ra)
2($a0)
$ra
03A4
(0340)
0344
0344 ($ra)
1($a0)
restore
$v0 1 2
n>=2
ret n*(n-1)!
Chapter 3 Assembly Languages

32. Chapter 3 Assembly Languages
32-bit constants
A register can contain an integer between (-231) and
Immediate data can be between (-215) and 32767
addi $t0, $zero, 32767
How can we use 32-bit constant?
lui (load upper immediate) instruction
Chapter 3 Assembly Languages

33. load upper immediate instruction: lui
Store 16-bit immediate data in the upper half of the register
lui $t0, # put in the upper half of $t0
To store a 32-bit constant in a register
add $t0, $zero, $zero
lui $t0, 16384
addi $t0, $t0, 5435
Chapter 3 Assembly Languages

34. Jumping to far-away instruction
In beq or bne instructions, only  215 distance can be specified.
To jump to further instructions
beq $t0, $t1, L1
...
L1:
j L2
L2:
Chapter 3 Assembly Languages

35. Memory Addressing Modes
direct
mem[address]
register indirect
mem[content[reg]]
mem[content[address]]
register indirect displacement
mem[content[reg]+displacement]
mem[content[address]+displacement]
register indirect index and displacement
Chapter 3 Assembly Languages

36. Chapter 3 Assembly Languages
MIPS Addressing Modes
Register addressing (R-format)
add $t0,$t1,$t2
Base (Displacement) addressing (I-format)
lw $t1, 12($t2)
Immediate addressing (J-format)
addi $t0, $t1, 34 op rs rt rd …
funct
register
memory op rs rt
address +
register op rs rt
Immediate data
Chapter 3 Assembly Languages

37. Chapter 3 Assembly Languages
MIPS Addressing Modes
PC-relative addressing (I-format)
beq $t0, $t1, label
Pseudo-direct addressing
j label
memory op rs rt
address + PC op
address : PC
Chapter 3 Assembly Languages