EEL 3801 Part IV The Assembler

OFFSET Operator Returns address of variable used as operand. Actually, it represents the offset from the beginning of the segment. The destination operand must be a 16-bit register. When a register holds an address (offset) rather than the value therein, it is a pointer to that variable.

SEG Operator Returns the segment part of a label’s address. The segment from which the offset is being displaced. Not the offset.

Example Used when the base segment register must be initialized to a new segment. Assume array is in a segment other than what DS points to: push ds;Save contents of DS mov ax,seg array ; set DS to seg mov ds,ax ; of array mov bx,offset array ; set offset.; compute whatever pop ds; restore original DS

PTR Operator Specifies the size of an operand. Can override an operand’s default size –BYTE PTR (8-bit) –WORD PTR (16-bit) –DWORD PTR (32-bit) –QWORD PTR (64-bit) –TBYTE PTR (80-bit)

LABEL Directive Another way to override a variable’s default type. Does not allocate more memory Just redefines an existing variable.

Transfer of Control Instructions CPU executes instructions sequentially, in the exact order presented. Occasionally, we want a slightly different order of execution, –so must tell assembler so that it knows what is the next instruction to load and decode prior to execution.

Transfer of Control Instructions (cont.) Two types: –Conditional transfers –Unconditional transfers.

Unconditional Transfers Program branches to new location all the time, unconditionally. New value loaded into the instruction pointer.

Conditional Transfer Branching only if certain conditions are true. CPU interprets true/false condition based on content of CX and Flags registers. Some examples of these instructions:

JMP Instruction Tells CPU to begin execution at another location. New location to be identified by label Label translated by assembler into new address. If jump is to label in current segment, label’s offset loaded into the IP register. If jump is to another segment, segment address additionally loaded into CS.

JMP Instruction (cont.) Syntax is: JMP SHORT/NEAR PTR/FAR PTR destination where SHORT => destination within –128 to 127 bytes NEAR PTR => destination in same segment (default) FAR PTR => destination in another segment destination => a label or 32 bit segment-offset address.

JMP Instruction (cont.) Can move to just about anywhere, to same procedure, to another procedure, to another segment, to RAM or ROM or completely out of the current program. Loop based on JMP will never end.

LOOP Instruction Repeats a block of instructions a specific number of times. Uses CX as a counter, and decrements it every iteration. The number of cycles must be loaded into CX prior to the loop taking place. Format is: LOOP destination

LOOP Instruction (cont.) Destination must be from –128 to 127 bytes away from the current location. Destination typically behind loop instruction. When it gets to LOOP, assembler decrements CX by 1. If not zero, transfers control to destination.

Example #1 mov cx,12*80 next: mov ah,2;DOS function display char mov dl,’A’ int 21h; Call DOS function on ah loop next

Example #2 sum_an_array: mov ax,0 mov di,offset intarray mov cx,4 ; array size read_int: add ax,[di]; add integer to accum add di,2 loop read_int intarray dw 200h, 100h, 300h, 600h

Procedures It is generally infeasible to write a program consisting of long sequence of instructions. True in assembly or high level language. More likely, blocks of code that do something logically related complex mathematical calculation, setting up or retrieving a data structure, printing something reading a file.

Procedures (cont) By grouping and interacting these blocks of code, a program is much easier to write, debug and document. Moreover, the blocks of code may be reusable either in the same program, or in other programs. These blocks of code are called procedures, or subroutines.

Procedures (cont) Procedures or subroutines represent a branching of the program control when a call to a subroutine is reached in the program execution. The assembler must return to the instruction after the one that called the subroutine.

Procedures (cont) The subroutine can be called through the instruction CALL followed by the name of the subroutine. CALL saves address of next instruction to stack, depending on whether near or far call. This is different from the JMP instruction: –JMP does not require a return to the original address from where it was called.

Procedures (cont) Subroutines that return a value. They are typically equated to a label that takes on the value resulting from the function execution. Procedures do not normally return a value. PROC and ENDP are the bookends that mark the beginning and end of a procedure.

