Lectures 3-4: MIPS Instructions: Motivation

Inf2C (Computer Systems) - 2008-2009 1
Lectures 3-4: MIPS instructions

! Motivation
Learn how a processors native language looks like
Discover the most important software-hardware
interface
Outline
! Instruction set
! Basic arithmetic & logic instructions
! Processor registers
! Getting data from the memory
! Control-flow instructions
! Method calls
Processor instructions
! Instruction set (IS): collection of all machine
instructions recognized by a particular
processor
! The instruction set abstracts away the hardware
details from the programmer
The same way as an object hides its implementation
details from its users
! Instruction Set Architecture (ISA): a generic
processor implementation that recognizes a
particular IS
RISC CISC machines
! There are many ways of defining the hardware-software
interface defined by the instruction set
Depends on how much work the hardware is allowed to do
! RISC=Reduced Instruction Set Computer
CISC=Complex Instruction Set Computer
! High-level language (HLL): a=b+10
Assembly language:
RISC:
CISC:
lw r4,0(r2) # r4=memory[r2+0]
add r5,r4,10 # r5=r4+10
sw r5,0(r3) # memory[r3+0]=r5
ADDW3 (R5),(R2),10
Assembly language
! Instructions are represented internally as binary
numbers
Very hard to make out which instruction is which
! Assembly language: symbolic representation of
machine instructions
! We use the MIPS IS, typical of a RISC processor
Arithmetic & logical operations
! Data processing instructions look like:
operation destination var, 1
st
operand, 2
nd
operand
add a,b,c a = b+c
sub a,b,c a = bc
! Bit-wise logical instructions: and, or, xor
! Shift instructions:
sll a,b,shamt a = b << shamt
srl a,b,shamt a = b >> shamt, logical shift
Registers
! IS places restrictions on instruction operands
! RISC processors operate on registers only
! Registers are internal storage locations holding
program variables
! Size of register equals the machines word
! There is a relatively small number of registers
present; MIPS has 32
MIPS general-purpose registers
! Generally, any register available for any use
! Conventions exist for enabling code portability
! Java variables held in registers $s0 $s7
! Temporary variables: $t0 $t9
! Register 0 ($zero) is hardwired to 0
! Other registers with special roles
! Program Counter (PC) holds address of next
instruction to be executed
Not one of the general purpose registers
Immediate operands
! MIPS has instructions with one constant
(immediate) operand, e.g.
addi r1,r2,n # r1=r2+n
addi $s0,$zero,n # $s0=n ($s0
15-0
=n; $s0
31-16
=0)
lui $s1,n1 # $s1
15-0
=0; $s1
31-16
=n1
ori $s1,$s1,n2 # $s1
15-0
=n2; $s1
31-16
=n1
! Load a (small) constant into a register:
! Assembler pseudo-instruction li reg,constant
Translated into 1 instruction for immediates < 16bits
and to more instructions for more complicated
cases e.g. for a 32-bit immediate
Getting at the data
! Java:
! MIPS:
($s2 points to base of myObj)
Class MyClass {
int var1,var2;
}

myObj = new MyClass( )

temp = myObj.var2
lw $t1,4($s2) # $t1=memory[4+$s2]
offset of
var2 within myObj
$s2
4
8
2
30

0
32 bits
var1
var2
Data-transfer instructions
! Load Word:
! Store Word:
! Load Byte:
! Store Byte:
lw r1,n(r2) # r1=memory[n+r2]
sw r1,n(r2) # memory[n+r2]=r1
base address
offset
lb r1,n(r2) # r1
7-0
= memory[n+r2]
r1
31-8
= sign extension
sb r1,n(r2) # memory[n+r2]=r1
7-0

