| /* %%%%%%%%%%%%%%%%%%%% (c) William Landi 1991 %%%%%%%%%%%%%%%%%%%%%%%%%%%% */ |
| /* Permission to use this code is granted as long as the copyright */ |
| /* notice remains in place. */ |
| |
| /* =============================== debugger.c =============================== */ |
| /* Drives the whole simulatation/debugging process. Contains the debugging */ |
| /* Routines and calls the simulation routines (else where defined). */ |
| #include <string.h> |
| #include "memory.h" |
| #include "boolean.h" |
| #include "constants.h" |
| #include "sym_tab.h" |
| #include "sim_debug.h" |
| #include "machine.h" |
| #include "stringI.h" |
| /* ---------------------------------- Globals ------------------------------ */ |
| /* MAIN_ROUTINE Name of (program) module declared with */ |
| /* a START (main routine). */ |
| char MAIN_ROUTINE[LABEL_SIZE_1+1]; |
| |
| /* START_ADDRESS Location where execution begins */ |
| int START_ADDRESS = 0; |
| |
| /* SYM_TAB The symbol table */ |
| SYMBOL_TABLE SYM_TAB; |
| |
| /* RETURN_STATUS Status of machine when control returned*/ |
| int RETURN_STATUS = HALT_1; /* to debugger. */ |
| |
| /* TYPE_OUT_MODE Remembers the type out mode */ |
| char TYPE_OUT_MODE[6] = "Hex"; |
| |
| /* ----------------------------- Non-Globals ------------------------------- */ |
| #define MAX_NUM_BREAK_POINTS 16 |
| int BREAK_POINTS[MAX_NUM_BREAK_POINTS+1]; |
| int SORTED_BREAK_POINTS[MAX_NUM_BREAK_POINTS+1]; |
| int NUM_BREAK_POINTS = 0; |
| BOOLEAN TRACE = FALSE_1; |
| |
| /* ---------------------------- Procedures --------------------------------- */ |
| |
| extern int CHAR_TO_DIGIT(char CH,int NUM_BASE); |
| |
| /* -------------------------- IS_PREFIX_TO (local) ------------------------- */ |
| /* Returns TRUE iff PREFIX is a prefix of WORD */ |
| BOOLEAN IS_PREFIX_TO(char *PREFIX,char *WORD) |
| { |
| int COUNT; |
| int LEN; |
| |
| if ((LEN = strlen(PREFIX)) > strlen(WORD)) return FALSE_1; |
| for (COUNT=0; COUNT < LEN; COUNT ++) |
| if (PREFIX[COUNT] != WORD[COUNT]) return FALSE_1; |
| return TRUE_1; |
| } |
| |
| /* ---------------------------- REMOVE_WS (local) ------------------------- */ |
| /* Line is a pointer to a string. Changes LINE to point to the string that */ |
| /* starts at the first non-blank/tab character in *LINE. */ |
| void REMOVE_WS(char **LINE) |
| { |
| /* Skip SPACEs and TABs */ |
| while (((**LINE) == ' ') || ((**LINE) == ' ')) |
| (*LINE) ++; |
| } |
| |
| /* ------ Different types of things need to type into the debugger. */ |
| #define ADDRESS_0 0 |
| #define ADDR_REG_0 1 |
| #define NUMBER_0 2 |
| #define VALUE_0 3 |
| /* ----------------------------- TYPE_IN (local) --------------------------- */ |
| /* Return a value specified by a type in mode. Assumes: */ |
| /* No $ prefix Hexidecimal input */ |
| /* $D prefix Decimal input */ |
| /* $C prefix Character input. */ |
| /* $S prefix Address of a LABEL returned. */ |
| int TYPE_IN(char **COMMAND,BOOLEAN *LEGAL,int RESULT_TYPE) |
| { |
| int VALUE = 0; |
| int LOOP; |
| |
| (*LEGAL) = TRUE_1; |
| REMOVE_WS(COMMAND); |
| if ( (**COMMAND) == '$') |
| { |
| (*COMMAND) ++; |
| switch (**COMMAND) { |
| /* -------------------------------- $D prefix ------------------------------ */ |
| case 'D': |
| (*COMMAND) ++; |
| if (CHAR_TO_DIGIT((**COMMAND),10) == -1) { |
| (void) printf("Expected an decimal, found '%s'. Ignoring command.\n", |
| *COMMAND); |
| (*LEGAL) = FALSE_1; |
| } else { |
| while (CHAR_TO_DIGIT((**COMMAND),10) != -1) { |
| VALUE = VALUE * 10 + CHAR_TO_DIGIT((**COMMAND),10); |
| (*COMMAND) ++; |
| } |
| } |
| break; |
| |
| /* -------------------------------- $C prefix ------------------------------ */ |
| case 'C': |
| if (RESULT_TYPE != VALUE_0) (*LEGAL) = FALSE_1; |
| else { |
| (*COMMAND) ++; |
| VALUE = (int) **COMMAND; |
| if ( (**COMMAND != '\0')) (*COMMAND) ++; |
| } |
| break; |
| |
| /* -------------------------------- $S prefix ------------------------------ */ |
| case 'S': |
| if (RESULT_TYPE == NUMBER_0) (*LEGAL) = FALSE_1; |
| else { |
| (*COMMAND) ++; |
| REMOVE_WS(COMMAND); |
| if (!( ((**COMMAND) >= 'A') && ((**COMMAND) <= 'Z'))) { |
| (void) printf( |
| "Expected an identifier, found '%s'. Ignoring command.\n", |
| *COMMAND); |
| (*LEGAL) = FALSE_1; |
| return 0; |
| } else { |
| char SYMBOL[LABEL_SIZE_1+1]; |
| struct SYMBOL_TABLE_ENTRY *SYMB; |
| |
| for (LOOP=0; ( (LOOP < LABEL_SIZE_1) && |
| ( ((**COMMAND) >= 'A') && ((**COMMAND) <= 'Z'))); |
| LOOP ++) { |
| SYMBOL[LOOP] = **COMMAND; |
| (*COMMAND) ++; |
| } |
| for (;LOOP<LABEL_SIZE_1;LOOP++) |
| SYMBOL[LOOP] = ' '; |
| SYMBOL[LABEL_SIZE_1] = '\0'; |
| SYMB = LOOK_UP_SYMBOL(GLOBAL_1,SYMBOL,&SYM_TAB); |
| if (SYMB == NULL) { |
| (void) printf( |
| "Unknown identifier, found '%s'. Ignoring command.\n", |
| SYMBOL); |
| (*LEGAL) = FALSE_1; |
| return 0; |
| } |
| VALUE = (*SYMB).LOCATION; |
| } |
| } |
| break; |
| default: |
| (*LEGAL) = FALSE_1; |
| } |
| |
| if (!(*LEGAL)) { |
| switch (RESULT_TYPE) { |
| case ADDRESS_0: |
| (void) printf("Expected an type-in mode specifier ($D or $S).\n"); |
| break; |
| case NUMBER_0: |
| (void) printf("Expected an type-in mode specifier ($D).\n"); |
| break; |
| case ADDR_REG_0: |
| (void) printf( |
| "Expected an type-in mode specifier ($D, $S or $R).\n"); |
| break; |
| case VALUE_0: |
| (void) printf( |
| "Expected an type-in mode specifier ($C, $D, or $S).\n"); |
| break; |
| default: ; |
| } |
| (void) printf (" Found $%c. Ignoring command.\n",(**COMMAND)); |
| } |
| } |
| else |
| /* --------------------------NO $ prefix (hex) ----------------------------- */ |
| if (CHAR_TO_DIGIT((**COMMAND),16) == -1) { |
| |
| (void) printf("Expected an hexidecimal, found '%s'. Ignoring command.\n", |
| *COMMAND); |
| (*LEGAL) = FALSE_1; |
| } else { |
| while (CHAR_TO_DIGIT((**COMMAND),16) != -1) { |
| VALUE = VALUE * 16 + CHAR_TO_DIGIT((**COMMAND),16); |
| (*COMMAND) ++; |
| } |
| } |
| |
| return VALUE; |
| } |
| |
| /* ---------------------------- EXAMINE (local) ---------------------------- */ |
| /* DEBUGGER COMMAND. */ |
| /* Print of the contents of a register of memory location or store into a */ |
| /* Register or memory location. */ |
| void EXAMINE(char *COMMAND,BOOLEAN *LEGAL) |
| { |
| int ADDRESS; /* Register number of memory address dealing */ |
| /* with. */ |
| int VALUE; /* Value to store (if necessary) */ |
| char *START; /* START of address/register in command. */ |
| char *END; /* END of address/register in command. */ |
| BOOLEAN NO_ERROR; /* TRUE iff NO_ERROR has been found. */ |
| BOOLEAN STORE = FALSE_1; /* TRUE if a store command, else FALSE */ |
| |
| (*LEGAL) = TRUE_1; |
| REMOVE_WS(&COMMAND); |
| START = (COMMAND); |
| if (strlen(COMMAND) <2) ADDRESS = TYPE_IN(&COMMAND,&NO_ERROR,ADDR_REG_0); |
| else if ((COMMAND[0] != '$') || (COMMAND[1] != 'R')) |
| ADDRESS = TYPE_IN(&COMMAND,&NO_ERROR,ADDR_REG_0); |
| else { |
| /* ~~~~~~~~~~~~~~~~~~~~~ Get register number if $R type in mode. */ |
| COMMAND += 2; |
| switch (*COMMAND) { |
| case 'A': |
| ADDRESS = 0; break; |
| case 'X': |
| ADDRESS = 1; break; |
| case 'L': |
| ADDRESS = 2; break; |
| case 'B': |
| ADDRESS = 3; break; |
| case 'S': |
| if (*(COMMAND+1) == 'W') { |
| (COMMAND) ++; |
| ADDRESS = 9; |
| } else ADDRESS = 4; |
| break; |
| case 'T': |
| ADDRESS = 5; break; |
| case 'P': |
| if (*(COMMAND+1) == 'C') { |
| COMMAND ++; |
| ADDRESS = 8; |
| } else ADDRESS = -1; |
| break; |
| default: |
| ADDRESS = -1; break; |
| } |
| if (ADDRESS == -1) { |
| (void) printf( |
| "Expected a valid register name (A,X,L,B,S,T,SW, or PC).\n"); |
| (void) printf(" Found %s. Ignoring command.\n",COMMAND); |
| return; |
| } |
| /* ~~~~~~~~~~~~~~~~~~~~~ Handle registers. */ |
| COMMAND++; |
| END = COMMAND; |
| REMOVE_WS(&COMMAND); |
| /* --------------------- if '=' then a store command */ |
| if ((*COMMAND) == '=') { |
| COMMAND++; |
| VALUE = TYPE_IN(&COMMAND,&NO_ERROR,VALUE_0); |
| if (!NO_ERROR) return; |
| REMOVE_WS(&COMMAND); |
| STORE = TRUE_1; |
| } |
| if ((*COMMAND) != '\0') { |
| (void) printf( |
| "Expected end of statement, found '%s'. Ignoring command.\n" |
| ,COMMAND); |
| return; |
| } |
| else { |
| /* ------------------------ Do what is supposed to be done. */ |
| (*END) = '\0'; |
| if (STORE) { |
| REGISTER[ADDRESS] = VALUE; |
| (void) printf("Set "); |
| } |
| (void) printf("Register %s = ",START); |
| (void) PRINT_CONSTANT("",REGISTER[ADDRESS],".\n"); |
| return; |
| } |
| } |
| { |
| /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Handle memory address */ |
| END = COMMAND; |
| REMOVE_WS(&COMMAND); |
| if (NO_ERROR) |
| if ( (0 > ADDRESS) || (MEM_SIZE_1 <= ADDRESS+2)) |
| PRINT_CONSTANT("",ADDRESS," is a legal memory [word] address.\n"); |
| else { |
| /* --------------------- if '=' then a store command */ |
| if ((*COMMAND) == '=') { |
| COMMAND++; |
| VALUE = TYPE_IN(&COMMAND,&NO_ERROR,VALUE_0); |
| if (!NO_ERROR) return; |
| REMOVE_WS(&COMMAND); |
| STORE = TRUE_1; |
| } |
| |
| if ((*COMMAND) != '\0') |
| (void) printf( |
| "Expected end of statement, found '%s'. Ignoring command.\n" |
| ,COMMAND); |
| else { |
| |
| (*END) = '\0'; |
| /* ------------ Take the appropriate action (STORE/EXAMINE) */ |
| if (STORE) { |
| REGISTER[ADDRESS] = VALUE; |
| MEMORY[ADDRESS] = VALUE/(256*256); |
| MEMORY[ADDRESS+1] = (VALUE - INT(MEMORY[ADDRESS])*256*256)/256; |
| MEMORY[ADDRESS+2] = (VALUE - INT(MEMORY[ADDRESS+1])*256); |
| (void) printf("Set "); |
| } |
| VALUE = ((INT(MEMORY[ADDRESS])*256 + INT(MEMORY[ADDRESS+1]))*256+ |
| INT(MEMORY[ADDRESS+2])); |
| (void) printf("Location %s = ",START); |
| if (TYPE_OUT_MODE[0] != 'I') |
| PRINT_ADDRESS("",VALUE,".\n"); |
| else { |
| (void) printf("\n"); |
| PRINT_INSTRUCTION(ADDRESS,TRUE_1,&VALUE); |
| } |
| } |
| } |
| } |
| } |
| |
| /* ---------------------------- LIST_BP (local) ---------------------------- */ |
| /* DEBUGGER COMMAND. */ |
| /* Print out all the currently set break points. */ |
| void LIST_BP(char *COMMAND,BOOLEAN *LEGAL) |
| { |
| int COUNT; /* A loop counter. */ |
| |
| REMOVE_WS(&COMMAND); |
| (*LEGAL) = TRUE_1; |
| |
| if ((*COMMAND) != '\0') |
| (void) printf("Expected end of statement, found '%s'. Ignoring command.\n" |
| ,COMMAND); |
| else |
| if (NUM_BREAK_POINTS == 0) |
| (void) printf("No break points set.\n"); |
| else for (COUNT=0;COUNT<MAX_NUM_BREAK_POINTS;COUNT++) |
| if (BREAK_POINTS[COUNT] != -1) { |
| PRINT_CONSTANT("Set B",COUNT,"= "); |
| PRINT_ADDRESS("",BREAK_POINTS[COUNT],"\n"); |
| } |
| } |
| |
| /* ---------------------------- SET_BP (local) ----------------------------- */ |
| /* DEBUGGER COMMAND. */ |
| /* Check if list breakpoint command. If so call LIST_BP, other wise set a */ |
| /* break point. A sorted version of the breakpoints is kept so that binary */ |
| /* search can be used on them. */ |
| void SET_BP(char *COMMAND,BOOLEAN *LEGAL) |
| { |
| BOOLEAN NO_ERROR; /* TRUE iff NO_ERROR has been found. */ |
| int ADDR; |
| int OPEN_SPOT; |
| int COUNT; |
| |
| if ((*COMMAND) == '?') { |
| LIST_BP(&(COMMAND[1]),LEGAL); |
| return; |
| } |
| (*LEGAL) = TRUE_1; |
| ADDR = TYPE_IN(&COMMAND,&NO_ERROR,ADDRESS_0); |
| REMOVE_WS(&COMMAND); |
| if (NO_ERROR) |
| if ( (0 > ADDR) || (MEM_SIZE_1 <= ADDR)) |
| PRINT_CONSTANT( |
| "Address specified ",ADDR," out of range. No break point set.\n"); |
| else if (NUM_BREAK_POINTS == MAX_NUM_BREAK_POINTS) |
| PRINT_CONSTANT("All ",MAX_NUM_BREAK_POINTS," breakpoints are in use.\n"); |
| else if ((*COMMAND) != '\0') |
| (void) printf("Expected end of statement, found '%s'. Ignoring command.\n" |
| ,COMMAND); |
| else { |
| for (OPEN_SPOT=0;BREAK_POINTS[OPEN_SPOT] != -1; OPEN_SPOT++); |
| BREAK_POINTS[OPEN_SPOT] = ADDR; |
| |
| for (COUNT=NUM_BREAK_POINTS; |
| ((BREAK_POINTS[SORTED_BREAK_POINTS[COUNT]] > ADDR) && |
| (COUNT > 0)); |
| COUNT --) |
| SORTED_BREAK_POINTS[COUNT+1] = SORTED_BREAK_POINTS[COUNT]; |
| SORTED_BREAK_POINTS[COUNT+1] = OPEN_SPOT; |
| NUM_BREAK_POINTS ++; |
| PRINT_CONSTANT("Set B",OPEN_SPOT,"= "); |
| PRINT_ADDRESS("",BREAK_POINTS[OPEN_SPOT],"\n"); |
| } |
| } |
| |
| /* ----------------------------- RESET (local) ----------------------------- */ |
| /* DEBUGGER COMMAND. */ |
| /* Remove the specified break point. */ |
| void RESET_BP(char *COMMAND,BOOLEAN *LEGAL) |
| { |
| BOOLEAN NO_ERROR; /* TRUE iff NO_ERROR has been found. */ |
| int NUM; /* NUM of the break point to remove. */ |
| int BP; /* Loop counter, steps through the break points*/ |
| |
| (*LEGAL) = TRUE_1; |
| NUM = TYPE_IN(&COMMAND,&NO_ERROR,NUMBER_0); |
| REMOVE_WS(&COMMAND); |
| if (NO_ERROR) |
| if ( (0 > NUM) || (NUM_BREAK_POINTS <= NUM)) { |
| PRINT_CONSTANT("",NUM," is not a legal break point.\n"); |
| PRINT_CONSTANT("Expected a number 0 - ",MAX_NUM_BREAK_POINTS, |
| ". Command ignored.\n"); |
| } |
| else if ((*COMMAND) != '\0') |
| (void) printf("Expected end of statement, found '%s'. Ignoring command.\n" |
| ,COMMAND); |
| else |
| if (BREAK_POINTS[NUM] == -1) |
| PRINT_CONSTANT("Break point ",NUM," is not set. Command ignored.\n"); |
| else { |
| for (BP=1; |
| ((SORTED_BREAK_POINTS[BP] != NUM) && (BP <= NUM_BREAK_POINTS)); |
| BP++); |
| BREAK_POINTS[NUM] = -1; |
| for (;BP <= NUM_BREAK_POINTS; BP ++) |
| SORTED_BREAK_POINTS[BP] = SORTED_BREAK_POINTS[BP+1]; |
| NUM_BREAK_POINTS --; |
| PRINT_CONSTANT("Removed break point ",NUM,".\n"); |
| } |
| } |
| |
| /* ------------------------------ AT_BREAK_POINT (local) ------------------- */ |
| /* returns TRUE iff PC points to an instruction that has a byte in it that */ |
| /* has been set as a break point. */ |
| BOOLEAN AT_BREAK_POINT(void) |
| { |
| /* Binary Searches the sorted array of break_points for the breakpoint */ |
| int MID; |
| int HIGH; |
| int LOW = 1; |
| int RANGE; /* How many bytes the instruction is */ |
| |
| if (NUM_BREAK_POINTS == 0) return FALSE_1; |
| HIGH = NUM_BREAK_POINTS; |
| PRINT_INSTRUCTION(PC_0,FALSE_1,&RANGE); |
| do { |
| MID = (LOW + HIGH)/2; |
| if ((BREAK_POINTS[SORTED_BREAK_POINTS[MID]] >= PC_0) && |
| (BREAK_POINTS[SORTED_BREAK_POINTS[MID]] <= PC_0 + RANGE - 1)) |
| return TRUE_1; |
| if (BREAK_POINTS[SORTED_BREAK_POINTS[MID]] <= PC_0) |
| LOW = MID + 1; |
| else HIGH = MID - 1; |
| } while (LOW <= HIGH); |
| return FALSE_1; |
| } |
| |
| /* ---------------------------- RUN_IT (local) ----------------------------- */ |
| /* DEBUGGER COMMAND. */ |
| /* Set up the machine for execution of the proceedure and keep executing */ |
| /* instructions until it stops or hits a break point. */ |
| void RUN_IT(char *COMMAND,BOOLEAN *LEGAL) |
| { |
| REMOVE_WS(&COMMAND); |
| (*LEGAL) = TRUE_1; |
| |
| if ((*COMMAND) != '\0') |
| (void) printf("Expected end of statement, found '%s'. Ignoring command.\n" |
| ,COMMAND); |
| else { |
| int DONT_CARE; |
| |
| RETURN_STATUS = EXECUTING_1; |
| L_0 = RETURN_TO_OS_1; |
| PC_0 = START_ADDRESS; |
| RESET_DEVICES(); |
| |
| SW_0 = 61440; /* 00000001111000000000000 binary = 61440 decimal */ |
| /* User mode, Running, PID = 0, CC = 0, MASK = 1111, ICODE = 0 */ |
| if (TRACE) PRINT_INSTRUCTION(PC_0,TRUE_1,&DONT_CARE); |
| while ((RETURN_STATUS == EXECUTING_1) && !AT_BREAK_POINT()) { |
| EXEC(TRUE_1,TRACE); |
| if ((TRACE) && (RETURN_STATUS == EXECUTING_1)) { |
| (void) printf("\n"); |
| PRINT_INSTRUCTION(PC_0,TRUE_1,&DONT_CARE); |
| } |
| } |
| if (RETURN_STATUS == EXECUTING_1) |
| PRINT_ADDRESS("Break point encountered at ",PC_0,".\n"); |
| } |
| } |
| |
| /* ---------------------------- PROCEED (local) ---------------------------- */ |
| /* DEBUGGER COMMAND. */ |
| /* Continue execution a program from a break point until the program */ |
| /* terminates or another break point is found. */ |
| void PROCEED(char *COMMAND,BOOLEAN *LEGAL) |
| { |
| int DONT_CARE; |
| |
| REMOVE_WS(&COMMAND); |
| (*LEGAL) = TRUE_1; |
| |
| if ((*COMMAND) != '\0') |
| (void) printf("Expected end of statement, found '%s'. Ignoring command.\n" |
| ,COMMAND); |
| else { |
| |
| if (RETURN_STATUS != EXECUTING_1) |
| (void) printf("Can not continue. Instruction ignored.\n"); |
| else |
| do { |
| EXEC(TRUE_1,TRACE); |
| if ((TRACE) && (RETURN_STATUS == EXECUTING_1)) { |
| (void) printf("\n"); |
| PRINT_INSTRUCTION(PC_0,TRUE_1,&DONT_CARE); |
| } |
| } while ((RETURN_STATUS == EXECUTING_1) && !AT_BREAK_POINT()); |
| |
| if (RETURN_STATUS == EXECUTING_1) |
| PRINT_ADDRESS("Break point encountered at ",PC_0,".\n"); |
| } |
| } |
| |
| /* ---------------------------- EXAMINE (local) ---------------------------- */ |
| /* DEBUGGER COMMAND. */ |
| /* Execute on instruction, printing the result and the next instruction to */ |
| /* execute. */ |
| void STEP(char *COMMAND,BOOLEAN *LEGAL) |
| { |
| int DONT_CARE; |
| |
| REMOVE_WS(&COMMAND); |
| (*LEGAL) = TRUE_1; |
| |
| if ((*COMMAND) != '\0') |
| (void) printf("Expected end of statement, found '%s'. Ignoring command.\n" |
| ,COMMAND); |
| else { |
| |
| if (RETURN_STATUS != EXECUTING_1) |
| (void) printf("Can not continue. Instruction ignored.\n"); |
| else { |
| EXEC(TRUE_1,TRUE_1); |
| (void) printf("\n"); |
| if (RETURN_STATUS == EXECUTING_1) |
| PRINT_INSTRUCTION(PC_0,TRUE_1,&DONT_CARE); |
| } |
| |
| } |
| } |
| |
| /* ------------------------------- HELP (local) ---------------------------- */ |
| /* DEBUGGER COMMAND. */ |
| /* Prints out the debuggers help message. */ |
| void HELP(char *COMMAND,BOOLEAN *LEGAL) |
| { |
| REMOVE_WS(&COMMAND); |
| (*LEGAL) = TRUE_1; |
| if ((*COMMAND) != '\0') |
| (void) printf("Expected end of statement, found '%s'. Ignoring command.\n" |
| ,COMMAND); |
| else { |
| (void) printf("List of commands:\n"); |
| (void) printf(" Short Long Function\n\n"); |
| (void) printf(" B<addr> BREAK<addr> Set break point at <addr>.\n"); |
| (void) printf(" B? BREAK? List out the break points.\n"); |
| (void) printf(" H HELP Displays this table.\n"); |
| (void) printf( |
| " L<loc> LOC<loc> Examines contents of memory and registers.\n"); |
| (void) printf( |
| " L<loc>=<v> LOC<loc>=<v> Examines contents of memory and registers.\n"); |
| (void) printf(" M<mode> MODE<mode> Set type out mode.\n"); |
| (void) printf(" P PROCEED Proceed from break point.\n"); |
| (void) printf(" Q QUIT Exit Debugger.\n"); |
| (void) printf( |
| " R RUN Start execution at entry point.\n"); |
| (void) printf(" RB<num> RESET<num> Remve break point <num>.\n"); |
| (void) printf(" S STEP Execute one instruction.\n"); |
| (void) printf(" T TRACE Trace the execution.\n"); |
| (void) printf( |
| " U UNTRACE Stop tracing the execution.\n"); |
| (void) printf("\n"); |
| (void) printf("<addr> = memory address or label.\n"); |
| (void) printf("<loc> = memory address, label or register.\n"); |
| (void) printf( |
| "<mode> = H (hexidecimal), D (decimal), or I (instruction).\n"); |
| (void) printf( |
| "<v> = hexidecimal number, decimal number, or 1 character.\n\n"); |
| } |
| } |
| |
| /* ---------------------------- EXAMINE (local) ---------------------------- */ |
| /* DEBUGGER COMMAND. */ |
| /* Tells the debugger that the user wish to terminate the debugging session. */ |
| void QUIT(char *COMMAND,BOOLEAN *LEGAL) |
| { |
| (*LEGAL) = TRUE_1; |
| REMOVE_WS(&COMMAND); |
| if ((*COMMAND) != '\0') |
| (void) printf("Expected end of statement, found '%s'. Ignoring command.\n" |
| ,COMMAND); |
| else { |
| RETURN_STATUS = QUIT_1; |
| } |
| } |
| |
| /* ---------------------------- TRACE_P (local) ---------------------------- */ |
| /* DEBUGGER COMMAND. */ |
| /* Turns on the tracing mode. */ |
| void TRACE_P(char *COMMAND,BOOLEAN *LEGAL) |
| { |
| (*LEGAL) = TRUE_1; |
| REMOVE_WS(&COMMAND); |
| if ((*COMMAND) != '\0') |
| (void) printf("Expected end of statement, found '%s'. Ignoring command.\n" |
| ,COMMAND); |
| else |
| if (TRACE) (void) printf("Trace is already on.\n"); |
| else { |
| TRACE = TRUE_1; |
| (void) printf("Trace is now on.\n"); |
| } |
| } |
| |
| /* --------------------------- UNTRACE_P (local) --------------------------- */ |
| /* DEBUGGER COMMAND. */ |
| /* Turns off tracing mode. */ |
| void UNTRACE(char *COMMAND,BOOLEAN *LEGAL) |
| { |
| (*LEGAL) = TRUE_1; |
| REMOVE_WS(&COMMAND); |
| if ((*COMMAND) != '\0') |
| (void) printf("Expected end of statement, found '%s'. Ignoring command.\n" |
| ,COMMAND); |
| else |
| if (!TRACE) (void) printf("Trace is already off.\n"); |
| else { |
| TRACE = FALSE_1; |
| (void) printf("Trace is now off.\n"); |
| } |
| } |
| |
| /* ------------------------------ MODE (local) ----------------------------- */ |
| /* DEBUGGER COMMAND. */ |
| /* Set the type out mode [(H)exidecimal, (D)ecimal, (I)nstruction] */ |
| void MODE(char *COMMAND,BOOLEAN *LEGAL) |
| { |
| (*LEGAL) = TRUE_1; |
| REMOVE_WS(&COMMAND); |
| if (*COMMAND == '\0') |
| (void) printf("Unexpected end of command. Ignoring command.\n"); |
| else { |
| if (*(COMMAND+1) == '\0') |
| switch (*COMMAND) { |
| case 'H': |
| (void) strcpy(TYPE_OUT_MODE,"Hex"); |
| return; |
| break; |
| case 'D': |
| (void) strcpy(TYPE_OUT_MODE,"Dec"); |
| return; |
| break; |
| case 'I': |
| (void) strcpy(TYPE_OUT_MODE,"Instr"); |
| return; |
| break; |
| default: ; |
| } |
| |
| (void) printf( |
| "Expected valid mode (H,D, or I). Found %s. Ignoring command.\n", |
| COMMAND); |
| } |
| } |
| |
| /* ---------------------- CAPITALIZE_STRING -------------------------------- */ |
| /* Make all lower case letters in the string STR upper case letters */ |
| void CAPITALIZE_STRING(char STR[]) |
| { |
| int I; |
| for (I=0; I<= (strlen(STR)); I++) |
| if ((STR[I] >= 'a') && (STR[I] <= 'z')) |
| STR[I] = STR[I] - 'a' + 'A'; |
| } |
| |
| |
| #define STEP0 1 |
| #define SET_BP0 2 |
| #define EXAMINE0 3 |
| #define RESET_BP0 4 |
| #define RUN_IT0 5 |
| #define HELP0 6 |
| #define MODE0 7 |
| #define PROCEED0 8 |
| #define TRACE_P0 9 |
| #define UNTRACE0 10 |
| #define QUIT0 11 |
| |
| /* ~~~~~~~~~~~~~~~~~~~~~~ Table with the debugger commands */ |
| #define COM_TAB_SIZE_1 11 |
| struct COMMAND_TYPE { |
| char *SHORT; /* Short version of command. */ |
| char *LONG; /* Long version of the command. */ |
| int FUNCTION; |
| } COMMANDS[COM_TAB_SIZE_1] = |
| {{"S","STEP",STEP0}, |
| {"B","BREAK",SET_BP0}, |
| {"L","LOC",EXAMINE0}, |
| {"RB","RESET",RESET_BP0}, |
| {"R","RUN",RUN_IT0}, |
| {"H","HELP",HELP0}, |
| {"M","MODE",MODE0}, |
| {"P","PROCEED",PROCEED0}, |
| {"T","TRACE",TRACE_P0}, |
| {"U","UNTRACE",UNTRACE0}, |
| {"Q","QUIT",QUIT0}}; |
| |
| void CALL_FUNCTION(int FUNC,char *COMMAND,BOOLEAN *LEGAL) |
| { |
| switch(FUNC) { |
| case STEP0: STEP(COMMAND,LEGAL); |
| break; |
| case SET_BP0: SET_BP(COMMAND,LEGAL); |
| break; |
| case EXAMINE0: EXAMINE(COMMAND,LEGAL); |
| break; |
| case RESET_BP0: RESET_BP(COMMAND,LEGAL); |
| break; |
| case RUN_IT0: RUN_IT(COMMAND,LEGAL); |
| break; |
| case HELP0: HELP(COMMAND,LEGAL); |
| break; |
| case MODE0: MODE(COMMAND,LEGAL); |
| break; |
| case PROCEED0: PROCEED(COMMAND,LEGAL); |
| break; |
| case TRACE_P0: TRACE_P(COMMAND,LEGAL); |
| break; |
| case UNTRACE0: UNTRACE(COMMAND,LEGAL); |
| break; |
| case QUIT0: QUIT(COMMAND,LEGAL); |
| break; |
| } |
| } |
| /* -------------------------------- DEBUGGER ------------------------------- */ |
| /* Drives the entire simulatation/debugging process. */ |
| void DEBUGGER(BOOLEAN DEBUG_MODE) |
| { |
| char *COMMAND; /* The debugging command. */ |
| BOOLEAN LEGAL_COMMAND; /* Is this a recognized command? */ |
| int COUNT; /* Loop counter. */ |
| |
| for (COUNT=0; COUNT <= MAX_NUM_BREAK_POINTS; COUNT ++) |
| BREAK_POINTS[COUNT] = -1; |
| |
| if (!DEBUG_MODE) { |
| /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ No Debugging, just execute it */ |
| RETURN_STATUS = EXECUTING_1; |
| L_0 = RETURN_TO_OS_1; |
| PC_0 = START_ADDRESS; |
| |
| SW_0 = 61440; /* 00000001111000000000000 binary = 61440 decimal */ |
| /* User mode, Running, PID = 0, CC = 0, MASK = 1111, ICODE = 0 */ |
| EXEC(FALSE_1,FALSE_1); |
| } else |
| /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Debug the program. */ |
| while (RETURN_STATUS != QUIT_1) { |
| LEGAL_COMMAND = FALSE_1; |
| (void) printf("%s> ",TYPE_OUT_MODE); |
| GET_LINE(&COMMAND,stdin); |
| REMOVE_WS(&COMMAND); |
| if ((*COMMAND) != '\0') { |
| CAPITALIZE_STRING(COMMAND); |
| |
| for (COUNT=0; (COUNT < COM_TAB_SIZE_1) && !LEGAL_COMMAND; COUNT++) |
| if (IS_PREFIX_TO(COMMANDS[COUNT].LONG,COMMAND)) |
| CALL_FUNCTION(COMMANDS[COUNT].FUNCTION, |
| &(COMMAND[strlen(COMMANDS[COUNT].LONG)]), |
| &LEGAL_COMMAND); |
| else if (IS_PREFIX_TO(COMMANDS[COUNT].SHORT,COMMAND)) |
| CALL_FUNCTION(COMMANDS[COUNT].FUNCTION, |
| &(COMMAND[strlen(COMMANDS[COUNT].SHORT)]), |
| &LEGAL_COMMAND); |
| |
| if (!LEGAL_COMMAND) { |
| (void) printf("'%s' is not a legal command. Ignoring it.\n",COMMAND); |
| (void) printf("Type HELP for the list of legal commands.\n"); |
| } |
| } |
| if (RETURN_STATUS == ABNORMAL_1) { |
| int CODE; |
| |
| RETURN_STATUS = HALT_1; |
| CODE = SW_0 - (SW_0/256)*256; |
| PRINT_CONSTANT("error code =",CODE," "); |
| switch (CODE) { |
| case 0: (void) printf("Illegal instruction.\n"); break; |
| case 1: (void) printf("Privileged instruction in user mode.\n"); break; |
| case 2: (void) printf("Address out of range.\n"); break; |
| case 3: (void) printf("Memory-protection violation.\n"); break; |
| case 4: (void) printf("Aritmetic overflow.\n"); break; |
| case 10: (void) printf("Page fault.\n"); break; |
| case 11: (void) printf("Segment fault.\n"); break; |
| case 12: (void) printf("Segment-protection violation.\n"); break; |
| case 13: (void) printf("Segment length exceeded.\n"); break; |
| default: (void) printf("\n"); break; |
| } |
| } |
| } |
| } |
