Embed Size (px)
Citation preview
1
Introduction to MIPS Processor
• The processor we will be considering in this tutorial is the MIPS processor.
• The MIPS processor, designed in 1984 by researchers at Stanford University, is
a RISC (Reduced Instruction Set Computer) processor. Compared with
their CISC (Complex Instruction Set Computer) counterparts (such as the Intel Pentium
processors), RISC processors typically support fewer and much simpler instructions.
• RISC processor can be made much faster than a CISC processor because of its simpler
design. • These days, it is generally accepted that RISC processors are more efficient than CISC
processors; and even the only popular CISC processor that is still around (Intel Pentium)
internally translates the CISC instructions into RISC instructions before they are
executed. • MARS is MIPS assembler and simulator.
• It runs on Windows, OSX, and Linux; just make sure that you have the Java J2SE 1.5 (or
later) SDK installed on your computer.
• Some MIPS instructions don’t have direct hardware implementations.
• MIPS assembler recognizes them and translate them to sequence of MIPS True
instructions
• MIPS Pseudo Instruction: A MIPS instruction that does not turn directly into a machine
language instruction, but into other MIPS instructions
Register Move
move reg2,reg1
Expands to:
add reg2,$zero,reg1 • The MIPS family provides instructions to perform the following operations:
Load registers with values, either from RAM or with literal values.
Store register values (i.e. copy them) out to RAM locations.
Basic integer arithmetic: add, subtract, multiply, divide with remainder.
Basic floating-point arithmetic: add, subtract, multiply, divide.
Logical operations: AND, OR, NOT, exclusive OR (XOR).
Shift operations: shift left, shift right.
Comparison operations: ==, !=, <, >, <=, >=
Instructions to change the flow of control: relative branches and jumps.
The basic structure of a MIPS assembly language program is:
Data section, where your variables and their data sizes are named. The assembler will
choose where in RAM to store your variables. The data section is identified by a line with
the assembler directive
.data
Code section, which contains your assembly language instructions. The code section is
identified by a line with the assembler directive
2
.text
Your code section must contain a starting point for your program's execution, marked by
the label
main:
and your main code must end with a call to the exit system call, which tells the CPU to
stop the program.
3
4
•
5
Instruction Set
6
Supported Syscalls by MARS
System calls are asking OS to perform services syscall:
o checks $v0 for the type of the service o the arguments (if any) are passed in $a0 - $a3
7
MIPS Assembly Language Overview
Data representation
We cannot refer to individual bits Addressable groups in MIPS:
o byte - 8 bits o word - 4 bytes = 32 bits o halfword - 2 bytes = 16 bits
Two's complement representation
To represent a negative number:
1. start with the positive binary representation
2. invert every bit
3. add 1 to the result Examples with 4-bit integers:
-1 == 0001 ==> 1110 ==> 1111
-4 == 0100 ==> 1011 ==> 1100
-7 == 0111 ==> 1000 ==> 1001
9. Sign extension
To change the size of an integer without changing its value o if positive (left-most bit 0), pad left with 0s o if negative (left-most bit 1), pad left with 1s
12. Assembly program template
Data and code segments
# comment
.data
# constant and variable definitions go here
.text
# assembly instructions go here
8
16. MIPS register names and conventions
Number Name Usage Preserved?
------ ------- ----------------------- ----------
$0 $zero constant 0x00000000 N/A
$1 $at assembler temporary No
$2-$3 $v0-$v1 function return values No
$4-$7 $a0-$a3 function arguments No
$8-$15 $t0-$t7 temporaries No
$16-$23 $s0-$s7 saved temporaries Yes
$24-$25 $t8-$t9 more temporaries No
$26-$27 $k0-$k1 reserved for OS kernel N/A
$28 $gp global pointer Yes
$29 $sp stack pointer Yes
$30 $fp frame pointer Yes
$31 $ra return address Yes
Assembly program example
.eqv SYSCALL_PRINT_STRING 4
.eqv SYSCALL_EXIT_PROG 10
.data # data segment begins
# Define a greeting message:
Message: .asciiz "Hello World!\n"
.text
# Print the greeting message:
li $v0, SYSCALL_PRINT_STRING
la $a0, Message
syscall # print string
# Return to the operating system:
li $v0, SYSCALL_EXIT_PROG
syscall # exit program
Integer Multiplication
Result of multiplication is a 64-bit number, stored in two 32-bit registers named "hi" and "lo"
# Instruction # Meaning in pseudocode
mult $t1, $t2 # hi,lo = $t1 * $t2
mflo $t0 # $t0 = lo
mfhi $t3 # $t3 = hi
9
There is a shortcut (macro instruction):
mul $t0, $t1, $t2 # hi,lo = $t1 * $t2; $t0 = lo
which expands to:
mult $t1, $t2
mflo $t0
Integer Division
Computes quotient and remainder. Simultaneously stores quotient in "lo" and remainder in "hi"
# Instruction # Meaning in pseudocode
div $t1, $t2 # lo = $t1 / $t2; hi = $t1 % $t2
mflo $t0 # $t0 = lo quotient
mfhi $t3 # $t3 = hi remainder
Reading from data memory
Basic instruction to read integer from memory is called load word
lw $t1, 4($t2) # $t1 = Memory[$t2+4]
Here, $t2 contains the base address, and 4 is the offset
Note that there is a shortcut:
lw $t1, 0($t2)
lw $t1, $t2 # the same
lw $t1, label # $t1 = Memory[label]
lw $t1, label + 4 # $t1 = Memory[label+4]
Writing to data memory
Basic instruction to write integer to memory is called store word
sw $t1, 4($t2) # Memory[$t2+4] = $t1
$t2 contains the base address
4 is the offset
10
Shortcuts:
sw $t1, 0($t2)
sw $t1, $t2 # the same
sw $t1, label # Memory[label] = $t1
sw $t1, label + 4 # Memory[label+4] = $t1
Expression and Assembly example
# Pseudocode:
# c = (a+3) * (b-2) + a
# Register mappings:
# a: $t0, b: $t1, c: $t2
# tmp1: $t3, tmp2: $t4, tmp3: $t5
addi $t3, $t0, 3 # tmp1 = a+3
subi $t4, $t1, 2 # tmp2 = b-2
mul $t5, $t3, $t4 # tmp3 = tmp1 * tmp2
add $t2, $t5, $t0 # c = tmp3 + a
Example adding three numbers
# Add three numbers in memory and print the result
.data
# string to print before the result
STR_PROMPT: .asciiz "Result: "
# numbers to add
nums: .word -77, 13, -5 # numbers to add
result: .word 0 # result
.text
# print the initial string
li $v0, 4 # ask for print string service
la $a0, STR_PROMPT
syscall
# load three numbers into registers
la $t0, nums
lw $t1, 0($t0) # lw $t1, nums
lw $t2, 4($t0) # lw $t2, nums + 4
lw $t3, 8($t0) # lw $t3, nums + 8
# add and store the result in $a0 for printing
add $a0, $t1, $t2 # add the first two numbers
add $a0, $a0, $t3 # add the third to the sum
# save a0 in memory
sw $a0, result
# print the result
li $v0, 1 # ask for $a0 print service
11
syscall
# exit
li $v0, 10 # ask for exit service
syscall
Bitwise logic operations
and $t1, $t2, $t3 # $t1 = $t2 & $t3 (bitwise and)
or $t1, $t2, $t3 # $t1 = $t2 | $t3 (bitwise or)
xor $t1, $t2, $t3 # $t1 = $t2 ^ $t3 (bitwise xor)
Immediate formats
andi $t1, $t2, 0x0F # $t1 = $t2 & 0x0F (bitwise and)
ori $t1, $t2, 0xF0 # $t1 = $t2 | 0xF0 (bitwise or)
xori $t1, $t2, 0xFF # $t1 = $t2 ^ 0xFF (bitwise xor)
Bitwise examples
1 0 1 0
and 0 0 1 1
-------
0 0 1 0
1 0 1 0
or 0 0 1 1
-------
1 0 1 1
1 0 1 0
xor 0 0 1 1
-------
1 0 0 1
Logical expressions
seq $t1, $t2, $t3 # $t1 = $t2 == $t3 ? 1 : 0
sne $t1, $t2, $t3 # $t1 = $t2 != $t3 ? 1 : 0
sge $t1, $t2, $t3 # $t1 = $t2 >= $t3 ? 1 : 0
sgt $t1, $t2, $t3 # $t1 = $t2 > $t3 ? 1 : 0
sle $t1, $t2, $t3 # $t1 = $t2 <= $t3 ? 1 : 0
slt $t1, $t2, $t3 # $t1 = $t2 < $t3 ? 1 : 0
MARS Immediate formats:
slti $t1, $t2, 42 # $t1 = $t2 < 42 ? 1 : 0
12
...and so on...
Logical expression example 1
# Pseudocode:
# c = ( a < b ) || ( ( a + b ) == 10 )
# Register mappings:
# a: t0
# b: t1
# c: t2
add $t3, $t0, $t1 # tmp = a+b
li $t4, 10 # tmp = tmp == 10
seq $t3, $t3, $t4
slt $t2, $t0, $t1 # c = a < b
or $t2, $t2, $t3 # c = c | tmp
Logical expression example 2
# Pseudocode:
# c = (a < b) && ((a+b) % 3) == 2
# Register mappings:
# a: t0, b: t1, c: t2
# tmp1: t3, tmp2: t4
add $t3, $t0, $t1 # tmp1 = a+b
li $t4, 3 # tmp1 = tmp1 % 3
div $t3, $t4
mfhi $t3
seq $t3, $t3, 2 # tmp1 = tmp1 == 2
slt $t4, $t0, $t1 # tmp2 = a < b
and $t2, $t3, $t4 # c = tmp2 & tmp1
Conditional jumps
# Basic instructions
beq $t1, $t2, label # if ($t1 == $t2) goto label
bne $t1, $t2, label # if ($t1 != $t2) goto label
bgez $t1, label # if ($t1 >= 0) goto label
bgtz $t1, label # if ($t1 > 0) goto label
blez $t1, label # if ($t1 <= 0) goto label
bltz $t1, label # if ($t1 < 0) goto label
# Macro instructions
beqz $t1, label # if ($t1 == 0) goto label
bnez $t1, label # if ($t1 != 0) goto label
beq $t1, 123, label # if ($t1 == 123) goto label
bne $t1, 123, label # if ($t1 != 123) goto label
bge $t1, $t2, label # if ($t1 >= $t2) goto label
bgt $t1, $t2, label # if ($t1 > $t2) goto label
13
bge $t1, 123, label # if ($t1 >= 123) goto label
bgt $t1, 123, label # if ($t1 > 123) goto label
ble ... # similar
blt ... # similar
Conditional jump example 1
# Pseudocode:
# if (a < b + 3)
# a = a + 1
# else
# a = a + 2
# b = b + a
# Register mappings:
# a: $t0, b: $t1
addi $t2, $t1, 3 # tmp = b + 3
blt $t0, $t2, ifless # if (a < tmp)
addi $t0, $t0, 2 # otherwise a = a + 2
j finish
ifless:
addi $t0, $t0, 1 # if true, a = a + 1
finish:
add $t1, $t1, $t0 # b = b + a
Conditional jump example 2
# Pseudocode:
# if (a < b + 3)
# a = a + 1
# b = b + a
# Register mappings:
# a: $t0, b: $t1
# One implementation
addi $t2, $t1, 3 # tmp = b + 3
blt $t0, $t2, ifless # if (a < tmp)
j finish
ifless:
addi $t0, $t0, 1 # if true, a = a + 1
finish:
add $t1, $t1, $t0 # b = b + a
# Another implementation
addi $t2, $t1, 3 # tmp = b + 3
bge $t0, $t2, finish # if (a >= tmp) goto finish
addi $t0, $t0, 1 # a + 1
finish:
add $t1, $t1, $t0 # b = b + a
14
while loop example
# Translate to lower-level pseudocode:
# sum = 0
# i = 0
# while (i < n) {
# sum = sum + i
# i = i + 1
# }
li $t2, 0 # sum = 0
li $t1, 0 # i = 0
loop:
bge $t1, $t0, endloop # Loop begins: if i >= n goto endloop
add $t2, $t2, $t1 # sum = sum + i
addi $t1, $t1, 1 # i = i + 1
j loop
endloop:
Pipelining
Goal: execute programs faster How:
o separate processor into stages o overlap the execution of consecutive instructions
MIPS is designed for pipelining
Pipelining – non pipelining
15
MIPS Instruction pipelining
Pipeline stages:
1. IF - Instruction Fetch
2. ID - Instruction Decode
3. EX - EXecute
4. ME - MEmory access
5. WB - Write Back
MIPS Instruction pipeline example
Pipeline Hazards
Hazard is a dependency that breaks pipelining o Data hazard program needs a value that has not been computed yet
16
o Control hazard program does not know which instruction is next
Data hazard example:
add $t1, $t2, $t3 # IF ID EX ME WB-$t1 is set here
addi $t4, $t1, 1 # IF ID-$t1 is read here EX ME WB
Solution 1: processor inserts delays
add $t1, $t2, $t3 # IF ID EX ME WB-$t1 is set here
addi $t4, $t1, 1 # IF XX XX XX ID-$t1 is read here EX ME WB
Solution 2: processor reorders instructions to avoid data hazards
Examples
Take 2 numbers from user and print the sum of them
1
Swap numbers
1
Print 2 different strings
17
Addition, subtract, multiplication, division
Read from memory using loop
