MIPS Processor Overview

Transcription

1 MIPS Processor Cptr280 Dr Curtis Nelson MIPS Processor Overview Hardware Design philosophy Architecture Software Assembly language program structure QTSpim simulator Example programs 1

2 MIPS Processor Power PC

3 Data Path Diagram Program Counter (PC) Program Memory Instruction Register ALU Address Control Logic Rs Data In Rdest Rt 4 Data Memory (Register File) The MIPS Instruction Set Used as an example throughout the text book. Stanford MIPS commercialized by MIPS Technologies A discussion of MIPS can be found on Wikipedia Decent share of embedded core market Applications in consumer electronics, network/storage equipment, cameras, printers, Typical of many modern ISAs 3

4 Two Key Principles of Processor Design Instructions are represented as numbers and, as such, are indistinguishable from data. Programs are stored in alterable memory (that can be read or written to) just like data. Stored-program concept - Programs can be shipped as files of binary numbers binary compatibility. - Computers can inherit ready-made software provided they are compatible with an existing Instruction Set Architecture (ISA) leads industry to align around a small number of ISAs. Memory Accounting prg (machine code) C compiler (machine code) Payroll data Source code in C for Acct prg MIPS (RISC) Design Principles Simplicity favors regularity: Fixed size instructions. Small number of instruction formats. Operation code always the first 6 bits in an instruction. Smaller is faster: Limited instruction set. Limited number of registers in register file. Limited number of addressing modes. Make the common case fast: Arithmetic operands taken only from the register file. Allow instructions to contain immediate operands. 4

5 MIPS Architecture The MIPS architecture is considered to be a typical RISC architecture Simplified instruction set => easier to study Most new machines use a Reduced Instruction Set (RISC) Programmable storage 32 x 32-bit General Purpose Registers (r0 = 0) special purpose registers - HI, LO, PC 32 x 32-bit Floating Point registers 2^32 bytes of addressable main memory Memory is byte addressable Words are 32 bits = 4 bytes Words start at multiple of 4 address MIPS-32 ISA Instruction Categories Computational Load/Store Jump and Branch Floating Point Coprocessor Memory Management Special Registers R0 - R31 PC HI LO 3 Instruction Formats: all 32 bits wide op op op rs rt rd sa funct rs rt immediate jump target R format I format J format 5

6 MIPS Register File Holds thirty-two 32-bit registers Two read ports and One write port src1 addr src2 addr Register 32 bits File Registers dst addr 32 Are faster than main write memory data - But register files with more locations are slower (e.g., a 64 word file could write control be as much as 50% slower than a 32 word file) Are easier for a compiler to use - e.g., (A*B) (C*D) (E*F) can do multiplies in any order vs. using data on a stack Can hold variables so that - Code density improves (since registers are named with fewer bits than a memory location) locations src1 data src2 data Registers 32 general-purpose registers Register preceded by $ in assembly language instruction Two formats for addressing: using register number: example $0 through $31 using mnemonic names: example $t1, $sp Register use conventions $t0 - $t9 ( = $8 - $15, $24, $25) are general use registers; need not be preserved across procedure calls $s0 - $s7 ( = $16 - $23) are general use registers; should be preserved across procedure calls $sp ( = $29) is stack pointer $fp ( = $30) is frame pointer $ra ( = $31) is return address storage for subroutine call $a0 - $a3 ( = $4 - $7) are used to pass arguments to subroutines $v0, $v1 ( = $2, $3) are used to hold return values from subroutine 6

7 Registers - continued Special registers Lo and Hi used to store result of multiplication and division Not directly addressable; contents accessed with special instruction mfhi ("move from Hi") and mflo ("move from Lo") Stack grows from high memory to low memory MIPS Register Convention Name Register Number Usage Preserve on call? $zero 0 constant 0 (hardware) n.a. $at 1 reserved for assembler n.a. $v0 - $v1 2-3 returned values no $a0 - $a3 4-7 arguments yes $t0 - $t temporaries no $s0 - $s saved values yes $t8 - $t temporaries no $gp 28 global pointer yes $sp 29 stack pointer yes $fp 30 frame pointer yes $ra 31 return addr (hardware) yes 7

8 Register Names in MIPS Assembly Language With MIPS, there is a convention for mapping register names into general purpose register numbers. name register number usage $zero 0 constant 0 $v0-$v1 2-3 results $a0-$a3 4-7 arguments $t0-$t temporaries $s0-$s saved $t8-$t more temps $gp 28 global pointer $sp 29 stack pointer $fp 30 frame pointer $ra 31 return address MIPS Data Types and Literals Data types: byte, halfword (2 bytes), word (4 bytes) a character requires 1 byte of storage an integer requires 1 word (4 bytes) of storage Literals: numbers entered as is: example 4 characters enclosed in single quotes: example 'b' strings enclosed in double quotes: example "A string" 8

