| /* %%%%%%%%%%%%%%%%%%%% (c) William Landi 1991 %%%%%%%%%%%%%%%%%%%%%%%%%%%% */ |
| /* Permission to use this code is granted as long as the copyright */ |
| /* notice remains in place. */ |
| |
| /* =============================== format.c ================================ */ |
| /* Returns the registers associtiated with a FORMAT2 instruction (handles */ |
| /* BITS 8-15) and the Address or value associated with a FORMAT3/FORMAT4 */ |
| /* instruction (handles BITS 6-23 or BITS 6-31). */ |
| |
| #include <math.h> |
| #include "boolean.h" |
| #include "memory.h" |
| #include "machine.h" |
| #include "convert.h" |
| #include "constants.h" |
| #include "instruct.h" |
| #include "interupt.h" |
| |
| |
| /* ------------------------------ FORMAT2 ---------------------------------- */ |
| /* Handles bits 8-15 of format 2 instruction. Puts bits 8-11 in REG1, bits */ |
| /* 12-15 in REG2 and updates PC. */ |
| void FORMAT2(int *REG1,int *REG2) |
| { |
| (*REG1) = INT(MEMORY[PC_0+1]) / 16; |
| (*REG2) = INT(MEMORY[PC_0+1]) - (*REG1) * 16; |
| PC_0 += 2; |
| } |
| |
| |
| /* ----------------------------- FORMAT3_4 --------------------------------- */ |
| /* Handles bits 6-23 for format 3 instructions, and bits 5-31 for format 4 */ |
| /* instructions. Updates PC and returns ADDRESS or VALUE of the operand */ |
| /* Depending on demand. */ |
| int FORMAT3_4(int DEMAND,int BYTES) |
| { |
| int INSTR[4*BITS_PER_BYTE_2]; /* BIT for of the instruction. */ |
| |
| BOOLEAN RANGE_ERROR = FALSE_1; /* TRUE iff an illegal address is found. */ |
| int FORMAT = 3; /* Format 3 or format 4 instruction. */ |
| int ADDRESS; /* Address specified by instruction. */ |
| int VALUE; /* Value specified by instruction */ |
| |
| if (PC_0+2 >= MEM_SIZE_1) RANGE_ERROR = TRUE_1; |
| else { |
| BYTES_TO_BITS(INT(MEMORY[PC_0]),1,INSTR); |
| BYTES_TO_BITS(INT(MEMORY[PC_0+1]),1,&(INSTR[8])); |
| BYTES_TO_BITS(INT(MEMORY[PC_0+2]),1,&(INSTR[16])); |
| |
| /* ------------------ if expended format bit on and not plane SIC -----------*/ |
| if ((INSTR[11] == 1) && !((INSTR[6] == 0) && (INSTR[7] == 0))) |
| if (PC_0+3 >= MEM_SIZE_1) RANGE_ERROR = TRUE_1; |
| else { |
| BYTES_TO_BITS(INT(MEMORY[PC_0+3]),1,&(INSTR[24])); |
| FORMAT = 4; |
| } |
| } |
| |
| /* ------------ Check for Address out of range error */ |
| if (RANGE_ERROR) { |
| SIGNAL_INTERUPT(2,02); |
| return (0); |
| } |
| |
| PC_0 += FORMAT; |
| /* ------- if plane SIC ---------------------------------------------------- */ |
| if ((INSTR[6] == 0) && (INSTR[7] == 0)) |
| ADDRESS = BITS_TO_BYTE(&(INSTR[12]),12); |
| else if (FORMAT == 3) { |
| ADDRESS = BITS_TO_BYTE(&(INSTR[12]),12); |
| /* ------------ Check for Illegal instruction */ |
| if ((INSTR[9] == 1) && (INSTR[10] == 1)) { |
| SIGNAL_INTERUPT(2,00); |
| return (0); |
| } |
| if (INSTR[8] == 1) ADDRESS += X_0; |
| if (INSTR[9] == 1) ADDRESS += B_0; |
| if (INSTR[10] == 1) { |
| if (ADDRESS >= MAX_PC_RELATIVE_1 / 2) |
| ADDRESS = (ADDRESS - MAX_PC_RELATIVE_1) + PC_0; |
| else ADDRESS += PC_0; |
| } |
| } else { |
| /* ~~~~~~~~~~~~~~~~~~~~~~ FORMAT 4 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ |
| /* ------------ Check for Illegal instruction */ |
| if ((INSTR[9] == 1) || (INSTR[10] == 1)) { |
| SIGNAL_INTERUPT(2,00); |
| return (0); |
| } |
| ADDRESS = BITS_TO_BYTE(&(INSTR[12]),20); |
| if (INSTR[8] == 1) ADDRESS += X_0; |
| } |
| |
| /* ~~~~~~~~~~~~~~~~~~~~~~~ DIRECT ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ |
| if ((INSTR[6] == 1) && (INSTR[7] == 1)) { |
| |
| if (DEMAND == VALUE_1) { |
| int I; |
| |
| /* ------------ Check for Illegal instruction */ |
| if ((ADDRESS < 0) || (ADDRESS+2 >= MEM_SIZE_1)) { |
| SIGNAL_INTERUPT(2,00); |
| return (0); |
| } |
| |
| VALUE = 0; |
| for (I = 0; I < BYTES; I ++) |
| VALUE = VALUE * 256 + INT(MEMORY[ADDRESS + I]); |
| |
| /* -------------- If unitialized value that will not fit in SIC/XE make it 0 */ |
| if (VALUE >= (int) pow(2.0,BITS_PER_WORD_1*1.0)) VALUE = 0; |
| return VALUE; |
| } else return ADDRESS; |
| } |
| |
| /* ~~~~~~~~~~~~~~~~~~~~~~~ INDIRECT ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ |
| if ((INSTR[6] == 1) && (INSTR[7] == 0)) { |
| /* ------------ Check for Illegal instruction */ |
| if ((ADDRESS < 0) || (ADDRESS+2 >= MEM_SIZE_1)) { |
| SIGNAL_INTERUPT(2,00); |
| return (0); |
| } |
| ADDRESS = (((INT(MEMORY[ADDRESS]) * 256) + INT(MEMORY[ADDRESS+1]))*256 + |
| INT(MEMORY[ADDRESS+2])); |
| |
| if (DEMAND == VALUE_1) { |
| int I; |
| |
| /* ------------ Check for Address out of range error */ |
| if (ADDRESS > MEM_SIZE_1) { |
| SIGNAL_INTERUPT(2,02); |
| return (0); |
| } |
| |
| VALUE = 0; |
| for (I = 0; I < BYTES; I ++) |
| VALUE = VALUE * 256 + INT(MEMORY[ADDRESS + I]); |
| |
| /* -------------- If unitialized value that will not fit in SIC/XE make it 0 */ |
| if (VALUE >= (int) pow(2.0,BITS_PER_WORD_1*1.0)) VALUE = 0; |
| return VALUE; |
| } else return ADDRESS; |
| } |
| |
| /* ~~~~~~~~~~~~~~~~~~~~~~~ Immediate ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ |
| if ((INSTR[6] == 0) && (INSTR[7] == 1)) { |
| /* ------------ Check for Illegal instruction */ |
| if (ADDRESS >= (int) pow(2.0,BITS_PER_WORD_1*1.0)) { |
| SIGNAL_INTERUPT(2,00); |
| return (0); |
| } |
| return (ADDRESS); |
| } |
| return(0); /* This will never be executed, but to keep lint happy */ |
| } |
