Download presentation

Presentation is loading. Please wait.

Published byDakota Waye Modified about 1 year ago

1
CPE 442 Lec4.1 Intro Computer Architectures CS455/CpE 442 Computer Architecture and Engineering MIPS Instruction Set Architecture Instructor: Prof. Hany H Ammar, LCSEE, WVU

2
CPE 442 Lec4.2 Intro Computer Architectures Overview of Today’s Lecture: MIPS et al °Review from Last Lecture (3 minutes) °MIPS ISA (20 minutes) °More MIPS (25 minutes) °MIPS (VAX, 80x86?) (25 minutes)

3
CPE 442 Lec4.3 Intro Computer Architectures Review: Instruction Set Design instruction set software hardware

4
CPE 442 Lec4.4 Intro Computer Architectures Execution Cycle Instruction Fetch Instruction Decode Operand Fetch Execute Result Store Next Instruction Obtain instruction from program storage Determine required actions and instruction size Locate and obtain operand data Compute result value or status Deposit results in storage for later use Determine successor instruction

5
CPE 442 Lec4.5 Intro Computer Architectures Review: Summary °Use general purpose registers with a load-store architecture; °Provide at least 16 general purpose registers plus separate floating- point registers, °Support these addressing modes: displacement (with an address offset size of 12 to 16 bits), immediate (size 8 to 16 bits), and register deferred; ° Be sure all addressing modes apply to all data transfer instructions, °Use fixed instruction encoding if interested in performance and use variable instruction encoding if interested in code size; °Support these data sizes and types: 8-bit, 16-bit, 32-bit integers and 32- bit and 64-bit IEEE 754 floating point numbers; °Support these simple instructions, since they will dominate the number of instructions executed: load, store, add, subtract, move register- register, and, shift, compare equal, compare not equal, branch (with a PC-relative address at least 8-bits long), jump, call, and return; ° Aim for a minimalist instruction set.

6
CPE 442 Lec4.6 Intro Computer Architectures Overview of Today’s Lecture: MIPS et al °Review from Last Lecture (3 minutes) °MIPS ISA (20 minutes) °More MIPS (25 minutes) °MIPS (VAX, 80x86?) (25 minutes)

7
CPE 442 Lec4.7 Intro Computer Architectures MIPS R2000 / R3000 Registers °Programmable storage2^32 x bytes31 x 32-bit GPRs (R0 = 0)32 x 32-bit FP regs (paired DP)HI, LO, PC

8
CPE 442 Lec4.8 Intro Computer Architectures MIPS Addressing Modes/Instruction Formats oprsrtrd Displ register Register (direct) oprsrt register Displacement + Memory immedoprsrt Immediate Disploprsrt PC PC-relative + Memory

9
CPE 442 Lec4.9 Intro Computer Architectures MIPS arithmetic instructions InstructionExampleMeaningComments add add $1,$2,$3$1 = $2 + $33 operands; exception possible subtractsub $1,$2,$3$1 = $2 – $33 operands; exception possible add immediateaddi $1,$2,100$1 = $ constant; exception possible add unsignedaddu $1,$2,$3$1 = $2 + $33 operands; no exceptions subtract unsignedsubu $1,$2,$3$1 = $2 – $33 operands; no exceptions add imm. unsign.addiu $1,$2,100$1 = $ constant; no exceptions multiply mult $2,$3Hi, Lo = $2 x $364-bit signed product multiply unsignedmultu$2,$3Hi, Lo = $2 x $364-bit unsigned product divide div $2,$3Lo = $2 ÷ $3,Lo = quotient, Hi = remainder Hi = $2 mod $3 divide unsigned divu $2,$3Lo = $2 ÷ $3,Unsigned quotient & remainder Hi = $2 mod $3 Move from Himfhi $1$1 = HiUsed to get copy of Hi Move from Lomflo $1$1 = LoUsed to get copy of Lo

10
CPE 442 Lec4.10 Intro Computer Architectures MIPS logical instructions InstructionExampleMeaningComment and and $1,$2,$3$1 = $2 & $33 reg. operands; Logical AND oror $1,$2,$3$1 = $2 | $33 reg. operands; Logical OR xorxor $1,$2,$3$1 = $2 $33 reg. operands; Logical XOR nornor $1,$2,$3$1 = ~($2 |$3)3 reg. operands; Logical NOR and immediateandi $1,$2,10$1 = $2 & 10Logical AND reg, constant or immediateori $1,$2,10$1 = $2 | 10Logical OR reg, constant xor immediate xori $1, $2,10 $1 = ~$2 &~10Logical XOR reg, constant shift left logicalsll $1,$2,10$1 = $2 << 10Shift left by constant shift right logicalsrl $1,$2,10$1 = $2 >> 10Shift right by constant shift right arithm.sra $1,$2,10$1 = $2 >> 10Shift right (sign extend) shift left logicalsllv $1,$2,$3$1 = $2 << $3 Shift left by variable shift right logicalsrlv $1,$2, $3 $1 = $2 >> $3 Shift right by variable shift right arithm.srav $1,$2, $3 $1 = $2 >> $3 Shift right arith. by variable