9 MIPS Addressing Modes Addressing modes specify where the data used by an instruction is located. mode example action register direct add $s1, $s2, $s3 $s1 = $s2 + $s3 immediate addi $s1, $s2, 200 $s1 = $s base+index lw $s1, 200($s2) $s1 = mem[200*4 + $s2] PC-relative beq $s1, $s2, 200 if ($s1 == $s2) PC = PC+4+200*4 Pseudo-direct j 4000 PC = (PC[31:28], 4000*4) Often, the type of addressing mode depends on the type of operation being performed (e.g., branches all use PC relative) MIPS Arithmetic Instructions MIPS assembly language arithmetic instructions: add $t0, $s1, $s2 sub $t0, $s1, $s2 Each arithmetic instruction performs one operation. Each specifies exactly three operands that are all contained in the datapath's register file ($t0,$s1,$s2) destination source1 op source2 Instruction Format (R format) x22 9

10 MIPS Instruction Fields MIPS fields are given names to make them easier to refer to: op rs rt rd shamt funct op 6-bits opcode that specifies the operation rs 5-bits register file address of the first source operand rt 5-bits register file address of the second source operand rd 5-bits register file address of the result s destination shamt 5-bits shift amount (for shift instructions) funct 6-bits function code augmenting the opcode Memory Operands Values must be fetched from memory before instructions can operate on them. Load word lw $t0, memory-address Register Memory Store word sw $t0, memory-address Register Memory 10

11 MIPS Instruction Set MIPS Instruction Set 11

12 MIPS Instruction Set MIPS Instruction Set 12

13 MIPS Instruction Set MIPS Floating Point Instruction Set 13

14 MIPS Assembly Language Program Structure Just plain text file with data declarations, program code (name of file should end in suffix.s to be used with SPIM simulator) Data declaration section followed by program code section Data Declarations Placed in section of program identified with assembler directive.data Declares variable names used in program; storage allocated in main memory (RAM) 14

15 Code Placed in section of text identified with assembler directive.text Contains program code (instructions) Starting point for code execution given label main: Ending point of main code should use exit system call (covered later under System Calls) Comments Anything following # on a line # This stuff would be considered a comment 15

16 Template for a MIPS assembly language program # Comment giving name of program and description of function # Template.s # Bare-bones outline of MIPS assembly language program.data # variable declarations here #....text main: # indicates start of code (first instruction to execute) # remainder of program code here #... #... Example Program: add2numbersprog1.asm ## Program adds 10 and 11.text.globl main # text section # call main by SPIM main: ori $8,$0,0xA # load 10" into register 8 ori $9,$0,0xB # load 11" into register 9 add $10,$8,$9 # add registers 8 and 9, put result # in register 10 16

17 Summary MIPS processors have been around since the 1980 s Commercially available and used extensively MIPS uses 32 registers for local storage Data types are standard Each processor defines an instruction set This set is a compromise between programmer convenience and hardware cost; Some instruction sets are the same length, some not. Most processors contains a bank of registers for high-speed storage; Processors are classified as either RISC or CISC. QTSPIM Introduction What is SPIM? a simulator that runs assembly programs for MIPS R2000/R3000 RISC computers What does SPIM do? reads MIPS assembly language files and translates to machine language executes the machine language instructions shows contents of registers and memory works as a debugger (supports break-points and single-stepping) provides basic Operating System (OS)-like services, like simple I/O 17

18 Learning MIPS & SPIM MIPS assembly is a low-level programming language. The best way to learn any programming language is from live code. We will start by going through a few example programs and explaining the key concepts. Further, an examples directory has been created in /wwu/class/cptr280 of several simple, well-documented assembly programs for you to experiment with. Line-by-line syntax can best be learned by picking up what you need from the textbook and on-line tutorials. Start by copying existing programs and modifying them incrementally making sure you understand the behavior at each step. Tip: The best way to understand and remember a construct or keyword is to experiment with it in code, not by reading about it. PCSpim Windows Interface Registers window shows the values of all registers in the MIPS CPU and FPU Messages window shows PCSpim messages Data segment window shows the data loaded into the program s memory and the data of the program s stack Text segment window shows assembly instructions & corresponding machine code Separate console window appears for I/O 18

