X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tools%2Ftranslate.c;h=bec6d0741c1f30fa1dd4c4b60cf4b20347278426;hb=865f1acac49aa6648651de91c1b27396f8679ef1;hp=d80d32bece13d636392d72a946be8dac8f2a6afe;hpb=b2bd20c04cbabc101db5bfdf35bb9f5fd5aebe33;p=ia32rtools.git diff --git a/tools/translate.c b/tools/translate.c index d80d32b..bec6d07 100644 --- a/tools/translate.c +++ b/tools/translate.c @@ -60,6 +60,9 @@ enum op_flags { OPF_DONE = (1 << 19), /* already fully handled by analysis */ OPF_PPUSH = (1 << 20), /* part of complex push-pop graph */ OPF_NOREGS = (1 << 21), /* don't track regs of this op */ + OPF_FPUSH = (1 << 22), /* pushes x87 stack */ + OPF_FPOP = (1 << 23), /* pops x87 stack */ + OPF_FSHIFT = (1 << 24), /* x87 stack shift is actually needed */ }; enum op_op { @@ -116,11 +119,29 @@ enum op_op { OP_LOOP, OP_JCC, OP_SCC, - // x87 - // mmx - OP_EMMS, - // undefined - OP_UD2, + // x87 + OP_FLD, + OP_FILD, + OP_FLDc, + OP_FST, + OP_FADD, + OP_FDIV, + OP_FMUL, + OP_FSUB, + OP_FDIVR, + OP_FSUBR, + OP_FIADD, + OP_FIDIV, + OP_FIMUL, + OP_FISUB, + OP_FIDIVR, + OP_FISUBR, + // mmx + OP_EMMS, + // pseudo-ops for lib calls + OPP_FTOL, + // undefined + OP_UD2, }; enum opr_type { @@ -187,7 +208,8 @@ struct parsed_op { }; // datap: -// OP_CALL - parser proto hint (str) +// on start: function/data type hint (sctproto) +// after analysis: // (OPF_CC) - points to one of (OPF_FLAGS) that affects cc op // OP_PUSH - points to OP_POP in complex push/pop graph // OP_POP - points to OP_PUSH in simple push/pop pair @@ -227,6 +249,16 @@ enum ida_func_attr { IDAFA_FPD = (1 << 5), }; +enum x87_const { + X87_CONST_1 = 1, + X87_CONST_2T, + X87_CONST_2E, + X87_CONST_PI, + X87_CONST_LG2, + X87_CONST_LN2, + X87_CONST_Z, +}; + // note: limited to 32k due to p_argnext #define MAX_OPS 4096 #define MAX_ARG_GRP 2 @@ -239,6 +271,7 @@ static struct label_ref g_label_refs[MAX_OPS]; static const struct parsed_proto *g_func_pp; static struct parsed_data *g_func_pd; static int g_func_pd_cnt; +static int g_func_lmods; static char g_func[256]; static char g_comment[256]; static int g_bp_frame; @@ -269,12 +302,26 @@ const char *regs_r32[] = { "eax", "ebx", "ecx", "edx", "esi", "edi", "ebp", "esp", // not r32, but list here for easy parsing and printing "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7", + "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)" }; const char *regs_r16[] = { "ax", "bx", "cx", "dx", "si", "di", "bp", "sp" }; const char *regs_r8l[] = { "al", "bl", "cl", "dl" }; const char *regs_r8h[] = { "ah", "bh", "ch", "dh" }; -enum x86_regs { xUNSPEC = -1, xAX, xBX, xCX, xDX, xSI, xDI, xBP, xSP }; +enum x86_regs { + xUNSPEC = -1, + xAX, xBX, xCX, xDX, + xSI, xDI, xBP, xSP, + xMM0, xMM1, xMM2, xMM3, // mmx + xMM4, xMM5, xMM6, xMM7, + xST0, xST1, xST2, xST3, // x87 + xST4, xST5, xST6, xST7, +}; + +#define mxAX (1 << xAX) +#define mxDX (1 << xDX) +#define mxST0 (1 << xST0) +#define mxST1 (1 << xST1) // possible basic comparison types (without inversion) enum parsed_flag_op { @@ -595,7 +642,7 @@ static char *default_cast_to(char *buf, size_t buf_size, { buf[0] = 0; - if (!opr->is_ptr) + if (!opr->is_ptr || strchr(opr->name, '[')) return buf; if (opr->pp == NULL || opr->pp->type.name == NULL || opr->pp->is_fptr) @@ -753,6 +800,9 @@ static int parse_operand(struct parsed_opr *opr, equ_find(NULL, parse_stack_el(opr->name, NULL, 1), &i); if (eq) opr->lmod = eq->lmod; + + // might be unaligned access + g_func_lmods |= 1 << OPLM_BYTE; } return wordc; } @@ -961,9 +1011,35 @@ static const struct { { "setg", OP_SCC, 1, 1, OPF_DATA|OPF_CC, PFO_LE, 1 }, { "setnle", OP_SCC, 1, 1, OPF_DATA|OPF_CC, PFO_LE, 1 }, // x87 + { "fld", OP_FLD, 1, 1, OPF_FPUSH }, + { "fild", OP_FILD, 1, 1, OPF_FPUSH }, + { "fld1", OP_FLDc, 0, 0, OPF_FPUSH }, + { "fldz", OP_FLDc, 0, 0, OPF_FPUSH }, + { "fstp", OP_FST, 1, 1, OPF_FPOP }, + { "fst", OP_FST, 1, 1, 0 }, + { "fadd", OP_FADD, 0, 2, 0 }, + { "faddp", OP_FADD, 0, 2, OPF_FPOP }, + { "fdiv", OP_FDIV, 0, 2, 0 }, + { "fdivp", OP_FDIV, 0, 2, OPF_FPOP }, + { "fmul", OP_FMUL, 0, 2, 0 }, + { "fmulp", OP_FMUL, 0, 2, OPF_FPOP }, + { "fsub", OP_FSUB, 0, 2, 0 }, + { "fsubp", OP_FSUB, 0, 2, OPF_FPOP }, + { "fdivr", OP_FDIVR, 0, 2, 0 }, + { "fdivrp", OP_FDIVR, 0, 2, OPF_FPOP }, + { "fsubr", OP_FSUBR, 0, 2, 0 }, + { "fsubrp", OP_FSUBR, 0, 2, OPF_FPOP }, + { "fiadd", OP_FIADD, 1, 1, 0 }, + { "fidiv", OP_FIDIV, 1, 1, 0 }, + { "fimul", OP_FIMUL, 1, 1, 0 }, + { "fisub", OP_FISUB, 1, 1, 0 }, + { "fidivr", OP_FIDIVR, 1, 1, 0 }, + { "fisubr", OP_FISUBR, 1, 1, 0 }, // mmx - { "emms", OP_EMMS, 0, 0, OPF_DATA }, - { "movq", OP_MOV, 2, 2, OPF_DATA }, + { "emms", OP_EMMS, 0, 0, OPF_DATA }, + { "movq", OP_MOV, 2, 2, OPF_DATA }, + // pseudo-ops for lib calls + { "_ftol", OPP_FTOL }, // must be last { "ud2", OP_UD2 }, }; @@ -977,7 +1053,7 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc) int op_w = 0; int opr = 0; int w = 0; - int i; + int i, j; for (i = 0; i < ARRAY_SIZE(pref_table); i++) { if (IS(words[w], pref_table[i].name)) { @@ -1028,6 +1104,9 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc) else op->regmask_src |= regmask; op->regmask_src |= regmask_ind; + + if (op->operand[opr].lmod != OPLM_UNSPEC) + g_func_lmods |= 1 << op->operand[opr].lmod; } if (w < wordc) @@ -1087,7 +1166,7 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc) op->operand_cnt = 2; setup_reg_opr(&op->operand[0], xAX, OPLM_BYTE, &op->regmask_src); op->regmask_dst = op->regmask_src; - setup_reg_opr(&op->operand[1], xDX, OPLM_DWORD, &op->regmask_src); + setup_reg_opr(&op->operand[1], xBX, OPLM_DWORD, &op->regmask_src); break; case OP_CDQ: @@ -1099,37 +1178,42 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc) case OP_LODS: case OP_STOS: case OP_SCAS: - if (op->operand_cnt != 0) - break; if (words[op_w][4] == 'b') lmod = OPLM_BYTE; else if (words[op_w][4] == 'w') lmod = OPLM_WORD; else if (words[op_w][4] == 'd') lmod = OPLM_DWORD; - op->operand_cnt = 3; - setup_reg_opr(&op->operand[0], op->op == OP_LODS ? xSI : xDI, - lmod, &op->regmask_src); - setup_reg_opr(&op->operand[1], xCX, OPLM_DWORD, &op->regmask_src); + j = 0; + op->regmask_src = 0; + setup_reg_opr(&op->operand[j++], op->op == OP_LODS ? xSI : xDI, + OPLM_DWORD, &op->regmask_src); op->regmask_dst = op->regmask_src; - setup_reg_opr(&op->operand[2], xAX, OPLM_DWORD, + setup_reg_opr(&op->operand[j++], xAX, lmod, op->op == OP_LODS ? &op->regmask_dst : &op->regmask_src); + if (op->flags & OPF_REP) { + setup_reg_opr(&op->operand[j++], xCX, OPLM_DWORD, &op->regmask_src); + op->regmask_dst |= 1 << xCX; + } + op->operand_cnt = j; break; case OP_MOVS: case OP_CMPS: - if (op->operand_cnt != 0) - break; if (words[op_w][4] == 'b') lmod = OPLM_BYTE; else if (words[op_w][4] == 'w') lmod = OPLM_WORD; else if (words[op_w][4] == 'd') lmod = OPLM_DWORD; - op->operand_cnt = 3; - setup_reg_opr(&op->operand[0], xDI, lmod, &op->regmask_src); - setup_reg_opr(&op->operand[1], xSI, OPLM_DWORD, &op->regmask_src); - setup_reg_opr(&op->operand[2], xCX, OPLM_DWORD, &op->regmask_src); + j = 0; + op->regmask_src = 0; + // note: lmod is not correct, don't have where to place it + setup_reg_opr(&op->operand[j++], xDI, lmod, &op->regmask_src); + setup_reg_opr(&op->operand[j++], xSI, OPLM_DWORD, &op->regmask_src); + if (op->flags & OPF_REP) + setup_reg_opr(&op->operand[j++], xCX, OPLM_DWORD, &op->regmask_src); + op->operand_cnt = j; op->regmask_dst = op->regmask_src; break; @@ -1181,6 +1265,7 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc) op->operand[1].lmod = OPLM_BYTE; break; + case OP_SHLD: case OP_SHRD: op->regmask_src |= op->regmask_dst; if (op->operand[2].lmod == OPLM_UNSPEC) @@ -1231,16 +1316,69 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc) op->regmask_src = 1 << xBP; break; + case OP_FLD: + case OP_FILD: + op->regmask_dst |= mxST0; + break; + + case OP_FLDc: + op->regmask_dst |= mxST0; + if (IS(words[op_w] + 3, "1")) + op->operand[0].val = X87_CONST_1; + else if (IS(words[op_w] + 3, "z")) + op->operand[0].val = X87_CONST_Z; + else + aerr("TODO\n"); + break; + + case OP_FST: + op->regmask_src |= mxST0; + break; + + case OP_FADD: + case OP_FDIV: + case OP_FMUL: + case OP_FSUB: + case OP_FDIVR: + case OP_FSUBR: + op->regmask_src |= mxST0; + if (op->operand_cnt == 2) + op->regmask_src |= op->regmask_dst; + else if (op->operand_cnt == 1) { + memcpy(&op->operand[1], &op->operand[0], sizeof(op->operand[1])); + op->operand[0].type = OPT_REG; + op->operand[0].lmod = OPLM_QWORD; + op->operand[0].reg = xST0; + op->regmask_dst |= mxST0; + } + else + // IDA doesn't use this + aerr("no operands?\n"); + break; + + case OP_FIADD: + case OP_FIDIV: + case OP_FIMUL: + case OP_FISUB: + case OP_FIDIVR: + case OP_FISUBR: + op->regmask_src |= mxST0; + op->regmask_dst |= mxST0; + break; + default: break; } if (op->operand[0].type == OPT_REG - && op->operand[0].lmod == OPLM_DWORD && op->operand[1].type == OPT_CONST) { - if ((op->op == OP_AND && op->operand[1].val == 0) - || (op->op == OP_OR && op->operand[1].val == ~0)) + struct parsed_opr *op1 = &op->operand[1]; + if ((op->op == OP_AND && op1->val == 0) + || (op->op == OP_OR + && (op1->val == ~0 + || (op->operand[0].lmod == OPLM_WORD && op1->val == 0xffff) + || (op->operand[0].lmod == OPLM_BYTE && op1->val == 0xff)))) { op->regmask_src = 0; } @@ -1412,10 +1550,45 @@ static const char *opr_reg_p(struct parsed_op *po, struct parsed_opr *popr) return regs_r32[popr->reg]; } +static int check_simple_cast(const char *cast, int *bits, int *is_signed) +{ + if (IS_START(cast, "(s8)") || IS_START(cast, "(u8)")) + *bits = 8; + else if (IS_START(cast, "(s16)") || IS_START(cast, "(u16)")) + *bits = 16; + else if (IS_START(cast, "(s32)") || IS_START(cast, "(u32)")) + *bits = 32; + else if (IS_START(cast, "(s64)") || IS_START(cast, "(u64)")) + *bits = 64; + else + return -1; + + *is_signed = cast[1] == 's' ? 1 : 0; + return 0; +} + +static int check_deref_cast(const char *cast, int *bits) +{ + if (IS_START(cast, "*(u8 *)")) + *bits = 8; + else if (IS_START(cast, "*(u16 *)")) + *bits = 16; + else if (IS_START(cast, "*(u32 *)")) + *bits = 32; + else if (IS_START(cast, "*(u64 *)")) + *bits = 64; + else + return -1; + + return 0; +} + // cast1 is the "final" cast static const char *simplify_cast(const char *cast1, const char *cast2) { static char buf[256]; + int bits1, bits2; + int s1, s2; if (cast1[0] == 0) return cast2; @@ -1423,14 +1596,22 @@ static const char *simplify_cast(const char *cast1, const char *cast2) return cast1; if (IS(cast1, cast2)) return cast1; - if (IS(cast1, "(s8)") && IS(cast2, "(u8)")) - return cast1; - if (IS(cast1, "(s16)") && IS(cast2, "(u16)")) - return cast1; - if (IS(cast1, "(u8)") && IS_START(cast2, "*(u8 *)")) - return cast2; - if (IS(cast1, "(u16)") && IS_START(cast2, "*(u16 *)")) - return cast2; + + if (check_simple_cast(cast1, &bits1, &s1) == 0 + && check_simple_cast(cast2, &bits2, &s2) == 0) + { + if (bits1 <= bits2) + return cast1; + } + if (check_simple_cast(cast1, &bits1, &s1) == 0 + && check_deref_cast(cast2, &bits2) == 0) + { + if (bits1 == bits2) { + snprintf(buf, sizeof(buf), "*(%c%d *)", s1 ? 's' : 'u', bits1); + return buf; + } + } + if (strchr(cast1, '*') && IS_START(cast2, "(u32)")) return cast1; @@ -1734,6 +1915,14 @@ static int stack_frame_access(struct parsed_op *po, snprintf(buf, buf_size, "%ssf.d[%d]", prefix, sf_ofs / 4); break; + case OPLM_QWORD: + ferr_assert(po, !(sf_ofs & 7)); + ferr_assert(po, ofs_reg[0] == 0); + // float callers set is_lea + ferr_assert(po, is_lea); + snprintf(buf, buf_size, "%ssf.q[%d]", prefix, sf_ofs / 8); + break; + default: ferr(po, "bp_stack bad lmod: %d\n", popr->lmod); } @@ -1968,6 +2157,52 @@ static char *out_src_opr_u32(char *buf, size_t buf_size, return out_src_opr(buf, buf_size, po, popr, NULL, 0); } +static char *out_src_opr_float(char *buf, size_t buf_size, + struct parsed_op *po, struct parsed_opr *popr) +{ + const char *cast = NULL; + char tmp[256]; + + switch (popr->type) { + case OPT_REG: + if (popr->reg < xST0 || popr->reg > xST7) + ferr(po, "bad reg: %d\n", popr->reg); + + snprintf(buf, buf_size, "f_st%d", popr->reg - xST0); + break; + + case OPT_REGMEM: + case OPT_LABEL: + case OPT_OFFSET: + switch (popr->lmod) { + case OPLM_QWORD: + cast = "double"; + break; + case OPLM_DWORD: + cast = "float"; + break; + default: + ferr(po, "unhandled lmod: %d\n", popr->lmod); + break; + } + out_src_opr(tmp, sizeof(tmp), po, popr, "", 1); + snprintf(buf, buf_size, "*((%s *)%s)", cast, tmp); + break; + + default: + ferr(po, "invalid float type: %d\n", popr->type); + } + + return buf; +} + +static char *out_dst_opr_float(char *buf, size_t buf_size, + struct parsed_op *po, struct parsed_opr *popr) +{ + // same? + return out_src_opr_float(buf, buf_size, po, popr); +} + static void out_test_for_cc(char *buf, size_t buf_size, struct parsed_op *po, enum parsed_flag_op pfo, int is_inv, enum opr_lenmod lmod, const char *expr) @@ -3218,14 +3453,28 @@ static int get_pp_arg_regmask_dst(const struct parsed_proto *pp) { if (strstr(pp->ret_type.name, "int64")) return (1 << xAX) | (1 << xDX); + if (IS(pp->ret_type.name, "float") + || IS(pp->ret_type.name, "double")) + { + return mxST0; + } if (strcasecmp(pp->ret_type.name, "void") == 0) return 0; - return (1 << xAX); + return mxAX; } static void resolve_branches_parse_calls(int opcnt) { + static const struct { + const char *name; + enum op_op op; + unsigned int flags; + unsigned int regmask_src; + unsigned int regmask_dst; + } pseudo_ops[] = { + { "__ftol", OPP_FTOL, OPF_FPOP, mxST0, mxAX | mxDX }, + }; const struct parsed_proto *pp_c; struct parsed_proto *pp; struct parsed_data *pd; @@ -3240,13 +3489,45 @@ static void resolve_branches_parse_calls(int opcnt) po->bt_i = -1; po->btj = NULL; + if (po->datap != NULL) { + pp = calloc(1, sizeof(*pp)); + my_assert_not(pp, NULL); + + ret = parse_protostr(po->datap, pp); + if (ret < 0) + ferr(po, "bad protostr supplied: %s\n", (char *)po->datap); + free(po->datap); + po->datap = NULL; + po->pp = pp; + } + if (po->op == OP_CALL) { pp = NULL; - if (po->operand[0].type == OPT_LABEL) { + if (po->pp != NULL) + pp = po->pp; + else if (po->operand[0].type == OPT_LABEL) + { tmpname = opr_name(po, 0); if (IS_START(tmpname, "loc_")) ferr(po, "call to loc_*\n"); + + // convert some calls to pseudo-ops + for (l = 0; l < ARRAY_SIZE(pseudo_ops); l++) { + if (!IS(tmpname, pseudo_ops[l].name)) + continue; + + po->op = pseudo_ops[l].op; + po->operand_cnt = 0; + po->regmask_src = pseudo_ops[l].regmask_src; + po->regmask_dst = pseudo_ops[l].regmask_dst; + po->flags = pseudo_ops[l].flags; + po->flags |= po->regmask_dst ? OPF_DATA : 0; + break; + } + if (l < ARRAY_SIZE(pseudo_ops)) + continue; + pp_c = proto_parse(g_fhdr, tmpname, g_header_mode); if (!g_header_mode && pp_c == NULL) ferr(po, "proto_parse failed for call '%s'\n", tmpname); @@ -3256,16 +3537,6 @@ static void resolve_branches_parse_calls(int opcnt) my_assert_not(pp, NULL); } } - else if (po->datap != NULL) { - pp = calloc(1, sizeof(*pp)); - my_assert_not(pp, NULL); - - ret = parse_protostr(po->datap, pp); - if (ret < 0) - ferr(po, "bad protostr supplied: %s\n", (char *)po->datap); - free(po->datap); - po->datap = NULL; - } if (pp != NULL) { if (pp->is_fptr) @@ -3542,36 +3813,11 @@ static void scan_prologue_epilogue(int opcnt) } } -static const struct parsed_proto *resolve_icall(int i, int opcnt, - int *pp_i, int *multi_src) -{ - const struct parsed_proto *pp = NULL; - int search_advice = 0; - - *multi_src = 0; - *pp_i = -1; - - switch (ops[i].operand[0].type) { - case OPT_REGMEM: - case OPT_LABEL: - case OPT_OFFSET: - pp = try_recover_pp(&ops[i], &ops[i].operand[0], &search_advice); - if (!search_advice) - break; - // fallthrough - default: - scan_for_call_type(i, &ops[i].operand[0], i + opcnt * 9, &pp, - pp_i, multi_src); - break; - } - - return pp; -} - // find an instruction that changed opr before i op // *op_i must be set to -1 by the caller -// *entry is set to 1 if one source is determined to be the caller +// *is_caller is set to 1 if one source is determined to be g_func arg // returns 1 if found, *op_i is then set to origin +// returns -1 if multiple origins are found static int resolve_origin(int i, const struct parsed_opr *opr, int magic, int *op_i, int *is_caller) { @@ -3708,9 +3954,14 @@ static int find_next_read(int i, int opcnt, } if (!is_opr_read(opr, po)) { - if (is_opr_modified(opr, po)) + if (is_opr_modified(opr, po) + && (po->op == OP_CALL + || ((po->flags & OPF_DATA) + && po->operand[0].lmod == OPLM_DWORD))) + { // it's overwritten return ret; + } if (po->flags & OPF_TAIL) return ret; continue; @@ -3745,6 +3996,96 @@ static int try_resolve_const(int i, const struct parsed_opr *opr, return -1; } +static const struct parsed_proto *resolve_icall(int i, int opcnt, + int *pp_i, int *multi_src) +{ + const struct parsed_proto *pp = NULL; + int search_advice = 0; + int offset = -1; + char name[256]; + char s_reg[4]; + int reg, len; + int ret; + + *multi_src = 0; + *pp_i = -1; + + switch (ops[i].operand[0].type) { + case OPT_REGMEM: + // try to resolve struct member calls + ret = sscanf(ops[i].operand[0].name, "%3s+%x%n", + s_reg, &offset, &len); + if (ret == 2 && len == strlen(ops[i].operand[0].name)) + { + reg = char_array_i(regs_r32, ARRAY_SIZE(regs_r32), s_reg); + if (reg >= 0) { + struct parsed_opr opr = OPR_INIT(OPT_REG, OPLM_DWORD, reg); + int j = -1; + ret = resolve_origin(i, &opr, i + opcnt * 19, &j, NULL); + if (ret != 1) + break; + if (ops[j].op == OP_MOV && ops[j].operand[1].type == OPT_REGMEM + && ops[j].operand[0].lmod == OPLM_DWORD + && ops[j].pp == NULL) // no hint + { + // allow one simple dereference (directx) + reg = char_array_i(regs_r32, ARRAY_SIZE(regs_r32), + ops[j].operand[1].name); + if (reg < 0) + break; + struct parsed_opr opr2 = OPR_INIT(OPT_REG, OPLM_DWORD, reg); + int k = -1; + ret = resolve_origin(j, &opr2, j + opcnt * 19, &k, NULL); + if (ret != 1) + break; + j = k; + } + if (ops[j].op != OP_MOV) + break; + if (ops[j].operand[0].lmod != OPLM_DWORD) + break; + if (ops[j].pp != NULL) { + // type hint in asm + pp = ops[j].pp; + } + else if (ops[j].operand[1].type == OPT_REGMEM) { + // allow 'hello[ecx]' - assume array of same type items + ret = sscanf(ops[j].operand[1].name, "%[^[][e%2s]", + name, s_reg); + if (ret != 2) + break; + pp = proto_parse(g_fhdr, name, g_quiet_pp); + } + else if (ops[j].operand[1].type == OPT_LABEL) + pp = proto_parse(g_fhdr, ops[j].operand[1].name, g_quiet_pp); + else + break; + if (pp == NULL) + break; + if (pp->is_func || pp->is_fptr || !pp->type.is_struct) { + pp = NULL; + break; + } + pp = proto_lookup_struct(g_fhdr, pp->type.name, offset); + } + break; + } + // fallthrough + case OPT_LABEL: + case OPT_OFFSET: + pp = try_recover_pp(&ops[i], &ops[i].operand[0], &search_advice); + if (!search_advice) + break; + // fallthrough + default: + scan_for_call_type(i, &ops[i].operand[0], i + opcnt * 9, &pp, + pp_i, multi_src); + break; + } + + return pp; +} + static struct parsed_proto *process_call_early(int i, int opcnt, int *adj_i) { @@ -4154,10 +4495,14 @@ static int collect_call_args_r(struct parsed_op *po, int i, if (ret == 1 && k >= 0) { if (ops[k].op == OP_LEA) { + if (!g_func_pp->is_vararg) + ferr(&ops[k], "lea used, but %s is not vararg?\n", + g_func_pp->name); + snprintf(buf, sizeof(buf), "arg_%X", g_func_pp->argc_stack * 4); - if (!g_func_pp->is_vararg - || strstr(ops[k].operand[1].name, buf)) + if (strstr(ops[k].operand[1].name, buf) + || strstr(ops[k].operand[1].name, "arglist")) { ops[k].flags |= OPF_RMD | OPF_NOREGS | OPF_DONE; ops[j].flags |= OPF_RMD | OPF_NOREGS | OPF_VAPUSH; @@ -4165,7 +4510,7 @@ static int collect_call_args_r(struct parsed_op *po, int i, reg = -1; } else - ferr(&ops[j], "lea va_list used, but no vararg?\n"); + ferr(&ops[k], "va_list arg detection failed\n"); } // check for va_list from g_func_pp arg too else if (ops[k].op == OP_MOV @@ -4272,6 +4617,7 @@ static void reg_use_pass(int i, int opcnt, unsigned char *cbits, int *regmask_init, int regmask_arg) { struct parsed_op *po; + unsigned int mask; int already_saved; int regmask_new; int regmask_op; @@ -4376,6 +4722,27 @@ static void reg_use_pass(int i, int opcnt, unsigned char *cbits, if (po->flags & OPF_NOREGS) continue; + if (po->flags & OPF_FPUSH) { + if (regmask_now & mxST1) + ferr(po, "TODO: FPUSH on active ST1\n"); + if (regmask_now & mxST0) + po->flags |= OPF_FSHIFT; + mask = mxST0 | mxST1; + regmask_now = (regmask_now & ~mask) | ((regmask_now & mxST0) << 1); + } + + // if incomplete register is used, clear it on init to avoid + // later use of uninitialized upper part in some situations + if ((po->flags & OPF_DATA) && po->operand[0].type == OPT_REG + && po->operand[0].lmod != OPLM_DWORD) + { + reg = po->operand[0].reg; + ferr_assert(po, reg >= 0); + + if (!(regmask_now & (1 << reg))) + *regmask_init |= 1 << reg; + } + regmask_op = po->regmask_src | po->regmask_dst; regmask_new = po->regmask_src & ~regmask_now & ~regmask_arg; @@ -4414,8 +4781,21 @@ static void reg_use_pass(int i, int opcnt, unsigned char *cbits, regmask_now |= regmask_op; *regmask |= regmask_now; - if (po->flags & OPF_TAIL) + // released regs + if (po->flags & OPF_FPOP) { + mask = mxST0 | mxST1; + if (!(regmask_now & mask)) + ferr(po, "float pop on empty stack?\n"); + if (regmask_now & mxST1) + po->flags |= OPF_FSHIFT; + regmask_now = (regmask_now & ~mask) | ((regmask_now & mxST1) >> 1); + } + + if (po->flags & OPF_TAIL) { + if (regmask_now & (mxST0 | mxST1)) + ferr(po, "float regs on tail: %x\n", regmask_now); return; + } } } @@ -4669,6 +5049,9 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) po->regmask_src |= get_pp_arg_regmask_src(pp); po->regmask_dst |= get_pp_arg_regmask_dst(pp); + if (po->regmask_dst & mxST0) + po->flags |= OPF_FPUSH; + if (strstr(pp->ret_type.name, "int64")) need_tmp64 = 1; @@ -4843,22 +5226,32 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) } } else if (po->op == OP_DIV || po->op == OP_IDIV) { - // 32bit division is common, look for it - if (po->op == OP_DIV) - ret = scan_for_reg_clear(i, xDX); - else - ret = scan_for_cdq_edx(i); - if (ret >= 0) - po->flags |= OPF_32BIT; + if (po->operand[0].lmod == OPLM_DWORD) { + // 32bit division is common, look for it + if (po->op == OP_DIV) + ret = scan_for_reg_clear(i, xDX); + else + ret = scan_for_cdq_edx(i); + if (ret >= 0) + po->flags |= OPF_32BIT; + else + need_tmp64 = 1; + } else - need_tmp64 = 1; + need_tmp_var = 1; } else if (po->op == OP_CLD) po->flags |= OPF_RMD | OPF_DONE; + else if (po->op == OPP_FTOL) { + struct parsed_opr opr = OPR_INIT(OPT_REG, OPLM_DWORD, xDX); + j = -1; + find_next_read(i + 1, opcnt, &opr, i + opcnt * 18, &j); + if (j == -1) + po->flags |= OPF_32BIT; + } - if (po->op == OP_RCL || po->op == OP_RCR || po->op == OP_XCHG) { + if (po->op == OP_RCL || po->op == OP_RCR || po->op == OP_XCHG) need_tmp_var = 1; - } } // output starts here @@ -4944,8 +5337,14 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) // declare stack frame, va_arg if (g_stack_fsz) { - fprintf(fout, " union { u32 d[%d]; u16 w[%d]; u8 b[%d]; } sf;\n", - (g_stack_fsz + 3) / 4, (g_stack_fsz + 1) / 2, g_stack_fsz); + fprintf(fout, " union { u32 d[%d];", (g_stack_fsz + 3) / 4); + if (g_func_lmods & (1 << OPLM_WORD)) + fprintf(fout, " u16 w[%d];", (g_stack_fsz + 1) / 2); + if (g_func_lmods & (1 << OPLM_BYTE)) + fprintf(fout, " u8 b[%d];", g_stack_fsz); + if (g_func_lmods & (1 << OPLM_QWORD)) + fprintf(fout, " double q[%d];", (g_stack_fsz + 7) / 8); + fprintf(fout, " } sf;\n"); had_decl = 1; } @@ -4998,6 +5397,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) } } } + // ... mmx if (regmask_now & 0xff00) { for (reg = 8; reg < 16; reg++) { if (regmask_now & (1 << reg)) { @@ -5009,6 +5409,18 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) } } } + // ... x87 + if (regmask_now & 0xff0000) { + for (reg = 16; reg < 24; reg++) { + if (regmask_now & (1 << reg)) { + fprintf(fout, " double f_st%d", reg - 16); + if (regmask_init & (1 << reg)) + fprintf(fout, " = 0"); + fprintf(fout, ";\n"); + had_decl = 1; + } + } + } if (regmask_save) { for (reg = 0; reg < 8; reg++) { @@ -5259,45 +5671,48 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) break; case OP_LODS: - assert_operand_cnt(3); if (po->flags & OPF_REP) { + assert_operand_cnt(3); // hmh.. ferr(po, "TODO\n"); } else { - fprintf(fout, " eax = %sesi; esi %c= %d;", - lmod_cast_u_ptr(po, po->operand[0].lmod), + assert_operand_cnt(2); + fprintf(fout, " %s = %sesi; esi %c= %d;", + out_dst_opr(buf1, sizeof(buf1), po, &po->operand[1]), + lmod_cast_u_ptr(po, po->operand[1].lmod), (po->flags & OPF_DF) ? '-' : '+', - lmod_bytes(po, po->operand[0].lmod)); + lmod_bytes(po, po->operand[1].lmod)); strcpy(g_comment, "lods"); } break; case OP_STOS: - assert_operand_cnt(3); if (po->flags & OPF_REP) { + assert_operand_cnt(3); fprintf(fout, " for (; ecx != 0; ecx--, edi %c= %d)\n", (po->flags & OPF_DF) ? '-' : '+', - lmod_bytes(po, po->operand[0].lmod)); + lmod_bytes(po, po->operand[1].lmod)); fprintf(fout, " %sedi = eax;", - lmod_cast_u_ptr(po, po->operand[0].lmod)); + lmod_cast_u_ptr(po, po->operand[1].lmod)); strcpy(g_comment, "rep stos"); } else { + assert_operand_cnt(2); fprintf(fout, " %sedi = eax; edi %c= %d;", - lmod_cast_u_ptr(po, po->operand[0].lmod), + lmod_cast_u_ptr(po, po->operand[1].lmod), (po->flags & OPF_DF) ? '-' : '+', - lmod_bytes(po, po->operand[0].lmod)); + lmod_bytes(po, po->operand[1].lmod)); strcpy(g_comment, "stos"); } break; case OP_MOVS: - assert_operand_cnt(3); j = lmod_bytes(po, po->operand[0].lmod); strcpy(buf1, lmod_cast_u_ptr(po, po->operand[0].lmod)); l = (po->flags & OPF_DF) ? '-' : '+'; if (po->flags & OPF_REP) { + assert_operand_cnt(3); fprintf(fout, " for (; ecx != 0; ecx--, edi %c= %d, esi %c= %d)\n", l, j, l, j); @@ -5306,6 +5721,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) strcpy(g_comment, "rep movs"); } else { + assert_operand_cnt(2); fprintf(fout, " %sedi = %sesi; edi %c= %d; esi %c= %d;", buf1, buf1, l, j, l, j); strcpy(g_comment, "movs"); @@ -5314,11 +5730,11 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) case OP_CMPS: // repe ~ repeat while ZF=1 - assert_operand_cnt(3); j = lmod_bytes(po, po->operand[0].lmod); strcpy(buf1, lmod_cast_u_ptr(po, po->operand[0].lmod)); l = (po->flags & OPF_DF) ? '-' : '+'; if (po->flags & OPF_REP) { + assert_operand_cnt(3); fprintf(fout, " for (; ecx != 0; ecx--) {\n"); if (pfomask & (1 << PFO_C)) { @@ -5339,6 +5755,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) (po->flags & OPF_REPZ) ? "e" : "ne"); } else { + assert_operand_cnt(2); fprintf(fout, " cond_z = (%sesi == %sedi); esi %c= %d; edi %c= %d;", buf1, buf1, l, j, l, j); @@ -5352,16 +5769,16 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) case OP_SCAS: // only does ZF (for now) // repe ~ repeat while ZF=1 - assert_operand_cnt(3); - j = lmod_bytes(po, po->operand[0].lmod); + j = lmod_bytes(po, po->operand[1].lmod); l = (po->flags & OPF_DF) ? '-' : '+'; if (po->flags & OPF_REP) { + assert_operand_cnt(3); fprintf(fout, " for (; ecx != 0; ecx--) {\n"); fprintf(fout, " cond_z = (%seax == %sedi); edi %c= %d;\n", - lmod_cast_u(po, po->operand[0].lmod), - lmod_cast_u_ptr(po, po->operand[0].lmod), l, j); + lmod_cast_u(po, po->operand[1].lmod), + lmod_cast_u_ptr(po, po->operand[1].lmod), l, j); fprintf(fout, " if (cond_z %s 0) break;\n", (po->flags & OPF_REPZ) ? "==" : "!="); @@ -5371,9 +5788,10 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) (po->flags & OPF_REPZ) ? "e" : "ne"); } else { + assert_operand_cnt(2); fprintf(fout, " cond_z = (%seax == %sedi); edi %c= %d;", - lmod_cast_u(po, po->operand[0].lmod), - lmod_cast_u_ptr(po, po->operand[0].lmod), l, j); + lmod_cast_u(po, po->operand[1].lmod), + lmod_cast_u_ptr(po, po->operand[1].lmod), l, j); strcpy(g_comment, "scas"); } pfomask &= ~(1 << PFO_Z); @@ -5470,11 +5888,14 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) assert_operand_cnt(3); propagate_lmod(po, &po->operand[0], &po->operand[1]); l = lmod_bytes(po, po->operand[0].lmod) * 8; - out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]); - out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]); out_src_opr_u32(buf3, sizeof(buf3), po, &po->operand[2]); - if (po->operand[2].type != OPT_CONST) - ferr(po, "TODO: masking\n"); + if (po->operand[2].type != OPT_CONST) { + // no handling for "undefined" case, hopefully not needed + snprintf(buf2, sizeof(buf2), "(%s & 0x1f)", buf3); + strcpy(buf3, buf2); + } + out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]); + out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]); if (po->op == OP_SHLD) { fprintf(fout, " %s <<= %s; %s |= %s >> (%d - %s);", buf1, buf3, buf1, buf2, l, buf3); @@ -5574,7 +5995,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) fprintf(fout, " cond_c = tmp64 >> 32;\n"); fprintf(fout, " %s = (u32)tmp64;", out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0])); - strcat(g_comment, "add64"); + strcat(g_comment, " add64"); } else { fprintf(fout, " cond_c = ((u32)%s + %s) >> %d;\n", @@ -5640,7 +6061,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) output_std_flags(fout, po, &pfomask, buf1); last_arith_dst = &po->operand[0]; delayed_flag_op = NULL; - strcat(g_comment, "bsf"); + strcat(g_comment, " bsf"); break; case OP_DEC: @@ -5726,34 +6147,51 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) case OP_DIV: case OP_IDIV: assert_operand_cnt(1); - if (po->operand[0].lmod != OPLM_DWORD) - ferr(po, "unhandled lmod %d\n", po->operand[0].lmod); - out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]); - strcpy(buf2, lmod_cast(po, po->operand[0].lmod, + strcpy(cast, lmod_cast(po, po->operand[0].lmod, po->op == OP_IDIV)); switch (po->operand[0].lmod) { case OPLM_DWORD: if (po->flags & OPF_32BIT) - snprintf(buf3, sizeof(buf3), "%seax", buf2); + snprintf(buf2, sizeof(buf2), "%seax", cast); else { fprintf(fout, " tmp64 = ((u64)edx << 32) | eax;\n"); - snprintf(buf3, sizeof(buf3), "%stmp64", + snprintf(buf2, sizeof(buf2), "%stmp64", (po->op == OP_IDIV) ? "(s64)" : ""); } if (po->operand[0].type == OPT_REG && po->operand[0].reg == xDX) { - fprintf(fout, " eax = %s / %s%s;", buf3, buf2, buf1); - fprintf(fout, " edx = %s %% %s%s;\n", buf3, buf2, buf1); + fprintf(fout, " eax = %s / %s%s;\n", buf2, cast, buf1); + fprintf(fout, " edx = %s %% %s%s;", buf2, cast, buf1); } else { - fprintf(fout, " edx = %s %% %s%s;\n", buf3, buf2, buf1); - fprintf(fout, " eax = %s / %s%s;", buf3, buf2, buf1); + fprintf(fout, " edx = %s %% %s%s;\n", buf2, cast, buf1); + fprintf(fout, " eax = %s / %s%s;", buf2, cast, buf1); } break; + case OPLM_WORD: + fprintf(fout, " tmp = (edx << 16) | (eax & 0xffff);\n"); + snprintf(buf2, sizeof(buf2), "%stmp", + (po->op == OP_IDIV) ? "(s32)" : ""); + if (po->operand[0].type == OPT_REG + && po->operand[0].reg == xDX) + { + fprintf(fout, " LOWORD(eax) = %s / %s%s;\n", + buf2, cast, buf1); + fprintf(fout, " LOWORD(edx) = %s %% %s%s;", + buf2, cast, buf1); + } + else { + fprintf(fout, " LOWORD(edx) = %s %% %s%s;\n", + buf2, cast, buf1); + fprintf(fout, " LOWORD(eax) = %s / %s%s;", + buf2, cast, buf1); + } + strcat(g_comment, " div16"); + break; default: - ferr(po, "unhandled division type\n"); + ferr(po, "unhandled div lmod %d\n", po->operand[0].lmod); } last_arith_dst = NULL; delayed_flag_op = NULL; @@ -5790,13 +6228,13 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) case OP_JECXZ: fprintf(fout, " if (ecx == 0)\n"); fprintf(fout, " goto %s;", po->operand[0].name); - strcat(g_comment, "jecxz"); + strcat(g_comment, " jecxz"); break; case OP_LOOP: - fprintf(fout, " if (--ecx == 0)\n"); + fprintf(fout, " if (--ecx != 0)\n"); fprintf(fout, " goto %s;", po->operand[0].name); - strcat(g_comment, "loop"); + strcat(g_comment, " loop"); break; case OP_JMP: @@ -5849,17 +6287,22 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) } else if (!IS(pp->ret_type.name, "void")) { if (po->flags & OPF_TAIL) { - if (regmask_ret & (1 << xAX)) { + if (regmask_ret & mxAX) { fprintf(fout, "return "); if (g_func_pp->ret_type.is_ptr != pp->ret_type.is_ptr) fprintf(fout, "(%s)", g_func_pp->ret_type.name); } + else if (regmask_ret & mxST0) + ferr(po, "float tailcall\n"); } - else if (po->regmask_dst & (1 << xAX)) { + else if (po->regmask_dst & mxAX) { fprintf(fout, "eax = "); if (pp->ret_type.is_ptr) fprintf(fout, "(u32)"); } + else if (po->regmask_dst & mxST0) { + fprintf(fout, "f_st0 = "); + } } if (pp->name[0] == 0) @@ -5962,16 +6405,17 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) // else already handled as 'return f()' if (ret) { - if (regmask_ret & (1 << xAX)) { - ferr(po, "int func -> void func tailcall?\n"); - } - else { - fprintf(fout, "\n%sreturn;", buf3); - strcat(g_comment, " ^ tailcall"); - } + fprintf(fout, "\n%sreturn;", buf3); + strcat(g_comment, " ^ tailcall"); } else strcat(g_comment, " tailcall"); + + if ((regmask_ret & (1 << xAX)) + && IS(pp->ret_type.name, "void") && !pp->is_noreturn) + { + ferr(po, "int func -> void func tailcall?\n"); + } } if (pp->is_noreturn) strcat(g_comment, " noreturn"); @@ -6076,9 +6520,123 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) no_output = 1; break; + // x87 + case OP_FLD: + if (po->flags & OPF_FSHIFT) + fprintf(fout, " f_st1 = f_st0;\n"); + if (po->operand[0].type == OPT_REG + && po->operand[0].reg == xST0) + { + strcat(g_comment, " fld st"); + break; + } + fprintf(fout, " f_st0 = %s;", + out_src_opr_float(buf1, sizeof(buf1), po, &po->operand[0])); + strcat(g_comment, " fld"); + break; + + case OP_FILD: + if (po->flags & OPF_FSHIFT) + fprintf(fout, " f_st1 = f_st0;\n"); + fprintf(fout, " f_st0 = (double)%s;", + out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], + lmod_cast(po, po->operand[0].lmod, 1), 0)); + strcat(g_comment, " fild"); + break; + + case OP_FLDc: + if (po->flags & OPF_FSHIFT) + fprintf(fout, " f_st1 = f_st0;\n"); + fprintf(fout, " f_st0 = "); + switch (po->operand[0].val) { + case X87_CONST_1: fprintf(fout, "1.0;"); break; + case X87_CONST_Z: fprintf(fout, "0.0;"); break; + default: ferr(po, "TODO\n"); break; + } + break; + + case OP_FST: + if ((po->flags & OPF_FPOP) && po->operand[0].type == OPT_REG + && po->operand[0].reg == xST0) + { + no_output = 1; + break; + } + fprintf(fout, " %s = f_st0;", + out_dst_opr_float(buf1, sizeof(buf1), po, &po->operand[0])); + if (po->flags & OPF_FSHIFT) + fprintf(fout, "\n f_st0 = f_st1;"); + strcat(g_comment, " fst"); + break; + + case OP_FADD: + case OP_FDIV: + case OP_FMUL: + case OP_FSUB: + switch (po->op) { + case OP_FADD: j = '+'; break; + case OP_FDIV: j = '/'; break; + case OP_FMUL: j = '*'; break; + case OP_FSUB: j = '-'; break; + default: j = 'x'; break; + } + if (po->flags & OPF_FSHIFT) { + fprintf(fout, " f_st0 = f_st1 %c f_st0;", j); + } + else { + fprintf(fout, " %s %c= %s;", + out_dst_opr_float(buf1, sizeof(buf1), po, &po->operand[0]), + j, + out_src_opr_float(buf2, sizeof(buf2), po, &po->operand[1])); + } + break; + + case OP_FDIVR: + case OP_FSUBR: + if (po->flags & OPF_FSHIFT) + snprintf(buf1, sizeof(buf1), "f_st0"); + else + out_dst_opr_float(buf1, sizeof(buf1), po, &po->operand[0]); + fprintf(fout, " %s = %s %c %s;", buf1, + out_src_opr_float(buf2, sizeof(buf2), po, &po->operand[1]), + po->op == OP_FDIVR ? '/' : '-', + out_src_opr_float(buf3, sizeof(buf3), po, &po->operand[0])); + break; + + case OP_FIADD: + case OP_FIDIV: + case OP_FIMUL: + case OP_FISUB: + switch (po->op) { + case OP_FIADD: j = '+'; break; + case OP_FIDIV: j = '/'; break; + case OP_FIMUL: j = '*'; break; + case OP_FISUB: j = '-'; break; + default: j = 'x'; break; + } + fprintf(fout, " f_st0 %c= (double)%s;", j, + out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], + lmod_cast(po, po->operand[0].lmod, 1), 0)); + break; + + case OP_FIDIVR: + case OP_FISUBR: + fprintf(fout, " f_st0 = %s %c f_st0;", + out_src_opr_float(buf2, sizeof(buf2), po, &po->operand[1]), + po->op == OP_FIDIVR ? '/' : '-'); + break; + + case OPP_FTOL: + ferr_assert(po, po->flags & OPF_32BIT); + fprintf(fout, " eax = (s32)f_st0;"); + if (po->flags & OPF_FSHIFT) + fprintf(fout, "\n f_st0 = f_st1;"); + strcat(g_comment, " ftol"); + break; + // mmx case OP_EMMS: - strcpy(g_comment, "(emms)"); + strcpy(g_comment, " (emms)"); break; default: @@ -7433,6 +7991,7 @@ do_pending_endp: pd->d = NULL; } g_func_pd_cnt = 0; + g_func_lmods = 0; pd = NULL; if (end) @@ -7577,11 +8136,8 @@ do_pending_endp: parse_op(&ops[pi], words, wordc); - if (sctproto != NULL) { - if (ops[pi].op == OP_CALL || ops[pi].op == OP_JMP) - ops[pi].datap = sctproto; - sctproto = NULL; - } + ops[pi].datap = sctproto; + sctproto = NULL; pi++; }