MIPS R2000 Assembly Language (Procedure Call, Interrupt, IO, Syscall) CS 230

Transcription

1 MIPS R2000 Assembly Language (Procedure Call, Interrupt, IO, Syscall) CS 230 이준원 1

2 Procedure Call Why do we need it? structured programming reuse frequently used routine Who takes care of it? compiler for HLL programmer for assembly programming What should be done? 1. save registers whose values will be needed after the call who will do this job? caller or callee 2. save return address 3. pass arguments to the callee Anything else? space to store local variables of the callee data structure to handle nested calls stack 2

3 Stack last in first out data structure push: puts an item into the stack pop: gets the item at the top of the stack stack pointer (SP) in most architecture why? because stack is used so frequently MIPS stack push sub $sp, $sp, 4 sw $t0, ($sp) pop lw$t0, ($sp) $sp add $sp, $sp, 4 old new high addr low addr 3

4 caller MIPS Procedure Calls $ra jal loc loc: callee jr $ra What if the callee calls another procedure? 4

5 MIPS Procedure Call (2) caller $ra jal loc $ra loc: callee & caller sub $sp, 4 sw $ra, ($sp) jal loc2 lw $ra, ($sp) add $sp, 4 jr $ra loc2: another callee jr $ra 5

6 Saving Private Registers use registers as many as possible they are much faster than memory (more than 10 times) there are only a limited number of registers (32 in MIPS) callee save vs caller save whichever that needs to save less registers MIPS conventions $s0..$s7 are callee saves $t0..$t9 are caller saves problems registers are not enough a procedure calles another procedure solution: you save/restore variables on the stack carefully stack frame it is for a compiler 6

7 Stack Frame purpose store data used by a procedure in a single frame data can be accessed using a single pointer ($fp) within a procedure the stack may be used for other purpose expression evaluation accessing data using $sp can be tricky stack is used for other purposes Is it really necessary? yes, for recursive calls yes, for complex chained procedure calls no, for simple programs compilers use it! contents in a stack frame arguments other than stored in a0..a3 saved register values variables local to the procedure 7

8 Stack Frame SF of procedue A SF of procedue B SF of procedue C stack argument 5 argument 6. saved registers local variables stack grows and shrinks during expression evaluation old $fp offset from $fp new $fp $sp 8

9 Stack Frames for Procedure Calls stack main program starts SF of main main calls procedure A Proc A calls procedure B Proc B calls procedure C SF of procedure A SF of procedure B SF of procedure C 9

10 Stack Frames for Procedure Calls stack main program starts SF of main main Procedure calls procedure A finishesa Proc Procedure A calls procedure B finishesb SF of procedure A SF of procedure B Procedure C finishes SF of procedure C 10

11 caller callee put arguments Procedure Call Actions - review first four in $a0 ~ $a3 and remaining ones on stack save any registers that will be used later $t0..$t9 callee will save $fp, $ra, and $s0 ~ $s7 if necessary jump to the procedure using jal instruction jump to the given address and saves the return address in $ra ($31) calculate the size of its frame and allocate it on the stack save $fp save $ra on the stack if the callee itself will call another procedure save $s0 ~ $s7 if the callee will modify them establish $fp return values in $v0, $v1 $fp argument 5 argument 6. saved registers $sp local variables 11

12 Procedure Call Actions (cont d) callee returns if it is to return a value, place it on $v0, $v1 restore all callee-saved registers pop the frame from the stack jump to the address stored in $ra 12

13 A Simple Procedure Call Example - factorial! main:.text.globl main subu $sp, $sp, 32 sw $ra, 20($sp) sw $fp, 16($sp) addu $fp, $sp, 32 fact:.text subu $sp, $sp, 32 sw $ra, 20($sp) sw $fp, 16($sp) addu $fp, $sp, 32 sw $a0, 0($fp) # save arg, n $LC: li $a0, 10 jal fact la $a0, $LC move $a1, $v0 jal printf lw $ra, 20($sp) lw $fp, 16($sp) addu $sp, $sp, 32 jr $ra.rdata.ascii The answer is %d\n\000 $L2: $L1: lw $v0, 0($fp) # load n bgtz $v0, $L2 li $v0, 1 # return 1 j $L1 # to return code lw $v1, 0($fp) # load n subu $v0, $v1, 1 # compute n-1 move $a0, $v0 # move arg to $a0 jal fact lw $v1, 0($fp) # load n mul $v0, $v0, $v1 # return val in $v0 lw $ra, 20($sp) lw $fp, 16($sp) addu $sp, $sp, 32 jr $ra 13

14 Optimizing Procedure Call by Compiler Procedure Call Taxonomy non-leaf routines that call other routines previous example leaf routines that do not execute any procedure calls more classification one that needs stack storage for local variables» no need for saving return address one that do not have local variables» no need for stack frame 14

