Professional Documents
Culture Documents
1. 2. 3. 4. Instructions and Addressing Procedures and Data Assembly Language Programs Instruction Set Variations
m 2 32 up to 2 30 words ...
Memory
Loc Loc m8 m4
EIU
(Main proc.)
$0 $1 $2
FPU
(Coproc. 1)
$0 $1 $2
Floatingpoint unit
$31
ALU
Integer mul/div
Hi Lo
FP arith TMU
$31
Figure 5.1
Instruction-Set Architecture
Data Types
MiniMIPS registers hold 32-bit (4-byte) words. Other common data sizes include byte, halfword, and doubleword.
Instruction-Set Architecture
$0 $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 $15 $16 $17 $18 $19 $20 $21 $22 $23 $24 $25 $26 $27 $28 $29 $30 $31
$zero $at $v0 $v1 $a0 $a1 $a2 $a3 $t0 $t1 $t2 $t3 $t4 $t5 $t6 $t7 $s0 $s1 $s2 $s3 $s4 $s5 $s6 $s7 $t8 $t9 $k0 $k1 $gp $sp $fp $ra
A 4-b yte word sits in consecutive memory addresses according to the big-endian order (most significant byte has the lowest address) Byte numbering:
3 2 1
3 2 1 0
Register Conventions
Temporary values
When loading a byte into a register, it goes in the low end Byte
Word Doublew ord
Operands
More temporaries Reserved for OS (kernel) Global pointer Stack pointer Frame pointer Return address
Saved
Instruction-Set Architecture
10 temporary registers
Temporary values
8 operand registers
Change Wallet
Keys
Operands
More temporaries
Figure 5.2
Instruction-Set Architecture
(partial)
Instruction Formats
High-level language statement: a = b + c
Register file
Register file
$17 $18
ALU
$24
Register readout
Operation
Data read/store
Register writeback
Figure 5.3
Instruction-Set Architecture
Decimal and hex constants Decimal Hexadecimal 25, 123456, 2873 0x59, 0x12b4c6, 0xffff0000
Machine instruction typically contains an opcode one or more source operands possibly a destination operand
Instruction-Set Architecture
31
25
rs
5 bits Source register 1
20
rt
5 bits Source register 2
15
rd
5 bits
10
sh
5 bits Shift amount
fn
6 bits Opcode extension
Destination register
15
31
op
6 bits Opcode
25
rs
5 bits Source or base
20
rt
5 bits
operand / offset
16 bits Imm ediate operand or address offset
Destination or data
31
op
6 bits Opcode
25
Figure 5.4 MiniMIPS instructions come in only three formats: register (R), immediate (I), and jump (J).
Instruction-Set Architecture
# # # # # #
rt
to to to to to to
10
op
rs
20
fn
0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 1 0 0 0 x 0 ALU instruction Source register 1 Source register 2 Destination register Unused add = 32 sub = 34
Figure 5.5 The arithmetic instructions add and sub have a format that is common to all two-operand ALU instructions. For these, the fn field specifies the arithmetic/logic operation to be performed.
Instruction-Set Architecture 10
Figure 5.6 Instructions such as addi allow us to perform an arithmetic or logic operation for which one operand is a small constant.
Instruction-Set Architecture
11
op
25
rs
20
rt
15
operand / offset
1 0 x 0 1 1 1 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 lw = 35 sw = 43 Base register Data register Offset relative to base Note on base and offset: The memory address is the sum of (rs ) and an immediate value. Calling one of these the base and the other the offset is quite arbitrary. It would make perfect sense to interpret the address A($s3) as having the base A and the offset ($s3). However, a 16-bit base confines us to a small portion of memory space.
Memory
A[0] A[1] A[2]
. . .
lw lw
$t0,40($s3) $t0,A($s3)
Address in base register
A[i]
Figure 5.7 MiniMIPS lw and sw instructions and their memory addressing convention that allows for simple access to array elements via a base address and an offset (offset = 4i leads us to the i th word).
Instruction-Set Architecture 12
31
op
25
rs
rt
15
operand / offset
Figure 5.8 The lui instruction allows us to load an arbitrary 16-bit value into the upper half of a register while setting its lower half to 0s.
Instruction-Set Architecture 13
Initializing a Register
Example 5.2 Show how each of these bit patterns can be loaded into $s0: 0010 0001 0001 0000 0000 0000 0011 1101 1111 1111 1111 1111 1111 1111 1111 1111 Solution The first bit pattern has the hex representation: 0x2110003d lui ori $s0,0x2110 $s0,0x003d # put the upper half in $s0 # put the lower half in $s0
Same can be done, with immediate values changed to 0xffff for the second bit pattern. But, the following is simpler and faster: nor $s0,$zero,$zero # because (0 0) = 1
Instruction-Set Architecture
14
verify $ra
op
# go to mem loc named verify # go to address that is in $ra; # $ra may hold a return address
25
31
0 0 0 0 1 0 j=2
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1
x x x x 0 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 From PC
(incremented) op
31
rs
20
rt
15
rd
10
sh
fn
Figure 5.9 The jump instruction j of MiniMIPS is a J-type instruction which is shown along with how its effective target address is obtained. The jump register (jr) instruction is R-type, with its specified register often being $ra.
Instruction-Set Architecture 15
op
25
rs
rt
15
operand / offset
0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 1 bltz = 1
31
Source
25
Zero
20
op
rs
rt
operand / offset
Instruction-Set Architecture
16
slt
$s1,$s2,$s3
slti
$s1,$s2,61
# # # # #
20
if ($s2)<($s3), set $s1 to 1 else set $s1 to 0; often followed by beq/bne if ($s2)<61, set $s1 to 1 else set $s1 to 0
15
31
op
25
rs
rt
rd
10
sh
fn
0 0 0 0 0 0 1 0 0 1 0 1 0 0 1 1 1 0 0 0 1 0 0 0 0 0 1 0 1 0 1 0 ALU instruction
31
Source 1 register
25
Source 2 register
20
Destination
Unused
slt = 42
op
rs
rt
15
operand / offset
Instruction-Set Architecture
17
Forming if-then constructs; e.g., if (i == j) x = x + y bne $s1,$s2,endif add $t1,$t1,$t2 endif: ... # branch on ij # execute the then part
If the condition were (i < j), we would change the first line to: slt beq $t0,$s1,$s2 $t0,$0,endif # set $t0 to 1 if i<j # branch if ($t0)=0; # i.e., i not< j or ij
18
Instruction-Set Architecture
Instruction-Set Architecture
19
Addressing Modes
Addressing Implied Instruction Other elements involved
Some place in the machine Extend, if required Reg spec Reg file Reg data
Operand
Immediate
Register
Base
Reg base
PC-relative
Constant offset
Incremented PC
Pseudodirect
PC
$t0,0($s1) $t1,$zero,0 $t1,$t1,1 $t1,$s2,done $t2,$t1,$t1 $t2,$t2,$t2 $t2,$t2,$s1 $t3,0($t2) $t4,$t0,$t3 $t4,$zero,loop $t0,$t3,0 loop
# # # # # # # # # #
initialize maximum to A[0] initialize index i to 0 increment index i by 1 if all elements examined, quit compute 2i in $t2 compute 4i in $t2 form address of A[i] in $t2 load value of A[i] into $t3 maximum < A[i]? if not, repeat with no change # if so, A[i] is the new
Usage
lui add sub slt addi slti and or xor nor andi ori xori lw sw j jr bltz beq bne rt,imm rd,rs,rt rd,rs,rt rd,rs,rt rt,rs,imm rd,rs,imm rd,rs,rt rd,rs,rt rd,rs,rt rd,rs,rt rt,rs,imm rt,rs,imm rt,rs,imm rt,imm(rs) rt,imm(rs) L rs rs,L rs,rt,L rs,rt,L
op fn
15 0 0 0 8 10 0 0 0 0 12 13 14 35 43 2 0 1 4 5 32 34 42 36 37 38 39
op
6 bits Opcode
25
rs
5 bits
20
rt
5 bits
15
rd
5 bits
10
sh
5 bits Shift amount
fn
6 bits Opcode extension
Source register 1
25
Source register 2
20
Destination register
15
31
op
6 bits Opcode
rs
5 bits Source or base
rt
5 bits
operand / offset
16 bits Immediate operand or address offset
Destination or data
31
op
6 bits Opcode
25
Control transfer
Table 5.1
Instruction-Set Architecture
Load upper immediate Add Subtract Set less than Add immediate Set less than immediate AND OR XOR NOR AND immediate OR immediate XOR immediate Load word Store word Jump Jump register Branch less than 0 Branch equal Branch not equal
22
MiniMIPS instructions for procedure call and return from procedure: jal proc # jump to loc proc and link; # link means save the return # address (PC)+4 in $ra ($31) # go to loc addressed by rs
jr
rs
Instruction-Set Architecture
24
Prepare to continue
Restore
jr $ra
Figure 6.1
Instruction-Set Architecture
25
$0 $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 $15 $16 $17 $18 $19 $20 $21 $22 $23 $24 $25 $26 $27 $28 $29 $30 $31
$zero $at $v0 $v1 $a0 $a1 $a2 $a3 $t0 $t1 $t2 $t3 $t4 $t5 $t6 $t7 $s0 $s1 $s2 $s3 $s4 $s5 $s6 $s7 $t8 $t9 $k0 $k1 $gp $sp $fp $ra
A 4-b yte word sits in consecutive memory addresses according to the big-endian order (most significant byte has the lowest address) Byte numbering:
3 2 1
3 2 1 0
Temporary values
When loading a byte into a register, it goes in the low end Byte
Word Doublew ord
Operands
More temporaries Reserved for OS (kernel) Global pointer Stack pointer Frame pointer Return address
Saved
Instruction-Set Architecture
26
|($a0)|
In practice, we seldom use such short procedures because of the overhead that they entail. In this example, we have 3-4 instructions of overhead for 3 instructions of useful computation.
Instruction-Set Architecture 27
PC
abc
Procedure xyz
Restore
jr $ra jr $ra
Figure 6.2
Instruction-Set Architecture
28
sp Push c
b a
sp
c b a
sp sp = sp 4 mem[sp] = c
b a
x = mem[sp] sp = sp + 4
Figure 6.4
push: addi sw
Instruction-Set Architecture
29
00000000 00400000
Reserved
Program
10000000 10008000 1000ffff
80000000
Stack
Stack segment
7ffffffc
z y . . .
$sp
c b a . . .
c b a . . .
Figure 6.5
Instruction-Set Architecture
31
$sp
# # # # #
put top stack element in $s0 put 2nd stack element in $ra restore $sp to original state restore $fp to original state return from procedure
Instruction-Set Architecture
32
Data Types
Data size (number of bits), data type (meaning assigned to bits) Signed integer: Unsigned integer: Floating-point number: Bit string: byte byte byte word word word word
doubleword doubleword
Instruction-Set Architecture
33
ASCII Characters
Table 6.1
0 1 2 3 4 5 6 7 8 9 a b c d e f 0 NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI
8-bit ASCII code (col #, row #)hex e.g., code for + is (2b) hex or (0010 1011)two
Instruction-Set Architecture
34
# # # # #
20
load rt with mem[8+($s3)] sign-extend to fill reg load rt with mem[8+($s3)] zero-extend to fill reg LSB of rt to mem[A+($s3)]
15
rs
rt
immediate / offset
Figure 6.6
Instruction-Set Architecture
35
Figure 6.7 A 32-bit word has no inherent meaning and can be interpreted in a number of equally valid ways in the absence of other cues (e.g., context) for the intended meaning.
Instruction-Set Architecture 36
A[i] A[i + 1]
A[i] A[i + 1]
Figure 6.8 Stepping through the elements of an array using the indexing method and the pointer updating method.
Instruction-Set Architecture 37
Selection Sort
Example 6.4
To sort a list of numbers, repeatedly perform the following: Find the max element, swap it with the last item, move up the last pointer
A
first first max x
A
first
Start of iteration
Maximum identified
End of iteration
Figure 6.9
Instruction-Set Architecture
38
A
first
In $a0 In $a1
last
In $v0
last
In $v1
y
Start of iteration
Maximum identified
End of iteration
# # # # # # # #
single-element list is sorted call the max procedure load last element into $t0 copy the last element to max loc copy max value to last element decrement pointer to last element repeat sort for smaller list continue with rest of program
Instruction-Set Architecture
39
Additional Instructions
MiniMIPS instructions for multiplication and division: mult div mfhi mflo $s0, $s1 $s0, $s1 $t0 $t0
31
# # # # #
rs
20
op
25
rd
10
sh
fn
0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 x 0 ALU instruction Source register 1 Source register 2 Unused Unused mult = 24 div = 26
Figure 6.10
R
op
25
rs
20
rt
15
rd
10
sh
fn
Figure 6.11 MiniMIPS instructions for copying the contents of Hi and Lo registers into general registers .
Instruction-Set Architecture
40
Logical Shifts
MiniMIPS instructions for left and right shifting: sll srl sllv srlv
31
# # # #
20
rs
rd
sh
fn
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 x 0 ALU instruction Unused Source register Destination register Shift amount sll = 0 srl = 2
31
op
ALU instruction
25
rs
Amount register
20
rt
Source register
15
rd
10
sh
Unused
fn
sllv = 4 srlv = 6
0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 1 x 0 Destination register
Figure 6.12
Instruction-Set Architecture
41
MiniMIPS instructions for unsigned arithmetic (no overflow exception): addu subu multu divu $t0,$s0,$s1 $t0,$s0,$s1 $s0,$s1 $s0,$s1 # # # # # # # # set $t0 to ($s0)+($s1) set $t0 to ($s0)($s1) set Hi,Lo to ($s0)($s1) set Hi to ($s0)mod($s1) and Lo to ($s0)/($s1) set $t0 to ($s0)+61; the immediate operand is sign extended
addiu $t0,$s0,61
To make MiniMIPS more powerful and complete, we introduce later: sra $t0,$s1,2 srav $t0,$s1,$s0 syscall # sh. right arith (Sec. 10.5) # shift right arith variable # system call (Sec. 7.6)
Instruction-Set Architecture
42
The 20 MiniMIPS Instructions from Chapter 6 (40 in all so far) Instruction op fn Usage
Copy
Move from Hi Move from Lo Add unsigned Subtract unsigned Multiply Multiply unsigned Divide Divide unsigned Add immediate unsigned Shift left logical Shift right logical Shift right arithmetic Shift left logical variable Shift right logical variable Shift right arith variable Load byte Load byte unsigned Store byte Jump and link System call mfhi rd mflo rd addu rd,rs,rt subu rd,rs,rt mult rs,rt multu rs,rt div rs,rt divu rs,rt addiu rs,rt,imm sll rd,rt,sh srl rd,rt,sh sra rd,rt,sh sllv rd,rt,rs srlv rt,rd,rs srav rd,rt,rd lb rt,imm(rs) lbu rt,imm(rs) sb rt,imm(rs) jal L syscall
Arithmetic
op
6 bits Opcode
25
rs
5 bits
20
rt
5 bits
15
rd
5 bits
10
sh
5 bits Shift amount
fn
6 bits Opcode extension
Source register 1
25
Source register 2
20
Destination register
15
31
op
6 bits Opcode
rs
5 bits Source or base
rt
5 bits
operand / offset
16 bits Immediate operand or address offset
Shift
Destination or data
31
op
6 bits Opcode
25
0 0 0 0 0 0 0 0 9 0 0 0 0 0 0 32 36 40 3 0
16 18 33 35 24 25 26 27 0 2 3 4 6 7
12
43
Usage
lui add sub slt addi slti and or xor nor andi ori xori lw sw j jr bltz beq bne rt,imm rd,rs,rt rd,rs,rt rd,rs,rt rt,rs,imm rd,rs,imm rd,rs,rt rd,rs,rt rd,rs,rt rd,rs,rt rt,rs,imm rt,rs,imm rt,rs,imm rt,imm(rs) rt,imm(rs) L rs rs,L rs,rt,L rs,rt,L
Instruction
Move from Hi Move from Lo Add unsigned Subtract unsigned Multiply Multiply unsigned Divide Divide unsigned Add immediate unsigned Shift left logical Shift right logical Shift right arithmetic Shift left logical variable Shift right logical variable Shift right arith variable Load byte Load byte unsigned Store byte Jump and link System call
Usage
mfhi mflo addu subu mult multu div divu addiu sll srl sra sllv srlv srav lb lbu sb jal rd rd rd,rs,rt rd,rs,rt rs,rt rs,rt rs,rt rs,rt rs,rt,imm rd,rt,sh rd,rt,sh rd,rt,sh rd,rt,rs rd,rt,rs rd,rt,rs rt,imm(rs) rt,imm(rs) rt,imm(rs) L
syscall
44
Assembler
Figure 7.1 Steps in transforming an assembly language program to an executable program residing in memory.
Instruction-Set Architecture 46
Loader
Linker
Memory content
Symbol Table
Assembly language program
addi sub add test: bne addi add j done: sw $s0,$zero,9 $t0,$s0,$s0 $t1,$zero,$zero $t0,$s0,done $t0,$t0,1 $t1,$s0,$zero test $t1,result($gp)
Location
0 4 8 12 16 20 24 28
Symbol table
28 248 12
Figure 7.2 An assembly-language program, its machine-language version, and the symbol table created during the assembly process.
Instruction-Set Architecture
47
Assembler Directives
Assembler directives provide the assembler with info on how to translate the program but do not lead to the generation of machine instructions
.macro .end_macro .text ... .data .byte 156,0x7a .word 35000 .float 2E-3 .double 2E-3 .align 2 .space 600 .ascii a*b .asciiz xyz .global main # # # # # # # # # # # # # # start macro (see Section 7.4) end macro (see Section 7.4) start programs text segment program text goes here start programs data segment name & initialize data byte(s) name & initialize data word(s) name short float (see Chapter 12) name long float (see Chapter 12) align next item on word boundary reserve 600 bytes = 150 words name & initialize ASCII string null-terminated ASCII string consider main a global name
Instruction-Set Architecture
48
Instruction-Set Architecture
Slide 49
Pseudoinstructions
Example of one-to-one pseudoinstruction: The following
not $s0 # complement ($s0)
Instruction-Set Architecture
50
MiniMIPS Pseudo-instructions
Pseudoinstruction Copy
Move Load address Load immediate Absolute value Negate Multiply (into register) Divide (into register) Remainder Set greater than Set less or equal Set greater or equal Rotate left Rotate right NOT Load doubleword Store doubleword Branch less than Branch greater than Branch less or equal Branch greater or equal
Usage
move la li abs neg mul div rem sgt sle sge rol ror not ld sd blt bgt ble bge regd,regs regd,address regd,anyimm regd,regs regd,regs regd,reg1,reg2 regd,reg1,reg2 regd,reg1,reg2 regd,reg1,reg2 regd,reg1,reg2 regd,reg1,reg2 regd,reg1,reg2 regd,reg1,reg2 reg regd,address regd,address reg1,reg2,L reg1,reg2,L reg1,reg2,L reg1,reg2,L
51
Arithmetic
Table 7.1
Shift Logic Memory access Control transfer
Instruction-Set Architecture
Macroinstructions
A macro is a mechanism to give a name to an often-used sequence of instructions (shorthand notation)
.macro name(args) ... .end_macro # macro and arguments named # instrs defining the macro # macro terminator
Instruction-Set Architecture
52
If the macro is used as mx3r($t0,$s0,$s4,$s3), the assembler replaces the arguments m, a1, a2, a3 with $t0, $s0, $s4, $s3, respectively.
Instruction-Set Architecture
Slide 53
Instruction-Set Architecture
54
Spim is a simulator that can run MiniMIPS programs The name Spim comes from reversing MIPS Three versions of Spim are available for free downloading: PCSpim xspim spim for Windows machines for X-windows for Unix systems
SPIM
A MIPS32 Simulator
James Larus larus@microsoft.com Microsoft Research
Formerly: Professor, CS Dept., Univ. Wisconsin-Madison
spim is a self-contained simulator that will run MIPS32 assembly language programs. It reads and executes assembly . . .
Instruction-Set Architecture
55
($v0) Function
1 Print integer Output Input Cntl 2 Print floating-point 3 Print double-float 4 Print string 5 Read integer 6 Read floating-point 7 Read double-float 8 Read string 9 Allocate memory 10 Exit from program
Instruction-Set Architecture
56
PCSpim
File Simulator Window Help
File
Open Sav e Log File Ex it
?
EPC = 00000000 Cause = 00000000 HI = 00000000 LO = 00000000 General Registers R8 (t0) = 0 R16 (s0) = 0 R24 R9 (t1) = 0 R17 (s1) = 0 R25
Registers
PC = 00400000 Status = 00000000 R0 R1 (r0) = 0 (at) = 0
Simulator
Clear Regis ters Reinitializ e Reload Go Break Continue Single Step Multiple Step ... Breakpoints ... Set Value ... Disp Symbol Table Settings ...
Text Segment
[0x00400000] [0x00400004] [0x00400008] [0x0040000c] [0x00400010] 0x0c100008 0x00000021 0x2402000a 0x0000000c 0x00000021 jal 0x00400020 [main] addu $0, $0, $0 addiu $2, $0, 10 syscall addu $0, $0, $0 ; ; ; ; ; 43 44 45 46 47
Data Segment
DATA [0x10000000] [0x10000010] [0x10000020] 0x00000000 0x6c696146 0x20206465 0x676e6974 0x44444120 0x6554000a 0x44412067 0x000a4944 0x74736554
Window
Tile 1 Messages 2 Tex t Segment 3 Data Segment 4 Regis ters 5 Console Clear Console Toolbar Status bar
Messages
See the file README for a full copyright notice. Memory and registers have been cleared, and the simulator rei D:\temp\dos\TESTS\Alubare.s has been successfully loaded
Figure 7.3
Instruction-Set Architecture
Status bar
57
op
6 bits Opcode
25
rs
5 bits
20
rt
5 bits
15
rd
5 bits
10
sh
5 bits Shift amount
fn
6 bits Opcode extension
Source register 1
25
Source register 2
20
Destination register
15
31
op
6 bits Opcode
rs
5 bits Source or base
rt
5 bits
operand / offset
16 bits Immediate operand or address offset
Destination or data
31
op
6 bits Opcode
25
Instruction-Set Architecture
59
Complex Instructions
Table 8.1 (partial) Examples of complex instructions in two popular modern microprocessors and two computer families of historical significance
Machine
Pentium
Instruction
MOVS
Effect
Move one element in a string of bytes, words, or doublewords using addresses specified in two pointer registers; after the operation, increment or decrement the registers to point to the next element of the string Count the number of consecutive 0s in a specified source register beginning with bit position 0 and place the count in a destination register Compare and swap: Compare the content of a register to that of a memory location; if unequal, load the memory word into the register, else store the content of a different register into the same memory location Polynomial evaluation with double flp arithmetic: Evaluate a polynomial in x, with very high precision in intermediate results, using a coefficient table whose location in memory is given within the instruction
PowerPC
cntlzd CS
IBM 360-370
Digital VAX
POLYD
Instruction-Set Architecture
60
cntlzd
(Count leading 0s)
6 leading 0s
Destination string
POLYD
(Polynomial evaluation in double floating-point) cn1xn1 + . . . + c2x2 + c1x + c0
Coefficients
MOVS
(Move string)
Instruction-Set Architecture
61
Fewer instructions in program (less memory) Fewer memory accesses for instructions Programs may become easier to write/read/understand Potentially faster execution (complex steps are still done sequentially in multiple cycles, but hardware control can be faster than software loops)
More complex format (slower decoding) Less flexible (one algorithm for polynomial evaluation or sorting may not be the best in all cases)
If interrupts are processed at the end of instruction cycle, machine may become less responsive to time-critical events (interrupt handling)
Instruction-Set Architecture
62
Operand
Immediate
Register
Base
Reg base
PC-relative
Constant offset
PC
Pseudodirect
PC
Usage
lui add sub slt addi slti and or xor nor andi ori xori lw sw j jr bltz beq bne rt,imm rd,rs,rt rd,rs,rt rd,rs,rt rt,rs,imm rd,rs,imm rd,rs,rt rd,rs,rt rd,rs,rt rd,rs,rt rt,rs,imm rt,rs,imm rt,rs,imm rt,imm(rs) rt,imm(rs) L rs rs,L rs,rt,L rs,rt,L
Instruction
Move from Hi Move from Lo Add unsigned Subtract unsigned Multiply Multiply unsigned Divide Divide unsigned Add immediate unsigned Shift left logical Shift right logical Shift right arithmetic Shift left logical variable Shift right logical variable Shift right arith variable Load byte Load byte unsigned Store byte Jump and link System call
Usage
mfhi mflo addu subu mult multu div divu addiu sll srl sra sllv srlv srav lb lbu sb jal rd rd rd,rs,rt rd,rs,rt rs,rt rs,rt rs,rt rs,rt rs,rt,imm rd,rt,sh rd,rt,sh rd,rt,sh rd,rt,rs rd,rt,rs rd,rt,rs rt,imm(rs) rt,imm(rs) rt,imm(rs) L
syscall
64
Instruction
Operand
Indirect
PC Memory Mem addr This part maybe replaced with any Mem addr, other form of address specif ication 2nd access
x := Mem[Mem[p]]
Figure 8.1 Schematic representation of more elaborate addressing modes not supported in MiniMIPS.
Instruction-Set Architecture 65
Indirect mode: Case statement case: lw add add la add lw jr $t0,0($s0) $t0,$t0,$t0 $t0,$t0,$t0 $t1,T $t1,$t0,$t1 $t2,0($t1) $t2 # # # # get s form 2s form 4s base T
# entry
Instruction-Set Architecture
66
Format
Opcode
12 syscall
Description of operand(s)
One implied operand in register $v0 Jump target addressed (in pseudodirect form) Two source registers addressed, destination implied Destination and two source registers addressed
j
24 mult 32 add
0 rs rt 0 rs rt rd
Figure 8.2 Examples of MiniMIPS instructions with 0 to 3 addresses; shaded fields are unused.
Instruction-Set Architecture
67
Polish string: a b + d c
If a variable is used again, you may have to push it multiple times Special instructions such as Duplicate and Swap are helpful
Instruction-Set Architecture
68
May have to store accumulator contents in memory (example above) No store needed for a + b + c + d + . . . (accumulator)
Instruction-Set Architecture
69
Two-Address Architectures
Two addresses may be used in different ways: Operand1/result and operand 2 Condition to be checked and branch target address Example: Evaluating the expression (a + b) (c d) load add load subtract multiply $1,a $1,b $2,c $2,d $1,$2
A variation is to use one of the addresses as in a one-address machine and the second one to specify a branch in every instruction
Instruction-Set Architecture
70
Opcode (1-2 B)
ModR/M
SIB
Instruction-Set Architecture
71
Opcode
PUSH JE MOV XOR ADD TEST
Description of operand(s)
3-bit register specification 4-bit condition, 8-bit jump offset 8-bit register/mode, 8-bit offset 8-bit register/mode, 8-bit base/index, 8-bit offset 3-bit register spec, 32-bit immediate 8-bit register/mode, 32-bit immediate
Figure 8.3 Example 80x86 instructions ranging in width from 1 to 6 bytes; much wider instructions (up to 15 bytes) also exist
Instruction-Set Architecture
72
Implementation
Performance objectives
?
Tuning & bug fixes Feedback
Figure 8.4
Instruction-Set Architecture
Instruction-Set Architecture
74
The RISC version of the architecture also: Reduces the effort and team size for design Shortens the testing and debugging phase Simplifies documentation and maintenance Cheaper product and shorter time-to-market
Instruction-Set Architecture
76
Instruction-Set Architecture
77
# # # # #
Instruction-Set Architecture
79
URISC Hardware
Word 1 Word 2
Source 2 / Dest
Word 3
Jump target
Source 1
C in
PC in
MDR in
MAR in Read
Write
Adder N in Z in
N Z
P C
M D R
M A R
Memory unit
R in
1 Mux 0
PCout
Figure 8.5
Instruction-Set Architecture
80