no sign extension
Memory addressing
! Memory is byte addressable, but it is organised
so that a word can be accessed directly
! Where can a word be stored?
Anywhere (unaligned), or at an mult. 4 address (aligned)?
! Which is the address of a word?
byte0 byte1 byte2 byte3
0 1 2 3
bit 0 bit 31
Big Endian
word 4
4 5 6 7
byte3 byte2 byte1 byte0
3 2 1 0
bit 0 bit 31
Little Endian
word 4
7 6 5 4
Instruction formats
! Instruction representation composed of bit-fields
! Similar instructions have the same format
! MIPS instruction formats:
R-format (add, sub, )
op
31 26 21 16 0
rs rt immediate
op
31 26 21 16 11 6 0
rs rt rd shamt
Main
opcode
1st
operand
2nd
operand
result shift sub-function
opcode
func
result
I-format (addi, lw, sw, )
1st
operand
MIPS instructions part 2
! Last time:
Data processing instructions: add, sub, and,
! Registers only and immediate types
Data transfer instructions: lw, sw, lb, sb
Instruction encoding
! Today:
Control transfer instructions
Control transfers: If structures
Java:
MIPS:
branch if equal: compare value in $s1 with value in $s2
and if equal then branch to instruction marked label
if (i!=j)
stmnt1
else
stmnt2
stmnt3
beq $s1,$s2,label1
stmnt1
j label2 # skip stmnt2
label1: stmnt2
label2: stmnt3
if case
else case
follow through
beq $s1,$s2,label
Control transfer instructions
! Conditional branches, I-format:
In assembly code label is usually a string
In machine code label is obtained from immediate
value as: branch target = PC + 4 * offset
! Similarly:
! Unconditional jump, J-format: j label
beq r1,r2,label
bne r1,r2,label # if r1!=r2 go to label
4
31 26 21 16 0
r1 r2 offset
2
31 26 0
target
Loops in assembly language
! Java:
! MIPS:
! Java:
! MIPS:
while (count!=0) stmnt
loop: beq $s1,$zero,end # $s1 holds count
stmnt
j loop # branch back to loop
end:
while (flag1 && flag2) stmnt
loop: beq $s1,$zero,end # $s1 holds flag1
beq $s2,$zero,end # $s2 holds flag2
stmnt
j loop # branch back to loop
end:
Comparisons
! Set if less than (R-format):
set r1 to 1 if r2<r3, otherwise set r1 to 0
! Java:
! MIPS example:
assume that $s1 contains i and $s2 contains j
while (i > j) stmnt
loop: slt $t0,$s2,$s1 # $t0 = (i > j)
beq $t0,$zero,end # true if i <= j
stmnt
j loop # jump back to loop
end:
slt r1,r2,r3
Method calls
! Method calls are essential even for a small program
! Most processors provide support for method calls
! Java:

foo();

foo();

call to foo at line L1
call to foo at line L2
void foo() {

return;
}
where do we return to?
MIPS support for method calls
! Jumping into the method:
jump and link: set $ra to PC+4 and set PC to label
Another J-format instruction
! Returning:
jump register: set PC to value in register r1
jal label
jr r1
Using a stack for method calls
! Nested calls ! must save return address to prevent
overwriting. Solution: use a stack in memory
! to push a word:
! to pop a word:
call A

call B

call C
addi $sp,$sp,-4 # move sp down
sw $ra,0($sp) # save r1 on top of stack
sp
(stack
pointer)
C
B
A
lw $ra,0($sp) # fetch value from stack
addi $sp,$sp,4 # move sp up
Addr
Other uses of the stack
! Stack used to save callers registers, so that they
can be used by the callee
caller save or callee save convention
! Stack can also be used to pass and return
parameters
MIPS uses $a0 $a4 for the first 4 word-length
parameters, and $v0, $v1 for return values
return address
(caller context)
parameters

Lectures 3-4: MIPS Instructions: Motivation

Uploaded by

Copyright:

Available Formats

Lectures 3-4: MIPS Instructions: Motivation

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lectures 3-4: MIPS Instructions: Motivation

Uploaded by

Copyright:

Available Formats

Inf2C (Computer Systems) - 2008-2009 1

Lectures 3-4: MIPS instructions

You might also like