/* %%%%%%%%%%%%%%%%%%%% (c) William Landi 1991 %%%%%%%%%%%%%%%%%%%%%%%%%%%% */ /* Permission to use this code is granted as long as the copyright */ /* notice remains in place. */ /* ============================== code.c =================================== */ /* Does the 'real' work of PASS2. Produces one listing file line for a */ /* assembly instruction and all object file records, except those from pass1 */ /* EVERY line of listing file is produced in this module (except pass1 */ /* error messages). */ /* Before this is called everything the assembler needs to know is figured */ /* and this does (most of) the code generation. */ #include #include #include #include #include "pass1.h" #include "stringI.h" #include "scan_line.h" #include "convert.h" #include "sym_tab.h" #include "record.h" #include "assem.h" #include "constants.h" #include "buffer.h" #include "op_tab.h" /* ------------------------------- PSEUDO_CODE (local) --------------------- */ /* Generates listing line (except location counter which is handled */ /* elsewhere) for source lines dealing with PSEUDO OPs. Produces object */ /* records for pseudo ops that could not be figured at pass1 (line Header */ /* records; do not know length until pass2). */ void PSEUDO_CODE(char *OPERATOR,FILE *INPUT_STREAM,FILE *OBJECT_STREAM, FILE *LISTING_STREAM) { char CH; /* a character for looking ahead in the */ /* input stream. */ /* -------------------------------- Output any generated machine code */ if ( (strcmp(OPERATOR,"WORD")) && (strcmp(OPERATOR,"BYTE"))) /* -------------------------------- Only BYTE and WORD generate code */ /* (leave code part of listing blank) */ /* COLUMNS 8 - 17 8901234567 */ (void) fprintf(LISTING_STREAM," "); else { /* ---------------- Must look into pass1 output to see if any code generated */ CH = fgetc(INPUT_STREAM); if (CH == 't') { /* -------------- Code in text record. Put into text record and listing file */ /* -------------- put code into object file text records, and print on */ /* -------------- listing line. */ int LOCATION; char TEMP_CH; char *REST_OF_LINE; (void) fscanf(INPUT_STREAM,"%d%c",&LOCATION,&TEMP_CH); GET_LINE(&REST_OF_LINE,INPUT_STREAM); (void) fprintf(LISTING_STREAM,"%s",REST_OF_LINE); if (strlen(REST_OF_LINE) <= 8) { int I; for (I=(strlen(REST_OF_LINE)+1);I<=10;I++) (void) fprintf(LISTING_STREAM," "); } else (void) fprintf(LISTING_STREAM, /* COLUMNS 1 - 8 123456789012345678 */ " {source on next line}\n "); if ( TEMP_CH == 'W') ADD_TO_TEXT_RECORD(REST_OF_LINE,LOCATION,OBJECT_STREAM); else { char TEMP[HEX_CHAR_PER_BYTE_1+1]; int DELTA = 0; for (TEMP[HEX_CHAR_PER_BYTE_1]='\0';!eoln(*REST_OF_LINE); REST_OF_LINE+=HEX_CHAR_PER_BYTE_1) { (void) strncpy(TEMP,REST_OF_LINE,HEX_CHAR_PER_BYTE_1); ADD_TO_TEXT_RECORD(TEMP,(LOCATION+DELTA),OBJECT_STREAM); DELTA ++; } } } /* END if (CH == 't')*/ else { /* --------------- No code was generated for the BYTE/WORD because of errors */ (void) ungetc(CH,INPUT_STREAM); /* COLUMNS 8 - 17 8901234567 */ (void) fprintf(LISTING_STREAM," "); } } } /* ------------------------ GET_REG (local) -------------------------------- */ /* Converts the next thing in a string (pointed to by REG) into the number */ /* that corresponds to the register with that name. Returns -1 if next thing */ /* is not a register. when done, *REG will point to the character immediately*/ /* following the register name. */ int GET_REG(char **REG) { int VAL; switch (**REG) { case 'A': VAL = 0; break; case 'X': VAL = 1; break; case 'L': VAL = 2; break; case 'B': VAL = 3; break; case 'S': if (*((*REG)+1) == 'W') { (*REG) ++; VAL = 9; } else VAL = 4; break; case 'T': VAL = 5; break; case 'P': if (*((*REG)+1) == 'C') { (*REG) ++; VAL = 8; } else VAL = -1; break; default: VAL = -1; break; } (*REG)++; return VAL; } /* ------------------------- SET_BITS_TO (local) --------------------------- */ /* CODE is a 32 character string. Each element in that string is either a '0'*/ /* or a '1' and represents the machine code for an instruction. SET_BITS_TO */ /* sets the bits between LOW_BIT and HIGH_BIT (inclusive) so that they are */ /* the binary equivalen to VALUE (i.e. make is so that: */ /* SUM i=0 to (HIGH_BIT-LOW_BIT) {CODE[HIGH_BIT-i]*2^i} = VALUE. */ void SET_BITS_TO(int LOW_BIT,int HIGH_BIT,int VALUE,char *CODE) { int I; /* Loop counter variable */ int BIT; /* BIT of code to set next */ int VALUE_BIT; /* one BIT from VALUE to be moved to CODE*/ if ((HIGH_BIT < LOW_BIT) || (HIGH_BIT >= LARGEST_INSTRUCT_SIZE_1)) (void) printf("SET_BITS_TO called improperly.\n"); else { BIT = HIGH_BIT; for (I= ((int) pow(2.0,1.0*(HIGH_BIT-LOW_BIT))); I > 0; I /= 2) { VALUE_BIT = VALUE - (VALUE/2)*2; VALUE /= 2; CODE[BIT] = ((char) VALUE_BIT) + '0'; BIT --; } if (VALUE != 0) (void) printf("SET_BITS_TO called improperly, VALUE too large.\n"); } } /* ----------------------- PRT_CODE (local) -------------------------------- */ /* Output to OBJECT_STREAM, the number represented by the first BYTES bytes */ /* of the [binary] string CODE. Also add the number to the TEXT Record of the*/ /* object file (stream name is OBJECT_STREAM) at LOCATION. Output is */ /* hexidecimal. */ void PRT_CODE(char *CODE,int BYTES,int LOCATION,FILE *LISTING_STREAM, FILE *OBJECT_STREAM) { int BYTE_COUNTER; /* byte to output next */ int BIT_COUNTER; /* bit (of byte) to process next */ int CH; char NUM_STR[LARGEST_INSTRUCT_SIZE_1/4]; if (BYTES*4 > LARGEST_INSTRUCT_SIZE_1) (void) printf("PRT_CODE called improperly.\n"); else { /* ------- Make a hex string representing the number. */ for (BYTE_COUNTER=0;BYTE_COUNTER < BYTES; BYTE_COUNTER ++) { CH = 0; for (BIT_COUNTER=0; BIT_COUNTER < 4; BIT_COUNTER ++) CH = CH * 2 + ((int) CHAR_TO_DIGIT(CODE[BYTE_COUNTER*4+BIT_COUNTER],2)); if ( (CH >= 0) && (CH <= 9)) NUM_STR[BYTE_COUNTER] = (char) CH + '0'; else NUM_STR[BYTE_COUNTER] = (char) (CH - 10) + 'A'; } NUM_STR[BYTES] = '\0'; /* ----------------------- Put Number into listing stream and object stream. */ (void) fprintf(LISTING_STREAM,"%s",NUM_STR); ADD_TO_TEXT_RECORD(NUM_STR,LOCATION,OBJECT_STREAM); for (BYTE_COUNTER = BYTES; BYTE_COUNTER < (LARGEST_INSTRUCT_SIZE_1/4); BYTE_COUNTER ++) (void) fprintf(LISTING_STREAM," "); } } /* ------------------------------- REAL_CODE (local) ----------------------- */ /* Generates listing line (except location counter which is handled */ /* elsewhere) for source lines dealing with NON-PSEUDO OPs ('real' ops). */ /* Produces object records for real ops. It also produces the text and */ /* modification records (of object file) assocated with these source lines. */ void REAL_CODE(struct OP_ENTRY *OP_CODE,int EXTENDED,char *ARGUMENTS, int LOCATION,SYMBOL_TABLE *SYM_TAB,FILE *OBJECT_STREAM, FILE *LISTING_STREAM,int *ERROR) { char INSTRUCT_CODE[LARGEST_INSTRUCT_SIZE_1+1]; int I; /* loop counter */ int REG_NUMB; /* REGister NUMBer. Temporay storage*/ INSTRUCT_CODE[LARGEST_INSTRUCT_SIZE_1] = '\0'; for (I=0;I= '0') && (*ARGUMENTS <= '4')) SET_BITS_TO(8,11,(int) ((*ARGUMENTS) - '0'),INSTRUCT_CODE); else { ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF, "ERROR[43]: Illegal argument to SVC."); (*ERROR) = TRUE_1; } ARGUMENTS ++; } else /* --------------------- First (maybe only) argument must be a register. */ /* get it. */ if ((REG_NUMB = GET_REG(&ARGUMENTS)) < 0) { ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF, "ERROR[45]: Expected a valid register."); (*ERROR) = TRUE_1; ARGUMENTS ++; } else { SET_BITS_TO(8,11,REG_NUMB,INSTRUCT_CODE); if ((*OP_CODE).OPERAND != REG) /* -------------------- Two argument command, Get second after skipping comma*/ if ((*ARGUMENTS) != ',') { ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF, "ERROR[46]: Expected a comma after the first register."); (*ERROR) = TRUE_1; ARGUMENTS ++; } else { ARGUMENTS ++; if ((*OP_CODE).OPERAND == REG_NUM) { /* -------------------- Second argument must be a number 1-16 */ REG_NUMB = CHAR_TO_DIGIT(*ARGUMENTS,10); ARGUMENTS ++; if (REG_NUMB < 0) { ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF, "ERROR[49]: Expected a number 1-16 after comma."); (*ERROR) = TRUE_1; ARGUMENTS ++; } else { if (CHAR_TO_DIGIT(*ARGUMENTS,10) >= 0) { REG_NUMB = REG_NUMB*10+CHAR_TO_DIGIT(*ARGUMENTS,10); ARGUMENTS ++; REG_NUMB --; } else REG_NUMB --; if ((REG_NUMB < 0) || (REG_NUMB > 15)) { ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF, "ERROR[49]: Expected a number 1-16 after comma."); (*ERROR) = TRUE_1; } else SET_BITS_TO(12,15,REG_NUMB,INSTRUCT_CODE); } } else { /* ---------------------- Second argument must be a register. */ if ((REG_NUMB = GET_REG(&ARGUMENTS)) < 0) { ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF, "ERROR[47]: Expected a valid register after the comma."); (*ERROR) = TRUE_1; } else SET_BITS_TO(12,15,REG_NUMB,INSTRUCT_CODE); } } } /* ---------------------- make sure nothing illegal after argument[s] */ if (!IS_BLANK_OR_TAB(*ARGUMENTS) && !eoln(*ARGUMENTS)) { ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF, "ERROR[44]: Expected a after the operand."); (*ERROR) = TRUE_1; } PRT_CODE(INSTRUCT_CODE,4,LOCATION,LISTING_STREAM,OBJECT_STREAM); } /* END format TWO */ if ((*OP_CODE).FORMAT == THREE_FOUR) { /* ********************** Process FORMAT 3/4 instructions ****************** */ int VALUE; /* value of argument */ int WHAT_KIND = ABSOLUTE_OR_RELATIVE_1; /* type of argument */ /* ------ set extended bit correctly */ SET_BITS_TO(11,11,EXTENDED,INSTRUCT_CODE); if ((*OP_CODE).OPERAND == NONE) { /* ------- RSUB has no arguments... easy */ SET_BITS_TO(6,7,3,INSTRUCT_CODE); if (EXTENDED) PRT_CODE(INSTRUCT_CODE,8,LOCATION,LISTING_STREAM,OBJECT_STREAM); else PRT_CODE(INSTRUCT_CODE,6,LOCATION,LISTING_STREAM,OBJECT_STREAM); } else { /* ------ check for immediate or indirect mode, and set the bits accordingly */ switch (*ARGUMENTS) { case '@': SET_BITS_TO(6,6,1,INSTRUCT_CODE); ARGUMENTS ++; break; case '#': SET_BITS_TO(7,7,1,INSTRUCT_CODE); ARGUMENTS ++; break; default: SET_BITS_TO(6,7,3,INSTRUCT_CODE); } /* ------- get the value of the argument and the type (kind) of that argument*/ VALUE = GET_EXPRESSION(&ARGUMENTS,MEM_ADDR_SIZE_1+1, LOCATION+1,SYM_TAB,&WHAT_KIND); if ( ERROR_REC_BUF.HEAD_OF_BUFFER != NULL) (*ERROR) = TRUE_1; if ( ((*ARGUMENTS) == ',') && (*(ARGUMENTS+1) == 'X')) { ARGUMENTS += 2; SET_BITS_TO(8,8,1,INSTRUCT_CODE); } if (EXTENDED) { char MOD_REC[9]; /* ------ 2's complement negative numbers */ if (VALUE < 0) VALUE = MEM_SIZE_1 + VALUE; if (WHAT_KIND == RELATIVE_VALUE_1) { NUM_TO_STR(LOCATION+1,16,6,MOD_REC); (void) strcat(MOD_REC,"05"); ADD_TO_END_OF_BUFFER(&MOD_REC_BUF,MOD_REC); } SET_BITS_TO(12,31,VALUE,INSTRUCT_CODE); PRT_CODE(INSTRUCT_CODE,8,LOCATION,LISTING_STREAM,OBJECT_STREAM); } else { /* ------- format 3's */ if (WHAT_KIND == EXTERN_VALUE_1) { ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF, "ERROR[53]: EXTREF label can not be used in a format THREE instruction."); (*ERROR) = TRUE_1; VALUE = 0; } if (WHAT_KIND == RELATIVE_VALUE_1) VALUE = VALUE - (LOCATION + 3); if ( ( (WHAT_KIND == RELATIVE_VALUE_1) && (VALUE >= (MAX_PC_RELATIVE_1/2 ))) || ( (WHAT_KIND != RELATIVE_VALUE_1) && (VALUE >= (MAX_PC_RELATIVE_1)))) { if (WHAT_KIND == RELATIVE_VALUE_1) ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF, "ERROR[51]: Location is not within PC relative range."); else ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF, "ERROR[52]: Constant too large for a format THREE instruction."); (*ERROR) = TRUE_1; VALUE = 0; } if (VALUE < 0) { /* --------- 2's complement negative values */ VALUE = MAX_PC_RELATIVE_1 + VALUE; if ( (VALUE >= MAX_PC_RELATIVE_1) || (VALUE < MAX_PC_RELATIVE_1 /2) ) { if (WHAT_KIND == RELATIVE_VALUE_1) ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF, "ERROR[51]: Location is not within PC relative range."); else ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF, "ERROR[52]: Constant too large for a format THREE instruction."); (*ERROR) = TRUE_1; VALUE = 0; } } SET_BITS_TO(12,23,VALUE,INSTRUCT_CODE); if (WHAT_KIND == RELATIVE_VALUE_1) SET_BITS_TO(10,10,1,INSTRUCT_CODE); PRT_CODE(INSTRUCT_CODE,6,LOCATION,LISTING_STREAM,OBJECT_STREAM); } if (!IS_BLANK_OR_TAB(*ARGUMENTS) && !eoln(*ARGUMENTS)) { ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF, "ERROR[44]: Expected a after the operand."); (*ERROR) = 1; } } } /* END format THREE_FOUR */ (void) fprintf(LISTING_STREAM," "); } /* ================================= CODE ================================== */ /* Determines the location counter value for a line, puts it into the */ /* listing stream and calls the correct procedures to output the code */ void CODE(FILE *INPUT_STREAM,SYMBOL_TABLE *SYM_TAB,FILE *OBJECT_STREAM, FILE *LISTING_STREAM,int *ERROR) { char LABEL[LABEL_SIZE_1+1]; /* label on the source line */ char OPERATOR[LABEL_SIZE_1+1]; /* operator on the source line */ char *ARGUMENTS; /* source line after operator */ char *INPUT_LINE; int LOCATION_COUNTER; int EXTENDED; /* is this an extended instruction? */ struct OP_ENTRY *OP_CODE; struct SYMBOL_TABLE_ENTRY *TABLE_ENTRY; (void) fscanf(INPUT_STREAM,"%d",&LOCATION_COUNTER); (void) getc(INPUT_STREAM); /* remove space after s */ SCAN_LINE(LOCATION_COUNTER,&INPUT_LINE,LABEL,&EXTENDED,OPERATOR,&ARGUMENTS, pass2,(FILE *) NULL,INPUT_STREAM); CAPITALIZE_STRING(LABEL); CAPITALIZE_STRING(OPERATOR); OP_CODE = LOOK_UP_OP(OPERATOR); if (!strcmp(LABEL,"") && !strcmp(OPERATOR,"") && (EXTENDED == 0)) /* ----- blank source line */ /* 123456789012345678 */ (void) fprintf(LISTING_STREAM," %s\n",INPUT_LINE); else { if (!strcmp(OPERATOR,"")) { /* --------- a no-op */ PRT_NUM(LOCATION_COUNTER,16,6,LISTING_STREAM); (void) fprintf(LISTING_STREAM," "); } /* OUTPUT blanks for address, if PSEUDO OP that doesn't display a location */ else if ((*OP_CODE).OPERAND == PSEUDO_NOLOC) /* 1234567 */ (void) fprintf(LISTING_STREAM," "); else if ((*OP_CODE).OPERAND == PSEUDO_ADDR) { /* -------- OUTPUT value as address if START,CSECT, or EQU */ if (!strcmp(OPERATOR,"EQU")) { TABLE_ENTRY = LOOK_UP_SYMBOL(MODULE_NAME,LABEL,SYM_TAB); if (TABLE_ENTRY == NULL) LOCATION_COUNTER = 0; else LOCATION_COUNTER = (*TABLE_ENTRY).LOCATION; } else { if (!strcmp(LABEL,"")) GET_NEXT_MISSING_LABEL(LABEL,SYM_TAB); TABLE_ENTRY = LOOK_UP_SYMBOL(LABEL,LABEL,SYM_TAB); if (TABLE_ENTRY == NULL) { (void) printf( "CODE: Something is wrong with code. This shouldn't be executed.\n"); /* ------ In all other case output the location counter and the address */ } else LOCATION_COUNTER = (*TABLE_ENTRY).LOCATION; } PRT_NUM(LOCATION_COUNTER,16,6,LISTING_STREAM); (void) fprintf(LISTING_STREAM," "); } else { PRT_NUM(LOCATION_COUNTER,16,6,LISTING_STREAM); (void) fprintf(LISTING_STREAM," "); } { char *SAVE_LINE; /* SAVE the source line so that other routines can mess it up without */ /* worrying. This was necessary because PSEUDO_CODE might have to look a */ /* whole line ahead in the input */ SAVE_LINE = malloc((unsigned int) (strlen(INPUT_LINE) + 1)); (void) strcpy(SAVE_LINE,INPUT_LINE); CAPITALIZE_STRING(ARGUMENTS); /* call correct procedure to produce the code. */ if ((*OP_CODE).FORMAT == NOT_FOUND) /* COLUMNS 8 - 17 8901234567 */ (void) fprintf(LISTING_STREAM," "); else if ((*OP_CODE).FORMAT == PSEUDO) PSEUDO_CODE(OPERATOR,INPUT_STREAM,OBJECT_STREAM,LISTING_STREAM); else REAL_CODE(OP_CODE,EXTENDED,ARGUMENTS,LOCATION_COUNTER, SYM_TAB,OBJECT_STREAM,LISTING_STREAM,ERROR); (void) fprintf(LISTING_STREAM,"%s\n",SAVE_LINE); free(SAVE_LINE); } } }