DOSPLUS 3.5 for the Model III - SYS6/SYS Disassembled

SYS6/SYS

Other Navigation

DOSPLUS 3.5 SYS6/SYS Disassembly - The DEBUG Monitor (Model III)

SYS6/SYS is the low overlay of the DEBUG monitor, requested with code 53H by DEBUG@ (440DH). DEBUG@ is reached by an RST 30H (the monitor's breakpoints are RST 30H instructions, F7H), by the BREAK key when the DEBUG on BREAK switch at 429BHH is set, and by the D key at start-up; with DEBUG on, ABORT@ also leads to it. The file is a load module of 5 blocks, 1022 bytes, from 4E00H to 51FDH, with the transfer address 4E00H. Its variables are outside the overlay, at 4265HH-4286HH, so the breakpoints, the display mode and the addresses last from one entry to the next.

The Parts of SYS6/SYS

Entering and Leaving

The monitor drops the overlay handler's return and the word it saved from 429AHH-429BHH, so it never returns through the handler, and saves the program's registers on the stack and from there to 426DHH-4284HH: AF, BC, DE, HL, the alternate set, IX, IY, the SP and the PC (the return address of the RST 30H or the call to DEBUG@). It then runs on the program's stack. When the byte before the PC is F7H, the PC is moved back onto it, so a breakpoint's own instruction runs next; then both breakpoints are taken out, each one's old byte put back if the F7H is still there (4E36H).

G takes an address for the PC and up to two breakpoints; O goes to EXIT@ (402DH). Both set 429BHH to FFH, so BREAK enters DEBUG again, put every register back from the save area and jump to the PC (4FA7H). A breakpoint that cannot be set (the F7H does not stay, as in ROM) sends the monitor back to its command loop (4FCDH).

The Display and the Commands

X shows the twelve registers, each with the 16 bytes at its address in hexadecimal or as characters (H or A), or the flags as letters (S Z 1 H 1 P N C, a minus sign for a clear flag) for AF and AF', then four lines of memory from the display address; S shows sixteen lines, the 256 byte page of that address. ; and - move the display by 64 or 256 bytes, D sets its address and U repeats the display until a key is pressed. Commands are typed on the last line of the screen (3FC0H). M shows the address and the byte on lines 13 and 14, marks the byte in the memory lines with the graphics 8AH and 85H, and takes new values, a space or comma moving on and ENTER ending. R takes a register name and a value. Numbers are hexadecimal, ended by a space, a comma or ENTER (51A2H); a wrong key ends the command.

The Single Step

I and C find the length and kind of the instruction at the PC in three tables of masks (50E3H, 5111H, 5118H): one byte opcodes, those after EDH, those after DDH and FDH. A breakpoint goes after the instruction; a jump, call or return also gets one at its target: the operand's address (JP, CALL), the displacement (JR, DJNZ), the word at the program's SP (RET, RETN, RETI), or the saved HL, IX or IY (JP (HL), JP (IX), JP (IY)). C does not follow a CALL: the call runs to the breakpoint after it. Conditional instructions get both breakpoints. An RST is treated as a one byte instruction, so the step runs the whole restart routine before it stops.

Differences from the Manual

The manual lists the commands as the bytes have them. Three things it does not say: the step of JP (IX) takes its target from IY, because the test at 50D2H looks at bit 5 of the byte after the prefix (E9H) instead of the prefix itself; the M command keeps its address in the second breakpoint block; and the C command steps over a call by running it.

Differences from the Model I

The code is the Model I SYS6/SYS at the same addresses; only the work area is elsewhere, 4265H-4286H in place of 405DH-407EH, and the DEBUG on BREAK switch is 429BH. The screen addresses (3F40H, 3F80H, 3FC0H) and the ROM routines (0033H, 0049H, 002BH) are the same.

4265H - The Monitor's Work Area

Not in the file: SYS6/SYS keeps its variables in the RAM at 4265H-4286H, outside the overlay area, so they last from one entry of the monitor to the next.

4E00H - The Routine Table

Data: SYS6/SYS's table of routines 2 and 3, one word each, used by SYS0/SYS's overlay request handler (its 49D3H-49E6H) for the request codes 52H and 53H. DEBUG@ (440DH, which jumps to 445DH) requests 53H; no file of the diskette requests 52H.

4E04H - Routine 2

Nothing to do when SYS0/SYS's record locator brings SYS6/SYS back.

4E06H - DEBUG - Entering the Monitor

Routine 3, requested by DEBUG@ (445DH: PUSH AF / LD A,53H / RST 28H), which RST 30H (400FH), the BREAK key with 429BH set, and the start-up's D key reach. The stack holds the handler's return 49E7H, the word it saved from 429AH-429BH, the program's AF and the program's return address (its PC). The monitor saves every register of the program to 426DH-4284H (the PC at 4283H, the SP at 4281H), runs on the program's own stack, steps the PC back over an RST 30H breakpoint, and takes its two breakpoints out of memory.

4E52H - The Command Loop

Shows the display, reads a command key on the bottom line and runs the command. Every command returns here (4E52H is pushed as its return), which also resets the Stack Pointer from 4281H. G and O leave the monitor; S and X choose the display, A and H the form of memory bytes, ; and - move the memory display, D sets its address, U updates the display until a key is pressed, M changes memory, R changes a register, and I and C step one instruction.

4ED7H - The Display

Clears the screen (cursor home and 1CH) and shows either the register display (X: the twelve registers, each with the 16 bytes at its address or, for AF and AF', the flags, then four lines of memory from 426BH) or the full screen display (S: sixteen lines of 16 bytes from the start of the 256 byte page of 426BH).

4F83H - O and G - Leaving the Monitor

O puts 402DH (EXIT@) into the PC and goes; G takes an optional address for the PC and up to two breakpoint addresses (separated by a comma or a space, ENTER ending). Going sets 429BH, so BREAK enters DEBUG again, puts the registers back from the save area, loads the Stack Pointer and jumps to the PC with Register Pair HL restored last.

4FCDH - Setting a Breakpoint

Puts an RST 30H (F7H) at Register Pair HL and records the address and the old byte in the block that ends at Register Pair DE (the byte at Register Pair DE, then the address below it); Register Pair DE returns 3 bytes lower, the end of the block before. When the byte does not take the F7H (ROM), the monitor goes back to 4E36H, which takes out what was set.

4FDEH - M - Changing Memory

Takes an optional address (else the last one, 4268H), shows the display with the address on line 13 and the byte on line 14 (and the byte marked in the memory lines by 8AH and 85H), and takes a new value: a value is stored, nothing typed leaves the byte, a space or comma moves on to the next address, ENTER ends. The address is kept in 4268H-4269H, the second breakpoint block, which 4E36H cleared on entry.

5014H - R - Changing a Register

Takes a register name of two characters, or three for AF', BC', DE' and HL', then a space or comma and a hexadecimal value, which is stored in the save area; the name is looked up in the table at 4F57H.

5060H - I and C - The Single Step

Finds the length and the kind of the instruction at the PC from three tables of masks (5080H): 50E3H for one byte opcodes, 5111H after EDH and 5118H after DDH or FDH. A breakpoint goes after the instruction (block 4268H-426AH); for a jump, a call or a return a second breakpoint goes at its target (block 4265H-4267H), worked out from the saved registers. The C command does not follow a CALL: only the breakpoint after it is set. Then the program goes (4FA7H) and comes back to the monitor at the first breakpoint it reaches.

50E3H - The Instruction Tables

Data: entries of three bytes, a mask, a value and a byte that gives the kind (bits 7-4) and the length (bits 3-0) of the instructions whose byte, ANDed with the mask, equals the value; the first entry that matches is taken. Each table ends with a byte below 05H, the length of every instruction it does not list. Kinds: 00H no jump, 10H JP (HL), 20H JP (IX) or (IY), 30H relative, 40H to the operand's address, 50H return, 60H call.

5134H - A Line of 16 Bytes

Displays a colon and a space, then the 16 bytes at Register Pair HL, in hexadecimal (H) or as characters (A, a dot for a control or space compression code). Before each byte 5163H displays a space, or 8AH and 85H around the byte at 4268H (the address of the M command), and an extra space after the eighth byte. Register Pair HL returns 16 bytes on.

5187H - Reading a Key

Waits for a key (ROM 0049H) and returns it in Register A. ENTER returns the Z FLAG and the C FLAG without displaying it; a comma or a space is displayed and returns the Z FLAG; any other key is displayed and returns the NZ FLAG, letters as capitals. Register Pair DE is kept.

51A2H - Reading a Hexadecimal Number

Reads hexadecimal digits into Register Pair HL until ENTER, a space or a comma. With no digit before the separator the Z FLAG returns and Register Pair HL is kept. With digits the NZ FLAG returns, with the C FLAG when ENTER ended them (the RRA / ADC A,81H at 51BAH turns the C FLAG of 5187H into that result). A key that is not a digit goes back to the command loop at 4E52H.

51CFH - Displaying Numbers and Characters

51CFH displays the byte at Register Pair HL in hexadecimal and moves Register Pair HL on; 51D3H displays Register Pair HL as four digits; 51D8H Register A as two digits; 51E1H the low four bits of Register A as one digit; 51ECH a space; 51F0H a carriage return; 51F4H the three characters at Register Pair HL, which moves on 3. All display through the ROM's 0033H.