diff options
Diffstat (limited to 'assemble.c')
| -rw-r--r-- | assemble.c | 2799 |
1 files changed, 1518 insertions, 1281 deletions
@@ -79,68 +79,63 @@ extern struct itemplate *nasm_instructions[]; typedef struct { - int sib_present; /* is a SIB byte necessary? */ - int bytes; /* # of bytes of offset needed */ - int size; /* lazy - this is sib+bytes+1 */ - unsigned char modrm, sib; /* the bytes themselves */ + int sib_present; /* is a SIB byte necessary? */ + int bytes; /* # of bytes of offset needed */ + int size; /* lazy - this is sib+bytes+1 */ + unsigned char modrm, sib; /* the bytes themselves */ } ea; -static unsigned long cpu; /* cpu level received from nasm.c */ +static unsigned long cpu; /* cpu level received from nasm.c */ static efunc errfunc; static struct ofmt *outfmt; static ListGen *list; -static long calcsize (long, long, int, insn *, const char *); -static void gencode (long, long, int, insn *, const char *, long); -static int regval (operand *o); -static int matches (struct itemplate *, insn *); -static ea * process_ea (operand *, ea *, int, int, int); -static int chsize (operand *, int); +static long calcsize(long, long, int, insn *, const char *); +static void gencode(long, long, int, insn *, const char *, long); +static int regval(operand * o); +static int matches(struct itemplate *, insn *); +static ea *process_ea(operand *, ea *, int, int, int); +static int chsize(operand *, int); /* * This routine wrappers the real output format's output routine, * in order to pass a copy of the data off to the listing file * generator at the same time. */ -static void out (long offset, long segto, const void *data, unsigned long type, - long segment, long wrt) +static void out(long offset, long segto, const void *data, + unsigned long type, long segment, long wrt) { - static long lineno = 0; /* static!!! */ + static long lineno = 0; /* static!!! */ static char *lnfname = NULL; if ((type & OUT_TYPMASK) == OUT_ADDRESS) { - if (segment != NO_SEG || wrt != NO_SEG) { - /* - * This address is relocated. We must write it as - * OUT_ADDRESS, so there's no work to be done here. - */ - list->output (offset, data, type); - } - else { - unsigned char p[4], *q = p; - /* - * This is a non-relocated address, and we're going to - * convert it into RAWDATA format. - */ - if ((type & OUT_SIZMASK) == 4) { - WRITELONG (q, * (long *) data); - list->output (offset, p, OUT_RAWDATA+4); - } - else { - WRITESHORT (q, * (long *) data); - list->output (offset, p, OUT_RAWDATA+2); - } - } - } - else if ((type & OUT_TYPMASK) == OUT_RAWDATA) { - list->output (offset, data, type); - } - else if ((type & OUT_TYPMASK) == OUT_RESERVE) { - list->output (offset, NULL, type); - } - else if ((type & OUT_TYPMASK) == OUT_REL2ADR || - (type & OUT_TYPMASK) == OUT_REL4ADR) { - list->output (offset, data, type); + if (segment != NO_SEG || wrt != NO_SEG) { + /* + * This address is relocated. We must write it as + * OUT_ADDRESS, so there's no work to be done here. + */ + list->output(offset, data, type); + } else { + unsigned char p[4], *q = p; + /* + * This is a non-relocated address, and we're going to + * convert it into RAWDATA format. + */ + if ((type & OUT_SIZMASK) == 4) { + WRITELONG(q, *(long *)data); + list->output(offset, p, OUT_RAWDATA + 4); + } else { + WRITESHORT(q, *(long *)data); + list->output(offset, p, OUT_RAWDATA + 2); + } + } + } else if ((type & OUT_TYPMASK) == OUT_RAWDATA) { + list->output(offset, data, type); + } else if ((type & OUT_TYPMASK) == OUT_RESERVE) { + list->output(offset, NULL, type); + } else if ((type & OUT_TYPMASK) == OUT_REL2ADR || + (type & OUT_TYPMASK) == OUT_REL4ADR) { + list->output(offset, data, type); } /* @@ -152,1026 +147,1168 @@ static void out (long offset, long segto, const void *data, unsigned long type, * if it did. thus, these variables must be static */ - if (src_get(&lineno,&lnfname)) - { - outfmt->current_dfmt->linenum(lnfname,lineno,segto); + if (src_get(&lineno, &lnfname)) { + outfmt->current_dfmt->linenum(lnfname, lineno, segto); } - outfmt->output (segto, data, type, segment, wrt); + outfmt->output(segto, data, type, segment, wrt); } -static int jmp_match (long segment, long offset, int bits, - insn *ins, const char *code) -{ long isize; +static int jmp_match(long segment, long offset, int bits, + insn * ins, const char *code) +{ + long isize; unsigned char c = code[0]; - - if (c != 0370 && c != 0371) return 0; + if (c != 0370 && c != 0371) + return 0; if (ins->oprs[0].opflags & OPFLAG_FORWARD) { - if ((optimizing<0 || (ins->oprs[0].type & STRICT)) - && c==0370) return 1; - else return (pass0==0); /* match a forward reference */ + if ((optimizing < 0 || (ins->oprs[0].type & STRICT)) + && c == 0370) + return 1; + else + return (pass0 == 0); /* match a forward reference */ } - isize = calcsize (segment, offset, bits, ins, code); - if (ins->oprs[0].segment != segment) return 0; - isize = ins->oprs[0].offset - offset - isize; /* isize is now the delta */ - if (isize >= -128L && isize <= 127L) return 1; /* it is byte size */ + isize = calcsize(segment, offset, bits, ins, code); + if (ins->oprs[0].segment != segment) + return 0; + isize = ins->oprs[0].offset - offset - isize; /* isize is now the delta */ + if (isize >= -128L && isize <= 127L) + return 1; /* it is byte size */ return 0; -} - +} -long assemble (long segment, long offset, int bits, unsigned long cp, - insn *instruction, struct ofmt *output, efunc error, - ListGen *listgen) +long assemble(long segment, long offset, int bits, unsigned long cp, + insn * instruction, struct ofmt *output, efunc error, + ListGen * listgen) { struct itemplate *temp; - int j; - int size_prob; - long insn_end; - long itimes; - long start = offset; - long wsize = 0; /* size for DB etc. */ - - errfunc = error; /* to pass to other functions */ + int j; + int size_prob; + long insn_end; + long itimes; + long start = offset; + long wsize = 0; /* size for DB etc. */ + + errfunc = error; /* to pass to other functions */ cpu = cp; - outfmt = output; /* likewise */ - list = listgen; /* and again */ - - switch (instruction->opcode) - { - case -1: return 0; - case I_DB: wsize = 1; break; - case I_DW: wsize = 2; break; - case I_DD: wsize = 4; break; - case I_DQ: wsize = 8; break; - case I_DT: wsize = 10; break; + outfmt = output; /* likewise */ + list = listgen; /* and again */ + + switch (instruction->opcode) { + case -1: + return 0; + case I_DB: + wsize = 1; + break; + case I_DW: + wsize = 2; + break; + case I_DD: + wsize = 4; + break; + case I_DQ: + wsize = 8; + break; + case I_DT: + wsize = 10; + break; } if (wsize) { - extop * e; - long t = instruction->times; - if (t < 0) - errfunc(ERR_PANIC, "instruction->times < 0 (%ld) in assemble()",t); - - while (t--) /* repeat TIMES times */ - { - for (e = instruction->eops; e; e = e->next) - { - if (e->type == EOT_DB_NUMBER) - { - if (wsize == 1) { - if (e->segment != NO_SEG) - errfunc (ERR_NONFATAL, - "one-byte relocation attempted"); - else { - unsigned char out_byte = e->offset; - out (offset, segment, &out_byte, OUT_RAWDATA+1, - NO_SEG, NO_SEG); - } - } - else if (wsize > 5) { - errfunc (ERR_NONFATAL, "integer supplied to a D%c" - " instruction", wsize==8 ? 'Q' : 'T'); - } - else - out (offset, segment, &e->offset, - OUT_ADDRESS+wsize, e->segment, - e->wrt); - offset += wsize; - } - else if (e->type == EOT_DB_STRING) - { - int align; - - out (offset, segment, e->stringval, - OUT_RAWDATA+e->stringlen, NO_SEG, NO_SEG); - align = e->stringlen % wsize; - - if (align) { - align = wsize - align; - out (offset, segment, "\0\0\0\0\0\0\0\0", - OUT_RAWDATA+align, NO_SEG, NO_SEG); - } - offset += e->stringlen + align; - } - } - if (t > 0 && t == instruction->times-1) - { - /* - * Dummy call to list->output to give the offset to the - * listing module. - */ - list->output (offset, NULL, OUT_RAWDATA); - list->uplevel (LIST_TIMES); - } - } - if (instruction->times > 1) - list->downlevel (LIST_TIMES); - return offset - start; + extop *e; + long t = instruction->times; + if (t < 0) + errfunc(ERR_PANIC, + "instruction->times < 0 (%ld) in assemble()", t); + + while (t--) { /* repeat TIMES times */ + for (e = instruction->eops; e; e = e->next) { + if (e->type == EOT_DB_NUMBER) { + if (wsize == 1) { + if (e->segment != NO_SEG) + errfunc(ERR_NONFATAL, + "one-byte relocation attempted"); + else { + unsigned char out_byte = e->offset; + out(offset, segment, &out_byte, + OUT_RAWDATA + 1, NO_SEG, NO_SEG); + } + } else if (wsize > 5) { + errfunc(ERR_NONFATAL, "integer supplied to a D%c" + " instruction", wsize == 8 ? 'Q' : 'T'); + } else + out(offset, segment, &e->offset, + OUT_ADDRESS + wsize, e->segment, e->wrt); + offset += wsize; + } else if (e->type == EOT_DB_STRING) { + int align; + + out(offset, segment, e->stringval, + OUT_RAWDATA + e->stringlen, NO_SEG, NO_SEG); + align = e->stringlen % wsize; + + if (align) { + align = wsize - align; + out(offset, segment, "\0\0\0\0\0\0\0\0", + OUT_RAWDATA + align, NO_SEG, NO_SEG); + } + offset += e->stringlen + align; + } + } + if (t > 0 && t == instruction->times - 1) { + /* + * Dummy call to list->output to give the offset to the + * listing module. + */ + list->output(offset, NULL, OUT_RAWDATA); + list->uplevel(LIST_TIMES); + } + } + if (instruction->times > 1) + list->downlevel(LIST_TIMES); + return offset - start; } - if (instruction->opcode == I_INCBIN) - { - static char fname[FILENAME_MAX]; - FILE * fp; - long len; + if (instruction->opcode == I_INCBIN) { + static char fname[FILENAME_MAX]; + FILE *fp; + long len; char *prefix = "", *combine; - char** pPrevPath = NULL; - - len = FILENAME_MAX-1; - if (len > instruction->eops->stringlen) - len = instruction->eops->stringlen; - strncpy (fname, instruction->eops->stringval, len); - fname[len] = '\0'; - - while (1) /* added by alexfru: 'incbin' uses include paths */ - { - combine = nasm_malloc(strlen(prefix) + len + 1); - strcpy(combine, prefix); - strcat(combine, fname); - - if ( (fp = fopen(combine, "rb")) != NULL) - { - nasm_free(combine); - break; - } - - nasm_free(combine); - pPrevPath = pp_get_include_path_ptr (pPrevPath); - if (pPrevPath == NULL) - break; - prefix = *pPrevPath; + char **pPrevPath = NULL; + + len = FILENAME_MAX - 1; + if (len > instruction->eops->stringlen) + len = instruction->eops->stringlen; + strncpy(fname, instruction->eops->stringval, len); + fname[len] = '\0'; + + while (1) { /* added by alexfru: 'incbin' uses include paths */ + combine = nasm_malloc(strlen(prefix) + len + 1); + strcpy(combine, prefix); + strcat(combine, fname); + + if ((fp = fopen(combine, "rb")) != NULL) { + nasm_free(combine); + break; + } + + nasm_free(combine); + pPrevPath = pp_get_include_path_ptr(pPrevPath); + if (pPrevPath == NULL) + break; + prefix = *pPrevPath; } if (fp == NULL) - error (ERR_NONFATAL, "`incbin': unable to open file `%s'", fname); - else if (fseek(fp, 0L, SEEK_END) < 0) - error (ERR_NONFATAL, "`incbin': unable to seek on file `%s'", - fname); - else - { - static char buf[2048]; - long t = instruction->times; - long base = 0; - - len = ftell (fp); - if (instruction->eops->next) { - base = instruction->eops->next->offset; - len -= base; - if (instruction->eops->next->next && - len > instruction->eops->next->next->offset) - len = instruction->eops->next->next->offset; - } - /* - * Dummy call to list->output to give the offset to the - * listing module. - */ - list->output (offset, NULL, OUT_RAWDATA); - list->uplevel(LIST_INCBIN); - while (t--) - { - long l; - - fseek (fp, base, SEEK_SET); - l = len; - while (l > 0) { - long m = fread (buf, 1, (l>sizeof(buf)?sizeof(buf):l), - fp); - if (!m) { - /* - * This shouldn't happen unless the file - * actually changes while we are reading - * it. - */ - error (ERR_NONFATAL, "`incbin': unexpected EOF while" - " reading file `%s'", fname); - t=0; /* Try to exit cleanly */ - break; - } - out (offset, segment, buf, OUT_RAWDATA+m, - NO_SEG, NO_SEG); - l -= m; - } - } - list->downlevel(LIST_INCBIN); - if (instruction->times > 1) { - /* - * Dummy call to list->output to give the offset to the - * listing module. - */ - list->output (offset, NULL, OUT_RAWDATA); - list->uplevel(LIST_TIMES); - list->downlevel(LIST_TIMES); - } - fclose (fp); - return instruction->times * len; - } - return 0; /* if we're here, there's an error */ + error(ERR_NONFATAL, "`incbin': unable to open file `%s'", + fname); + else if (fseek(fp, 0L, SEEK_END) < 0) + error(ERR_NONFATAL, "`incbin': unable to seek on file `%s'", + fname); + else { + static char buf[2048]; + long t = instruction->times; + long base = 0; + + len = ftell(fp); + if (instruction->eops->next) { + base = instruction->eops->next->offset; + len -= base; + if (instruction->eops->next->next && + len > instruction->eops->next->next->offset) + len = instruction->eops->next->next->offset; + } + /* + * Dummy call to list->output to give the offset to the + * listing module. + */ + list->output(offset, NULL, OUT_RAWDATA); + list->uplevel(LIST_INCBIN); + while (t--) { + long l; + + fseek(fp, base, SEEK_SET); + l = len; + while (l > 0) { + long m = + fread(buf, 1, (l > sizeof(buf) ? sizeof(buf) : l), + fp); + if (!m) { + /* + * This shouldn't happen unless the file + * actually changes while we are reading + * it. + */ + error(ERR_NONFATAL, + "`incbin': unexpected EOF while" + " reading file `%s'", fname); + t = 0; /* Try to exit cleanly */ + break; + } + out(offset, segment, buf, OUT_RAWDATA + m, + NO_SEG, NO_SEG); + l -= m; + } + } + list->downlevel(LIST_INCBIN); + if (instruction->times > 1) { + /* + * Dummy call to list->output to give the offset to the + * listing module. + */ + list->output(offset, NULL, OUT_RAWDATA); + list->uplevel(LIST_TIMES); + list->downlevel(LIST_TIMES); + } + fclose(fp); + return instruction->times * len; + } + return 0; /* if we're here, there's an error */ } size_prob = FALSE; temp = nasm_instructions[instruction->opcode]; while (temp->opcode != -1) { - int m = matches (temp, instruction); - if (m == 99) - m += jmp_match(segment, offset, bits, instruction, temp->code); - - if (m == 100) /* matches! */ - { - const char *codes = temp->code; - long insn_size = calcsize(segment, offset, bits, - instruction, codes); - itimes = instruction->times; - if (insn_size < 0) /* shouldn't be, on pass two */ - error (ERR_PANIC, "errors made it through from pass one"); - else while (itimes--) { - for (j=0; j<instruction->nprefix; j++) { - unsigned char c=0; - switch (instruction->prefixes[j]) { - case P_LOCK: - c = 0xF0; break; - case P_REPNE: case P_REPNZ: - c = 0xF2; break; - case P_REPE: case P_REPZ: case P_REP: - c = 0xF3; break; - case R_CS: c = 0x2E; break; - case R_DS: c = 0x3E; break; - case R_ES: c = 0x26; break; - case R_FS: c = 0x64; break; - case R_GS: c = 0x65; break; - case R_SS: c = 0x36; break; - case R_SEGR6: - case R_SEGR7: - error (ERR_NONFATAL, "segr6 and segr7 cannot be used as prefixes"); - break; - case P_A16: - if (bits != 16) - c = 0x67; - break; - case P_A32: - if (bits != 32) - c = 0x67; - break; - case P_O16: - if (bits != 16) - c = 0x66; - break; - case P_O32: - if (bits != 32) - c = 0x66; - break; - default: - error (ERR_PANIC, - "invalid instruction prefix"); - } - if (c != 0) { - out (offset, segment, &c, OUT_RAWDATA+1, - NO_SEG, NO_SEG); - offset++; - } - } - insn_end = offset + insn_size; - gencode (segment, offset, bits, instruction, codes, insn_end); - offset += insn_size; - if (itimes > 0 && itimes == instruction->times-1) { - /* - * Dummy call to list->output to give the offset to the - * listing module. - */ - list->output (offset, NULL, OUT_RAWDATA); - list->uplevel (LIST_TIMES); - } - } - if (instruction->times > 1) - list->downlevel (LIST_TIMES); - return offset - start; - } else if (m > 0 && m > size_prob) { - size_prob = m; - } - temp++; + int m = matches(temp, instruction); + if (m == 99) + m += jmp_match(segment, offset, bits, instruction, temp->code); + + if (m == 100) { /* matches! */ + const char *codes = temp->code; + long insn_size = calcsize(segment, offset, bits, + instruction, codes); + itimes = instruction->times; + if (insn_size < 0) /* shouldn't be, on pass two */ + error(ERR_PANIC, "errors made it through from pass one"); + else + while (itimes--) { + for (j = 0; j < instruction->nprefix; j++) { + unsigned char c = 0; + switch (instruction->prefixes[j]) { + case P_LOCK: + c = 0xF0; + break; + case P_REPNE: + case P_REPNZ: + c = 0xF2; + break; + case P_REPE: + case P_REPZ: + case P_REP: + c = 0xF3; + break; + case R_CS: + c = 0x2E; + break; + case R_DS: + c = 0x3E; + break; + case R_ES: + c = 0x26; + break; + case R_FS: + c = 0x64; + break; + case R_GS: + c = 0x65; + break; + case R_SS: + c = 0x36; + break; + case R_SEGR6: + case R_SEGR7: + error(ERR_NONFATAL, + "segr6 and segr7 cannot be used as prefixes"); + break; + case P_A16: + if (bits != 16) + c = 0x67; + break; + case P_A32: + if (bits != 32) + c = 0x67; + break; + case P_O16: + if (bits != 16) + c = 0x66; + break; + case P_O32: + if (bits != 32) + c = 0x66; + break; + default: + error(ERR_PANIC, "invalid instruction prefix"); + } + if (c != 0) { + out(offset, segment, &c, OUT_RAWDATA + 1, + NO_SEG, NO_SEG); + offset++; + } + } + insn_end = offset + insn_size; + gencode(segment, offset, bits, instruction, codes, + insn_end); + offset += insn_size; + if (itimes > 0 && itimes == instruction->times - 1) { + /* + * Dummy call to list->output to give the offset to the + * listing module. + */ + list->output(offset, NULL, OUT_RAWDATA); + list->uplevel(LIST_TIMES); + } + } + if (instruction->times > 1) + list->downlevel(LIST_TIMES); + return offset - start; + } else if (m > 0 && m > size_prob) { + size_prob = m; + } + temp++; } - if (temp->opcode == -1) { /* didn't match any instruction */ - if (size_prob == 1) /* would have matched, but for size */ - error (ERR_NONFATAL, "operation size not specified"); - else if (size_prob == 2) - error (ERR_NONFATAL, "mismatch in operand sizes"); - else if (size_prob == 3) - error (ERR_NONFATAL, "no instruction for this cpu level"); - else - error (ERR_NONFATAL, - "invalid combination of opcode and operands"); + if (temp->opcode == -1) { /* didn't match any instruction */ + if (size_prob == 1) /* would have matched, but for size */ + error(ERR_NONFATAL, "operation size not specified"); + else if (size_prob == 2) + error(ERR_NONFATAL, "mismatch in operand sizes"); + else if (size_prob == 3) + error(ERR_NONFATAL, "no instruction for this cpu level"); + else + error(ERR_NONFATAL, + "invalid combination of opcode and operands"); } return 0; } -long insn_size (long segment, long offset, int bits, unsigned long cp, - insn *instruction, efunc error) +long insn_size(long segment, long offset, int bits, unsigned long cp, + insn * instruction, efunc error) { struct itemplate *temp; - errfunc = error; /* to pass to other functions */ + errfunc = error; /* to pass to other functions */ cpu = cp; if (instruction->opcode == -1) - return 0; + return 0; if (instruction->opcode == I_DB || - instruction->opcode == I_DW || - instruction->opcode == I_DD || - instruction->opcode == I_DQ || - instruction->opcode == I_DT) - { - extop *e; - long isize, osize, wsize = 0; /* placate gcc */ - - isize = 0; - switch (instruction->opcode) - { - case I_DB: wsize = 1; break; - case I_DW: wsize = 2; break; - case I_DD: wsize = 4; break; - case I_DQ: wsize = 8; break; - case I_DT: wsize = 10; break; - } - - for (e = instruction->eops; e; e = e->next) - { - long align; - - osize = 0; - if (e->type == EOT_DB_NUMBER) - osize = 1; - else if (e->type == EOT_DB_STRING) - osize = e->stringlen; - - align = (-osize) % wsize; - if (align < 0) - align += wsize; - isize += osize + align; - } - return isize * instruction->times; + instruction->opcode == I_DW || + instruction->opcode == I_DD || + instruction->opcode == I_DQ || instruction->opcode == I_DT) { + extop *e; + long isize, osize, wsize = 0; /* placate gcc */ + + isize = 0; + switch (instruction->opcode) { + case I_DB: + wsize = 1; + break; + case I_DW: + wsize = 2; + break; + case I_DD: + wsize = 4; + break; + case I_DQ: + wsize = 8; + break; + case I_DT: + wsize = 10; + break; + } + + for (e = instruction->eops; e; e = e->next) { + long align; + + osize = 0; + if (e->type == EOT_DB_NUMBER) + osize = 1; + else if (e->type == EOT_DB_STRING) + osize = e->stringlen; + + align = (-osize) % wsize; + if (align < 0) + align += wsize; + isize += osize + align; + } + return isize * instruction->times; } - if (instruction->opcode == I_INCBIN) - { - char fname[FILENAME_MAX]; - FILE * fp; - long len; + if (instruction->opcode == I_INCBIN) { + char fname[FILENAME_MAX]; + FILE *fp; + long len; char *prefix = "", *combine; - char** pPrevPath = NULL; - - len = FILENAME_MAX-1; - if (len > instruction->eops->stringlen) - len = instruction->eops->stringlen; - strncpy (fname, instruction->eops->stringval, len); - fname[len] = '\0'; - - while (1) /* added by alexfru: 'incbin' uses include paths */ - { - combine = nasm_malloc(strlen(prefix) + len + 1); - strcpy(combine, prefix); - strcat(combine, fname); - - if ( (fp = fopen(combine, "rb")) != NULL) - { - nasm_free(combine); - break; - } - - nasm_free(combine); - pPrevPath = pp_get_include_path_ptr (pPrevPath); - if (pPrevPath == NULL) - break; - prefix = *pPrevPath; + char **pPrevPath = NULL; + + len = FILENAME_MAX - 1; + if (len > instruction->eops->stringlen) + len = instruction->eops->stringlen; + strncpy(fname, instruction->eops->stringval, len); + fname[len] = '\0'; + + while (1) { /* added by alexfru: 'incbin' uses include paths */ + combine = nasm_malloc(strlen(prefix) + len + 1); + strcpy(combine, prefix); + strcat(combine, fname); + + if ((fp = fopen(combine, "rb")) != NULL) { + nasm_free(combine); + break; + } + + nasm_free(combine); + pPrevPath = pp_get_include_path_ptr(pPrevPath); + if (pPrevPath == NULL) + break; + prefix = *pPrevPath; } if (fp == NULL) - error (ERR_NONFATAL, "`incbin': unable to open file `%s'", fname); - else if (fseek(fp, 0L, SEEK_END) < 0) - error (ERR_NONFATAL, "`incbin': unable to seek on file `%s'", - fname); - else - { - len = ftell (fp); - fclose (fp); - if (instruction->eops->next) - { - len -= instruction->eops->next->offset; - if (instruction->eops->next->next && - len > instruction->eops->next->next->offset) - { - len = instruction->eops->next->next->offset; - } - } - return instruction->times * len; - } - return 0; /* if we're here, there's an error */ + error(ERR_NONFATAL, "`incbin': unable to open file `%s'", + fname); + else if (fseek(fp, 0L, SEEK_END) < 0) + error(ERR_NONFATAL, "`incbin': unable to seek on file `%s'", + fname); + else { + len = ftell(fp); + fclose(fp); + if (instruction->eops->next) { + len -= instruction->eops->next->offset; + if (instruction->eops->next->next && + len > instruction->eops->next->next->offset) { + len = instruction->eops->next->next->offset; + } + } + return instruction->times * len; + } + return 0; /* if we're here, there's an error */ } temp = nasm_instructions[instruction->opcode]; while (temp->opcode != -1) { - int m = matches(temp, instruction); - if (m == 99) - m += jmp_match(segment, offset, bits, instruction, temp->code); - - if (m == 100) { - /* we've matched an instruction. */ - long isize; - const char * codes = temp->code; - int j; - - isize = calcsize(segment, offset, bits, instruction, codes); - if (isize < 0) - return -1; - for (j = 0; j < instruction->nprefix; j++) - { - if ((instruction->prefixes[j] != P_A16 && - instruction->prefixes[j] != P_O16 && bits==16) || - (instruction->prefixes[j] != P_A32 && - instruction->prefixes[j] != P_O32 && bits==32)) - { - isize++; - } - } - return isize * instruction->times; - } - temp++; + int m = matches(temp, instruction); + if (m == 99) + m += jmp_match(segment, offset, bits, instruction, temp->code); + + if (m == 100) { + /* we've matched an instruction. */ + long isize; + const char *codes = temp->code; + int j; + + isize = calcsize(segment, offset, bits, instruction, codes); + if (isize < 0) + return -1; + for (j = 0; j < instruction->nprefix; j++) { + if ((instruction->prefixes[j] != P_A16 && + instruction->prefixes[j] != P_O16 && bits == 16) || + (instruction->prefixes[j] != P_A32 && + instruction->prefixes[j] != P_O32 && bits == 32)) { + isize++; + } + } + return isize * instruction->times; + } + temp++; } - return -1; /* didn't match any instruction */ + return -1; /* didn't match any instruction */ } - /* check that opn[op] is a signed byte of size 16 or 32, and return the signed value*/ -static int is_sbyte (insn *ins, int op, int size) +static int is_sbyte(insn * ins, int op, int size) { signed long v; int ret; - - ret = !(ins->forw_ref && ins->oprs[op].opflags ) && /* dead in the water on forward reference or External */ - optimizing>=0 && - !(ins->oprs[op].type & STRICT) && - ins->oprs[op].wrt==NO_SEG && ins->oprs[op].segment==NO_SEG; + + ret = !(ins->forw_ref && ins->oprs[op].opflags) && /* dead in the water on forward reference or External */ + optimizing >= 0 && + !(ins->oprs[op].type & STRICT) && + ins->oprs[op].wrt == NO_SEG && ins->oprs[op].segment == NO_SEG; v = ins->oprs[op].offset; - if (size==16) v = (signed short)v; /* sign extend if 16 bits */ - - return ret && v>=-128L && v<=127L; + if (size == 16) + v = (signed short)v; /* sign extend if 16 bits */ + + return ret && v >= -128L && v <= 127L; } -static long calcsize (long segment, long offset, int bits, - insn *ins, const char *codes) +static long calcsize(long segment, long offset, int bits, + insn * ins, const char *codes) { - long length = 0; - unsigned char c; - - (void) segment; /* Don't warn that this parameter is unused */ - (void) offset; /* Don't warn that this parameter is unused */ - - while (*codes) switch (c = *codes++) { - case 01: case 02: case 03: - codes += c, length += c; break; - case 04: case 05: case 06: case 07: - length++; break; - case 010: case 011: case 012: - codes++, length++; break; - case 017: - length++; break; - case 014: case 015: case 016: - length++; break; - case 020: case 021: case 022: - length++; break; - case 024: case 025: case 026: - length++; break; - case 030: case 031: case 032: - length += 2; break; - case 034: case 035: case 036: - if ( ins->oprs[c-034].type & (BITS16|BITS32) ) - length += (ins->oprs[c-034].type & BITS16) ? 2 : 4; - else - length += (bits == 16) ? 2 : 4; - break; - case 037: - length += 2; break; - case 040: case 041: case 042: - length += 4; break; - case 044: case 045: case 046: - length += ((ins->oprs[c-044].addr_size ? - ins->oprs[c-044].addr_size : bits) == 16 ? 2 : 4); break; - case 050: case 051: case 052: - length++; break; - case 060: case 061: case 062: - length += 2; break; - case 064: case 065: case 066: - if ( ins->oprs[c-064].type & (BITS16|BITS32) ) - length += (ins->oprs[c-064].type & BITS16) ? 2 : 4; - else - length += (bits == 16) ? 2 : 4; - break; - case 070: case 071: case 072: - length += 4; break; - case 0130: case 0131: case 0132: - length += is_sbyte(ins, c-0130, 16) ? 1 : 2; break; - case 0133: case 0134: case 0135: - codes+=2; length++; break; - case 0140: case 0141: case 0142: - length += is_sbyte(ins, c-0140, 32) ? 1 : 4; break; - case 0143: case 0144: case 0145: - codes+=2; length++; break; - case 0300: case 0301: case 0302: - length += chsize (&ins->oprs[c-0300], bits); - break; - case 0310: - length += (bits==32); - break; - case 0311: - length += (bits==16); - break; - case 0312: - break; - case 0320: - length += (bits==32); - break; - case 0321: - length += (bits==16); - break; - case 0322: - break; - case 0330: - codes++, length++; break; - case 0331: - case 0332: - break; - case 0333: - length++; break; - case 0340: case 0341: case 0342: - if (ins->oprs[0].segment != NO_SEG) - errfunc (ERR_NONFATAL, "attempt to reserve non-constant" - " quantity of BSS space"); - else - length += ins->oprs[0].offset << (c-0340); - break; - case 0370: case 0371: case 0372: - break; - case 0373: - length++; break; - default: /* can't do it by 'case' statements */ - if (c>=0100 && c<=0277) { /* it's an EA */ - ea ea_data; - if (!process_ea (&ins->oprs[(c>>3)&7], &ea_data, bits, 0, - ins->forw_ref)) { - errfunc (ERR_NONFATAL, "invalid effective address"); - return -1; - } else - length += ea_data.size; - } else - errfunc (ERR_PANIC, "internal instruction table corrupt" - ": instruction code 0x%02X given", c); - } + long length = 0; + unsigned char c; + + (void)segment; /* Don't warn that this parameter is unused */ + (void)offset; /* Don't warn that this parameter is unused */ + + while (*codes) + switch (c = *codes++) { + case 01: + case 02: + case 03: + codes += c, length += c; + break; + case 04: + case 05: + case 06: + case 07: + length++; + break; + case 010: + case 011: + case 012: + codes++, length++; + break; + case 017: + length++; + break; + case 014: + case 015: + case 016: + length++; + break; + case 020: + case 021: + case 022: + length++; + break; + case 024: + case 025: + case 026: + length++; + break; + case 030: + case 031: + case 032: + length += 2; + break; + case 034: + case 035: + case 036: + if (ins->oprs[c - 034].type & (BITS16 | BITS32)) + length += (ins->oprs[c - 034].type & BITS16) ? 2 : 4; + else + length += (bits == 16) ? 2 : 4; + break; + case 037: + length += 2; + break; + case 040: + case 041: + case 042: + length += 4; + break; + case 044: + case 045: + case 046: + length += ((ins->oprs[c - 044].addr_size ? + ins->oprs[c - 044].addr_size : bits) == + 16 ? 2 : 4); + break; + case 050: + case 051: + case 052: + length++; + break; + case 060: + case 061: + case 062: + length += 2; + break; + case 064: + case 065: + case 066: + if (ins->oprs[c - 064].type & (BITS16 | BITS32)) + length += (ins->oprs[c - 064].type & BITS16) ? 2 : 4; + else + length += (bits == 16) ? 2 : 4; + break; + case 070: + case 071: + case 072: + length += 4; + break; + case 0130: + case 0131: + case 0132: + length += is_sbyte(ins, c - 0130, 16) ? 1 : 2; + break; + case 0133: + case 0134: + case 0135: + codes += 2; + length++; + break; + case 0140: + case 0141: + case 0142: + length += is_sbyte(ins, c - 0140, 32) ? 1 : 4; + break; + case 0143: + case 0144: + case 0145: + codes += 2; + length++; + break; + case 0300: + case 0301: + case 0302: + length += chsize(&ins->oprs[c - 0300], bits); + break; + case 0310: + length += (bits == 32); + break; + case 0311: + length += (bits == 16); + break; + case 0312: + break; + case 0320: + length += (bits == 32); + break; + case 0321: + length += (bits == 16); + break; + case 0322: + break; + case 0330: + codes++, length++; + break; + case 0331: + case 0332: + break; + case 0333: + length++; + break; + case 0340: + case 0341: + case 0342: + if (ins->oprs[0].segment != NO_SEG) + errfunc(ERR_NONFATAL, "attempt to reserve non-constant" + " quantity of BSS space"); + else + length += ins->oprs[0].offset << (c - 0340); + break; + case 0370: + case 0371: + case 0372: + break; + case 0373: + length++; + break; + default: /* can't do it by 'case' statements */ + if (c >= 0100 && c <= 0277) { /* it's an EA */ + ea ea_data; + if (!process_ea + (&ins->oprs[(c >> 3) & 7], &ea_data, bits, 0, + ins->forw_ref)) { + errfunc(ERR_NONFATAL, "invalid effective address"); + return -1; + } else + length += ea_data.size; + } else + errfunc(ERR_PANIC, "internal instruction table corrupt" + ": instruction code 0x%02X given", c); + } return length; } -static void gencode (long segment, long offset, int bits, - insn *ins, const char *codes, long insn_end) +static void gencode(long segment, long offset, int bits, + insn * ins, const char *codes, long insn_end) { - static char condval[] = { /* conditional opcodes */ - 0x7, 0x3, 0x2, 0x6, 0x2, 0x4, 0xF, 0xD, 0xC, 0xE, 0x6, 0x2, - 0x3, 0x7, 0x3, 0x5, 0xE, 0xC, 0xD, 0xF, 0x1, 0xB, 0x9, 0x5, - 0x0, 0xA, 0xA, 0xB, 0x8, 0x4 + static char condval[] = { /* conditional opcodes */ + 0x7, 0x3, 0x2, 0x6, 0x2, 0x4, 0xF, 0xD, 0xC, 0xE, 0x6, 0x2, + 0x3, 0x7, 0x3, 0x5, 0xE, 0xC, 0xD, 0xF, 0x1, 0xB, 0x9, 0x5, + 0x0, 0xA, 0xA, 0xB, 0x8, 0x4 }; unsigned char c; unsigned char bytes[4]; - long data, size; + long data, size; while (*codes) - switch (c = *codes++) - { - case 01: case 02: case 03: - out (offset, segment, codes, OUT_RAWDATA+c, NO_SEG, NO_SEG); - codes += c; - offset += c; - break; - - case 04: case 06: - switch (ins->oprs[0].basereg) - { - case R_CS: - bytes[0] = 0x0E + (c == 0x04 ? 1 : 0); break; - case R_DS: - bytes[0] = 0x1E + (c == 0x04 ? 1 : 0); break; - case R_ES: - bytes[0] = 0x06 + (c == 0x04 ? 1 : 0); break; - case R_SS: - bytes[0] = 0x16 + (c == 0x04 ? 1 : 0); break; - default: - errfunc (ERR_PANIC, "bizarre 8086 segment register received"); - } - out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset++; - break; - - case 05: case 07: - switch (ins->oprs[0].basereg) { - case R_FS: bytes[0] = 0xA0 + (c == 0x05 ? 1 : 0); break; - case R_GS: bytes[0] = 0xA8 + (c == 0x05 ? 1 : 0); break; - default: - errfunc (ERR_PANIC, "bizarre 386 segment register received"); - } - out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset++; - break; - - case 010: case 011: case 012: - bytes[0] = *codes++ + regval(&ins->oprs[c-010]); - out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset += 1; - break; - - case 017: - bytes[0] = 0; - out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset += 1; - break; - - case 014: case 015: case 016: - if (ins->oprs[c-014].offset < -128 - || ins->oprs[c-014].offset > 127) - { - errfunc (ERR_WARNING, "signed byte value exceeds bounds"); - } - - if (ins->oprs[c-014].segment != NO_SEG) - { - data = ins->oprs[c-014].offset; - out (offset, segment, &data, OUT_ADDRESS+1, - ins->oprs[c-014].segment, ins->oprs[c-014].wrt); - } - else { - bytes[0] = ins->oprs[c-014].offset; - out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG); - } - offset += 1; - break; - - case 020: case 021: case 022: - if (ins->oprs[c-020].offset < -256 - || ins->oprs[c-020].offset > 255) - { - errfunc (ERR_WARNING, "byte value exceeds bounds"); - } - if (ins->oprs[c-020].segment != NO_SEG) { - data = ins->oprs[c-020].offset; - out (offset, segment, &data, OUT_ADDRESS+1, - ins->oprs[c-020].segment, ins->oprs[c-020].wrt); - } - else { - bytes[0] = ins->oprs[c-020].offset; - out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG); - } - offset += 1; - break; - - case 024: case 025: case 026: - if (ins->oprs[c-024].offset < 0 || ins->oprs[c-024].offset > 255) - errfunc (ERR_WARNING, "unsigned byte value exceeds bounds"); - if (ins->oprs[c-024].segment != NO_SEG) { - data = ins->oprs[c-024].offset; - out (offset, segment, &data, OUT_ADDRESS+1, - ins->oprs[c-024].segment, ins->oprs[c-024].wrt); - } - else { - bytes[0] = ins->oprs[c-024].offset; - out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG); - } - offset += 1; - break; - - case 030: case 031: case 032: - if (ins->oprs[c-030].segment == NO_SEG && - ins->oprs[c-030].wrt == NO_SEG && - (ins->oprs[c-030].offset < -65536L || - ins->oprs[c-030].offset > 65535L)) - { - errfunc (ERR_WARNING, "word value exceeds bounds"); - } - data = ins->oprs[c-030].offset; - out (offset, segment, &data, OUT_ADDRESS+2, - ins->oprs[c-030].segment, ins->oprs[c-030].wrt); - offset += 2; - break; - - case 034: case 035: case 036: - if ( ins->oprs[c-034].type & (BITS16|BITS32) ) - size = (ins->oprs[c-034].type & BITS16) ? 2 : 4; - else - size = (bits == 16) ? 2 : 4; - data = ins->oprs[c-034].offset; - if (size==2 && (data < -65536L || data > 65535L)) - errfunc (ERR_WARNING, "word value exceeds bounds"); - out (offset, segment, &data, OUT_ADDRESS+size, - ins->oprs[c-034].segment, ins->oprs[c-034].wrt); - offset += size; - break; - - case 037: - if (ins->oprs[0].segment == NO_SEG) - errfunc (ERR_NONFATAL, "value referenced by FAR is not" - " relocatable"); - data = 0L; - out (offset, segment, &data, OUT_ADDRESS+2, - outfmt->segbase(1+ins->oprs[0].segment), - ins->oprs[0].wrt); - offset += 2; - break; - - case 040: case 041: case 042: - data = ins->oprs[c-040].offset; - out (offset, segment, &data, OUT_ADDRESS+4, - ins->oprs[c-040].segment, ins->oprs[c-040].wrt); - offset += 4; - break; - - case 044: case 045: case 046: - data = ins->oprs[c-044].offset; - size = ((ins->oprs[c-044].addr_size ? - ins->oprs[c-044].addr_size : bits) == 16 ? 2 : 4); - if (size==2 && (data < -65536L || data > 65535L)) - errfunc (ERR_WARNING, "word value exceeds bounds"); - out (offset, segment, &data, OUT_ADDRESS+size, - ins->oprs[c-044].segment, ins->oprs[c-044].wrt); - offset += size; - break; - - case 050: case 051: case 052: - if (ins->oprs[c-050].segment != segment) - errfunc (ERR_NONFATAL, "short relative jump outside segment"); - data = ins->oprs[c-050].offset - insn_end; - if (data > 127 || data < -128) - errfunc (ERR_NONFATAL, "short jump is out of range"); - bytes[0] = data; - out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset += 1; - break; - - case 060: case 061: case 062: - if (ins->oprs[c-060].segment != segment) { - data = ins->oprs[c-060].offset; - out (offset, segment, &data, OUT_REL2ADR+insn_end-offset, - ins->oprs[c-060].segment, ins->oprs[c-060].wrt); - } else { - data = ins->oprs[c-060].offset - insn_end; - out (offset, segment, &data, - OUT_ADDRESS+2, NO_SEG, NO_SEG); - } - offset += 2; - break; - - case 064: case 065: case 066: - if ( ins->oprs[c-064].type & (BITS16|BITS32) ) - size = (ins->oprs[c-064].type & BITS16) ? 2 : 4; - else - size = (bits == 16) ? 2 : 4; - if (ins->oprs[c-064].segment != segment) { - long reltype = (size == 2 ? OUT_REL2ADR : OUT_REL4ADR); - data = ins->oprs[c-064].offset; - out (offset, segment, &data, reltype+insn_end-offset, - ins->oprs[c-064].segment, ins->oprs[c-064].wrt); - } else { - data = ins->oprs[c-064].offset - insn_end; - out (offset, segment, &data, - OUT_ADDRESS+size, NO_SEG, NO_SEG); - } - offset += size; - break; - - case 070: case 071: case 072: - if (ins->oprs[c-070].segment != segment) { - data = ins->oprs[c-070].offset; - out (offset, segment, &data, OUT_REL4ADR+insn_end-offset, - ins->oprs[c-070].segment, ins->oprs[c-070].wrt); - } else { - data = ins->oprs[c-070].offset - insn_end; - out (offset, segment, &data, - OUT_ADDRESS+4, NO_SEG, NO_SEG); - } - offset += 4; - break; - - case 0130: case 0131: case 0132: - data = ins->oprs[c-0130].offset; - if (is_sbyte(ins, c-0130, 16)) { - bytes[0] = data; - out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset++; - } else { - if (ins->oprs[c-0130].segment == NO_SEG && - ins->oprs[c-0130].wrt == NO_SEG && - (data < -65536L || data > 65535L)) { - errfunc (ERR_WARNING, "word value exceeds bounds"); - } - out (offset, segment, &data, OUT_ADDRESS+2, - ins->oprs[c-0130].segment, ins->oprs[c-0130].wrt); - offset += 2; - } - break; - - case 0133: case 0134: case 0135: - codes++; - bytes[0] = *codes++; - if (is_sbyte(ins, c-0133, 16)) bytes[0] |= 2; /* s-bit */ - out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset++; - break; - - case 0140: case 0141: case 0142: - data = ins->oprs[c-0140].offset; - if (is_sbyte(ins, c-0140, 32)) { - bytes[0] = data; - out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset++; - } else { - out (offset, segment, &data, OUT_ADDRESS+4, - ins->oprs[c-0140].segment, ins->oprs[c-0140].wrt); - offset += 4; - } - break; - - case 0143: case 0144: case 0145: - codes++; - bytes[0] = *codes++; - if (is_sbyte(ins, c-0143, 32)) bytes[0] |= 2; /* s-bit */ - out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset++; - break; - - case 0300: case 0301: case 0302: - if (chsize (&ins->oprs[c-0300], bits)) { - *bytes = 0x67; - out (offset, segment, bytes, - OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset += 1; - } else - offset += 0; - break; - - case 0310: - if (bits==32) { - *bytes = 0x67; - out (offset, segment, bytes, - OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset += 1; - } else - offset += 0; - break; - - case 0311: - if (bits==16) { - *bytes = 0x67; - out (offset, segment, bytes, - OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset += 1; - } else - offset += 0; - break; - - case 0312: - break; - - case 0320: - if (bits==32) { - *bytes = 0x66; - out (offset, segment, bytes, - OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset += 1; - } else - offset += 0; - break; - - case 0321: - if (bits==16) { - *bytes = 0x66; - out (offset, segment, bytes, - OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset += 1; - } else - offset += 0; - break; - - case 0322: - break; - - case 0330: - *bytes = *codes++ ^ condval[ins->condition]; - out (offset, segment, bytes, - OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset += 1; - break; - - case 0331: - case 0332: - break; - - case 0333: - *bytes = 0xF3; - out (offset, segment, bytes, - OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset += 1; - break; - - case 0340: case 0341: case 0342: - if (ins->oprs[0].segment != NO_SEG) - errfunc (ERR_PANIC, "non-constant BSS size in pass two"); - else { - long size = ins->oprs[0].offset << (c-0340); - if (size > 0) - out (offset, segment, NULL, - OUT_RESERVE+size, NO_SEG, NO_SEG); - offset += size; - } - break; - - case 0370: case 0371: case 0372: - break; - - case 0373: - *bytes = bits==16 ? 3 : 5; - out (offset, segment, bytes, - OUT_RAWDATA+1, NO_SEG, NO_SEG); - offset += 1; - break; - - default: /* can't do it by 'case' statements */ - if (c>=0100 && c<=0277) { /* it's an EA */ - ea ea_data; - int rfield; - unsigned char *p; - long s; - - if (c<=0177) /* pick rfield from operand b */ - rfield = regval (&ins->oprs[c&7]); - else /* rfield is constant */ - rfield = c & 7; - - if (!process_ea (&ins->oprs[(c>>3)&7], &ea_data, bits, rfield, - ins->forw_ref)) - { - errfunc (ERR_NONFATAL, "invalid effective address"); - } - - p = bytes; - *p++ = ea_data.modrm; - if (ea_data.sib_present) - *p++ = ea_data.sib; - - s = p-bytes; - out (offset, segment, bytes, OUT_RAWDATA + s, - NO_SEG, NO_SEG); - - switch (ea_data.bytes) { - case 0: - break; - case 1: - if (ins->oprs[(c>>3)&7].segment != NO_SEG) { - data = ins->oprs[(c>>3)&7].offset; - out (offset, segment, &data, OUT_ADDRESS+1, - ins->oprs[(c>>3)&7].segment, - ins->oprs[(c>>3)&7].wrt); - } else { - *bytes = ins->oprs[(c>>3)&7].offset; - out (offset, segment, bytes, OUT_RAWDATA+1, - NO_SEG, NO_SEG); - } - s++; - break; - case 2: - case 4: - data = ins->oprs[(c>>3)&7].offset; - out (offset, segment, &data, - OUT_ADDRESS+ea_data.bytes, - ins->oprs[(c>>3)&7].segment, ins->oprs[(c>>3)&7].wrt); - s += ea_data.bytes; - break; - } - offset += s; - } else - errfunc (ERR_PANIC, "internal instruction table corrupt" - ": instruction code 0x%02X given", c); - } + switch (c = *codes++) { + case 01: + case 02: + case 03: + out(offset, segment, codes, OUT_RAWDATA + c, NO_SEG, NO_SEG); + codes += c; + offset += c; + break; + + case 04: + case 06: + switch (ins->oprs[0].basereg) { + case R_CS: + bytes[0] = 0x0E + (c == 0x04 ? 1 : 0); + break; + case R_DS: + bytes[0] = 0x1E + (c == 0x04 ? 1 : 0); + break; + case R_ES: + bytes[0] = 0x06 + (c == 0x04 ? 1 : 0); + break; + case R_SS: + bytes[0] = 0x16 + (c == 0x04 ? 1 : 0); + break; + default: + errfunc(ERR_PANIC, + "bizarre 8086 segment register received"); + } + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset++; + break; + + case 05: + case 07: + switch (ins->oprs[0].basereg) { + case R_FS: + bytes[0] = 0xA0 + (c == 0x05 ? 1 : 0); + break; + case R_GS: + bytes[0] = 0xA8 + (c == 0x05 ? 1 : 0); + break; + default: + errfunc(ERR_PANIC, + "bizarre 386 segment register received"); + } + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset++; + break; + + case 010: + case 011: + case 012: + bytes[0] = *codes++ + regval(&ins->oprs[c - 010]); + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset += 1; + break; + + case 017: + bytes[0] = 0; + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset += 1; + break; + + case 014: + case 015: + case 016: + if (ins->oprs[c - 014].offset < -128 + || ins->oprs[c - 014].offset > 127) { + errfunc(ERR_WARNING, "signed byte value exceeds bounds"); + } + + if (ins->oprs[c - 014].segment != NO_SEG) { + data = ins->oprs[c - 014].offset; + out(offset, segment, &data, OUT_ADDRESS + 1, + ins->oprs[c - 014].segment, ins->oprs[c - 014].wrt); + } else { + bytes[0] = ins->oprs[c - 014].offset; + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, + NO_SEG); + } + offset += 1; + break; + + case 020: + case 021: + case 022: + if (ins->oprs[c - 020].offset < -256 + || ins->oprs[c - 020].offset > 255) { + errfunc(ERR_WARNING, "byte value exceeds bounds"); + } + if (ins->oprs[c - 020].segment != NO_SEG) { + data = ins->oprs[c - 020].offset; + out(offset, segment, &data, OUT_ADDRESS + 1, + ins->oprs[c - 020].segment, ins->oprs[c - 020].wrt); + } else { + bytes[0] = ins->oprs[c - 020].offset; + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, + NO_SEG); + } + offset += 1; + break; + + case 024: + case 025: + case 026: + if (ins->oprs[c - 024].offset < 0 + || ins->oprs[c - 024].offset > 255) + errfunc(ERR_WARNING, "unsigned byte value exceeds bounds"); + if (ins->oprs[c - 024].segment != NO_SEG) { + data = ins->oprs[c - 024].offset; + out(offset, segment, &data, OUT_ADDRESS + 1, + ins->oprs[c - 024].segment, ins->oprs[c - 024].wrt); + } else { + bytes[0] = ins->oprs[c - 024].offset; + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, + NO_SEG); + } + offset += 1; + break; + + case 030: + case 031: + case 032: + if (ins->oprs[c - 030].segment == NO_SEG && + ins->oprs[c - 030].wrt == NO_SEG && + (ins->oprs[c - 030].offset < -65536L || + ins->oprs[c - 030].offset > 65535L)) { + errfunc(ERR_WARNING, "word value exceeds bounds"); + } + data = ins->oprs[c - 030].offset; + out(offset, segment, &data, OUT_ADDRESS + 2, + ins->oprs[c - 030].segment, ins->oprs[c - 030].wrt); + offset += 2; + break; + + case 034: + case 035: + case 036: + if (ins->oprs[c - 034].type & (BITS16 | BITS32)) + size = (ins->oprs[c - 034].type & BITS16) ? 2 : 4; + else + size = (bits == 16) ? 2 : 4; + data = ins->oprs[c - 034].offset; + if (size == 2 && (data < -65536L || data > 65535L)) + errfunc(ERR_WARNING, "word value exceeds bounds"); + out(offset, segment, &data, OUT_ADDRESS + size, + ins->oprs[c - 034].segment, ins->oprs[c - 034].wrt); + offset += size; + break; + + case 037: + if (ins->oprs[0].segment == NO_SEG) + errfunc(ERR_NONFATAL, "value referenced by FAR is not" + " relocatable"); + data = 0L; + out(offset, segment, &data, OUT_ADDRESS + 2, + outfmt->segbase(1 + ins->oprs[0].segment), + ins->oprs[0].wrt); + offset += 2; + break; + + case 040: + case 041: + case 042: + data = ins->oprs[c - 040].offset; + out(offset, segment, &data, OUT_ADDRESS + 4, + ins->oprs[c - 040].segment, ins->oprs[c - 040].wrt); + offset += 4; + break; + + case 044: + case 045: + case 046: + data = ins->oprs[c - 044].offset; + size = ((ins->oprs[c - 044].addr_size ? + ins->oprs[c - 044].addr_size : bits) == 16 ? 2 : 4); + if (size == 2 && (data < -65536L || data > 65535L)) + errfunc(ERR_WARNING, "word value exceeds bounds"); + out(offset, segment, &data, OUT_ADDRESS + size, + ins->oprs[c - 044].segment, ins->oprs[c - 044].wrt); + offset += size; + break; + + case 050: + case 051: + case 052: + if (ins->oprs[c - 050].segment != segment) + errfunc(ERR_NONFATAL, + "short relative jump outside segment"); + data = ins->oprs[c - 050].offset - insn_end; + if (data > 127 || data < -128) + errfunc(ERR_NONFATAL, "short jump is out of range"); + bytes[0] = data; + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset += 1; + break; + + case 060: + case 061: + case 062: + if (ins->oprs[c - 060].segment != segment) { + data = ins->oprs[c - 060].offset; + out(offset, segment, &data, + OUT_REL2ADR + insn_end - offset, + ins->oprs[c - 060].segment, ins->oprs[c - 060].wrt); + } else { + data = ins->oprs[c - 060].offset - insn_end; + out(offset, segment, &data, + OUT_ADDRESS + 2, NO_SEG, NO_SEG); + } + offset += 2; + break; + + case 064: + case 065: + case 066: + if (ins->oprs[c - 064].type & (BITS16 | BITS32)) + size = (ins->oprs[c - 064].type & BITS16) ? 2 : 4; + else + size = (bits == 16) ? 2 : 4; + if (ins->oprs[c - 064].segment != segment) { + long reltype = (size == 2 ? OUT_REL2ADR : OUT_REL4ADR); + data = ins->oprs[c - 064].offset; + out(offset, segment, &data, reltype + insn_end - offset, + ins->oprs[c - 064].segment, ins->oprs[c - 064].wrt); + } else { + data = ins->oprs[c - 064].offset - insn_end; + out(offset, segment, &data, + OUT_ADDRESS + size, NO_SEG, NO_SEG); + } + offset += size; + break; + + case 070: + case 071: + case 072: + if (ins->oprs[c - 070].segment != segment) { + data = ins->oprs[c - 070].offset; + out(offset, segment, &data, + OUT_REL4ADR + insn_end - offset, + ins->oprs[c - 070].segment, ins->oprs[c - 070].wrt); + } else { + data = ins->oprs[c - 070].offset - insn_end; + out(offset, segment, &data, + OUT_ADDRESS + 4, NO_SEG, NO_SEG); + } + offset += 4; + break; + + case 0130: + case 0131: + case 0132: + data = ins->oprs[c - 0130].offset; + if (is_sbyte(ins, c - 0130, 16)) { + bytes[0] = data; + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, + NO_SEG); + offset++; + } else { + if (ins->oprs[c - 0130].segment == NO_SEG && + ins->oprs[c - 0130].wrt == NO_SEG && + (data < -65536L || data > 65535L)) { + errfunc(ERR_WARNING, "word value exceeds bounds"); + } + out(offset, segment, &data, OUT_ADDRESS + 2, + ins->oprs[c - 0130].segment, ins->oprs[c - 0130].wrt); + offset += 2; + } + break; + + case 0133: + case 0134: + case 0135: + codes++; + bytes[0] = *codes++; + if (is_sbyte(ins, c - 0133, 16)) + bytes[0] |= 2; /* s-bit */ + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset++; + break; + + case 0140: + case 0141: + case 0142: + data = ins->oprs[c - 0140].offset; + if (is_sbyte(ins, c - 0140, 32)) { + bytes[0] = data; + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, + NO_SEG); + offset++; + } else { + out(offset, segment, &data, OUT_ADDRESS + 4, + ins->oprs[c - 0140].segment, ins->oprs[c - 0140].wrt); + offset += 4; + } + break; + + case 0143: + case 0144: + case 0145: + codes++; + bytes[0] = *codes++; + if (is_sbyte(ins, c - 0143, 32)) + bytes[0] |= 2; /* s-bit */ + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset++; + break; + + case 0300: + case 0301: + case 0302: + if (chsize(&ins->oprs[c - 0300], bits)) { + *bytes = 0x67; + out(offset, segment, bytes, + OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset += 1; + } else + offset += 0; + break; + + case 0310: + if (bits == 32) { + *bytes = 0x67; + out(offset, segment, bytes, + OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset += 1; + } else + offset += 0; + break; + + case 0311: + if (bits == 16) { + *bytes = 0x67; + out(offset, segment, bytes, + OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset += 1; + } else + offset += 0; + break; + + case 0312: + break; + + case 0320: + if (bits == 32) { + *bytes = 0x66; + out(offset, segment, bytes, + OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset += 1; + } else + offset += 0; + break; + + case 0321: + if (bits == 16) { + *bytes = 0x66; + out(offset, segment, bytes, + OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset += 1; + } else + offset += 0; + break; + + case 0322: + break; + + case 0330: + *bytes = *codes++ ^ condval[ins->condition]; + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset += 1; + break; + + case 0331: + case 0332: + break; + + case 0333: + *bytes = 0xF3; + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset += 1; + break; + + case 0340: + case 0341: + case 0342: + if (ins->oprs[0].segment != NO_SEG) + errfunc(ERR_PANIC, "non-constant BSS size in pass two"); + else { + long size = ins->oprs[0].offset << (c - 0340); + if (size > 0) + out(offset, segment, NULL, + OUT_RESERVE + size, NO_SEG, NO_SEG); + offset += size; + } + break; + + case 0370: + case 0371: + case 0372: + break; + + case 0373: + *bytes = bits == 16 ? 3 : 5; + out(offset, segment, bytes, OUT_RAWDATA + 1, NO_SEG, NO_SEG); + offset += 1; + break; + + default: /* can't do it by 'case' statements */ + if (c >= 0100 && c <= 0277) { /* it's an EA */ + ea ea_data; + int rfield; + unsigned char *p; + long s; + + if (c <= 0177) /* pick rfield from operand b */ + rfield = regval(&ins->oprs[c & 7]); + else /* rfield is constant */ + rfield = c & 7; + + if (!process_ea + (&ins->oprs[(c >> 3) & 7], &ea_data, bits, rfield, + ins->forw_ref)) { + errfunc(ERR_NONFATAL, "invalid effective address"); + } + + p = bytes; + *p++ = ea_data.modrm; + if (ea_data.sib_present) + *p++ = ea_data.sib; + + s = p - bytes; + out(offset, segment, bytes, OUT_RAWDATA + s, + NO_SEG, NO_SEG); + + switch (ea_data.bytes) { + case 0: + break; + case 1: + if (ins->oprs[(c >> 3) & 7].segment != NO_SEG) { + data = ins->oprs[(c >> 3) & 7].offset; + out(offset, segment, &data, OUT_ADDRESS + 1, + ins->oprs[(c >> 3) & 7].segment, + ins->oprs[(c >> 3) & 7].wrt); + } else { + *bytes = ins->oprs[(c >> 3) & 7].offset; + out(offset, segment, bytes, OUT_RAWDATA + 1, + NO_SEG, NO_SEG); + } + s++; + break; + case 2: + case 4: + data = ins->oprs[(c >> 3) & 7].offset; + out(offset, segment, &data, + OUT_ADDRESS + ea_data.bytes, + ins->oprs[(c >> 3) & 7].segment, + ins->oprs[(c >> 3) & 7].wrt); + s += ea_data.bytes; + break; + } + offset += s; + } else + errfunc(ERR_PANIC, "internal instruction table corrupt" + ": instruction code 0x%02X given", c); + } } #include "regvals.c" -static int regval (operand *o) +static int regval(operand * o) { - if ( o->basereg < EXPR_REG_START || o->basereg >= REG_ENUM_LIMIT ) { - errfunc (ERR_PANIC, "invalid operand passed to regval()"); + if (o->basereg < EXPR_REG_START || o->basereg >= REG_ENUM_LIMIT) { + errfunc(ERR_PANIC, "invalid operand passed to regval()"); } return regvals[o->basereg]; } -static int matches (struct itemplate *itemp, insn *instruction) +static int matches(struct itemplate *itemp, insn * instruction) { int i, size[3], asize, oprs, ret; @@ -1180,347 +1317,447 @@ static int matches (struct itemplate *itemp, insn *instruction) /* * Check the opcode */ - if (itemp->opcode != instruction->opcode) return 0; + if (itemp->opcode != instruction->opcode) + return 0; /* * Count the operands */ - if (itemp->operands != instruction->operands) return 0; + if (itemp->operands != instruction->operands) + return 0; /* * Check that no spurious colons or TOs are present */ - for (i=0; i<itemp->operands; i++) - if (instruction->oprs[i].type & ~itemp->opd[i] & (COLON|TO)) - return 0; + for (i = 0; i < itemp->operands; i++) + if (instruction->oprs[i].type & ~itemp->opd[i] & (COLON | TO)) + return 0; /* * Check that the operand flags all match up */ - for (i=0; i<itemp->operands; i++) - if (itemp->opd[i] & ~instruction->oprs[i].type || - ((itemp->opd[i] & SIZE_MASK) && - ((itemp->opd[i] ^ instruction->oprs[i].type) & SIZE_MASK))) - { - if ((itemp->opd[i] & ~instruction->oprs[i].type & NON_SIZE) || - (instruction->oprs[i].type & SIZE_MASK)) - return 0; - else + for (i = 0; i < itemp->operands; i++) + if (itemp->opd[i] & ~instruction->oprs[i].type || + ((itemp->opd[i] & SIZE_MASK) && + ((itemp->opd[i] ^ instruction->oprs[i].type) & SIZE_MASK))) { + if ((itemp->opd[i] & ~instruction->oprs[i].type & NON_SIZE) || + (instruction->oprs[i].type & SIZE_MASK)) + return 0; + else /* ret = 1; */ - return 1; - } + return 1; + } /* * Check operand sizes */ if (itemp->flags & IF_ARMASK) { - size[0] = size[1] = size[2] = 0; - - switch (itemp->flags & IF_ARMASK) { - case IF_AR0: i = 0; break; - case IF_AR1: i = 1; break; - case IF_AR2: i = 2; break; - default: break; /* Shouldn't happen */ - } - if (itemp->flags & IF_SB) { - size[i] = BITS8; - } else if (itemp->flags & IF_SW) { - size[i] = BITS16; - } else if (itemp->flags & IF_SD) { - size[i] = BITS32; - } + size[0] = size[1] = size[2] = 0; + + switch (itemp->flags & IF_ARMASK) { + case IF_AR0: + i = 0; + break; + case IF_AR1: + i = 1; + break; + case IF_AR2: + i = 2; + break; + default: + break; /* Shouldn't happen */ + } + if (itemp->flags & IF_SB) { + size[i] = BITS8; + } else if (itemp->flags & IF_SW) { + size[i] = BITS16; + } else if (itemp->flags & IF_SD) { + size[i] = BITS32; + } } else { - asize = 0; - if (itemp->flags & IF_SB) { - asize = BITS8; - oprs = itemp->operands; - } else if (itemp->flags & IF_SW) { - asize = BITS16; - oprs = itemp->operands; - } else if (itemp->flags & IF_SD) { - asize = BITS32; - oprs = itemp->operands; - } - size[0] = size[1] = size[2] = asize; + asize = 0; + if (itemp->flags & IF_SB) { + asize = BITS8; + oprs = itemp->operands; + } else if (itemp->flags & IF_SW) { + asize = BITS16; + oprs = itemp->operands; + } else if (itemp->flags & IF_SD) { + asize = BITS32; + oprs = itemp->operands; + } + size[0] = size[1] = size[2] = asize; } if (itemp->flags & (IF_SM | IF_SM2)) { - oprs = (itemp->flags & IF_SM2 ? 2 : itemp->operands); - asize = 0; - for (i=0; i<oprs; i++) { - if ( (asize = itemp->opd[i] & SIZE_MASK) != 0) { - int j; - for (j=0; j<oprs; j++) - size[j] = asize; - break; - } - } + oprs = (itemp->flags & IF_SM2 ? 2 : itemp->operands); + asize = 0; + for (i = 0; i < oprs; i++) { + if ((asize = itemp->opd[i] & SIZE_MASK) != 0) { + int j; + for (j = 0; j < oprs; j++) + size[j] = asize; + break; + } + } } else { - oprs = itemp->operands; + oprs = itemp->operands; } - for (i=0; i<itemp->operands; i++) - if (!(itemp->opd[i] & SIZE_MASK) && - (instruction->oprs[i].type & SIZE_MASK & ~size[i])) + for (i = 0; i < itemp->operands; i++) + if (!(itemp->opd[i] & SIZE_MASK) && + (instruction->oprs[i].type & SIZE_MASK & ~size[i])) /* ret = 2; */ - return 2; + return 2; /* * Check template is okay at the set cpu level */ - if ((itemp->flags & IF_PLEVEL) > cpu) return 3; - + if ((itemp->flags & IF_PLEVEL) > cpu) + return 3; + /* * Check if special handling needed for Jumps */ - if ((unsigned char)(itemp->code[0]) >= 0370) return 99; - + if ((unsigned char)(itemp->code[0]) >= 0370) + return 99; + return ret; } -static ea *process_ea (operand *input, ea *output, int addrbits, int rfield, - int forw_ref) +static ea *process_ea(operand * input, ea * output, int addrbits, + int rfield, int forw_ref) { - if (!(REGISTER & ~input->type)) { /* it's a single register */ - static int regs[] = { - R_AL, R_CL, R_DL, R_BL, R_AH, R_CH, R_DH, R_BH, - R_AX, R_CX, R_DX, R_BX, R_SP, R_BP, R_SI, R_DI, - R_EAX, R_ECX, R_EDX, R_EBX, R_ESP, R_EBP, R_ESI, R_EDI, - R_MM0, R_MM1, R_MM2, R_MM3, R_MM4, R_MM5, R_MM6, R_MM7, - R_XMM0, R_XMM1, R_XMM2, R_XMM3, R_XMM4, R_XMM5, R_XMM6, R_XMM7 - }; - int i; - - for (i=0; i<elements(regs); i++) - if (input->basereg == regs[i]) break; - if (i<elements(regs)) { - output->sib_present = FALSE;/* no SIB necessary */ - output->bytes = 0; /* no offset necessary either */ + if (!(REGISTER & ~input->type)) { /* it's a single register */ + static int regs[] = { + R_AL, R_CL, R_DL, R_BL, R_AH, R_CH, R_DH, R_BH, + R_AX, R_CX, R_DX, R_BX, R_SP, R_BP, R_SI, R_DI, + R_EAX, R_ECX, R_EDX, R_EBX, R_ESP, R_EBP, R_ESI, R_EDI, + R_MM0, R_MM1, R_MM2, R_MM3, R_MM4, R_MM5, R_MM6, R_MM7, + R_XMM0, R_XMM1, R_XMM2, R_XMM3, R_XMM4, R_XMM5, R_XMM6, R_XMM7 + }; + int i; + + for (i = 0; i < elements(regs); i++) + if (input->basereg == regs[i]) + break; + if (i < elements(regs)) { + output->sib_present = FALSE; /* no SIB necessary */ + output->bytes = 0; /* no offset necessary either */ output->modrm = 0xC0 | (rfield << 3) | (i & 7); - } - else - return NULL; - } else { /* it's a memory reference */ - if (input->basereg==-1 && (input->indexreg==-1 || input->scale==0)) { - /* it's a pure offset */ - if (input->addr_size) - addrbits = input->addr_size; - output->sib_present = FALSE; - output->bytes = (addrbits==32 ? 4 : 2); - output->modrm = (addrbits==32 ? 5 : 6) | (rfield << 3); - } - else { /* it's an indirection */ - int i=input->indexreg, b=input->basereg, s=input->scale; - long o=input->offset, seg=input->segment; - int hb=input->hintbase, ht=input->hinttype; - int t; - - if (s==0) i = -1; /* make this easy, at least */ - - if (i==R_EAX || i==R_EBX || i==R_ECX || i==R_EDX - || i==R_EBP || i==R_ESP || i==R_ESI || i==R_EDI - || b==R_EAX || b==R_EBX || b==R_ECX || b==R_EDX - || b==R_EBP || b==R_ESP || b==R_ESI || b==R_EDI) { - /* it must be a 32-bit memory reference. Firstly we have - * to check that all registers involved are type Exx. */ - if (i!=-1 && i!=R_EAX && i!=R_EBX && i!=R_ECX && i!=R_EDX - && i!=R_EBP && i!=R_ESP && i!=R_ESI && i!=R_EDI) - return NULL; - if (b!=-1 && b!=R_EAX && b!=R_EBX && b!=R_ECX && b!=R_EDX - && b!=R_EBP && b!=R_ESP && b!=R_ESI && b!=R_EDI) - return NULL; - - /* While we're here, ensure the user didn't specify WORD. */ - if (input->addr_size == 16) - return NULL; - - /* now reorganise base/index */ - if (s == 1 && b != i && b != -1 && i != -1 && - ((hb==b&&ht==EAH_NOTBASE) || (hb==i&&ht==EAH_MAKEBASE))) - t = b, b = i, i = t; /* swap if hints say so */ - if (b==i) /* convert EAX+2*EAX to 3*EAX */ - b = -1, s++; - if (b==-1 && s==1 && !(hb == i && ht == EAH_NOTBASE)) - b = i, i = -1; /* make single reg base, unless hint */ - if (((s==2 && i!=R_ESP && !(input->eaflags & EAF_TIMESTWO)) || - s==3 || s==5 || s==9) && b==-1) - b = i, s--; /* convert 3*EAX to EAX+2*EAX */ - if (i==-1 && b!=R_ESP && (input->eaflags & EAF_TIMESTWO)) - i = b, b = -1, s = 1; - /* convert [NOSPLIT EAX] to sib format with 0x0 displacement */ - if (s==1 && i==R_ESP) /* swap ESP into base if scale is 1 */ - i = b, b = R_ESP; - if (i==R_ESP || (s!=1 && s!=2 && s!=4 && s!=8 && i!=-1)) - return NULL; /* wrong, for various reasons */ - - if (i==-1 && b!=R_ESP) {/* no SIB needed */ - int mod, rm; - switch(b) { - case R_EAX: rm = 0; break; - case R_ECX: rm = 1; break; - case R_EDX: rm = 2; break; - case R_EBX: rm = 3; break; - case R_EBP: rm = 5; break; - case R_ESI: rm = 6; break; - case R_EDI: rm = 7; break; - case -1: rm = 5; break; - default: /* should never happen */ - return NULL; - } - if (b==-1 || (b!=R_EBP && o==0 && - seg==NO_SEG && !forw_ref && - !(input->eaflags & - (EAF_BYTEOFFS|EAF_WORDOFFS)))) - mod = 0; - else if (input->eaflags & EAF_BYTEOFFS || - (o>=-128 && o<=127 && seg==NO_SEG && !forw_ref && - !(input->eaflags & EAF_WORDOFFS))) { - mod = 1; - } - else - mod = 2; - - output->sib_present = FALSE; - output->bytes = (b==-1 || mod==2 ? 4 : mod); - output->modrm = (mod<<6) | (rfield<<3) | rm; - } - else { /* we need a SIB */ - int mod, scale, index, base; - - switch (b) { - case R_EAX: base = 0; break; - case R_ECX: base = 1; break; - case R_EDX: base = 2; break; - case R_EBX: base = 3; break; - case R_ESP: base = 4; break; - case R_EBP: case -1: base = 5; break; - case R_ESI: base = 6; break; - case R_EDI: base = 7; break; - default: /* then what the smeg is it? */ - return NULL; /* panic */ - } - - switch (i) { - case R_EAX: index = 0; break; - case R_ECX: index = 1; break; - case R_EDX: index = 2; break; - case R_EBX: index = 3; break; - case -1: index = 4; break; - case R_EBP: index = 5; break; - case R_ESI: index = 6; break; - case R_EDI: index = 7; break; - default: /* then what the smeg is it? */ - return NULL; /* panic */ - } - - if (i==-1) s = 1; - switch (s) { - case 1: scale = 0; break; - case 2: scale = 1; break; - case 4: scale = 2; break; - case 8: scale = 3; break; - default: /* then what the smeg is it? */ - return NULL; /* panic */ - } - - if (b==-1 || (b!=R_EBP && o==0 && - seg==NO_SEG && !forw_ref && - !(input->eaflags & - (EAF_BYTEOFFS|EAF_WORDOFFS)))) - mod = 0; - else if (input->eaflags & EAF_BYTEOFFS || - (o>=-128 && o<=127 && seg==NO_SEG && !forw_ref && - !(input->eaflags & EAF_WORDOFFS))) - mod = 1; - else - mod = 2; - - output->sib_present = TRUE; - output->bytes = (b==-1 || mod==2 ? 4 : mod); - output->modrm = (mod<<6) | (rfield<<3) | 4; - output->sib = (scale<<6) | (index<<3) | base; - } - } - else { /* it's 16-bit */ - int mod, rm; - - /* check all registers are BX, BP, SI or DI */ - if ((b!=-1 && b!=R_BP && b!=R_BX && b!=R_SI && b!=R_DI) || - (i!=-1 && i!=R_BP && i!=R_BX && i!=R_SI && i!=R_DI)) - return NULL; - - /* ensure the user didn't specify DWORD */ - if (input->addr_size == 32) - return NULL; - - if (s!=1 && i!=-1) return NULL;/* no can do, in 16-bit EA */ - if (b==-1 && i!=-1) { int tmp = b; b = i; i = tmp; } /* swap */ - if ((b==R_SI || b==R_DI) && i!=-1) - { int tmp = b; b = i; i = tmp; } - /* have BX/BP as base, SI/DI index */ - if (b==i) return NULL;/* shouldn't ever happen, in theory */ - if (i!=-1 && b!=-1 && - (i==R_BP || i==R_BX || b==R_SI || b==R_DI)) - return NULL; /* invalid combinations */ - if (b==-1) /* pure offset: handled above */ - return NULL; /* so if it gets to here, panic! */ - - rm = -1; - if (i!=-1) - switch (i*256 + b) { - case R_SI*256+R_BX: rm=0; break; - case R_DI*256+R_BX: rm=1; break; - case R_SI*256+R_BP: rm=2; break; - case R_DI*256+R_BP: rm=3; break; - } - else - switch (b) { - case R_SI: rm=4; break; - case R_DI: rm=5; break; - case R_BP: rm=6; break; - case R_BX: rm=7; break; - } - if (rm==-1) /* can't happen, in theory */ - return NULL; /* so panic if it does */ - - if (o==0 && seg==NO_SEG && !forw_ref && rm!=6 && - !(input->eaflags & (EAF_BYTEOFFS|EAF_WORDOFFS))) - mod = 0; - else if (input->eaflags & EAF_BYTEOFFS || - (o>=-128 && o<=127 && seg==NO_SEG && !forw_ref && - !(input->eaflags & EAF_WORDOFFS))) - mod = 1; - else - mod = 2; - - output->sib_present = FALSE; /* no SIB - it's 16-bit */ - output->bytes = mod; /* bytes of offset needed */ - output->modrm = (mod<<6) | (rfield<<3) | rm; - } - } + } else + return NULL; + } else { /* it's a memory reference */ + if (input->basereg == -1 + && (input->indexreg == -1 || input->scale == 0)) { + /* it's a pure offset */ + if (input->addr_size) + addrbits = input->addr_size; + output->sib_present = FALSE; + output->bytes = (addrbits == 32 ? 4 : 2); + output->modrm = (addrbits == 32 ? 5 : 6) | (rfield << 3); + } else { /* it's an indirection */ + int i = input->indexreg, b = input->basereg, s = input->scale; + long o = input->offset, seg = input->segment; + int hb = input->hintbase, ht = input->hinttype; + int t; + + if (s == 0) + i = -1; /* make this easy, at least */ + + if (i == R_EAX || i == R_EBX || i == R_ECX || i == R_EDX + || i == R_EBP || i == R_ESP || i == R_ESI || i == R_EDI + || b == R_EAX || b == R_EBX || b == R_ECX || b == R_EDX + || b == R_EBP || b == R_ESP || b == R_ESI || b == R_EDI) { + /* it must be a 32-bit memory reference. Firstly we have + * to check that all registers involved are type Exx. */ + if (i != -1 && i != R_EAX && i != R_EBX && i != R_ECX + && i != R_EDX && i != R_EBP && i != R_ESP && i != R_ESI + && i != R_EDI) + return NULL; + if (b != -1 && b != R_EAX && b != R_EBX && b != R_ECX + && b != R_EDX && b != R_EBP && b != R_ESP && b != R_ESI + && b != R_EDI) + return NULL; + + /* While we're here, ensure the user didn't specify WORD. */ + if (input->addr_size == 16) + return NULL; + + /* now reorganise base/index */ + if (s == 1 && b != i && b != -1 && i != -1 && + ((hb == b && ht == EAH_NOTBASE) + || (hb == i && ht == EAH_MAKEBASE))) + t = b, b = i, i = t; /* swap if hints say so */ + if (b == i) /* convert EAX+2*EAX to 3*EAX */ + b = -1, s++; + if (b == -1 && s == 1 && !(hb == i && ht == EAH_NOTBASE)) + b = i, i = -1; /* make single reg base, unless hint */ + if (((s == 2 && i != R_ESP + && !(input->eaflags & EAF_TIMESTWO)) || s == 3 + || s == 5 || s == 9) && b == -1) + b = i, s--; /* convert 3*EAX to EAX+2*EAX */ + if (i == -1 && b != R_ESP + && (input->eaflags & EAF_TIMESTWO)) + i = b, b = -1, s = 1; + /* convert [NOSPLIT EAX] to sib format with 0x0 displacement */ + if (s == 1 && i == R_ESP) /* swap ESP into base if scale is 1 */ + i = b, b = R_ESP; + if (i == R_ESP + || (s != 1 && s != 2 && s != 4 && s != 8 && i != -1)) + return NULL; /* wrong, for various reasons */ + + if (i == -1 && b != R_ESP) { /* no SIB needed */ + int mod, rm; + switch (b) { + case R_EAX: + rm = 0; + break; + case R_ECX: + rm = 1; + break; + case R_EDX: + rm = 2; + break; + case R_EBX: + rm = 3; + break; + case R_EBP: + rm = 5; + break; + case R_ESI: + rm = 6; + break; + case R_EDI: + rm = 7; + break; + case -1: + rm = 5; + break; + default: /* should never happen */ + return NULL; + } + if (b == -1 || (b != R_EBP && o == 0 && + seg == NO_SEG && !forw_ref && + !(input->eaflags & + (EAF_BYTEOFFS | EAF_WORDOFFS)))) + mod = 0; + else if (input->eaflags & EAF_BYTEOFFS || + (o >= -128 && o <= 127 && seg == NO_SEG + && !forw_ref + && !(input->eaflags & EAF_WORDOFFS))) { + mod = 1; + } else + mod = 2; + + output->sib_present = FALSE; + output->bytes = (b == -1 || mod == 2 ? 4 : mod); + output->modrm = (mod << 6) | (rfield << 3) | rm; + } else { /* we need a SIB */ + int mod, scale, index, base; + + switch (b) { + case R_EAX: + base = 0; + break; + case R_ECX: + base = 1; + break; + case R_EDX: + base = 2; + break; + case R_EBX: + base = 3; + break; + case R_ESP: + base = 4; + break; + case R_EBP: + case -1: + base = 5; + break; + case R_ESI: + base = 6; + break; + case R_EDI: + base = 7; + break; + default: /* then what the smeg is it? */ + return NULL; /* panic */ + } + + switch (i) { + case R_EAX: + index = 0; + break; + case R_ECX: + index = 1; + break; + case R_EDX: + index = 2; + break; + case R_EBX: + index = 3; + break; + case -1: + index = 4; + break; + case R_EBP: + index = 5; + break; + case R_ESI: + index = 6; + break; + case R_EDI: + index = 7; + break; + default: /* then what the smeg is it? */ + return NULL; /* panic */ + } + + if (i == -1) + s = 1; + switch (s) { + case 1: + scale = 0; + break; + case 2: + scale = 1; + break; + case 4: + scale = 2; + break; + case 8: + scale = 3; + break; + default: /* then what the smeg is it? */ + return NULL; /* panic */ + } + + if (b == -1 || (b != R_EBP && o == 0 && + seg == NO_SEG && !forw_ref && + !(input->eaflags & + (EAF_BYTEOFFS | EAF_WORDOFFS)))) + mod = 0; + else if (input->eaflags & EAF_BYTEOFFS || + (o >= -128 && o <= 127 && seg == NO_SEG + && !forw_ref + && !(input->eaflags & EAF_WORDOFFS))) + mod = 1; + else + mod = 2; + + output->sib_present = TRUE; + output->bytes = (b == -1 || mod == 2 ? 4 : mod); + output->modrm = (mod << 6) | (rfield << 3) | 4; + output->sib = (scale << 6) | (index << 3) | base; + } + } else { /* it's 16-bit */ + int mod, rm; + + /* check all registers are BX, BP, SI or DI */ + if ((b != -1 && b != R_BP && b != R_BX && b != R_SI + && b != R_DI) || (i != -1 && i != R_BP && i != R_BX + && i != R_SI && i != R_DI)) + return NULL; + + /* ensure the user didn't specify DWORD */ + if (input->addr_size == 32) + return NULL; + + if (s != 1 && i != -1) + return NULL; /* no can do, in 16-bit EA */ + if (b == -1 && i != -1) { + int tmp = b; + b = i; + i = tmp; + } /* swap */ + if ((b == R_SI || b == R_DI) && i != -1) { + int tmp = b; + b = i; + i = tmp; + } + /* have BX/BP as base, SI/DI index */ + if (b == i) + return NULL; /* shouldn't ever happen, in theory */ + if (i != -1 && b != -1 && + (i == R_BP || i == R_BX || b == R_SI || b == R_DI)) + return NULL; /* invalid combinations */ + if (b == -1) /* pure offset: handled above */ + return NULL; /* so if it gets to here, panic! */ + + rm = -1; + if (i != -1) + switch (i * 256 + b) { + case R_SI * 256 + R_BX: + rm = 0; + break; + case R_DI * 256 + R_BX: + rm = 1; + break; + case R_SI * 256 + R_BP: + rm = 2; + break; + case R_DI * 256 + R_BP: + rm = 3; + break; + } else + switch (b) { + case R_SI: + rm = 4; + break; + case R_DI: + rm = 5; + break; + case R_BP: + rm = 6; + break; + case R_BX: + rm = 7; + break; + } + if (rm == -1) /* can't happen, in theory */ + return NULL; /* so panic if it does */ + + if (o == 0 && seg == NO_SEG && !forw_ref && rm != 6 && + !(input->eaflags & (EAF_BYTEOFFS | EAF_WORDOFFS))) + mod = 0; + else if (input->eaflags & EAF_BYTEOFFS || + (o >= -128 && o <= 127 && seg == NO_SEG + && !forw_ref + && !(input->eaflags & EAF_WORDOFFS))) + mod = 1; + else + mod = 2; + + output->sib_present = FALSE; /* no SIB - it's 16-bit */ + output->bytes = mod; /* bytes of offset needed */ + output->modrm = (mod << 6) | (rfield << 3) | rm; + } + } } output->size = 1 + output->sib_present + output->bytes; return output; } -static int chsize (operand *input, int addrbits) +static int chsize(operand * input, int addrbits) { if (!(MEMORY & ~input->type)) { - int i=input->indexreg, b=input->basereg; - - if (input->scale==0) i = -1; - - if (i == -1 && b == -1) /* pure offset */ - return (input->addr_size != 0 && input->addr_size != addrbits); - - if (i==R_EAX || i==R_EBX || i==R_ECX || i==R_EDX - || i==R_EBP || i==R_ESP || i==R_ESI || i==R_EDI - || b==R_EAX || b==R_EBX || b==R_ECX || b==R_EDX - || b==R_EBP || b==R_ESP || b==R_ESI || b==R_EDI) - return (addrbits==16); - else - return (addrbits==32); - } - else - return 0; + int i = input->indexreg, b = input->basereg; + + if (input->scale == 0) + i = -1; + + if (i == -1 && b == -1) /* pure offset */ + return (input->addr_size != 0 && input->addr_size != addrbits); + + if (i == R_EAX || i == R_EBX || i == R_ECX || i == R_EDX + || i == R_EBP || i == R_ESP || i == R_ESI || i == R_EDI + || b == R_EAX || b == R_EBX || b == R_ECX || b == R_EDX + || b == R_EBP || b == R_ESP || b == R_ESI || b == R_EDI) + return (addrbits == 16); + else + return (addrbits == 32); + } else + return 0; } |