Procedures (cont) These directives must include the name of the procedure, which precedes the directive itself. Procedures must include the RET (return) instruction to pop old value of address from run-time stack. Procedures must not be overlapped. See example on page 107 of text book.

Near and Far Procedures The difference between them is how the assembler remembers where to return to.

Near Call Calling procedure and called procedure are in the same segment of the program. Assembler generates machine code for a near call. Before branching to the subroutine, the CALL instruction preserves the current content of the IP register (the instruction pointer) onto the run-time stack.

Near Call (cont) Remember that the IP points to the next instruction to be executed. It then copies the address of the first instruction of the called subroutine into the IP register. Thus, the CPU follows that sequence of instructions that begins at that address.

Near Call (cont.) At the end of the subroutine, the RET instruction pops the old value of IP into it again from the stack. Execution then resumes right from where the call was made.

Far Call This happens when the calling and called subroutines are in different segments of the code. The assembler then does a far call. Now the CALL instruction preserves both the contents of the IP and the CS register onto the stack. Uses a RETF instruction instead of RET.

Nested Calls Calls can be nested. The CALL instruction keeps the addresses in the run-time stack on a last-in-first-out basis, so there is no problem. The RET instructions are called in reverse order. See example on page 113, Figure 5.7.

Interrupts There are reasons why the CPU needs to be interrupted from its activity. Two types of interrupts: –Hardware interrupts –Software interrupts

Hardware Interrupts Are signals from other parts of the system (hardware) that something needs immediate attention from the CPU. These signals are generated by the Interrupt Controller, a chip called the 8529IC. They allow for important events occurring in the background to be “noticed” by the CPU and immediately acted upon.

Hardware Interrupts - Examples Examples of hardware interrupts are inputs that would be lost if not read and processed quickly. Sources of such interrupts are: –the keyboard, –external memory (disk) drives, –system clock.

The Interrupt Flag Occasionally, however, some processes are highly time-sensitive and do not tolerate any interrupts. The programmer can allow for this by turning off the ability to interrupt the CPU. This is done through the interrupt flag, IF.

The Interrupt Flag (cont.) When the IF is set, interrupts are enabled (normal value); When clear, interrupts are disabled. Instruction CLI clears the interrupt flag (disallows interrupts), Instruction STI sets the interrupt flag (re- enables interrupts).

Software Interrupts These are not really interrupts at all, but rather calls to outside routines such as BIOS or DOS functions. The INT instruction is used to introduce such “interrupts”. format as follows: INT number

The INT Instruction Calls a routine type identified by a number. The number can range between 0 and FFh. The routine type can be one of several, and each type will have its own range of possible functions. The number indicated as an operand of the INT instruction then is referred to the Interrupt Vector Table (IVT).

The INT Instruction (cont.) INT maps all the interrupt numbers to operating system subroutine type. IVT located in the lowest 1KB of memory. Each entry is a 32-bit segment-offset address, which points to the location where the Operating System subroutine resides. Executes the routine at that address.

The INT Instruction (cont.) The various interrupt types are: INT 10h: Video services (cursor position, graphics, scroll) INT 16h: Keyboard services (read keyboard and check status) INT 17h: Printer services (initialize, print, return printer status). INT 1Ah: Time of Day (no. of ticks since machine turned on)

The INT Instruction (cont.) INT 1Ch: User Timer Interrupt (executed 18.2 times per sec.) INT 21h: DOS services (DOS routines for file handling, memory management, I/O, - DOS function calls) The instruction IRET (interrupt return) tells the processor to resume execution at the next instruction of the calling program.

DOS Function Calls Called by INT 21h interrupt serv. routine Before the function type executes, it looks in register AH to determine the function number that identifies the subroutine itself (NOT the type of interrupt). Listed in page 116, figure 5.9.

DOS Function Calls These numbers are the ones that must be represented in register AH, as that is where the processor looks to see what the function number is. These are described in detail in the book. Please read over.

BIOS Level Video Control Instructions The BIOS level video control instructions are also listed in detail in the book. Please read them over.