15 A Real Procedure Call - non leaf float nonleaf(i, j) int I, *j { double atof(); int temp; temp = i - *j; if (I < *j) temp = -temp; return atof(temp); }.globl nonleaf.ent nonleaf # for debugger nonleaf: subu $sp, 24 # create stack frame sw $ra, 20($sp).mask 0x , -4 # only $31 is saved at $sp frame $sp, 24, $31 # for debugger: #frame size, return address lw $v0, 0($a1) # args are in $ao and $a1 subu $v1, $a0, $v0 # temp in #v1 bge $a0, $v0, $L1 negu $v1, $v1 # temp = -temp; $L1: move $a0, $v1 jal atof # call atof cvt.s.d $f0, $f0 lw $ra, 20($sp) #restore ra addu $sp, 24 jr $ra.end nonleaf # for debugger 15

16 A Real Procedure Call - leaf w/o stack int leaf(p1, p2) int p1, p2; { return (p1 > p2) p1: p2; } nonleaf.globl leaf.ent nonleaf # for debugger.frame $sp, 0, $31 # for debugger: #frame size, return address ble $a0, $a1, $L1 # args are in $ao and $a1 move $v0, $a0 b $L2 $L1: move $v0, $a1 $L2: jr $ra.end leaf 16

17 Floating Point We need a way to represent numbers with fractions, e.g., very small numbers, e.g., very large numbers, e.g., Representation: sign, exponent, significand: ( 1) sign significand 2 exponent more bits for significand gives more accuracy more bits for exponent increases range IEEE 754 floating point standard: single precision: 8 bit exponent, 23 bit significand double precision: 11 bit exponent, 52 bit significand s exp significand 17

18 Normalized Numbers you can always make the leading bit of significant = why? think about addition/subtraction! the computer prefers that all the floating numbers be normalized simplify addition/subtraction operations floating point operations are expensive but, normalized numbers waste the bits! 18

19 IEEE 754 floating-point standard Leading 1 bit of significand is implicit Exponent is biased to make sorting easier all 0s is smallest exponent all 1s is largest bias of 127 for single precision and 1023 for double precision summary: ( 1) sign exponent bias significand) 2 Example: decimal: -.75 = -3/4 = -3/2 2 binary: -.11 = -1.1 x 2-1 floating point: exponent = 126 = IEEE single precision:

20 Number Definition Normalized Numbers leading digit is not a zero make hardware simple Denormalized Numbers to represent very small numbers Infinity result of division by zero two infinities: +/- Zero two zeroes NaN not a number zero/zero exponent 1 ~ fraction normalized fraction denormalized fraction non-zero 20

21 MIPS Floating Point Registers Floating Point Registers (FPR) FPR 0 FPR 2 least most least most Floating Point General Purpose Registers (FGR) FGR 0 FGR 1 FGR 2 FGR 3 FGR 4 FPR 28 FPR 30 least most least most FGR 27 FGR 28 FGR 29 FGR 30 FGR 31 21

22 MIPS FP Instructions OP Description l.d $f4, addr s.s $f4, addr mov.d $f4, $f6 ctc1 $7, rd cfc1 $6, rd cvt.s.fmt cvt.d.fmt cvt.w.fmt load d-word to $f4 store s-word from $f4 move word move control word to FPA move from convert to single FP convert to double FP convert to fixed point fmt: Format s: single precision d: double precision w: binary fixed point (integer) exmaple: cvt.s.w FRdest, FRsrc cvt.d.w FRdest, FRsrc cvt.d.s FRdest, FRsrc 22

23 MIPS FP Instructions (2) OP add.fmt sub.fmt mul.fmt div.fmt abs.fmt mov.fmt neg.fmt Description add substract multiply divide absolute value move fp to fp negate compare and branch c.cond.format FR1, FR2 bc1t label bc1f label cond: Condition eq, le, lt, t, f, or, nlt, gt,.. result sets a flag in FPA branch instruction on this flag BC1T label # branch if true BC1F label # branch if false exmaple: add.s Frdest, FRsrc1, FRsrc2 add.d Frdest, FRsrc1, FRsrc2 sub.s Frdest, FRsrc1, DRsrc2 exmaple: c.eq.s FRsrc1, FRsrc2 bc1t xxx 23

24 user program Exception Exception: System Exception Handler return from exception normal control flow: sequential, jumps, branches, calls, returns Exception = unprogrammed control transfer system takes action to handle the exception must record the address of the offending instruction returns control to user must save & restore user state 24

25 User/System Modes By providing two modes of execution (user/system) it is possible for the computer to manage itself operating system is a special program that runs in the privileged mode and has access to all of the resources of the computer presents virtual resources to each user that are more convenient than the physical resources files vs. disk sectors virtual memory vs physical memory protects each user program from others Exceptions allow the system to take action in response to events that occur while user program is executing O/S begins at the handler 25

26 Two Types of Exceptions Interrupts caused by external events asynchronous to program execution may be handled between instructions simply suspend and resume user program Traps caused by internal events exceptional conditions (overflow) errors (parity) faults (non-resident page) synchronous to program execution condition must be remedied by the handler instruction may be retried or simulated and program continued or program may be aborted 26

27 MIPS Convention exception means any unexpected change in control flow, without distinguishing internal or external; use the term interrupt only when the event is externally caused. Type of event From where? MIPS terminology I/O device request External Interrupt Invoke OS from user program Internal Exception Arithmetic overflow Internal Exception Using an undefined instruction Internal Exception Hardware malfunctions Either Exception or Interrupt 27

28 Addressing the Exception Handler Traditional Approach: Interupt Vector PC <- MEM[ IV_base + cause 00] 370, 68000, Vax, 80x86,... iv_base cause handler code MIPS Approach: fixed entry PC <- EXC_addr Actually very small table RESET entry TLB other iv_base handler entry code cause 28

29 Saving State Push it onto the stack Vax, 68k, 80x86 Save it in special registers MIPS EPC, BadVaddr, Status, Cause Shadow Registers M88k Save state in a shadow of the internal pipeline registers 29

30 MIPS Registers for Exceptions EPC- Cause 32-bit register used to hold the address of the affected instruction (register 14 of coprocessor 0). register used to record the cause of the exception. In the MIPS architecture this register is 32 bits, though some bits are currently unused. Assume that bits 5 to 2 of this register encodes the two possible exception sources mentioned above: undefined instruction=0 and arithmetic overflow=1 (register 13 of coprocessor 0). BadVAddr Status register contained memory address at which memory reference occurred (register 8 of coprocessor 0) interrupt mask and enable bits (register 12 of coprocessor 0) 30

31 Status Cause Register Pending 5 2 Code Pending interrupt 5 hardware levels: bit set if interrupt occurs but not yet serviced handles cases when more than one interrupt occurs at same time, or while records interrupt requests when interrupts disabled Exception Code encodes reasons for interrupt 0 (INT) => external interrupt 1~3 => TLB related 4 (ADDRL) => address error exception (load or instr fetch) 5 (ADDRS) => address error exception (store) 6 (IBUS) => bus error on instruction fetch 7 (DBUS) => bus error on data fetch 8 (Syscall) => Syscall exception 9 (BKPT) => Breakpoint exception 10 (RI) => Reserved Instruction exception 12 (OVF) => Arithmetic overflow exception 31

32 Exception Handler Example.ktext 0x # MIPS jumps to here on an exception sw $a0 save0 # save registers that will be used by sw $a1 save1 # this routine on memory, NOT on stack # this code is not re-entrant mfc0 $k0 $13 # move cause register to $k0 mfc0 $k1 $14 # move EPC to $k1 # k reg need not be saved (users don t use them) sgt $v0 $k0 0x44 # is this correct? bgtz $v0 done # if it is an interrupt, ignore mov $a0, $k0 mov $a1, $k1 jal print_excp done: lw $a0 save0 lw $a1 save1 addiu $k1 $k1 4 # will return to saved PC + 4 rfe jr $k1.kdata save0:.word 0 save1:.word 0 # restore interrupted state 32

33 Input and Output IO Devices keyboard, screen, disk, network, CD,. Commanding IO devices special IO instruction memory mapped IO special locations of address space are mapped to IO devices need to access registers inside IO controllers Communicating with the processor polling CPU keeps checking status of IO device (status register) may waste CPU power (when events are rare) interrupt IO devices raises interrupt whenever necessary overhead to process interrupt 33

34 SPIM IO memory mapped IO 4 registers are mapped to memory locations to read data from keyboard Ready bit means that the Received data register has a data. When a data arrives, interrupt is raised if it is enabled. Unused Receiver control (0xffff0000) 1 1 Interrupt enable Ready Unused 8 Receiver data (0xffff0004) Received byte 34

35 Transmitter control (0xffff0008) SPIM IO (cont d) Unused 1 1 Interrupt enable Ready Transmitter data (0xffff000c) Unused 8 Transmitted byte to write a data on screen Ready bit indicates if the device is ready to accept a data An interrupt is raised whenever it is ready if it was enabled 35

36 System Call Syscall a.k.a. syscall call an interface through which user programs interacts with OS OS defines this interface protects OS from buggy(or malicious) user programs procedure 1. store parameters in registers 2. specify the syscall type (usually in a register) 3. syscall 4. something happens to invoke OS (later in OS course) 5. syscall routine of the OS is invoked 6. return to the user program how to return to the calling place? how to reinstate the state of the user program? expensive operation 36

37 SPIM syscall move $a0, $t2 li $v0, 1 syscall service call code arguments results print integer 1 int in $a0 print float 2 float in $a0 print double 3 double in $a0 print string 4 addr of string in $a0 read integer 5 int in $v0 read float 6 float in $v0 read double 7 double in $v0 read string 8 $a0=buffer, $a1=length sbrk 9 $a0 = amount addr in $v0 exit 10 37