Date post: | 05-Jan-2016 |
Category: |
Documents |
Upload: | preston-doyle |
View: | 226 times |
Download: | 0 times |
CSNB374: Microprocessor Systems
Chapter 5: Procedures and Interrupts
Procedures A procedure is a group of instructions that
usually performs a particular task. Also called subroutine, method or function. Allows the same piece of code to be reused
multiple times. Save memory space. Makes it easier to write program.
A procedure begins with the PROC directive and ends with the ENDP directive. Both are preceded by the procedure’s name.
Procedures The directive PROC is followed by the procedure
type: NEAR or FAR. NEAR is used for local procedures.
Means that the statement that calls the procedure is in the same segment as the procedure itself.
NEAR procedure is assumed if the procedure type is not defined.
Most procedures are NEAR procedures. FAR is used for global procedures.
i.e. the procedure is called by other programs. Means that the calling statement is in different segment.
General procedure syntax: Name PROC Type
; Body of the procedureRETName ENDP
Procedure Call The instruction used to call a procedure
is CALL. Syntax:
CALL procedure_name For NEAR procedure call, the CALL
instruction will cause: The return address to be saved on the
stack. More specifically the offset address of the next
instruction, which is contained in the IP register. The IP register to be loaded with the offset
address which points to the procedure.
Procedure Return We can return back to the instruction
from where the procedure is called by using the RET instruction. There must be at least one RET instruction
in the procedure. The RET instruction will cause the return
address to be removed from the stack and loaded into the IP register. Will cause the program to leave the
procedure and continue executing the instruction after the CALL instruction.
Procedure Call and Return
MAIN PROC
CALL PROC1next instruction
PROC1 PROCfirst instruction
RET
Procedure Call (Before CALL)
MAIN PROC
CALL PROC1next instruction
PROC1 PROCfirst instruction
RET
Code SegmentOffset address
00100012
0200
IPStack Segment
0100
00FE
00FC
Offset address
SP
Procedure Call (After CALL)
MAIN PROC
CALL PROC1next instruction
PROC1 PROCfirst instruction
RET
Code SegmentOffset address
00100012
0200IP
Stack Segment
0100
00FE
00FC
Offset address
SP0012
Procedure Return (Before RET)
MAIN PROC
CALL PROC1next instruction
PROC1 PROCfirst instruction
RET
Code SegmentOffset address
00100012
0200
IP
Stack Segment
0100
00FE
00FC
Offset address
SP0012
0300
Procedure Call (Before CALL)
MAIN PROC
CALL PROC1next instruction
PROC1 PROCfirst instruction
RET
Code SegmentOffset address
00100012
0200
IPStack Segment
0100
00FE
00FC
Offset address
SP0300
Passing Parameters to Procedure Procedures should be made general
enough so that it can operate on any value. Therefore, we need to be able to pass
parameters to a procedure. There are three ways to pass parameters
to a procedure. Pass through registers Pass through memory Pass through stack
Passing Parameters to Procedure Pass through registers:
Parameters are put inside pre-defined registers. The procedure will read the specified registers
to get the parameters. Pass through memory:
Parameters are put inside pre-defined variables. The procedure will read the specified variables
to get the parameters. The variable can be accessed either using its
name or using a pointer (a register which contains the offset address of the variable).
Passing Parameters to Procedure Pass through stack:
Parameters are pushed into stack before the procedure is called.
The procedure will then pop the stack to get the parameters.
Need to be aware that the return address is also pushed into the stack.
A procedure may also return values to the calling procedure. Can also be achieved by passing through
registers or memory.
Passing Parameters to Procedure If a procedure is to be used by other
people, it needs to be properly commented to specify how the parameters are passed and returned.
When a procedure performs its operation, it may need to use one or more registers. If this is the case, the registers to be used must
also be specified in the comments. This will prevent the procedure from overwriting
the registers used by the calling procedure.
Passing Parameters to Procedure A procedure can also be designed not
to overwrite any register. If any register were to be used inside the
procedure, the value of the register must first be pushed into the stack.
When the procedure is done using the register, the value is popped back from the stack into the register.
From the calling procedure point of view, nothing is changed.
Interrupts An interrupt is an event that causes the
CPU to stop executing the current program and execute a procedure to handle the interrupt. The procedure called by an interrupt is called
interrupt service routine or interrupt handler. It operates much like a procedure call, but
may happen automatically. There three types of interrupts:
Hardware interrupt Software interrupt Processor exception
Hardware Interrupt Allows hardware devices to interrupt the
operation of the CPU. For example, when a keyboard key is
pressed, the CPU must be interrupted to read the key code in the keyboard buffer.
The Intel processor has three pins that are related to hardware interrupt: INTR NMI (non-maskable interrupt) INTA
Hardware Interrupt
Hardware Interrupt The general operation of a hardware
interrupt goes as follows: The hardware that needs service sends an
interrupt request signal to the processor through the INTR pin.
The processor acknowledges by sending an interrupt acknowledge signal through the INTA pin.
The interrupting device responds by sending an 8-bit interrupt number on the data bus.
This interrupt number identifies the interrupt service routine to be executed, as is unique for each device.
Hardware Interrupt The processor suspends the current task it
is executing and calls the interrupt service routine.
The interrupt service routine services the hardware device and then returns back to the task that the processor was executing.
Interrupts can be enabled/disabled using the I bit in the flag register. The instruction STI enables interrupts. The instruction CLI disables interrupts.
Hardware Interrupt The NMI pin is an interrupt input pin
which cannot be disabled. An interrupt on this pin will invoke the Type
2 interrupt. This NMI pin is normally used to signal
major faults such as: Memory and I/O parity errors, which may
indicate bad chips. Power failures
Software Interrupt Software interrupt is used by programs to
request system services. It occurs when a program calls an interrupt
service routine using the INT instruction. Syntax:
INT interrupt_number The processor will treat the software
interrupt number the same way as the interrupt number generated by a hardware device.
Processor Exception Exception occurs when a condition
arises inside the processor that requires special handling.
Example: The divide instruction may cause a divide by
zero or a divide overflow error. This will cause an interrupt of Type 0. The processor will then executes the
interrupt service routine for interrupt Type 0 to handle this error.
Interrupt Vector Interrupt vector refers to the area in memory
which contains the addresses of interrupt service routines.
Located in the first 1024 bytes of memory (000000H – 0003FFH) in real mode.
In protected mode, the interrupt vector contains the interrupt descriptor table.
There are 256 interrupt vectors. Numbered from 0 – 255 (or 0H – FFH).
Each interrupt vector contains 4 bytes. The first 2 bytes contain the offset address of the
interrupt service routine. The last 2 bytes contain the segment address of the
interrupt service routine.
Interrupt Vector To find the interrupt
vector for interrupt number n, we just need to multiply n by 4.
Example: Interrupt 9 Offset address = 9 x
4 = 36 = 0024H. Segment address =
0024H + 2 = 0026H.Offset of INT 0
Segment of INT 0
Offset of INT 1
Segment of INT 1
Offset of INT FF
Segment of INT FF
0000
0002
0004
0006
03FC
03FF
Address Memory words
Interrupt Vector Intel reserves the first 32 interrupt vectors.
Interrupt Type 0 – 31 (or 0H – 1FH). These are where the BIOS interrupts are located. The first five of these are the same in all Intel
microprocessors (Interrupt Type 0 – 4). The operating systems may load its
interrupt service routine addresses in subsequent interrupt vectors. DOS interrupts can be found in Interrupt Type
20H – 3FH. Other interrupt vectors are available to
users.
BIOS Interrupts Interrupt 0H: Divide error
Generated after DIV/IDIV instruction if divide overflow or divide by 0 occurs.
Interrupt 1H: Single-step / trap Generated after execution of each
instruction if the trap flag bit (TF) is set. Interrupt 2H: Non-maskable interrupt
Generated when a logic 1 is placed on the NMI input pin.
BIOS Interrupts Interrupt 3H: Breakpoint
The only single-byte interrupt instruction. Commonly used to store a breakpoint in a program
for debugging. Interrupt 4H: Overflow
Generated when the instruction INTO (Interrupt if Overflow) is called and the overflow flag (OF) is set.
Interrupt 5H: Print Screen Generated when the Print Screen key is pressed. Also generated when the BOUND instruction is called
and the value given is outside the boundary specified.
BIOS Interrupts Interrupt 6H: Undefined Opcode
Generated when an invalid instruction is encountered in a program.
Interrupt 7H: Coprocessor not available Generated when an attempt is made to
execute a floating-point instruction and no numeric coprocessor is not available.
Interrupt 8H: Timer Implemented by the system timer circuit. The timer circuit generates Interrupt Type 8
once every 55ms (18.2 times per second).
BIOS Interrupts Interrupt 9H: Keyboard
Generated every time a keyboard key is pressed and released.
The interrupt service routine will read the scan code and store it in the keyboard buffer.
Interrupt 10H: Video Video driver – used by software programs.
Interrupt 13H: Disk I/O Disk driver – used by software programs.
BIOS Interrupts Interrupt 14H: Serial port communication
Communication driver – used by software programs. Interrupt 16H: Keyboard I/O
Keyboard driver – used by software programs. Interrupt 17H: Printer I/O
Printer driver – used by software programs. Interrupt 1AH: Real time clock
Allows a program to get and set the real-time clock (RTC).
Interrupt 1CH: Time tick Called by INT 8 service routine. Users may write own service routine to perform
timing operations.
DOS Interrupts Interrupt 20H: Program terminate
Allows a program to return control to DOS. However, INT 21H function 4CH is more
convenient for this purpose. Interrupt 21H: Function request
Provides functions for doing keyboard, video and file operations.
Interrupt 27H: Terminate but stay resident Allows a program to stay in memory after
termination.
User-defined Interrupt Service Routines There are many situations where it is useful to
write our own interrupt service routines. Create new interrupts on the unused interrupt
numbers. Replace the default BIOS interrupt service routine.
When interrupt occurs, it will perform the operations specified by our interrupt service routine rather than the default BIOS operations.
The interrupt service routine itself is just a normal procedure.
The only difference is that the last instruction is IRET instead of RET.
However, there are extra steps required to make it an interrupt service routine
User-defined Interrupt Service Routines Steps required to set up an interrupt
service routine. Save the current interrupt vector. Place the addresses of the user-defined
interrupt service routine in the interrupt vector.
Restore the previous vector when terminating the program.
There are two INT 21H functions that can be used to get and set interrupt vectors.
User-defined Interrupt Service Routines INT 21H, Function 25H
Set interrupt vector Input: AH = 25H
AL = Interrupt numberDS:DX = Address of ISR
Output: None INT 21H, Function 35H
Get interrupt vector from vector table Input: AH = 35H
AL = Interrupt number Output: ES:BX = Address of ISR