Chapter-2 ISA Reduced
Chapter-2 ISA Reduced
RISC-V
Edition
The Hardware/Software Interface
Chapter 2
Instructions: Language
of the Computer
Instruction Set
§2.1 Introduction
The repertoire of instructions of a
computer
Different computers have different
instruction sets
But with many aspects in common
Early computers had very simple
instruction sets
Simplified implementation
Many modern computers also have simple
instruction sets
2
The RISC-V Instruction Set
Used as the example throughout the book
Developed at UC Berkeley as open ISA
Now managed by the RISC-V Foundation
(riscv.org)
Typical of many modern ISAs
See RISC-V Reference Data tear-out card
Similar ISAs have a large share of embedded
core market
Applications in consumer electronics, network/storage
equipment, cameras, printers, …
3
Arithmetic Operations
4
Arithmetic Example
C code:
f = (g + h) - (i + j);
Compiled RISC-V code:
add t0, g, h // temp t0 = g + h
add t1, i, j // temp t1 = i + j
add f, t0, t1 // f = t0 - t1
5
Register Operands
6
RISC-V Registers
x0: the constant value 0
x1: return address
x2: stack pointer
x3: global pointer
x4: thread pointer
x5 – x7, x28 – x31: temporaries
x8: frame pointer
x9, x18 – x27: saved registers
x10 – x11: function arguments/results
x12 – x17: function arguments
7
Register Operand Example
C code:
f = (g + h) - (i + j);
f, …, j in x19, x20, …, x23
8
Memory Operands
Main memory used for composite data
Arrays, structures, dynamic data
To apply arithmetic operations
Load values from memory into registers
Store result from register to memory
Memory is byte addressed
Each address identifies an 8-bit byte
RISC-V is Little Endian
Least-significant byte at least address of a word
c.f. Big Endian: most-significant byte at least address
RISC-V does not require words to be aligned in
memory
Unlike some other ISAs
9
Memory Operand Example
C code:
A[12] = h + A[8];
h in x21, base address of A in x22
ld x9, 64(x22)
add x9, x21, x9
sd x9, 96(x22)
10
Registers vs. Memory
Registers are faster to access than
memory
Operating on memory data requires loads
and stores
More instructions to be executed
Compiler must use registers for variables
as much as possible
Only spill to memory for less frequently used
variables
Register optimization is important!
11
Immediate Operands
Constant data specified in an instruction
addi x22, x22, 4
12
Unsigned Binary Integers
Range: 0 to +2n – 1
Example
0000 0000 … 0000 10112
= 0 + … + 1×23 + 0×22 +1×21 +1×20
= 0 + … + 8 + 0 + 2 + 1 = 1110
Using 64 bits: 0 to +18,446,774,073,709,551,615
13
2s-Complement Signed Integers
Given an n-bit number
14
2s-Complement Signed Integers
Bit 63 is sign bit
1 for negative numbers
0 for non-negative numbers
–(–2n – 1) can’t be represented
Non-negative numbers have the same unsigned
and 2s-complement representation
Some specific numbers
0: 0000 0000 … 0000
–1: 1111 1111 … 1111
Most-negative: 1000 0000 … 0000
Most-positive: 0111 1111 … 1111
15
Signed Negation
Complement and add 1
Complement means 1 → 0, 0 → 1
Example: negate +2
+2 = 0000 0000 … 0010two
–2 = 1111 1111 … 1101two + 1
= 1111 1111 … 1110two
16
Sign Extension
Representing a number using more bits
Preserve the numeric value
Replicate the sign bit to the left
c.f. unsigned values: extend with 0s
Examples: 8-bit to 16-bit
+2: 0000 0010 => 0000 0000 0000 0010
–2: 1111 1110 => 1111 1111 1111 1110
17
Representing Instructions
RISC-V instructions
Encoded as 32-bit instruction words
Small number of formats encoding operation code
(opcode), register numbers, …
Regularity!
18
Hexadecimal
Base 16
Compact representation of bit strings
4 bits per hex digit
19
RISC-V R-format Instructions
funct7 rs2 rs1 funct3 rd opcode
7 bits 5 bits 5 bits 3 bits 5 bits 7 bits
Instruction fields
opcode: operation code
rd: destination register number
funct3: 3-bit function code (additional opcode)
rs1: the first source register number
rs2: the second source register number
funct7: 7-bit function code (additional opcode)
20
R-format Example
funct7 rs2 rs1 funct3 rd opcode
7 bits 5 bits 5 bits 3 bits 5 bits 7 bits
add x9,x20,x21
0 21 20 0 9 51
21
RISC-V I-format Instructions
immediate rs1 funct3 rd opcode
12 bits 5 bits 3 bits 5 bits 7 bits
22
RISC-V S-format Instructions
imm[11:5] rs2 rs1 funct3 imm[4:0] opcode
7 bits 5 bits 5 bits 3 bits 5 bits 7 bits
23
Stored Program Computers
The BIG Picture Instructions represented in
binary, just like data
Instructions and data stored
in memory
Programs can operate on
programs
e.g., compilers, linkers, …
Binary compatibility allows
compiled programs to work
on different computers
Standardized ISAs
24
Logical Operations
26
AND Operations
Useful to mask bits in a word
Select some bits, clear others to 0
and x9,x10,x11
27
OR Operations
Useful to include bits in a word
Set some bits to 1, leave others unchanged
or x9,x10,x11
28
XOR Operations
Differencing operation
Set some bits to 1, leave others unchanged
xor x9,x10,x12 // NOT operation
29
Conditional Operations
30
Compiling If Statements
C code:
if (i==j) f = g+h;
else f = g-h;
f, g, … in x19, x20, …
32
Basic Blocks
A basic block is a sequence of instructions
with
No embedded branches (except at end)
No branch targets (except at beginning)
33
More Conditional Operations
blt rs1, rs2, L1
if (rs1 < rs2) branch to instruction labeled L1
bge rs1, rs2, L1
if (rs1 >= rs2) branch to instruction labeled L1
Example
if (a > b) a += 1;
a in x22, b in x23
bge x23, x22, Exit // branch if b >= a
addi x22, x22, 1
Exit:
34
Signed vs. Unsigned
Signed comparison: blt, bge
Unsigned comparison: bltu, bgeu
Example
x22 = 1111 1111 1111 1111 1111 1111 1111 1111
x23 = 0000 0000 0000 0000 0000 0000 0000 0001
x22 < x23 // signed
–1 < +1
x22 > x23 // unsigned
+4,294,967,295 > +1
35
Procedure Calling
36
Procedure Call Instructions
Procedure call: jump and link
jal x1, ProcedureLabel
Address of following instruction put in x1
37
Leaf Procedure Example
C code:
long long int leaf_example (
long long int g, long long int h,
long long int i, long long int j) {
long long int f;
f = (g + h) - (i + j);
return f;
}
Arguments g, …, j in x10, …, x13
f in x20
temporaries x5, x6
38
Leaf Procedure Example
RISC-V code:
leaf_example:
addi sp,sp,-24
Save x5, x6, x20 on stack
sd x5,16(sp)
sd x6,8(sp)
sd x20,0(sp)
add x5,x10,x11
add x6,x12,x13 x5 = g + h
sub x20,x5,x6
addi x10,x20,0 x6 = i + j
ld x20,0(sp) f = x5 – x6
ld x6,8(sp) copy f to return register
ld x5,16(sp) Resore x5, x6, x20 from stack
addi sp,sp,24
jalr x0,0(x1)
Return to caller
39
Local Data on the Stack
40
Register Usage
x5 – x7, x28 – x31: temporary registers
Not preserved by the callee
41
Non-Leaf Procedures
Procedures that call other procedures
For nested call, caller needs to save on
the stack:
Its return address
Any arguments and temporaries needed after
the call
Restore from the stack after the call
42
Non-Leaf Procedure Example
C code:
long long int fact (long long int n)
{
if (n < 1) return (1);
else return n * fact(n - 1);
}
Argument n in x10
Result in x10
43
Leaf Procedure Example
RISC-V code:
fact:
addi sp,sp,-16 Save return address and n on stack
sd x1,8(sp)
sd x10,0(sp)
addi x5,x10,-1
bge x5,x0,L1 x5 = n - 1
addi x10,x0,1 if n >= 1, go to L1
addi sp,sp,16
Else, set return value to 1
jalr x0,0(x1)
L1: addi x10,x10,-1 Pop stack, don’t bother restoring values
jal x1,fact Return
addi x6,x10,0 n=n-1
ld x10,0(sp) call fact(n-1)
ld x1,8(sp)
addi sp,sp,16 move result of fact(n - 1) to x6
mul x10,x10,x6 Restore caller’s n
jalr x0,0(x1) Restore caller’s return address
Pop stack
return n * fact(n-1)
return
44
Memory Layout
Text: program code
Static data: global
variables
e.g., static variables in C,
constant arrays and strings
x3 (global pointer)
initialized to address
allowing ±offsets into this
segment
Dynamic data: heap
E.g., malloc in C, new in
Java
Stack: automatic storage
45
Local Data on the Stack
46
Byte/Halfword/Word Operations
RISC-V byte/halfword/word load/store
Load byte/halfword/word: Sign extend to 64 bits in rd
lb rd, offset(rs1)
lh rd, offset(rs1)
lw rd, offset(rs1)
Load byte/halfword/word unsigned: Zero extend to 64 bits in rd
lbu rd, offset(rs1)
lhu rd, offset(rs1)
lwu rd, offset(rs1)
Store byte/halfword/word: Store rightmost 8/16/32 bits
sb rs2, offset(rs1)
sh rs2, offset(rs1)
sw rs2, offset(rs1)
47
String Copy Example
C code:
Null-terminated string
void strcpy (char x[], char y[])
{ size_t i;
i = 0;
while ((x[i]=y[i])!='\0')
i += 1;
}
48
String Copy Example
RISC-V code:
strcpy:
addi sp,sp,-8 // adjust stack for 1 doubleword
sd x19,0(sp) // push x19
add x19,x0,x0 // i=0
L1: add x5,x19,x10 // x5 = addr of y[i]
lbu x6,0(x5) // x6 = y[i]
add x7,x19,x10 // x7 = addr of x[i]
sb x6,0(x7) // x[i] = y[i]
beq x6,x0,L2 // if y[i] == 0 then exit
addi x19,x19, 1 // i = i + 1
jal x0,L1 // next iteration of loop
L2: ld x19,0(sp) // restore saved x19
addi sp,sp,8 // pop 1 doubleword from stack
jalr x0,0(x1) // and return
49
32-bit Constants
50
Branch Addressing
Branch instructions specify
Opcode, two registers, target address
Most branch targets are near branch
Forward or backward
SB format:
imm imm
[10:5] rs2 rs1 funct3 [4:1] opcode
imm[12] imm[11]
PC-relative addressing
Target address = PC + immediate × 2
51
Jump Addressing
Jump and link (jal) target uses 20-bit
immediate for larger range
UJ format:
imm[10:1] imm[19:12] rd opcode
5 bits 7 bits
imm[20] imm[11]
52
RISC-V Addressing Summary
53
RISC-V Encoding Summary
54
RISC-V Instruction Set
55
RISC-V Arithmetic Instructions
56
RISC-V Logic Instructions
57
RISC-V Branch and Jump Instructions
58
RISC-V Load/Store Instructions
59
Other RISC-V Instructions
60
Fallacies
61
Concluding Remarks
62