Instructions Language of the...
Transcript of Instructions Language of the...
-
Instructions – Language of the Computer
Alexander Nelson
January 20, 2021
University of Arkansas - Department of Computer Science and Computer Engineering
-
The really decisive considerations from the
present point of view, in selecting a code, are
of a more practical nature: simplicity of the
equipment demanded by the code, and the
clarity of its application to the actually
important problems together with the speed
of its handling those problems.
-Arthur Burks, Herman Goldstine, von
Neumann
0
-
Instructions & Instruction Set
Instructions – individual words sent to a computer
Instruction Set – Vocabulary available to the computer
Each computer could have own instruction set
However
Basic underlying principles inform their development
Most instruction set architectures support similar vocabularies
1
-
Instruction & Instruction Set
Goal of instruction set – enable complex behavior through simple
equipment
We will primarily study the MIPS instruction set
MIPS – Instruction set from MIPS technologies since 1980s
Large share of embedded core market
Other ISAs we will look at
• ARMv7 – Similar to MIPS, >9B chips• Intel x86 – powers many PCs• ARMv8 – Extends v7 to 64-bit
2
-
Example Instruction
Basic arithmetic operation:
add a, b, c # a = b + c
sub a, b, c # a = b - c
Design Principle 1: Simplicity favors regularity
Regularity makes implementation simpler
Simplicity enables higher performance at lower cost
3
-
Arithmetic Example
C Code:
f = (g+h) - (i+j);
How would you do this in assembly?
4
-
Arithmetic Example
C Code:
f = (g+h) - (i+j);
How would you do this in assembly?
add t0, g, h #temp t0 = g + h
add t1, i, j #temp t1 = i + j
sub f, t0, t1 #f = t0 - t1
5
-
MIPS Instruction Set
6
-
MIPS Instruction Set
7
-
Register Operands
Arithmetic instructions use register operands
MIPS has a 32 x 32-bit register file
• Use for frequently accessed data• Numbered 0 to 31• 32-bit data called a “word”
Assembler Names:
• $t0, $t1, ..., $t9 for temporary values• $s0, $s1, ..., $s7 for saved variables
Design Principle 2: Smaller is faster
8
-
Arithmetic Example
C Code:
f = (g+h) - (i+j);
//Assume f, g, h, i, j in $s0-$s4 respectively
How would you do this in assembly?
add $t0, $s1, $s2 #temp $t0 = g + h
add $t1, $s3, $s4 #temp $t1 = i + j
sub $s0, $t0, $t1 #f = $t0 - $t1
9
-
Memory Operands
Main memory used for composite data
e.g. Arrays, data structures, dynamic data
To apply arithmetic operations:
• Load values from memory into registers• Compute arithmetic in registers• Store result from register into memory
10
-
Memory Operands
Memory is byte addressed
i.e. Each address identifies an 8-bit byte
Why?
11
-
Memory Operands
Memory is byte addressed
i.e. Each address identifies an 8-bit byte
Words are aligned in memory
Address must be a multiple of 4
Why?
12
-
Memory Operands
Memory is byte addressed
i.e. Each address identifies an 8-bit byte
Words are aligned in memory
Address must be a multiple of 4
MIPS is Big Endian
• Most-significant byte at least address of a word• Little-Endian – Least-significant byte at least address
13
-
Memory Operand Example 1
C Code:
g = h + A[8]; // Assume g in $s1, h in $s2
// Base address of A in $s3
Then Compiled MIPS (Index 8 requires offset of 32)
lw $t0, 32($s3) #32 is offset, $s3 base register
add $s1, $s2, $t0 #g = h + A[8]
14
-
Memory Operand Example 2
C Code:
A[12] = h + A[8]; // Assume h in $s2
// Base address of A in $s3
Then Compiled MIPS (Index 8 requires offset of 32)
Index 12 requires offset of ?
lw $t0, 32($s3) # 32 is offset, $s3 base register
add $t0, $s2, $t0 # g = h + A[8]
sw $t0, X($s3) # What is X?
15
-
Memory Operand Example 2
C Code:
A[12] = h + A[8]; // Assume h in $s2
// Base address of A in $s3
Then Compiled MIPS (Index 8 requires offset of 32)
Index 12 requires offset of 4× 12 = 48
lw $t0, 32($s3) # 32 is offset, $s3 base register
add $t0, $s2, $t0 # g = h + A[8]
sw $t0, 48($s3) # A[12] = h + A[8];
16
-
Registers vs. Memory
Registers – Faster access than memory
Operating on memory 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!
17
-
Immediate Operands
What about constant data?
e.g. a = b + 5
Constant data specified in an instruction:
addi $s3, $s4, 5
No subtract immediate instruction
• Use a negative constant• e.g. addi $s3, $s4, −5
Design Principle 3: Make the common case fast!
Small constants are common (e.g. i++, i+=2)
Immediate operand avoids a load instruction
18
-
Constant Zero
In MIPS, register 0 is a constant zero
Can be addressed as $zero
Cannot be overwritten
Useful for common operations
e.g. Copy registers
add $t2, $s1, $zero
19
-
Signed/Unsigned
Recall from Digital Design:
For binary 10102:
• Unsigned = 1010• Sign-Magnitude = −210• 1’s Complement = −510• 2’s Complement = −610
Signed values in MIPS are 2’s complement values
20
-
Signed Negation
For 2’s complement, to negate:
Complement and add 1
Example: Negate 210
2 = 00000010
Complement = 11111101
Add1 = 11111110
-2 = 11111110
21
-
Sign Extension
Sign extension – representing same number using more bits
2810 = 000111002 – Extend to 16 bits
−1810 = 111011102 – Extend to 16 bits
22
-
Sign Extension
Sign extension – representing same number using more bits
2810 = 000111002 – 00000000000111002
−1810 = 111011102 – 11111111111011102
23
-
Representing Instructions
-
Representing Instructions
Instructions are encoded in binary
• Called machine code
MIPS Instructions
• Encoded as 32-bit instruction words• Small number of formats encoding operation code (opcode),
register numbers
• Regularity!
Register Numbers
• $t0-$t7 are registers 8-15• $t8-$t9 are registers 24-25• $s0-$s7 are registers 16-23
24
-
Representing Instructions – R-Format
Instruction Fields:
• op – Operation• rs – First source register number• rt – Second source register number• rd – Destination register number• shamt – Shift amount (00000 for now)• funct – function code (extends opcode)
25
-
R-Format Example
Example: add $t0, $s1, $s2
special $s1 $s2 $t0 0 add
0 17 18 8 0 32
00000 1001 10010 01000 00000 100000
The machine code for this instruction would be
0000010011001001000000001000002
26
-
Representing Instructions – I-Format
Immediate arithmetic and load/store instructions
• rt – Destination or source register number• Constant: −215 to +215 − 1• Address: Offset added to base address in rs
Design Principle 4 – Good design demands good compromises
• Different formats complicate decoding, but allow 32-bitinstructions uniformly
• Keep formats as similar as possible
27
-
Stored Program Computers
Instructions represented in binary
• Just like dataInstructions and data stored in memory
Programs can operate on programs
• e.g. compilers, linkers, etc.Binary compatibility allows compiled
programs to work on different
computers
• Standardized ISAs
Big Picture
28
-
Logical Operations
Instructions for bitwise manipulation
Useful for extracting and inserting groups of bits in a word
29
-
Shift Operations
shamt – how many positions to shift
sll – shift left logical
• Shift left and fill with 0 bits• sll by i bits multiplies by 2i
srl – shift right logical
• Shift right and fill with 0 bits• srl by i bits divides by 2i (unsigned only)
30
-
AND Operations
Useful to mask bits in a word
• Select some bits, clear others to 0
e.g. and $t0, $t1, $t2
31
-
OR Operations
Useful to include bits in a word
• Set some bits to 1, leave others unchanged
e.g. or $t0, $t1, $t2
32
-
NOT Operations
Useful to invert bits in a word
• Change 0 to 1, 1 to 0
MIPS does not have a NOT operation
Has a 3-operand NOR instruction!
• a NOR b == NOT (a OR b)
e.g. nor $t0, $t1, $zero
33
-
Conditional Operations
Branch to a labeled instruction if a condition is true
• Otherwise, continue sequentially
beq – branch if equal
• beq rs, rt, L1 – branch to L1 if rs==rt
bne – branch not equal
• bne rs, rt, L1 – branch to L1 if rs!=rt
j – Unconditional jump
• j L1 – jump to instruction labeled L1
34
-
Compiling if statements
Example (code to right)
Assume f, g, h, i, j in $s0 - $s4
Compiled MIPS Code:
bne $s3, $s4, Else
add $s0, $s1, \$s2
j Exit
Else: sub $s0, $s1, $s2
Exit: (continue with program)
if (i==j)
f = g + h;
else
f = g-h;
35
-
Compiling Loop Statements
Example:
while(save[i] == k)
i += 1;
Assume i in $s3, k in $s5, address of save in $s6
How would we do this in assembly?
36
-
Compiling Loop Statements
Example:
while(save[i] == k)
i += 1;
Assume i in $s3, k in $s5, address of save in $s6
Loop: sll $t1, $s3, 2
add $t1, $t1, $s6
lw $t0, 0($t1)
bne $t0, $s5, Exit
addi $s3, $s3, 1
j Loop
Exit: (continue with program)
37
-
Basic Blocks
Basic Block – sequence of instructions with:
• No embedded branches (except at end)• No branch targets (except at beginning)
Compiler identifies basic blocks
for optimization
Advanced processor can
accelerate execution of basic
blocks
38
-
More Conditional Operations
slt – Set less than
slti – Set if less than immediate
These two operations set the destination register to 1 if evaluates
to true, otherwise , set to 0
slt $t0, $s3, $s4 # $if $s3 < $s4, $t0 = 1
# else $t0 = 0
slti $t0 , $s2, 10 # $if $s2 < 10, $t0 = 1
# else $t0 = 0
Commonly used with beq, bne
slt $t0, $s1, $s2 # if($s1 < $s2)
bne $t0, $zero, L # branch to L39
-
Branch Instruction Design
Why not blt, bge, etc?
40
-
Branch Instruction Design
Why not blt, bge, etc?
Hardware for
-
Branch Instruction Design
Why not blt, bge, etc?
Hardware for
-
Signed vs. Unsigned
Consider the following:
11111111111111012 = −210 – 2’s complement11111111111111012 = 6553310 – unsigned
00000000000000102 = 210
Assume $s1 = 11111111111111012
Assume $s2 = 00000000000000102
What is the value of $t0 after slt $t0, $s1, $s2?
43
-
Signed vs. Unsigned
There is no good solution with a single instruction
Compromise:
Signed comparison – slt, slti
Unsigned comparison – sltu, sltui
Assume $s1 = 11111111111111012
Assume $s2 = 00000000000000102
slt $t0, $s1, $s2 # Set $t0 1 if $s1 < $s2 (signed)
sltu $t1, $s1, $s2 # Set $t1 1 if $s1 < $s2 (unsigned)
What is the value of $t0, $t1?
44
-
Switch/Case Statement
Many languages allow for switch/case statements
Compiler may unroll them to several if/else statements
Some may be better coded as a table of jump addresses (called a
jump table)
Code indexes into the table, gets the proper memory location
jr – jump register, allows for jump to a memory address in a
register rather than a specific location
We will touch on this later
45
Representing Instructions