19 Using SPIM Loading source file Use File -> Open menu Simulation Simulator -> Settings : In the Display section check only the first two items: Save window positions and General registers in hexadecimal In the Execution section check only Allow pseudo instructions Simulator -> Set Value : to load PC with address of first instruction enter Address or Register Name as PC and enter Value as 0x reason: the text area of memory, where programs are stored, starts here Simulator -> Go : run loaded program Click the OK button in the Run Parameters pop-up window if the StartingAddress: value is 0x Simulator -> Break : stop execution Simulator -> Clear Registers and Reinitialize : clean-up before new run Using SPIM Simulator -> Reload : load file again after editing Simulator -> Single Step or Multiple Step : stepping to debug Simulator -> Breakpoints : set breakpoints Notes: Text segment window of SPIM shows assembly and corresponding machine code pseudo-instructions each expand to more than one machine instruction If Load trap file is checked in Simulator -> Settings then text segment shows additional trap-handling code If Delayed Branches is checked in Simulator -> Settings then statementx will execute before control jumps to L1 in following code to avoid this, insert nop before statementx: jal L1 statementx L1: nop 19

20 SPIM Example Program: add2numbersprog1.asm ## Program adds 10 and 11.text.globl main # text section # call main by SPIM main: ori $8,$0,0xA # load 10" into register 8 ori $9,$0,0xB # load 11" into register 9 add $10,$8,$9 # add registers 8 and 9, put result # in register 10 MIPS Assembly Code Layout Typical Program Layout.data #data section # user program data.text.globl main #code section #starting point: must be global main: # user program code 20

21 MIPS Assembler Directives Top-level Directives:.text indicates that following items are stored in the user text segment, typically instructions.data indicates that following data items are stored in the data segment.globl sym declare that symbol sym is global and can be referenced from other files More MIPS Assembler Directives Common Data Definitions:.word w1,, wn store n 32-bit quantities in successive memory words.half h1,, hn store n 16-bit quantities in successive memory halfwords.byte b1,, bn store n 8-bit quantities in successive memory bytes.ascii str store the string in memory but do not null-terminate it characters are represented in single quotes a strings are represented in double-quotes str special characters, e.g.. \n, \t, follow C convention.asciiz str store the string in memory and null-terminate it 21

22 More MIPS Assembler Directives More Common Data Definitions:.float f1,, fn store n floating point single precision numbers in successive memory locations.double d1,, dn store n floating point double precision numbers in successive memory locations.space n reserves n successive bytes of space.align n align the next datum on a 2 n byte boundary. For example,.align 2 aligns next value on a word boundary..align 0 turns off automatic alignment of.half,.word, etc. till next.data directive SPIM System Calls System Calls (syscall) OS-like services Method load system call code into register $v0 (see following table for codes) load arguments into registers $a0,, $a3 call system with SPIM instruction syscall after call, return value is in register $v0, or $f0 for floating point results 22

23 SPIM System Call Codes Service Code (put in $v0) Arguments Result print_int 1 $a0=integer print_float 2 $f12=float print_double 3 $f12=double print_string 4 $a0=address of string read_int 5 int in $v0 read_float 6 float in $f0 read_double 7 double in $f0 read_string 8 $a0=buffer, $a1=length sbrk 9 $a0=amount addr in $v0 exit 10 SPIM Example Program: systemcalls.asm ## Enter two integers in ## console window ## Sum is displayed.text.globl main main: la $t0, value lw $t1, 0($t0) lw $t2, 4($t0) add $t3, $t1, $t2 sw $t3, 8($t0) li $v0, 4 la $a0, msg1 syscall system call code for print_string li $v0, 5 syscall sw $v0, 0($t0) li $v0, 5 syscall sw $v0, 4($t0) system call code for read_int result returned by call li $v0, 1 move $a0, $t3 syscall li $v0, 10 syscall.data value:.word 0, 0, 0 msg1:.asciiz Sum = " argument to print_string call system call code for print_int argument to print_int call system call code for exit 23

24 More SPIM Example Programs In the class examples directory you will find 18 simple well-documented MIPS assembly programs. Run the code in the order below of increasing complexity. 1. add2numbersprog1 2. add2numbersprog2 3. storewords 4. swap2memorywords 5. branchjump 6. systemcalls 7. overflow 8. averageofbytes 9. printloop 10. sumofsquaresprog1 11. sumofsquaresprog2 12. sumofsquaresprog3 13. proccallsprog1 14. proccallsprog1modified 15. proccallsprog2 16. addfirst factorialnonrecursive 18. factorialrecursive Conclusions The code presented so far should get you started in writing your own MIPS assembly. Remember the only way to master the MIPS assembly language in fact, any computer language is to write lots and lots of code. For anyone aspiring to understand modern computer architecture it is extremely important to master MIPS assembly as all modern computers (since the mid-80 s) have been inspired by, if not based fully or partly on the MIPS instruction set architecture. 24