11
CPE 442 Lec4.11 Intro Computer Architectures MIPS data transfer instructions InstructionComment SW 500(R4), R3Store word SH 502(R2), R3Store half SB 41(R3), R2Store byte LW R1, 30(R2)Load word LH R1, 40(R3)Load halfword LHU R1, 40(R3)Load halfword unsigned LB R1, 40(R3)Load byte LBU R1, 40(R3)Load byte unsigned LUI R1, 40Load Upper Immediate (16 bits shifted left by 16)

12
CPE 442 Lec4.12 Intro Computer Architectures Compare and Branch °Compare and BranchBEQ rs, rt, offset if R[rs] == R[rt] then PC- relative branchBNE rs, rt, offset <> °BLEZ rs, offsetif R[rs] <= 0 then PC-relative branch °BGTZ rs, offset > °BLT < °BGEZ >=

13
CPE 442 Lec4.13 Intro Computer Architectures MIPS jump, branch, compare instructions InstructionExampleMeaning branch on equalbeq $1,$2,100if ($1 == $2) go to PC Equal test; PC relative branch branch on not eq.bne $1,$2,100if ($1!= $2) go to PC Not equal test; PC relative set on less thanslt $1,$2,$3if ($2 < $3) $1=1; else $1=0 Compare less than; 2’s comp. set less than imm.slti $1,$2,100if ($2 < 100) $1=1; else $1=0 Compare < constant; 2’s comp. set less than uns.sltu $1,$2,$3if ($2 < $3) $1=1; else $1=0 Compare less than; natural no. set l. t. imm. uns.sltiu $1,$2,100if ($2 < 100) $1=1; else $1=0 Compare < constant; natural jumpj 10000go to Jump to target address jump registerjr $31go to $31 For switch, procedure return jump and linkjal 10000$31 = PC + 4; go to For procedure call

14
CPE 442 Lec4.14 Intro Computer Architectures Overview of Today’s Lecture: MIPS et al °Review from Last Lecture (3 minutes) °MIPS ISA (20 minutes) °More MIPS (25 minutes) °MIPS (VAX, 80x86?) (25 minutes)

15
CPE 442 Lec4.15 Intro Computer Architectures Why Are Stacks So Great? Stacking of Subroutine Calls & Returns and Environments: A: CALL B CALL C C: RET B: A AB ABC AB A Some machines provide a memory stack as part of the architecture (e.g., the VAX) Sometimes stacks are implemented via software convention (e.g., MIPS)

16
CPE 442 Lec4.16 Intro Computer Architectures Call-Return Linkage: Stack Frames FP ARGS Callee Save Registers Local Variables SP Reference args and local variables at fixed (positive) offset from FP Grows and shrinks during expression evaluation (old FP, RA) High Mem Low Mem

17
CPE 442 Lec4.17 Intro Computer Architectures MIPS: Software conventions 0zeroconstant 0 1atreserved for assembler 2v0expression evaluation and 3v1function results 4a0arguments 5a1 6a2 7a3 8t0temporary: caller saves... 15t7 16s0callee saves... 23s7 24t8 25t9 26k0reserved for OS kernel 27k1 28gpPointer to global area 29spStack pointer 30fpframe pointer 31raReturn Address (HW)

18
CPE 442 Lec4.18 Intro Computer Architectures MIPS / GCC Calling Conventions FP SP fact: addiu $sp, $sp, -32 sw$ra, 0($sp) sw$fp, 4($sp) addu$fp, $sp, 8... sw$a0, 0($fp)... lw$ra, 0($sp) lw$fp, 4($sp) addiu$sp, $sp, 32 jr$ra ra old FP ra old FP ra FP SP ra FP SP low address First four args passed in registers. ; save ra ; save old fp ; Save arg0 ; restore ra ; restore old fp ; allocate a frame ; de-allocate ; return

19
CPE 442 Lec4.19 Intro Computer Architectures Example in C: swap swap(int v[], int k) { int temp; temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; } °Assume swap is called as a procedure °Assume temp is register $t7; arguments in $a1, $a2; $s0 is scratch reg: °Write MIPS code

