1 chapter 2 mips instructions instructions: language of the machine instruction set architecture -...
TRANSCRIPT
![Page 1: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/1.jpg)
1chapter 2
MIPS Instructions• Instructions: Language of the Machine
• Instruction set architecture - the attributes of a computer system seen by the programmer
• Attributes– organization of programmable storage
– data types and data structures, encodings, representations
– instruction format, operands
– instruction set (operation code set)
– addressing modes, accessing data items and instructions
– exceptional (interrupt) conditions
• We’ll be working with the MIPS instruction set architectures.
• MIPS : A typical RISC machine, 50M MIPS chips sold, used in computers, printers, network cards, video game (Nintendo).
![Page 2: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/2.jpg)
2chapter 2
Why do we study MIPS Instruction Set Architecture ?
Instruction set Number sold80x86 > 50,000,000MIPS > 50,500,000PowerPC > 3,300,000SPARC > 700,000HP PA-RISC > 300,000DEC Alpha > 200,000
![Page 3: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/3.jpg)
3chapter 2
0
200
400
600
800
1000
1200
1400
1998 1999 2000 2001 2002
Other
SPARC
Hitachi SH
PowerPC
Motorola 68K
MIPS
IA-32
ARM
millions of processors sold
![Page 4: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/4.jpg)
4chapter 2
Processor Performance Increase
1
10
100
1000
10000
1987 1989 1991 1993 1995 1997 1999 2001 2003
Year
Per
form
ance
(S
PE
C I
nt)
SUN-4/260 MIPS M/120MIPS M2000
IBM RS6000
HP 9000/750
DEC AXP/500 IBM POWER 100
DEC Alpha 4/266DEC Alpha 5/500
DEC Alpha 21264/600
DEC Alpha 5/300
DEC Alpha 21264A/667Intel Xeon/2000
Intel Pentium 4/3000
![Page 5: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/5.jpg)
5chapter 2 Where is the Market?
290
933
488
1143
892
135
4
862
1294
1122
1315
0
200
400
600
800
1000
1200
1998 1999 2000 2001 2002
Embedded
Desktop
Servers
Mill
ions
of C
om
pu
ters
![Page 6: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/6.jpg)
6chapter 2
• Power consumption – especially in the embedded market where battery life is important (and passive cooling)
– For power-limited applications, the most important metric is energy efficiency
![Page 7: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/7.jpg)
7chapter 2
Specification - bottom-up
• Instruction Format or Encoding– How is it decoded ?
• Location of the operands and result– where other than memory ?
– how many explicit operands ?
– how are memory operands located ?
– which can or cannot be in memory ?
• Data type and Size
• Operations– what are supported
• Successor Instruction– jumps, conditions, branches
instructionfetch
instructiondecode
operandfetch
execute
store result
next instruction
![Page 8: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/8.jpg)
8chapter 2
RISC vs CISC• RISC (reduced instruction set computer) instructions
– only load/store instructions access memory
– data (i.e., operands) must be in registers to perform operation
– each instruction roughly taking same amount of time
– simple addressing modes
– virtually all new instruction sets since 1982 have been RISC (M 68000 announced in year 1980)
– etc.
• CISC (complex instruction set computer) instructions– alu/logic instructions access memory to fetch operands
– load/store instructions access memory
– some instructions’ execution time is much longer than other instructions
– complex addressing modes
– etc.
![Page 9: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/9.jpg)
9chapter 2
RISC - Reduced Instruction Set Computer• RISC philosophy
– fixed instruction lengths
– load-store instruction sets
– limited addressing modes
– limited operations
• MIPS, Sun SPARC, HP PA-RISC, IBM PowerPC, Intel (Compaq) Alpha, …
• Instruction sets are measured by how well compilers use them as opposed to how well assembly language programmers use them
Design goals: speed, cost (design, fabrication, test, packaging), size, power consumption,
reliability, memory space (embedded systems)
![Page 10: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/10.jpg)
10chapter 2
MIPS Instructions• MIPS is a RISC machine
• programmable storage : 32 32-bit general purpose registers (GPR), represented as $0, $1, $2, ......, $31, the content of $0 is always 0.
• 230 memory words, such as Memory[0], Memory[4], etc Memory holds data structures such as arrays, and spilled registers
• MIPS uses byte addresses so sequential words differ by 4
• 32 32-bit floating point registers, paired for double precision
What is a spilled register ?
A variable is less commonly used and saved in memory rather than in registers
![Page 11: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/11.jpg)
11chapter 2
MIPS Addressing Mode
• Simple addressing modes
• All instructions 32 bits wide
• register addressingop rs rt rd -- --; rs, rt specify the operand (i.e., register number) directly
op rs rt immediate; immediate is the operand
• immediate addressing
• base addressing (base + offset or displacement)op rs rt immediate; rs + immediate is the address where the operand is located
• PC-relativeop rs rt immediate;PC + immediate is the address
![Page 12: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/12.jpg)
12chapter 2
MIPS Instructions
• R type instructionop rs rt rd shamt
funct
no. of bits 6 5 5 5 5 6
Some arithmetic and logic instructions are R-type
and $1, $2, $3 ; $1 = $2 & $3
add $1, $2, $3 ; $1 = $2 + $3
slt $1, $2, $3 ; if ($2 < $3) then $1 = 1; else $1 = 0
addu $1, $2, $3 ; add unsigned, no exceptions
sub $1, $2, $3 ;
subu $1, $2, $3 ; sub unsigned, no exceptions
![Page 13: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/13.jpg)
13chapter 2
MIPS Arithmetic
• All instructions have 3 operands
• Operand order is fixed (destination first)Example:
C code: A = B + C
MIPS code: add $s0, $s1, $s2
(associated with variables by compiler)
MIPS compiler uses $s0, $s1, ... for registers that correspond to variables in C program and $t0, $t1, ...
for temporary registers needed to compile a program
![Page 14: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/14.jpg)
14chapter 2
MIPS Arithmetic
• Another ExampleC code: A = B + C + D;
E = F - A;
MIPS code: add $t0, $s1, $s2
add $s0, $t0, $s3
sub $s4, $s5, $s0
• Operand must be registers, only 32 registers provided
• Design Principle: smaller is faster. Why ?
![Page 15: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/15.jpg)
15chapter 2
Register vs. Memory
• Arithmetic instructions operands must be registers, – only 32 registers provided
• Compiler associates variables with registers
• What about programs with lots of variables– use memory to store variables when all registers are used.
• Memory viewed as a large, single-dimension array, with an address.
• A memory address is an index into the array
• “Byte addressing” means that the index points to a byte of memory.
• For MIPS, a word is 32 bits or 4 bytes.
• 230 words with byte addresses 0, 4, 8, . . . 232 - 4
• 232 bytes with byte addresses from 0 to 232 - 1
• Words are aligned
![Page 16: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/16.jpg)
16chapter 2
MIPS Instructions
• I type instruction ; small constants are used frequently
op rs rt immediateno.of bits 6 5 5 16
instruction examplesadd immediateaddi $1, $2, 100; immediate = 100, rs = $2, rt = $1; op =8; $1 = $2 + 100
and immediateandi $1, $2, 100; immediate = 100, rs = $2, rt = $1; op = 12; $1 = $2 & 100
Good design demands good compromises.Where is the compromise here ? (rt used as destination reg.) (rt used as operand reg. in R type)
![Page 17: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/17.jpg)
17chapter 2
MIPS Instructions
• I type instructions
lw $1, 100($3); rs = $3, immediate = 100, rt = $1
$1 = Memory[100 + $3]
sw $1, 150($2); rs = $2, immediate = 150, rt = $1
Memory[$2 + 150] = $1
lui $1, 108; immediate = 108 rs = 0, rt = $1;
load 108 into upper 16 bits of register $1, $1 = 108 x 216
![Page 18: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/18.jpg)
18chapter 2
MIPS Instructions
• J type instruction op target addressno. of bits 6 26
jump instruction;
j 10000; go to target address 10000jal 10000; $31 = PC + 4; go to 10000; for procedure call, ; return address is saved in $31
![Page 19: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/19.jpg)
19chapter 2
MIPS Instructions
• Instructions for making decisions– alter the control flow,
– change the “next” instruction to be executed
beq $1, $2, L1; (I type )– go to the instruction labeled L1, if the value in $1 equals the
value in $2
bne $3, $4, L1; (I type)– go to the instruction labeled L1, if the value in $3 not equal the
value in $4
• example: C code if (i==j) h = i+j; MIPS code bne $s0, $s1, Label
add $s3, $s0, $s1
.....
Label: ....
![Page 20: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/20.jpg)
20chapter 2
MIPS Instructions• Control
– MIPS unconditional branch instructions:
j label
Example:
if (i != j) beq $s4, $s5, Lab1
h = i + j; add $s3, $s4, $s5
else j Lab2
h = i - j; Lab1: sub $s3, $s4, $s5
Lab2: ............
• Other cases such as compiling a while loop, a switch statement, a loop with array index, a procedure call, nested procedures into MIPS code (skip, this is too much into assembly language programming)
• This course is to design a processor
![Page 21: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/21.jpg)
21chapter 2
Addressing Objects
• Big Endian: address of most significant byte = word address, (xxx...00 = big end of the word)
– IBM, Motorola 68K, MIPS, Sparc, HP PA
• Little Endian: address of least significant byte = word address, (xxx...00 = little end of the word)
– Intel 80x86, DEC Vax, DEC Alpha
• alignment : require that objects fall on address that is multiple of their size
word 0
word 0
byte 0 byte 1 byte 2 byte 3
byte 3 byte 2 byte 1 byte 0
Big Endian
Little Endian
leftmost byte is word address
rightmost byte is word address
![Page 22: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/22.jpg)
22chapter 2
Byte Addresses
• Since 8-bit bytes are so useful, most architectures address individual bytes in memory
– The memory address of a word must be a multiple of 4 (alignment restriction)
• Big Endian: leftmost byte is word address IBM 360/370, Motorola 68k, MIPS, Sparc, HP PA
• Little Endian: rightmost byte is word addressIntel 80x86, DEC Vax, DEC Alpha (Windows NT)
msb lsb
3 2 1 0little endian byte 0
0 1 2 3big endian byte 0
![Page 23: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/23.jpg)
23chapter 2
Data Types
• Bit
• Bit String:– 4 bits is a nibble
– 8 bits is a byte
– 16 bits is a half word
– 32 bits is a word
– 64 bits is a double-word
• Character: ASCII 7 bit code
• Decimals : digits 0-9 encoded as 0000 through 1001
• Integers : 2’s complement
• Floating Point: – single precision, double precision
![Page 24: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/24.jpg)
24chapter 2
MIPS Instructions
• MIPS arithmetic instructions– add, addi, addu, sub, subi, subu, addiu
– all arithmetic operations operate on words
Which add for address arithmetic ?
Which add for integers ?
![Page 25: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/25.jpg)
25chapter 2
MIPS Instructions
• Logical Instructions– and, or, xor, nor, andi (and immediate), ori (or immediate),
sll (shift left logical), srl (shift right logical), sra (shift right arithmetic),
– examples
» sll $1, $2, 10 ; $1 = $2 << 10 (shift left logical 10 bits of $2)
» srl $1, $2, 10 ; $1 = $2 >> 10 (shift right logical 10 bit)
» or $1, $2, $3 ; $1 = $2 | $3
» and $1, $2, $3 ; $1 = $2 & $3
» ori $2, $3, 99 : $2 = $3 | 99
![Page 26: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/26.jpg)
26chapter 2
MIPS Instructions
• data transfer instructions– lw load word
– sw store word
– lbu load byte unsigned
– sb store byte
– lui load upper immediate
» lui $1, 100 ; $1 = 100 x 216
» load 100 into the upper 16 bits of $1,
![Page 27: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/27.jpg)
27chapter 2
MIPS Instructions
• slt set on less than, compare 2’s comp. – slt $1, $2, $3; if $2 < $3 then $1 = 1 else $1 = 0.
• slti set on less than immediate, compare 2’s comp.– slti $2, $3, 79; if $3 < 79 then $2 = 1, else $2 = 0
• sltu set on less than unsigned, compare natural numbers
• sltiu set on less than immediate unsigned, compare natural numbers
• jr jump register, – jr $31 ; go to register $31
![Page 28: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/28.jpg)
28chapter 2
MIPS Instructions
• Signed vs Unsigned Comparison
$1 = 0000 0000 0000...... 00001
$2 = 1111 1111 1111....... 11111
$3 = 0000 0000 0000........ 00000
slt $4, $1, $2
sltu $5, $1, $2
slt $6, $2, $3
sltu $7, $2, $3
$4=___________; $5 = ____________
$6=___________; $7 = _____________
![Page 29: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/29.jpg)
29chapter 2
MIPS Instructions
• $0 is always zero (you can not change it)
• branch and link save the return address PC+4 into $31
• all instructions change all 32 bits of the destination register
• logic immediates are zero extended to 32 bits
• arithmetic immediates are sign extended to 32 bits
• data loaded by the instructions lb, lh are extended as follows:
– lbu, lhu are zero extended (unsigned load)
– lb, lh are sign extended
• overflow can occur in signed arithmetic/logic instructions, will not occur in unsigned arithmetic/logic instructions.
![Page 30: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/30.jpg)
30chapter 2
MIPS Summary
• fixed instruction format (3 formats: R, I, J)
• 3-address, reg-reg arithmetic/logical instructions
• single addressing mode for load/store instructions– base + displacement
• simple branch conditions– compare against zero or two registers for equal, not_equal, no
integer condition code
• delayed branch (more examples in chapter 6)– execute instruction after the branch (or jump) even if the branch is
not taken. compiler fills a delayed branch with a useful instruction (50% correct).
• Three design principles:– Simplicity favors regularity
– Smaller is faster
– Good design demands good compromises
![Page 31: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/31.jpg)
31chapter 2
All Time Popular Instruction Set - 80x86
• 1978: 8086 is announced (16 bit architecture)• 1980: 8087 floating point coprocessor is added• 1982: 80286 increases address space to 24 bits + some
instructions• 1985: 80386 extends to 32 bits, new addressing modes• 1989 - 1995: 80486, Pentium, Pentium Pro add a few
instructions, mostly designed for higher performance• 1997: MMX is added• 1999: Intel added another 70 instructions labelded as
SSE (Streaming SIMD Extensions) as part of Pentium III• 2001: Intel added another 144 instructions as SSE II• 2003: IA-32 (but AMD announced AMD64)• 2004: Intel capitulates and embraces AMD64.
![Page 32: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/32.jpg)
32chapter 2
All Time Popular Instruction Set: 80x86
Complexity of 80x86instructions from 1 to 17 bytes longone operand must act as both a source and destinationone operand can come from memorycomplex addressing modes
This history illustrates the impact of the “golden handcuffs” ofcompatibility on 80x86. The existing software base was too important to jeopardize with significant architectural changes.
![Page 33: 1 chapter 2 MIPS Instructions Instructions: Language of the Machine Instruction set architecture - the attributes of a computer system seen by the programmer](https://reader036.vdocuments.mx/reader036/viewer/2022062518/5697bf9a1a28abf838c92768/html5/thumbnails/33.jpg)
33chapter 2
MIPS Summary
more powerful instructions mean higher performance T F
writing assembly language in order to obtain the highest performance T F
smaller is faster T F
simplicity favors regularity T F
good design demands compromise T F
make the common case fast T F
evaluate instruction sets – design time metrics : how long at what cost to implement
– static metrics : how many bytes program occupy memory
– dynamic metrics: