Computer Science 210 s1c Computer Systems 1 2010 Semester 1 Lecture Notes James Goodman Credits: Slides prepared by Gregory T. Byrd, North Carolina State University Subroutines & Traps Lecture 19, 26Apr10: Announcements New due date for assignment 2 • 5pm Wednesday, 5May Test is postponed one week • Will be given in-class on Monday, 10May • Coverage: 1. Chapters 1-10 of textbook 2. Lectures covering chapters 1-10 3. Assignments 1 & 2 4/29/10 CS210 249 9-251 System Calls Certain operations require specialized knowledge and protection: ! specific knowledge of I/O device registers and the sequence of operations needed to use them ! I/O resources shared among multiple users/programs; a mistake could affect lots of other users! Not every programmer knows (or wants to know) this level of detail Provide service routines or system calls (part of operating system) to safely and conveniently perform low-level, privileged operations 9-252 System Call 1. User program invokes system call. 2. Operating system code performs operation. 3. Returns control to user program. In LC-3, this is done through the TRAP mechanism.
Transcript
Computer Science 210 s1c Computer Systems 1
2010 Semester 1
Lecture Notes
James Goodman!
Credits: Slides prepared by Gregory T. Byrd, North Carolina State University
Subroutines & Traps Lecture 19, 26Apr10:
Announcements
New due date for assignment 2 • 5pm Wednesday, 5May
Test is postponed one week • Will be given in-class on Monday, 10May • Coverage:
AGAIN TRAP x23 ; Get char ADD R0, R0, R6 ; convert to number STR R0, R3, #0 ; store number ADD R3, R3, #1 ; incr pointer ADD R7, R7, -1 ; decr counter BRp AGAIN ; more? BRnzp NEXT
ASCII .FILL xFFD0 COUNT .FILL #10 Binary .BLKW #10 What’s wrong with this routine?
What happens to R7?
Computer Science 210 s1c Computer Systems 1
2010 Semester 1
Lecture Notes
James Goodman!
Credits: Slides prepared by Gregory T. Byrd, North Carolina State University
Subroutines; Stacks Lecture 20, 28Apr10:
9-269
Saving and Restoring Registers
Called routine -- “callee-save” ! Before start, save any registers that will be altered
(unless altered value is desired by calling program!) ! Before return, restore those same registers
Calling routine -- “caller-save” ! Save registers destroyed by own instructions or
by called routines (if known), if values needed later • save R7 before TRAP • save R0 before TRAP x23 (input character)
! Or avoid using those registers altogether
Values are saved by storing them in memory.
9-270
Question
Can a service routine call another service routine?
If so, is there anything special the calling service routine must do?
9-271
What about User Code?
Service routines provide three main functions: 1. Shield programmers from system-specific details. 2. Write frequently-used code just once. 3. Protect system resources from malicious/clumsy
programmers.
Are there any reasons to provide the same functions for non-system (user) code?
9-272
Subroutines
A subroutine is a program fragment that: ! lives in user space ! performs a well-defined task ! is invoked (called) by another user program ! returns control to the calling program when finished
Like a service routine, but not part of the OS ! not concerned with protecting hardware resources ! no special privilege required
Reasons for subroutines: ! reuse useful (and debugged!) code without having to
keep typing it in ! divide task among multiple programmers ! use vendor-supplied library of useful routines
9-274
JSR Instruction
Jumps to a location (like a branch but unconditional), and saves current PC (addr of next instruction) in R7. ! saving the return address is called “linking” ! target address is PC-relative (PC + Sext(IR[10:0])) ! bit 11 specifies addressing mode
• if =1, PC-relative: target address = PC + Sext(IR[10:0]) • if =0, register: target address = contents of register IR[8:6]
9-275
JSR
NOTE: PC has already been incremented during instruction fetch stage.
9-276
JSRR Instruction
Just like JSR, except Register addressing mode. ! target address is Base Register ! bit 11 specifies addressing mode
What important feature does JSRR provide that JSR does not?
9-277
JSRR
NOTE: PC has already been incremented during instruction fetch stage.
9-278
Returning from a Subroutine
RET (JMP R7) gets us back to the calling routine. ! just like TRAP
9-279
Example: Negate the value in R0
2sComp NOT R0, R0 ; flip bits ADD R0, R0, #1 ; add one RET ; return to caller
To call from a program (within 1024 instructions):
; need to compute R4 = R1 - R3 ADD R0, R3, #0 ; copy R3 to R0 JSR 2sComp ; negate ADD R4, R1, R0 ; add to R1 ...
Note: Caller should save R0 if we’ll need it later!
9-280
Passing Information to/from Subroutines
Arguments ! A value passed in to a subroutine is called an argument. ! This is a value needed by the subroutine to do its job. ! Examples:
• In 2sComp routine, R0 is the number to be negated • In OUT service routine, R0 is the character to be printed. • In PUTS routine, R0 is address of string to be printed.
Return Values ! A value passed out of a subroutine is called a return value. ! This is the value that you called the subroutine to compute. ! Examples:
• In 2sComp routine, negated value is returned in R0. • In GETC service routine, character read from the keyboard
is returned in R0.
9-281
Using Subroutines
In order to use a subroutine, a programmer must know: ! its address (or at least a label that will be bound to its address) ! its function (what does it do?)
• NOTE: The programmer does not need to know how the subroutine works, but what changes are visible in the machine’s state after the routine has run.
! its arguments (where to pass data in, if any) ! its return values (where to get computed data, if any)
9-282
Saving and Restore Registers
Since subroutines are just like service routines, we also need to save and restore registers, if needed.
Generally use “callee-save” strategy, except for return values. ! Save anything that the subroutine will alter internally
that shouldn’t be visible when the subroutine returns. ! It’s good practice to restore incoming arguments to
their original values (unless overwritten by return value).
Remember: You MUST save R7 if you call any other subroutine or service routine (TRAP). ! Otherwise, you won’t be able to return to caller.
9-288
Library Routines
Vendor may provide object files containing useful subroutines ! don’t want to provide source code -- intellectual property ! assembler/linker must support EXTERNAL symbols
(or starting address of routine must be supplied to user) ...
.EXTERNAL SQRT ...
LD R2, SQAddr ; load SQRT addr JSRR R2 ...
SQAddr .FILL SQRT
Using JSRR, because we don’t know whether SQRT is within 1024 instructions.
Confused about Type Conversion?
Example: The Bogus Program: 2 + 3 = e Section 10.4.1 (pp. 272-273)
4/29/10 CS210 289
Computer Science 210 s1c Computer Systems 1
2010 Semester 1
Lecture Notes
Credits: Slides prepared by Gregory T. Byrd, North Carolina State University
The Stack Chapter 10 And, Finally... The Stack
10-292
Stack: An Abstract Data Type
An important abstraction that you will encounter in many applications.
We will describe three uses: Interrupt-Driven I/O
! The rest of the story…
Evaluating arithmetic expressions ! Store intermediate results on stack instead of in registers
Data type conversion ! 2’s comp binary to ASCII strings
10-293
Stacks
A LIFO (last-in first-out) storage structure. ! The first thing you put in is the last thing you take out. ! The last thing you put in is the first thing you take out.
This means of access is what defines a stack, not the specific implementation.
Two main operations: PUSH: add an item to the stack POP: remove an item from the stack
By convention, R6 holds the Top of Stack (TOS) pointer. 10-297
Basic Push and Pop Code
For our implementation, stack grows downward (when item added, TOS moves closer to 0)
Push ADD R6, R6, #-1 ; decrement stack ptr
STR R0, R6, #0 ; store data (R0)
Pop LDR R0, R6, #0 ; load data from TOS ADD R6, R6, #1 ; decrement stack ptr
10-298
Pop with Underflow Detection
If we try to pop too many items off the stack, an underflow condition occurs. ! Check for underflow by checking TOS before removing data. ! Return status code in R5 (0 for success, 1 for underflow)
POP LD R1, EMPTY ; EMPTY = -x4000 ADD R2, R6, R1 ; Compare stack pointer BRz FAIL ; with x3FFF LDR R0, R6, #0 ADD R6, R6, #1 AND R5, R5, #0 ; SUCCESS: R5 = 0 RET FAIL AND R5, R5, #0 ; FAIL: R5 = 1 ADD R5, R5, #1 RET EMPTY .FILL xC000
10-299
Push with Overflow Detection
If we try to push too many items onto the stack, an overflow condition occurs. ! Check for underflow by checking TOS before adding data. ! Return status code in R5 (0 for success, 1 for overflow)
PUSH LD R1, MAX ; MAX = -x3FFB ADD R2, R6, R1 ; Compare stack pointer BRz FAIL ; with x3FFF ADD R6, R6, #-1 STR R0, R6, #0 AND R5, R5, #0 ; SUCCESS: R5 = 0 RET FAIL AND R5, R5, #0 ; FAIL: R5 = 1 ADD R5, R5, #1 RET MAX .FILL xC005
Computer Science 210 s1c Computer Systems 1
2010 Semester 1
Lecture Notes
James Goodman!
Credits: Slides prepared by Gregory T. Byrd, North Carolina State University
Stacks Lecture 21, 29Apr10:
Reminders
Due date for assignment 2 • 5pm Wednesday, 5May
Test date • Will be given in-class on Monday, 10May • Coverage:
Read section 10.4, especially 10.4.1, Example: The Bogus Program: 2 + 3 = e
See slides for same section in preliminary version of notes for week 7 (this week) on web (not covered in class)
4/29/10 CS210 303
Stack Implementation Details
In example, the first location (largest address) is never used • Push: Decrement SP, then store • Pop: Load using SP, then increment
Notice that SP always points to top element on the stack • Unless it is empty
Alternative implementation • Push: Store using SP, then decrement SP • Pop: Increment SP, then load
In first scheme, SP points to first element, but invalid address when stack is empty, and that address is never used • But points to invalid address when stack is empty • That location is never used!
In second scheme, SP points to first free location in stack
• But points to invalid address when the stack is full
4/29/10 CS210 307
10-308
Interrupt-Driven I/O (Part 2)
Interrupts were introduced in Chapter 8. 1. External device signals need to be serviced. 2. Processor saves state and starts service routine. 3. When finished, processor restores state and resumes program.
Chapter 8 didn’t explain how (2) and (3) occur, because it involves a stack.
Now, we’re ready…
Interrupt is an unscripted subroutine call, triggered by an external event.
10-309
Processor State
What state is needed to completely capture the state of a running process?
Program Counter ! Pointer to next instruction to be executed.
Registers ! All temporary state of the process that’s not stored in memory.
10-310
Where to Save Processor State?
Can’t use registers. ! Programmer doesn’t know when interrupt might occur,
so she can’t prepare by saving critical registers. ! When resuming, need to restore state exactly as it was.
Memory allocated by service routine? ! Must save state before invoking routine,
so we wouldn’t know where. ! Also, interrupts may be nested –
that is, an interrupt service routine might also get interrupted!
Use a stack! ! Location of stack “hard-wired”. ! Push state to save, pop to restore.
10-311
Supervisor Stack
A special region of memory used as the stack for interrupt service routines. ! Initial Supervisor Stack Pointer (SSP) stored in Saved.SSP. ! Another register for storing User Stack Pointer (USP):
Saved.USP.
Want to use R6 as stack pointer. ! So that our PUSH/POP routines still work.
When switching from User mode to Supervisor mode (as result of interrupt), save R6 to Saved.USP.
10-312
Invoking the Service Routine – The Details
1. If Priv = 1 (user), Saved.USP = R6, then R6 = Saved.SSP.
2. Push PSR and PC to Supervisor Stack. 3. Set PSR[15] = 0 (supervisor mode). 4. Set PSR[10:8] = priority of interrupt being serviced. 5. Set PSR[2:0] = 0. 6. Set MAR = x01vv, where vv = 8-bit interrupt vector
provided by interrupting device (e.g., keyboard = x80). 7. Load memory location (M[x01vv]) into MDR. 8. Set PC = MDR; now first instruction of ISR will be fetched.
Note: This all happens between the STORE RESULT of the last user instruction and the FETCH of the first ISR instruction.
10-313
Returning from Interrupt
Special instruction – RTI – that restores state.
1. Pop PC from supervisor stack. (PC = M[R6]; R6 = R6 + 1) 2. Pop PSR from supervisor stack. (PSR = M[R6]; R6 = R6 + 1) 3. If PSR[15] = 1, R6 = Saved.USP.
(If going back to user mode, need to restore User Stack Pointer.)
RTI is a privileged instruction. ! Can only be executed in Supervisor Mode. ! If executed in User Mode, causes an exception.
Executing ADD at location x3006 when Device B interrupts.
Saved.SSP
10-315
Example (2)
/ / / / / /
x3007 PSR for A
/ / / / / /
/ / / / / /
x6200 PC
R6
Program A
ADD x3006
Saved.USP = R6. R6 = Saved.SSP. Push PSR and PC onto stack, then transfer to Device B service routine (at x6200).
x6200
ISR for Device B
x6210 RTI
10-316
Example (3)
/ / / / / /
x3007 PSR for A
/ / / / / /
/ / / / / /
x6203 PC
R6
Program A
ADD x3006
Executing AND at x6202 when Device C interrupts.
x6200
ISR for Device B
AND x6202
x6210 RTI
10-317
Example (4)
/ / / / / /
x3007 PSR for A
x6203 PSR for B
x6300 PC
R6
Program A
ADD x3006
x6200
ISR for Device B
AND x6202
ISR for Device C
Push PSR and PC onto stack, then transfer to Device C service routine (at x6300).
x6300
x6315 RTI
x6210 RTI
10-318
Example (5)
/ / / / / /
x3007 PSR for A
x6203 PSR for B
x6203 PC
R6
Program A
ADD x3006
x6200
ISR for Device B
AND x6202
ISR for Device C
Execute RTI at x6315; pop PC and PSR from stack.
x6300
x6315 RTI
x6210 RTI
10-319
Example (6)
/ / / / / /
x3007 PSR for A
x6203 PSR for B
x3007 PC
Program A
ADD x3006
x6200
ISR for Device B
AND x6202
ISR for Device C
Execute RTI at x6210; pop PSR and PC from stack. Restore R6. Continue Program A as if nothing happened.
x6300
x6315 RTI
x6210 RTI
Saved.SSP
10-320
Exception: Internal Interrupt
When something unexpected happens inside the processor, it may cause an exception.
Examples: ! Privileged operation (e.g., RTI in user mode) ! Executing an illegal opcode ! Divide by zero ! Accessing an illegal address (e.g., protected system memory)
Handled just like an interrupt ! Vector is determined internally by type of exception ! Priority is the same as running program