20
CPE 442 Lec4.20 Intro Computer Architectures swap: MIPS swap: addiu$sp,$sp, –4; create space on stack sw$s0, 0($sp) ; callee saved register put onto stack sll$t2, $a2,2; mulitply k by 4 addu$t2, $a1,$t2; address of v[k] lw$t7, 0($t2); load v[k[ lw$s0, 4($t2); load v[k+1] sw$s0, 0($t2); store v[k+1] into v[k] sw$t7, 4($t2); store old value of v[k] into v[k+1] lw$s0, 0($sp) ; callee saved register restored from stack addiu$sp,$sp, 4 ; restore top of stack jr$ra ; return to place that called swap

21
CPE 442 Lec4.21 Intro Computer Architectures Miscellaneous MIPS instructions °breakA breakpoint trap occurs, transfers control to exception handler °syscallA system trap occurs, transfers control to exception handler °coprocessor instrs.Support for floating point: discussed later °TLB instructionsSupport for virtual memory: discussed later °restore from exceptionRestores previous interrupt mask & kernel/user mode bits into status register °load word left/rightSupports misaligned word loads °store word left/rightSupports misaligned word stores

22
CPE 442 Lec4.22 Intro Computer Architectures Details of the MIPS instruction set °Register zero always has the value zero (even if you try to write it) ° jump and link instructions put the return address PC+4 into the link register($31) °All instructions change all 32 bits of the destination reigster (including lui, lb, lh) and all read all 32 bits of sources (add, sub, and, or, …) °Immediate arithmetic and logical instructions are extended as follows: logical immediates are zero extended to 32 bits arithmetic immediates are sign extended to 32 bits °The data loaded by the instructions lb and lh are extended as follows: lbu, lhu are zero extended lb, lh are sign extended °Overflow can occur in these arithmetic and logical instructions: add, sub, addi it cannot occur in addu, subu, addiu, and, or, xor, nor, shifts, mult, multu, div, divu

23
CPE 442 Lec4.23 Intro Computer Architectures Overview of Today’s Lecture: MIPS et al °Review from Last Lecture (3 minutes) °MIPS ISA (20 minutes) °More MIPS (25 minutes) °MIPS (VAX, 80x86?) (25 minutes)

24
CPE 442 Lec4.24 Intro Computer Architectures Other ISAs °Intel 8086/88 => => => => Pentium => P few transistors to implement 16-bit microprocessor tried to be somewhat compatible with 8-bit microprocessor 8080 successors added features which where missing from 8086 over next 15 years product several different intel enigneers over 10 to 15 years Announced 1978 °VAX simple compilers & small code size => efficient instruction encoding powerful addressing modes powerful instructions few registers product of a single talented architect Announced 1977

25
CPE 442 Lec4.25 Intro Computer Architectures swap: MIPS vs. VAX swap: addiu$sp,$sp, –4.word ^m ; saves r0 to r3 sw$s0, 0($sp) sll$t2, $a2,2movlr2, 4(ap) ; move arg v[] to reg addu$t2, $a1,$t2movlr1, 8(ap) ; move arg k to reg lw$t7, 0($t2)movlr3, (r2)[r1] ; get v[k] lw$s0, 4($t2)addl3r0, #1,8(ap) ; reg gets k+1 sw$s0, 0($t2)movl(r2)[r1],(r2)[r0] ; v[k] = v[k+1] sw$t7, 4($t2)movl(r2)[r0],r3 ; v[k+1] gets old v[k] lw$s0, 0($sp) addiu$sp,$sp, 4 jr$raret; return to caller, restore r0 - r3

26
CPE 442 Lec4.26 Intro Computer Architectures Summary °Use general purpose registers with a load-store architecture: YES °Provide at least 16 general purpose registers plus separate floating- point registers: 31 GPR & 32 FPR °Support these addressing modes: displacement (with an address offset size of 12 to 16 bits), immediate (size 8 to 16 bits), and register deferred; : YES: 16 bits for immediate, displacement (disp=0 => register deferred) ° All addressing modes apply to all data transfer instructions : YES °Use fixed instruction encoding if interested in performance and use variable instruction encoding if interested in code size : Fixed °Support these data sizes and types: 8-bit, 16-bit, 32-bit integers and 32- bit and 64-bit IEEE 754 floating point numbers: YES °Support these simple instructions, since they will dominate the number of instructions executed: load, store, add, subtract, move register- register, and, shift, compare equal, compare not equal, branch (with a PC-relative address at least 8-bits long), jump, call, and return: YES, 16b ° Aim for a minimalist instruction set: YES

27
CPE 442 Lec4.27 Intro Computer Architectures Summary: Salient features of MIPS R bit fixed format instructions bit GPR (R0 contains zero) and 32 FP registers (and HI LO) partitioned by software convention 3-address, reg-reg arithmetic instr. Single address mode for load/store: base+displacement –no indirection –16-bit immediate plus LUI Simple branch conditions compare against zero or two registers for = no condition codes Delayed branch execute instruction after the branch (or jump) even if the branch is taken (Compiler can fill a delayed branch with useful work about 50% of the time)

Similar presentations

© 2016 SlidePlayer.com Inc.

All rights reserved.

Ads by Google