X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tools%2Ftranslate.c;h=fe6408786a3a59793caae9bc7a6d95ea4a4f668e;hb=71d50aa7a431645296bc8624618e02e7f3bf73ac;hp=eca8490aceb446ab804064aa10d7dfca80fb8359;hpb=226e8df1fab849b7f0d55989b13a002dadaf6b9c;p=ia32rtools.git diff --git a/tools/translate.c b/tools/translate.c index eca8490..fe64087 100644 --- a/tools/translate.c +++ b/tools/translate.c @@ -4,12 +4,22 @@ * * This work is licensed under the terms of 3-clause BSD license. * See COPYING file in the top-level directory. + * + * recognized asm hint comments: + * sctattr - function attributes (see code) + * sctend - force end of function/chunk + * sctpatch:

- replace current asm line with

+ * sctproto:

- prototype of ref'd function or struct + * sctref - variable is referenced, make global + * sctskip_start - start of skipped code chunk (inclusive) + * sctskip_end - end of skipped code chunk (inclusive) */ #define _GNU_SOURCE #include #include #include +#include #include "my_assert.h" #include "my_str.h" @@ -70,6 +80,8 @@ enum op_op { OP_NOP, OP_PUSH, OP_POP, + OP_PUSHA, + OP_POPA, OP_LEAVE, OP_MOV, OP_LEA, @@ -79,6 +91,7 @@ enum op_op { OP_NOT, OP_XLAT, OP_CDQ, + OP_BSWAP, OP_LODS, OP_STOS, OP_MOVS, @@ -124,6 +137,7 @@ enum op_op { OP_FILD, OP_FLDc, OP_FST, + OP_FIST, OP_FADD, OP_FDIV, OP_FMUL, @@ -136,10 +150,24 @@ enum op_op { OP_FISUB, OP_FIDIVR, OP_FISUBR, + OP_FCOM, + OP_FNSTSW, + OP_FCHS, + OP_FCOS, + OP_FPATAN, + OP_FPTAN, + OP_FSIN, + OP_FSQRT, + OP_FXCH, + OP_FYL2X, // mmx OP_EMMS, // pseudo-ops for lib calls + OPP_ALLSHL, + OPP_ALLSHR, OPP_FTOL, + OPP_CIPOW, + OPP_ABORT, // undefined OP_UD2, }; @@ -213,6 +241,7 @@ struct parsed_op { // (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 +// OP_FCOM - needed_status_word_bits | (is_z_check << 16) struct parsed_equ { char name[64]; @@ -290,6 +319,7 @@ static int g_stack_clear_len; static int g_regmask_init; static int g_skip_func; static int g_allow_regfunc; +static int g_allow_user_icall; static int g_quiet_pp; static int g_header_mode; @@ -332,6 +362,9 @@ enum x86_regs { #define mxDX (1 << xDX) #define mxST0 (1 << xST0) #define mxST1 (1 << xST1) +#define mxST1_0 (mxST1 | mxST0) +#define mxST7_2 (0xfc << xST0) +#define mxSTa (0xff << xST0) // possible basic comparison types (without inversion) enum parsed_flag_op { @@ -459,7 +492,7 @@ static int parse_indmode(char *name, int *regmask, int need_c_cvt) } if ('0' <= w[0] && w[0] <= '9') { - number = parse_number(w); + number = parse_number(w, 0); printf_number(d, sizeof(cvtbuf) - (d - cvtbuf), number); continue; } @@ -491,12 +524,12 @@ static int is_reg_in_str(const char *s) } static const char *parse_stack_el(const char *name, char *extra_reg, - int early_try) + int *base_val, int early_try) { const char *p, *p2, *s; char *endp = NULL; char buf[32]; - long val; + long val = -1; int len; if (g_bp_frame || early_try) @@ -555,8 +588,9 @@ static const char *parse_stack_el(const char *name, char *extra_reg, if (len < sizeof(buf) - 1) { strncpy(buf, s, len); buf[len] = 0; + errno = 0; val = strtol(buf, &endp, 16); - if (val == 0 || *endp != 0) { + if (val == 0 || *endp != 0 || errno != 0) { aerr("%s num parse fail for '%s'\n", __func__, buf); return NULL; } @@ -569,6 +603,8 @@ static const char *parse_stack_el(const char *name, char *extra_reg, if ('0' <= *p && *p <= '9') return NULL; + if (base_val != NULL) + *base_val = val; return p; } @@ -596,6 +632,9 @@ static int guess_lmod_from_name(struct parsed_opr *opr) static int guess_lmod_from_c_type(enum opr_lenmod *lmod, const struct parsed_type *c_type) { + static const char *qword_types[] = { + "uint64_t", "int64_t", "__int64", + }; static const char *dword_types[] = { "uint32_t", "int", "_DWORD", "UINT_PTR", "DWORD", "WPARAM", "LPARAM", "UINT", "__int32", @@ -644,6 +683,13 @@ static int guess_lmod_from_c_type(enum opr_lenmod *lmod, } } + for (i = 0; i < ARRAY_SIZE(qword_types); i++) { + if (IS(n, qword_types[i])) { + *lmod = OPLM_QWORD; + return 1; + } + } + return 0; } @@ -803,11 +849,12 @@ static int parse_operand(struct parsed_opr *opr, aerr("[] parse failure\n"); parse_indmode(opr->name, regmask_indirect, 1); - if (opr->lmod == OPLM_UNSPEC && parse_stack_el(opr->name, NULL, 1)) + if (opr->lmod == OPLM_UNSPEC + && parse_stack_el(opr->name, NULL, NULL, 1)) { // might be an equ struct parsed_equ *eq = - equ_find(NULL, parse_stack_el(opr->name, NULL, 1), &i); + equ_find(NULL, parse_stack_el(opr->name, NULL, NULL, 1), &i); if (eq) opr->lmod = eq->lmod; @@ -829,7 +876,7 @@ static int parse_operand(struct parsed_opr *opr, else if (('0' <= words[w][0] && words[w][0] <= '9') || words[w][0] == '-') { - number = parse_number(words[w]); + number = parse_number(words[w], 0); opr->type = OPT_CONST; opr->val = number; printf_number(opr->name, sizeof(opr->name), number); @@ -904,6 +951,8 @@ static const struct { { "nop", OP_NOP, 0, 0, 0 }, { "push", OP_PUSH, 1, 1, 0 }, { "pop", OP_POP, 1, 1, OPF_DATA }, + { "pusha",OP_PUSHA, 0, 0, 0 }, + { "popa", OP_POPA, 0, 0, OPF_DATA }, { "leave",OP_LEAVE, 0, 0, OPF_DATA }, { "mov" , OP_MOV, 2, 2, OPF_DATA }, { "lea", OP_LEA, 2, 2, OPF_DATA }, @@ -913,6 +962,7 @@ static const struct { { "not", OP_NOT, 1, 1, OPF_DATA }, { "xlat", OP_XLAT, 0, 0, OPF_DATA }, { "cdq", OP_CDQ, 0, 0, OPF_DATA }, + { "bswap",OP_BSWAP, 1, 1, OPF_DATA }, { "lodsb",OP_LODS, 0, 0, OPF_DATA }, { "lodsw",OP_LODS, 0, 0, OPF_DATA }, { "lodsd",OP_LODS, 0, 0, OPF_DATA }, @@ -1024,9 +1074,12 @@ static const struct { { "fld", OP_FLD, 1, 1, OPF_FPUSH }, { "fild", OP_FILD, 1, 1, OPF_FPUSH }, { "fld1", OP_FLDc, 0, 0, OPF_FPUSH }, + { "fldln2", 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 }, + { "fstp", OP_FST, 1, 1, OPF_FPOP }, + { "fist", OP_FIST, 1, 1, 0 }, + { "fistp", OP_FIST, 1, 1, OPF_FPOP }, { "fadd", OP_FADD, 0, 2, 0 }, { "faddp", OP_FADD, 0, 2, OPF_FPOP }, { "fdiv", OP_FDIV, 0, 2, 0 }, @@ -1045,11 +1098,25 @@ static const struct { { "fisub", OP_FISUB, 1, 1, 0 }, { "fidivr", OP_FIDIVR, 1, 1, 0 }, { "fisubr", OP_FISUBR, 1, 1, 0 }, + { "fcom", OP_FCOM, 0, 1, 0 }, + { "fcomp", OP_FCOM, 0, 1, OPF_FPOP }, + { "fnstsw", OP_FNSTSW, 1, 1, OPF_DATA }, + { "fchs", OP_FCHS, 0, 0, 0 }, + { "fcos", OP_FCOS, 0, 0, 0 }, + { "fpatan", OP_FPATAN, 0, 0, OPF_FPOP }, + { "fptan", OP_FPTAN, 0, 0, OPF_FPUSH }, + { "fsin", OP_FSIN, 0, 0, 0 }, + { "fsqrt", OP_FSQRT, 0, 0, 0 }, + { "fxch", OP_FXCH, 1, 1, 0 }, + { "fyl2x", OP_FYL2X, 0, 0, OPF_FPOP }, // mmx { "emms", OP_EMMS, 0, 0, OPF_DATA }, { "movq", OP_MOV, 2, 2, OPF_DATA }, // pseudo-ops for lib calls + { "_allshl",OPP_ALLSHL }, + { "_allshr",OPP_ALLSHR }, { "_ftol", OPP_FTOL }, + { "_CIpow", OPP_CIPOW }, // must be last { "ud2", OP_UD2 }, }; @@ -1147,6 +1214,7 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc) case OP_INC: case OP_DEC: case OP_NEG: + case OP_BSWAP: // more below.. op->regmask_src |= op->regmask_dst; break; @@ -1335,6 +1403,8 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc) 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, "ln2")) + op->operand[0].val = X87_CONST_LN2; else if (IS(words[op_w] + 3, "z")) op->operand[0].val = X87_CONST_Z; else @@ -1342,6 +1412,7 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc) break; case OP_FST: + case OP_FIST: op->regmask_src |= mxST0; break; @@ -1372,10 +1443,29 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc) case OP_FISUB: case OP_FIDIVR: case OP_FISUBR: + case OP_FCHS: + case OP_FCOS: + case OP_FSIN: + case OP_FSQRT: + case OP_FXCH: op->regmask_src |= mxST0; op->regmask_dst |= mxST0; break; + case OP_FPATAN: + case OP_FYL2X: + op->regmask_src |= mxST0 | mxST1; + op->regmask_dst |= mxST0; + break; + + case OP_FPTAN: + aerr("TODO\n"); + break; + + case OP_FCOM: + op->regmask_src |= mxST0; + break; + default: break; } @@ -1656,16 +1746,15 @@ static struct parsed_equ *equ_find(struct parsed_op *po, const char *name, *extra_offs = 0; namelen = strlen(name); - p = strchr(name, '+'); + p = strpbrk(name, "+-"); if (p != NULL) { namelen = p - name; if (namelen <= 0) ferr(po, "equ parse failed for '%s'\n", name); - if (IS_START(p, "0x")) - p += 2; + errno = 0; *extra_offs = strtol(p, &endp, 16); - if (*endp != 0) + if (*endp != 0 || errno != 0) ferr(po, "equ parse failed for '%s'\n", name); } @@ -1685,7 +1774,7 @@ static struct parsed_equ *equ_find(struct parsed_op *po, const char *name, static int is_stack_access(struct parsed_op *po, const struct parsed_opr *popr) { - return (parse_stack_el(popr->name, NULL, 0) + return (parse_stack_el(popr->name, NULL, NULL, 0) || (g_bp_frame && !(po->flags & OPF_EBP_S) && IS_START(popr->name, "ebp"))); } @@ -1709,15 +1798,15 @@ static void parse_stack_access(struct parsed_op *po, p = name + 4; if (IS_START(p, "0x")) p += 2; + errno = 0; offset = strtoul(p, &endp, 16); if (name[3] == '-') offset = -offset; - if (*endp != 0) + if (*endp != 0 || errno != 0) ferr(po, "ebp- parse of '%s' failed\n", name); } else { - bp_arg = parse_stack_el(name, ofs_reg, 0); - snprintf(g_comment, sizeof(g_comment), "%s", bp_arg); + bp_arg = parse_stack_el(name, ofs_reg, NULL, 0); eq = equ_find(po, bp_arg, &offset); if (eq == NULL) ferr(po, "detected but missing eq\n"); @@ -1735,11 +1824,47 @@ static void parse_stack_access(struct parsed_op *po, } *offset_out = offset; - *stack_ra_out = stack_ra; + if (stack_ra_out) + *stack_ra_out = stack_ra; if (bp_arg_out) *bp_arg_out = bp_arg; } +static int parse_stack_esp_offset(struct parsed_op *po, + const char *name, int *offset_out) +{ + char ofs_reg[16] = { 0, }; + struct parsed_equ *eq; + const char *bp_arg; + char *endp = NULL; + int base_val = 0; + int offset = 0; + + if (strstr(name, "esp") == NULL) + return -1; + bp_arg = parse_stack_el(name, ofs_reg, &base_val, 0); + if (bp_arg == NULL) { + // just plain offset? + if (!IS_START(name, "esp+")) + return -1; + errno = 0; + offset = strtol(name + 4, &endp, 0); + if (endp == NULL || *endp != 0 || errno != 0) + return -1; + *offset_out = offset; + return 0; + } + + if (ofs_reg[0] != 0) + return -1; + eq = equ_find(po, bp_arg, &offset); + if (eq == NULL) + ferr(po, "detected but missing eq\n"); + offset += eq->offset; + *offset_out = base_val + offset; + return 0; +} + static int stack_frame_access(struct parsed_op *po, struct parsed_opr *popr, char *buf, size_t buf_size, const char *name, const char *cast, int is_src, int is_lea) @@ -1754,7 +1879,6 @@ static int stack_frame_access(struct parsed_op *po, int offset = 0; int retval = -1; int sf_ofs; - int lim; if (po->flags & OPF_EBP_S) ferr(po, "stack_frame_access while ebp is scratch\n"); @@ -1762,6 +1886,8 @@ static int stack_frame_access(struct parsed_op *po, parse_stack_access(po, name, ofs_reg, &offset, &stack_ra, &bp_arg, is_lea); + snprintf(g_comment, sizeof(g_comment), "%s", bp_arg); + if (offset > stack_ra) { arg_i = (offset - stack_ra - 4) / 4; @@ -1860,7 +1986,7 @@ static int stack_frame_access(struct parsed_op *po, } if (unaligned) - snprintf(g_comment, sizeof(g_comment), "%s unaligned", bp_arg); + strcat(g_comment, " unaligned"); // common problem guess_lmod_from_c_type(&tmp_lmod, &g_func_pp->arg[i].type); @@ -1883,8 +2009,7 @@ static int stack_frame_access(struct parsed_op *po, g_stack_frame_used = 1; sf_ofs = g_stack_fsz + offset; - lim = (ofs_reg[0] != 0) ? -4 : 0; - if (offset > 0 || sf_ofs < lim) + if (ofs_reg[0] == 0 && (offset > 0 || sf_ofs < 0)) ferr(po, "bp_stack offset %d/%d\n", offset, g_stack_fsz); if (is_lea) @@ -1928,9 +2053,11 @@ static int stack_frame_access(struct parsed_op *po, 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); + // only used for x87 int64/float, float sets is_lea + if (is_lea) + snprintf(buf, buf_size, "%ssf.q[%d]", prefix, sf_ofs / 8); + else + snprintf(buf, buf_size, "*(s64 *)&sf.q[%d]", sf_ofs / 8); break; default: @@ -1949,7 +2076,7 @@ static void check_func_pp(struct parsed_op *po, int ret, i; if (pp->argc_reg != 0) { - if (/*!g_allow_regfunc &&*/ !pp->is_fastcall) { + if (!g_allow_user_icall && !pp->is_fastcall) { pp_print(buf, sizeof(buf), pp); ferr(po, "%s: unexpected reg arg in icall: %s\n", pfx, buf); } @@ -2168,7 +2295,7 @@ static char *out_src_opr_u32(char *buf, size_t buf_size, } static char *out_src_opr_float(char *buf, size_t buf_size, - struct parsed_op *po, struct parsed_opr *popr) + struct parsed_op *po, struct parsed_opr *popr, int need_float_stack) { const char *cast = NULL; char tmp[256]; @@ -2178,7 +2305,15 @@ static char *out_src_opr_float(char *buf, size_t buf_size, 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); + if (need_float_stack) { + if (popr->reg == xST0) + snprintf(buf, buf_size, "f_st[f_stp & 7]"); + else + snprintf(buf, buf_size, "f_st[(f_stp + %d) & 7]", + popr->reg - xST0); + } + else + snprintf(buf, buf_size, "f_st%d", popr->reg - xST0); break; case OPT_REGMEM: @@ -2196,7 +2331,7 @@ static char *out_src_opr_float(char *buf, size_t buf_size, break; } out_src_opr(tmp, sizeof(tmp), po, popr, "", 1); - snprintf(buf, buf_size, "*((%s *)%s)", cast, tmp); + snprintf(buf, buf_size, "*(%s *)(%s)", cast, tmp); break; default: @@ -2207,10 +2342,10 @@ static char *out_src_opr_float(char *buf, size_t buf_size, } static char *out_dst_opr_float(char *buf, size_t buf_size, - struct parsed_op *po, struct parsed_opr *popr) + struct parsed_op *po, struct parsed_opr *popr, int need_float_stack) { // same? - return out_src_opr_float(buf, buf_size, po, popr); + return out_src_opr_float(buf, buf_size, po, popr, need_float_stack); } static void out_test_for_cc(char *buf, size_t buf_size, @@ -2224,7 +2359,7 @@ static void out_test_for_cc(char *buf, size_t buf_size, switch (pfo) { case PFO_Z: - case PFO_BE: // CF=1||ZF=1; CF=0 + case PFO_BE: // CF==1||ZF==1; CF=0 snprintf(buf, buf_size, "(%s%s %s 0)", cast, expr, is_inv ? "!=" : "=="); break; @@ -2235,18 +2370,24 @@ static void out_test_for_cc(char *buf, size_t buf_size, scast, expr, is_inv ? ">=" : "<"); break; - case PFO_LE: // ZF=1||SF!=OF; OF=0 + case PFO_LE: // ZF==1||SF!=OF; OF=0 snprintf(buf, buf_size, "(%s%s %s 0)", scast, expr, is_inv ? ">" : "<="); break; + case PFO_C: // CF=0 + case PFO_O: // OF=0 + snprintf(buf, buf_size, "(%d)", !!is_inv); + break; + default: ferr(po, "%s: unhandled parsed_flag_op: %d\n", __func__, pfo); } } static void out_cmp_for_cc(char *buf, size_t buf_size, - struct parsed_op *po, enum parsed_flag_op pfo, int is_inv) + struct parsed_op *po, enum parsed_flag_op pfo, int is_inv, + int is_neg) { const char *cast, *scast, *cast_use; char buf1[256], buf2[256]; @@ -2280,8 +2421,13 @@ static void out_cmp_for_cc(char *buf, size_t buf_size, out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], cast_use, 0); if (po->op == OP_DEC) snprintf(buf2, sizeof(buf2), "1"); - else - out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], cast_use, 0); + else { + char cast_op2[64]; + snprintf(cast_op2, sizeof(cast_op2) - 1, "%s", cast_use); + if (is_neg) + strcat(cast_op2, "-"); + out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], cast_op2, 0); + } switch (pfo) { case PFO_C: @@ -2349,7 +2495,7 @@ static void out_cmp_test(char *buf, size_t buf_size, po->operand[0].lmod, buf3); } else if (po->op == OP_CMP) { - out_cmp_for_cc(buf, buf_size, po, pfo, is_inv); + out_cmp_for_cc(buf, buf_size, po, pfo, is_inv, 0); } else ferr(po, "%s: unhandled op: %d\n", __func__, po->op); @@ -2424,7 +2570,7 @@ static const char *op_to_c(struct parsed_op *po) // note: this skips over calls and rm'd stuff assuming they're handled // so it's intended to use at one of final passes static int scan_for_pop(int i, int opcnt, int magic, int reg, - int depth, int flags_set) + int depth, int seen_noreturn, int flags_set) { struct parsed_op *po; int relevant; @@ -2440,10 +2586,12 @@ static int scan_for_pop(int i, int opcnt, int magic, int reg, if (po->flags & OPF_TAIL) { if (po->op == OP_CALL) { if (po->pp != NULL && po->pp->is_noreturn) - // assume no stack cleanup for noreturn - return 1; + seen_noreturn = 1; + else + goto out; } - return -1; // deadend + else + goto out; } if (po->flags & (OPF_RMD|OPF_DONE|OPF_FARG)) @@ -2455,7 +2603,7 @@ static int scan_for_pop(int i, int opcnt, int magic, int reg, for (j = 0; j < po->btj->count; j++) { check_i(po, po->btj->d[j].bt_i); ret |= scan_for_pop(po->btj->d[j].bt_i, opcnt, magic, reg, - depth, flags_set); + depth, seen_noreturn, flags_set); if (ret < 0) return ret; // dead end } @@ -2465,7 +2613,7 @@ static int scan_for_pop(int i, int opcnt, int magic, int reg, check_i(po, po->bt_i); if (po->flags & OPF_CJMP) { ret |= scan_for_pop(po->bt_i, opcnt, magic, reg, - depth, flags_set); + depth, seen_noreturn, flags_set); if (ret < 0) return ret; // dead end } @@ -2494,7 +2642,9 @@ static int scan_for_pop(int i, int opcnt, int magic, int reg, } } - return -1; +out: + // for noreturn, assume msvc skipped stack cleanup + return seen_noreturn ? 1 : -1; } // scan for 'reg' pop backwards starting from i @@ -2544,8 +2694,9 @@ static int scan_for_rsave_pop_reg(int i, int magic, int reg, int set_flags) return -1; } - // nothing interesting on this path - return 0; + // nothing interesting on this path, + // still return ret for something recursive calls could find + return ret; } static void find_reachable_exits(int i, int opcnt, int magic, @@ -2596,7 +2747,8 @@ static int scan_for_pop_ret(int i, int opcnt, int reg, int set_flags) { static int exits[MAX_EXITS]; static int exit_count; - int j, ret; + int found = 0; + int e, j, ret; if (!set_flags) { exit_count = 0; @@ -2606,13 +2758,23 @@ static int scan_for_pop_ret(int i, int opcnt, int reg, int set_flags) } for (j = 0; j < exit_count; j++) { - ret = scan_for_rsave_pop_reg(exits[j], i + opcnt * 16 + set_flags, + e = exits[j]; + ret = scan_for_rsave_pop_reg(e, i + opcnt * 16 + set_flags, reg, set_flags); - if (ret == -1) - return -1; + if (ret != -1) { + found |= ret; + continue; + } + if (ops[e].op == OP_CALL && ops[e].pp != NULL + && ops[e].pp->is_noreturn) + { + // assume stack cleanup was skipped + continue; + } + return -1; } - return 1; + return found; } // scan for one or more pop of push @@ -2981,8 +3143,11 @@ static int scan_for_mod_opr0(struct parsed_op *po_test, return -1; } -static int scan_for_flag_set(int i, int magic, int *branched, - int *setters, int *setter_cnt) +static int try_resolve_const(int i, const struct parsed_opr *opr, + int magic, unsigned int *val); + +static int scan_for_flag_set(int i, int opcnt, int magic, + int *branched, int *setters, int *setter_cnt) { struct label_ref *lr; int ret; @@ -3001,7 +3166,7 @@ static int scan_for_flag_set(int i, int magic, int *branched, lr = &g_label_refs[i]; for (; lr->next; lr = lr->next) { check_i(&ops[i], lr->i); - ret = scan_for_flag_set(lr->i, magic, + ret = scan_for_flag_set(lr->i, opcnt, magic, branched, setters, setter_cnt); if (ret < 0) return ret; @@ -3012,7 +3177,7 @@ static int scan_for_flag_set(int i, int magic, int *branched, i = lr->i; continue; } - ret = scan_for_flag_set(lr->i, magic, + ret = scan_for_flag_set(lr->i, opcnt, magic, branched, setters, setter_cnt); if (ret < 0) return ret; @@ -3022,6 +3187,20 @@ static int scan_for_flag_set(int i, int magic, int *branched, if (ops[i].flags & OPF_FLAGS) { setters[*setter_cnt] = i; (*setter_cnt)++; + + if (ops[i].flags & OPF_REP) { + struct parsed_opr opr = OPR_INIT(OPT_REG, OPLM_DWORD, xCX); + unsigned int uval; + + ret = try_resolve_const(i, &opr, i + opcnt * 7, &uval); + if (ret != 1 || uval == 0) { + // can't treat it as full setter because of ecx=0 case, + // also disallow delayed compare + *branched = 1; + continue; + } + } + return 0; } @@ -3221,7 +3400,8 @@ static void scan_fwd_set_flags(int i, int opcnt, int magic, int flags) } static const struct parsed_proto *try_recover_pp( - struct parsed_op *po, const struct parsed_opr *opr, int *search_instead) + struct parsed_op *po, const struct parsed_opr *opr, + int is_call, int *search_instead) { const struct parsed_proto *pp = NULL; char buf[256]; @@ -3260,10 +3440,12 @@ static const struct parsed_proto *try_recover_pp( if (arg == g_func_pp->argc) ferr(po, "stack arg %d not in prototype?\n", arg_i); - pp = g_func_pp->arg[arg].fptr; - if (pp == NULL) - ferr(po, "icall sa: arg%d is not a fptr?\n", arg + 1); - check_func_pp(po, pp, "icall arg"); + pp = g_func_pp->arg[arg].pp; + if (is_call) { + if (pp == NULL) + ferr(po, "icall arg: arg%d has no pp\n", arg + 1); + check_func_pp(po, pp, "icall arg"); + } } else if (opr->type == OPT_REGMEM && strchr(opr->name + 1, '[')) { // label[index] @@ -3344,14 +3526,14 @@ static void scan_for_call_type(int i, const struct parsed_opr *opr, } if (i == g_func_pp->argc) return; - pp = g_func_pp->arg[i].fptr; + pp = g_func_pp->arg[i].pp; if (pp == NULL) ferr(po, "icall: arg%d (%s) is not a fptr?\n", i + 1, g_func_pp->arg[i].reg); check_func_pp(po, pp, "icall reg-arg"); } else - pp = try_recover_pp(po, opr, NULL); + pp = try_recover_pp(po, opr, 1, NULL); if (*pp_found != NULL && pp != NULL && *pp_found != pp) { if (!IS((*pp_found)->ret_type.name, pp->ret_type.name) @@ -3488,6 +3670,13 @@ static int get_pp_arg_regmask_dst(const struct parsed_proto *pp) return regmask | mxAX; } +static int are_ops_same(struct parsed_op *po1, struct parsed_op *po2) +{ + return po1->op == po2->op && po1->operand_cnt == po2->operand_cnt + && memcmp(po1->operand, po2->operand, + sizeof(po1->operand[0]) * po1->operand_cnt) == 0; +} + static void resolve_branches_parse_calls(int opcnt) { static const struct { @@ -3497,13 +3686,17 @@ static void resolve_branches_parse_calls(int opcnt) unsigned int regmask_src; unsigned int regmask_dst; } pseudo_ops[] = { - { "__ftol", OPP_FTOL, OPF_FPOP, mxST0, mxAX | mxDX }, + { "__allshl", OPP_ALLSHL, OPF_DATA, mxAX|mxDX|mxCX, mxAX|mxDX }, + { "__allshr", OPP_ALLSHR, OPF_DATA, mxAX|mxDX|mxCX, mxAX|mxDX }, + { "__ftol", OPP_FTOL, OPF_FPOP, mxST0, mxAX | mxDX }, + { "__CIpow", OPP_CIPOW, OPF_FPOP, mxST0|mxST1, mxST0 }, }; const struct parsed_proto *pp_c; struct parsed_proto *pp; struct parsed_data *pd; struct parsed_op *po; const char *tmpname; + enum op_op prev_op; int i, l; int ret; @@ -3535,6 +3728,8 @@ static void resolve_branches_parse_calls(int opcnt) tmpname = opr_name(po, 0); if (IS_START(tmpname, "loc_")) ferr(po, "call to loc_*\n"); + if (IS(tmpname, "__alloca_probe")) + continue; // convert some calls to pseudo-ops for (l = 0; l < ARRAY_SIZE(pseudo_ops); l++) { @@ -3565,8 +3760,10 @@ static void resolve_branches_parse_calls(int opcnt) if (pp != NULL) { if (pp->is_fptr) check_func_pp(po, pp, "fptr var call"); - if (pp->is_noreturn) + if (pp->is_noreturn) { po->flags |= OPF_TAIL; + po->flags &= ~OPF_ATAIL; // most likely... + } } po->pp = pp; continue; @@ -3611,15 +3808,22 @@ static void resolve_branches_parse_calls(int opcnt) tailcall: po->op = OP_CALL; po->flags |= OPF_TAIL; - if (i > 0 && ops[i - 1].op == OP_POP) + prev_op = i > 0 ? ops[i - 1].op : OP_UD2; + if (prev_op == OP_POP) + po->flags |= OPF_ATAIL; + if (g_stack_fsz + g_bp_frame == 0 && prev_op != OP_PUSH + && (g_func_pp == NULL || g_func_pp->argc_stack > 0)) + { po->flags |= OPF_ATAIL; + } i--; // reprocess } } static void scan_prologue_epilogue(int opcnt) { - int ecx_push = 0, esp_sub = 0; + int ecx_push = 0, esp_sub = 0, pusha = 0; + int sandard_epilogue; int found; int i, j, l; @@ -3633,14 +3837,19 @@ static void scan_prologue_epilogue(int opcnt) ops[1].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; i = 2; - if (ops[2].op == OP_SUB && IS(opr_name(&ops[2], 0), "esp")) { - g_stack_fsz = opr_const(&ops[2], 1); - ops[2].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; + if (ops[i].op == OP_PUSHA) { + ops[i].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; + pusha = 1; + i++; + } + + if (ops[i].op == OP_SUB && IS(opr_name(&ops[i], 0), "esp")) { + g_stack_fsz = opr_const(&ops[i], 1); + ops[i].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; i++; } else { // another way msvc builds stack frame.. - i = 2; while (ops[i].op == OP_PUSH && IS(opr_name(&ops[i], 0), "ecx")) { g_stack_fsz += 4; ops[i].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; @@ -3674,10 +3883,20 @@ static void scan_prologue_epilogue(int opcnt) j--; } - if ((ops[j].op == OP_POP && IS(opr_name(&ops[j], 0), "ebp")) - || ops[j].op == OP_LEAVE) + sandard_epilogue = 0; + if (ops[j].op == OP_POP && IS(opr_name(&ops[j], 0), "ebp")) + { + ops[j].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; + // the standard epilogue is sometimes even used without a sf + if (ops[j - 1].op == OP_MOV + && IS(opr_name(&ops[j - 1], 0), "esp") + && IS(opr_name(&ops[j - 1], 1), "ebp")) + sandard_epilogue = 1; + } + else if (ops[j].op == OP_LEAVE) { ops[j].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; + sandard_epilogue = 1; } else if (ops[i].op == OP_CALL && ops[i].pp != NULL && ops[i].pp->is_noreturn) @@ -3690,13 +3909,10 @@ static void scan_prologue_epilogue(int opcnt) else if (!(g_ida_func_attr & IDAFA_NORETURN)) ferr(&ops[j], "'pop ebp' expected\n"); - if (g_stack_fsz != 0) { + if (g_stack_fsz != 0 || sandard_epilogue) { if (ops[j].op == OP_LEAVE) j--; - else if (ops[j].op == OP_POP - && ops[j - 1].op == OP_MOV - && IS(opr_name(&ops[j - 1], 0), "esp") - && IS(opr_name(&ops[j - 1], 1), "ebp")) + else if (sandard_epilogue) // mov esp, ebp { ops[j - 1].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; j -= 2; @@ -3713,6 +3929,13 @@ static void scan_prologue_epilogue(int opcnt) } } + if (pusha) { + if (ops[j].op == OP_POPA) + ops[j].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; + else + ferr(&ops[j], "popa expected\n"); + } + found = 1; i++; } while (i < opcnt); @@ -3739,6 +3962,20 @@ static void scan_prologue_epilogue(int opcnt) { g_stack_fsz = ops[i].operand[1].val; ops[i].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; + i++; + esp_sub = 1; + break; + } + else if (ops[i].op == OP_MOV && ops[i].operand[0].reg == xAX + && ops[i].operand[1].type == OPT_CONST + && ops[i + 1].op == OP_CALL + && IS(opr_name(&ops[i + 1], 0), "__alloca_probe")) + { + g_stack_fsz += ops[i].operand[1].val; + ops[i].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; + i++; + ops[i].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; + i++; esp_sub = 1; break; } @@ -3781,11 +4018,11 @@ static void scan_prologue_epilogue(int opcnt) { g_sp_frame = 1; - i++; do { for (; i < opcnt; i++) if (ops[i].flags & OPF_TAIL) break; + j = i - 1; if (i == opcnt && (ops[j].flags & OPF_JMP)) { if (ops[j].bt_i != -1 || ops[j].btj != NULL) @@ -3806,13 +4043,22 @@ static void scan_prologue_epilogue(int opcnt) l += ops[j].operand[1].val / 4 - 1; } else - ferr(&ops[j], "'pop ecx' expected\n"); + break; ops[j].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; j--; } - if (l != ecx_push) + if (l != ecx_push) { + if (i < opcnt && ops[i].op == OP_CALL + && ops[i].pp != NULL && ops[i].pp->is_noreturn) + { + // noreturn tailcall with no epilogue + i++; + found = 1; + continue; + } ferr(&ops[j], "epilogue scan failed\n"); + } found = 1; } @@ -3820,12 +4066,25 @@ static void scan_prologue_epilogue(int opcnt) if (esp_sub) { if (ops[j].op != OP_ADD || !IS(opr_name(&ops[j], 0), "esp") - || ops[j].operand[1].type != OPT_CONST - || ops[j].operand[1].val != g_stack_fsz) + || ops[j].operand[1].type != OPT_CONST) + { + if (i < opcnt && ops[i].op == OP_CALL + && ops[i].pp != NULL && ops[i].pp->is_noreturn) + { + // noreturn tailcall with no epilogue + i++; + found = 1; + continue; + } ferr(&ops[j], "'add esp' expected\n"); + } - ops[j].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; - ops[j].operand[1].val = 0; // hack for stack arg scanner + if (ops[j].operand[1].val < g_stack_fsz) + ferr(&ops[j], "esp adj is too low (need %d)\n", g_stack_fsz); + + ops[j].operand[1].val -= g_stack_fsz; // for stack arg scanner + if (ops[j].operand[1].val == 0) + ops[j].flags |= OPF_RMD | OPF_DONE | OPF_NOREGS; found = 1; } @@ -3848,10 +4107,6 @@ static int resolve_origin(int i, const struct parsed_opr *opr, struct label_ref *lr; int ret = 0; - if (ops[i].cc_scratch == magic) - return 0; - ops[i].cc_scratch = magic; - while (1) { if (g_labels[i] != NULL) { lr = &g_label_refs[i]; @@ -3880,10 +4135,9 @@ static int resolve_origin(int i, const struct parsed_opr *opr, continue; if (*op_i >= 0) { - if (*op_i == i) + if (*op_i == i || are_ops_same(&ops[*op_i], &ops[i])) return ret | 1; - // XXX: could check if the other op does the same return -1; } @@ -3902,10 +4156,6 @@ static int resolve_last_ref(int i, const struct parsed_opr *opr, struct label_ref *lr; int ret = 0; - if (ops[i].cc_scratch == magic) - return 0; - ops[i].cc_scratch = magic; - while (1) { if (g_labels[i] != NULL) { lr = &g_label_refs[i]; @@ -3936,6 +4186,45 @@ static int resolve_last_ref(int i, const struct parsed_opr *opr, } } +// adjust datap of all reachable 'op' insns when moving back +// returns 1 if at least 1 op was found +// returns -1 if path without an op was found +static int adjust_prev_op(int i, enum op_op op, int magic, void *datap) +{ + struct label_ref *lr; + int ret = 0; + + if (ops[i].cc_scratch == magic) + return 0; + ops[i].cc_scratch = magic; + + while (1) { + if (g_labels[i] != NULL) { + lr = &g_label_refs[i]; + for (; lr != NULL; lr = lr->next) { + check_i(&ops[i], lr->i); + ret |= adjust_prev_op(lr->i, op, magic, datap); + } + if (i > 0 && LAST_OP(i - 1)) + return ret; + } + + i--; + if (i < 0) + return -1; + + if (ops[i].cc_scratch == magic) + return 0; + ops[i].cc_scratch = magic; + + if (ops[i].op != op) + continue; + + ops[i].datap = datap; + return 1; + } +} + // find next instruction that reads opr // *op_i must be set to -1 by the caller // on return, *op_i is set to first referencer insn @@ -3978,11 +4267,13 @@ static int find_next_read(int i, int opcnt, } if (!is_opr_read(opr, po)) { - if (is_opr_modified(opr, po) - && (po->op == OP_CALL - || ((po->flags & OPF_DATA) - && po->operand[0].lmod == OPLM_DWORD))) + int full_opr = 1; + if (opr->type == OPT_REG && po->operand[0].type == OPT_REG + && opr->reg == po->operand[0].reg && (po->flags & OPF_DATA)) { + full_opr = po->operand[0].lmod >= opr->lmod; + } + if (is_opr_modified(opr, po) && full_opr) { // it's overwritten return ret; } @@ -4001,6 +4292,65 @@ static int find_next_read(int i, int opcnt, return 0; } +// find next instruction that reads opr +// *op_i must be set to -1 by the caller +// on return, *op_i is set to first flag user insn +// returns 1 if exactly 1 flag user is found +static int find_next_flag_use(int i, int opcnt, int magic, int *op_i) +{ + struct parsed_op *po; + int j, ret = 0; + + for (; i < opcnt; i++) + { + if (ops[i].cc_scratch == magic) + return ret; + ops[i].cc_scratch = magic; + + po = &ops[i]; + if (po->op == OP_CALL) + return -1; + if (po->flags & OPF_JMP) { + if (po->btj != NULL) { + // jumptable + for (j = 0; j < po->btj->count; j++) { + check_i(po, po->btj->d[j].bt_i); + ret |= find_next_flag_use(po->btj->d[j].bt_i, opcnt, + magic, op_i); + } + return ret; + } + + if (po->flags & OPF_RMD) + continue; + check_i(po, po->bt_i); + if (po->flags & OPF_CJMP) + goto found; + else + i = po->bt_i - 1; + continue; + } + + if (!(po->flags & OPF_CC)) { + if (po->flags & OPF_FLAGS) + // flags changed + return ret; + if (po->flags & OPF_TAIL) + return ret; + continue; + } + +found: + if (*op_i >= 0) + return -1; + + *op_i = i; + return 1; + } + + return 0; +} + static int try_resolve_const(int i, const struct parsed_opr *opr, int magic, unsigned int *val) { @@ -4020,84 +4370,157 @@ 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) +static int resolve_used_bits(int i, int opcnt, int reg, + int *mask, int *is_z_check) +{ + struct parsed_opr opr = OPR_INIT(OPT_REG, OPLM_WORD, reg); + int j = -1, k = -1; + int ret; + + ret = find_next_read(i, opcnt, &opr, i + opcnt * 20, &j); + if (ret != 1) + return -1; + + find_next_read(j + 1, opcnt, &opr, i + opcnt * 20 + 1, &k); + if (k != -1) { + fnote(&ops[j], "(first read)\n"); + ferr(&ops[k], "TODO: bit resolve: multiple readers\n"); + } + + if (ops[j].op != OP_TEST || ops[j].operand[1].type != OPT_CONST) + ferr(&ops[j], "TODO: bit resolve: not a const test\n"); + + ferr_assert(&ops[j], ops[j].operand[0].type == OPT_REG); + ferr_assert(&ops[j], ops[j].operand[0].reg == reg); + + *mask = ops[j].operand[1].val; + if (ops[j].operand[0].lmod == OPLM_BYTE + && ops[j].operand[0].name[1] == 'h') + { + *mask <<= 8; + } + ferr_assert(&ops[j], (*mask & ~0xffff) == 0); + + *is_z_check = 0; + ret = find_next_flag_use(j + 1, opcnt, i + opcnt * 20 + 2, &k); + if (ret == 1) + *is_z_check = ops[k].pfo == PFO_Z; + + return 0; +} + +static const struct parsed_proto *resolve_deref(int i, int magic, + struct parsed_opr *opr, int level) { + struct parsed_opr opr_s = OPR_INIT(OPT_REG, OPLM_DWORD, 0); const struct parsed_proto *pp = NULL; - int search_advice = 0; - int offset = -1; - char name[256]; + int from_caller = 0; char s_reg[4]; - int reg, len; + int offset = 0; + int len = 0; + int j = -1; + int k = -1; + int reg; int ret; - *multi_src = 0; - *pp_i = -1; + ret = sscanf(opr->name, "%3s+%x%n", s_reg, &offset, &len); + if (ret != 2 || len != strlen(opr->name)) { + ret = sscanf(opr->name, "%3s%n", s_reg, &len); + if (ret != 1 || len != strlen(opr->name)) + return NULL; + } - 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; + reg = char_array_i(regs_r32, ARRAY_SIZE(regs_r32), s_reg); + if (reg < 0) + return NULL; + + opr_s.reg = reg; + ret = resolve_origin(i, &opr_s, i + magic, &j, NULL); + if (ret != 1) + return NULL; + + if (ops[j].op == OP_MOV && ops[j].operand[1].type == OPT_REGMEM + && strlen(ops[j].operand[1].name) == 3 + && ops[j].operand[0].lmod == OPLM_DWORD + && ops[j].pp == NULL // no hint + && level == 0) + { + // allow one simple dereference (com/directx) + reg = char_array_i(regs_r32, ARRAY_SIZE(regs_r32), + ops[j].operand[1].name); + if (reg < 0) + return NULL; + opr_s.reg = reg; + ret = resolve_origin(j, &opr_s, j + magic, &k, NULL); + if (ret != 1) + return NULL; + j = k; + } + if (ops[j].op != OP_MOV || ops[j].operand[0].lmod != OPLM_DWORD) + return NULL; + + if (ops[j].pp != NULL) { + // type hint in asm + pp = ops[j].pp; + } + else if (ops[j].operand[1].type == OPT_REGMEM) { + pp = try_recover_pp(&ops[j], &ops[j].operand[1], 0, NULL); + if (pp == NULL) { + // maybe structure ptr in structure + pp = resolve_deref(j, magic, &ops[j].operand[1], level + 1); + } + } + else if (ops[j].operand[1].type == OPT_LABEL) + pp = proto_parse(g_fhdr, ops[j].operand[1].name, g_quiet_pp); + else if (ops[j].operand[1].type == OPT_REG) { + // maybe arg reg? + k = -1; + ret = resolve_origin(j, &ops[j].operand[1], i + magic, + &k, &from_caller); + if (ret != 1 && from_caller && k == -1 && g_func_pp != NULL) { + for (k = 0; k < g_func_pp->argc; k++) { + if (g_func_pp->arg[k].reg == NULL) + continue; + if (IS(g_func_pp->arg[k].reg, ops[j].operand[1].name)) { + pp = g_func_pp->arg[k].pp; break; } - pp = proto_lookup_struct(g_fhdr, pp->type.name, offset); } - break; } + } + + if (pp == NULL) + return NULL; + if (pp->is_func || pp->is_fptr || !pp->type.is_struct) { + if (offset != 0) + ferr(&ops[j], "expected struct, got '%s %s'\n", + pp->type.name, pp->name); + return NULL; + } + + return proto_lookup_struct(g_fhdr, pp->type.name, offset); +} + +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: + // try to resolve struct member calls + pp = resolve_deref(i, i + opcnt * 19, &ops[i].operand[0], 0); + if (pp != NULL) + break; // fallthrough case OPT_LABEL: case OPT_OFFSET: - pp = try_recover_pp(&ops[i], &ops[i].operand[0], &search_advice); + pp = try_recover_pp(&ops[i], &ops[i].operand[0], + 1, &search_advice); if (!search_advice) break; // fallthrough @@ -4253,6 +4676,9 @@ static struct parsed_proto *process_call(int i, int opcnt) ferr(po, "too many args for '%s'\n", tmpname); } if (pp->argc_stack > adj / 4) { + if (pp->is_noreturn) + // assume no stack adjust was emited + goto out; fnote(po, "(this call)\n"); ferr(&ops[ret], "stack tracking failed for '%s': %x %x\n", tmpname, pp->argc_stack * 4, adj); @@ -4265,12 +4691,75 @@ static struct parsed_proto *process_call(int i, int opcnt) ferr(po, "missing esp_adjust for vararg func '%s'\n", pp->name); +out: return pp; } -static int collect_call_args_early(struct parsed_op *po, int i, - struct parsed_proto *pp, int *regmask) +static int collect_call_args_no_push(int i, struct parsed_proto *pp, + int *regmask_ffca) { + struct parsed_op *po; + int offset = 0; + int base_arg; + int j, arg; + int ret; + + for (base_arg = 0; base_arg < pp->argc; base_arg++) + if (pp->arg[base_arg].reg == NULL) + break; + + for (j = i; j > 0; ) + { + ferr_assert(&ops[j], g_labels[j] == NULL); + j--; + + po = &ops[j]; + ferr_assert(po, po->op != OP_PUSH); + if (po->op == OP_FST) + { + if (po->operand[0].type != OPT_REGMEM) + continue; + ret = parse_stack_esp_offset(po, po->operand[0].name, &offset); + if (ret != 0) + continue; + if (offset < 0 || offset >= pp->argc_stack * 4 || (offset & 3)) { + //ferr(po, "offset %d, %d args\n", offset, pp->argc_stack); + continue; + } + + arg = base_arg + offset / 4; + po->p_argnext = -1; + po->p_argnum = arg + 1; + ferr_assert(po, pp->arg[arg].datap == NULL); + pp->arg[arg].datap = po; + po->flags |= OPF_DONE | OPF_FARGNR | OPF_FARG; + if (regmask_ffca != NULL) + *regmask_ffca |= 1 << arg; + } + else if (po->op == OP_SUB && po->operand[0].reg == xSP + && po->operand[1].type == OPT_CONST) + { + po->flags |= OPF_RMD | OPF_DONE | OPF_FARGNR | OPF_FARG; + break; + } + } + + for (arg = base_arg; arg < pp->argc; arg++) { + ferr_assert(&ops[i], pp->arg[arg].reg == NULL); + po = pp->arg[arg].datap; + if (po == NULL) + ferr(&ops[i], "arg %d/%d not found\n", arg, pp->argc); + if (po->operand[0].lmod == OPLM_QWORD) + arg++; + } + + return 0; +} + +static int collect_call_args_early(int i, struct parsed_proto *pp, + int *regmask, int *regmask_ffca) +{ + struct parsed_op *po; int arg, ret; int j; @@ -4285,20 +4774,23 @@ static int collect_call_args_early(struct parsed_op *po, int i, return -1; j--; - if (ops[j].op == OP_CALL) + po = &ops[j]; + if (po->op == OP_CALL) return -1; - else if (ops[j].op == OP_ADD && ops[j].operand[0].reg == xSP) + else if (po->op == OP_ADD && po->operand[0].reg == xSP) return -1; - else if (ops[j].op == OP_POP) + else if (po->op == OP_POP) return -1; - else if (ops[j].flags & OPF_CJMP) + else if (po->flags & OPF_CJMP) return -1; - else if (ops[j].op == OP_PUSH) { - if (ops[j].flags & (OPF_FARG|OPF_FARGNR)) - return -1; - ret = scan_for_mod(&ops[j], j + 1, i, 1); - if (ret >= 0) + else if (po->op == OP_PUSH) { + if (po->flags & (OPF_FARG|OPF_FARGNR)) return -1; + if (!g_header_mode) { + ret = scan_for_mod(po, j + 1, i, 1); + if (ret >= 0) + return -1; + } if (pp->arg[arg].type.is_va_list) return -1; @@ -4308,6 +4800,17 @@ static int collect_call_args_early(struct parsed_op *po, int i, if (pp->arg[arg].reg == NULL) break; } + else if (po->op == OP_SUB && po->operand[0].reg == xSP + && po->operand[1].type == OPT_CONST) + { + if (po->flags & (OPF_RMD|OPF_DONE)) + return -1; + if (po->operand[1].val != pp->argc_stack * 4) + ferr(po, "unexpected esp adjust: %d\n", + po->operand[1].val * 4); + ferr_assert(po, pp->argc - arg == pp->argc_stack); + return collect_call_args_no_push(i, pp, regmask_ffca); + } } if (arg < pp->argc) @@ -4328,7 +4831,7 @@ static int collect_call_args_early(struct parsed_op *po, int i, ferr_assert(&ops[j], pp->arg[arg].datap == NULL); pp->arg[arg].datap = &ops[j]; - if (ops[j].operand[0].type == OPT_REG) + if (regmask != NULL && ops[j].operand[0].type == OPT_REG) *regmask |= 1 << ops[j].operand[0].reg; ops[j].flags |= OPF_RMD | OPF_DONE | OPF_FARGNR | OPF_FARG; @@ -4344,9 +4847,31 @@ static int collect_call_args_early(struct parsed_op *po, int i, return 0; } +static int sync_argnum(struct parsed_op *po, int argnum) +{ + struct parsed_op *po_tmp; + + // see if other branches don't have higher argnum + for (po_tmp = po; po_tmp != NULL; ) { + if (argnum < po_tmp->p_argnum) + argnum = po_tmp->p_argnum; + // note: p_argnext is active on current collect_call_args only + po_tmp = po_tmp->p_argnext >= 0 ? &ops[po_tmp->p_argnext] : NULL; + } + + // make all argnums consistent + for (po_tmp = po; po_tmp != NULL; ) { + if (po_tmp->p_argnum != 0) + po_tmp->p_argnum = argnum; + po_tmp = po_tmp->p_argnext >= 0 ? &ops[po_tmp->p_argnext] : NULL; + } + + return argnum; +} + static int collect_call_args_r(struct parsed_op *po, int i, - struct parsed_proto *pp, int *regmask, int *save_arg_vars, - int *arg_grp, int arg, int magic, int need_op_saving, int may_reuse) + struct parsed_proto *pp, int *regmask, int *arg_grp, + int arg, int argnum, int magic, int need_op_saving, int may_reuse) { struct parsed_proto *pp_tmp; struct parsed_op *po_tmp; @@ -4354,7 +4879,6 @@ static int collect_call_args_r(struct parsed_op *po, int i, int need_to_save_current; int arg_grp_current = 0; int save_args_seen = 0; - int save_args; int ret = 0; int reg; char buf[32]; @@ -4365,7 +4889,7 @@ static int collect_call_args_r(struct parsed_op *po, int i, return -1; } - for (; arg < pp->argc; arg++) + for (; arg < pp->argc; arg++, argnum++) if (pp->arg[arg].reg == NULL) break; magic = (magic & 0xffffff) | (arg << 24); @@ -4391,8 +4915,8 @@ static int collect_call_args_r(struct parsed_op *po, int i, check_i(&ops[j], lr->i); if ((ops[lr->i].flags & (OPF_JMP|OPF_CJMP)) != OPF_JMP) may_reuse = 1; - ret = collect_call_args_r(po, lr->i, pp, regmask, save_arg_vars, - arg_grp, arg, magic, need_op_saving, may_reuse); + ret = collect_call_args_r(po, lr->i, pp, regmask, arg_grp, + arg, argnum, magic, need_op_saving, may_reuse); if (ret < 0) return ret; } @@ -4406,8 +4930,8 @@ static int collect_call_args_r(struct parsed_op *po, int i, continue; } need_op_saving = 1; - ret = collect_call_args_r(po, lr->i, pp, regmask, save_arg_vars, - arg_grp, arg, magic, need_op_saving, may_reuse); + ret = collect_call_args_r(po, lr->i, pp, regmask, arg_grp, + arg, argnum, magic, need_op_saving, may_reuse); if (ret < 0) return ret; } @@ -4420,8 +4944,8 @@ static int collect_call_args_r(struct parsed_op *po, int i, pp_tmp = ops[j].pp; if (pp_tmp == NULL) - ferr(po, "arg collect hit unparsed call '%s'\n", - ops[j].operand[0].name); + ferr(po, "arg collect %d/%d hit unparsed call '%s'\n", + arg, pp->argc, ops[j].operand[0].name); if (may_reuse && pp_tmp->argc_stack > 0) ferr(po, "arg collect %d/%d hit '%s' with %d stack args\n", arg, pp->argc, opr_name(&ops[j], 0), pp_tmp->argc_stack); @@ -4465,8 +4989,9 @@ static int collect_call_args_r(struct parsed_op *po, int i, ops[j].p_argnext = po_tmp - ops; pp->arg[arg].datap = &ops[j]; + argnum = sync_argnum(&ops[j], argnum); + need_to_save_current = 0; - save_args = 0; reg = -1; if (ops[j].operand[0].type == OPT_REG) reg = ops[j].operand[0].reg; @@ -4476,25 +5001,15 @@ static int collect_call_args_r(struct parsed_op *po, int i, need_to_save_current = (ret >= 0); } if (need_op_saving || need_to_save_current) { - // mark this push as one that needs operand saving - ops[j].flags &= ~OPF_RMD; - if (ops[j].p_argnum == 0) { - ops[j].p_argnum = arg + 1; - save_args |= 1 << arg; - } - else if (ops[j].p_argnum < arg + 1) { - // XXX: might kill valid var.. - //*save_arg_vars &= ~(1 << (ops[j].p_argnum - 1)); - ops[j].p_argnum = arg + 1; - save_args |= 1 << arg; - } + // mark this arg as one that needs operand saving + pp->arg[arg].is_saved = 1; - if (save_args_seen & (1 << (ops[j].p_argnum - 1))) { + if (save_args_seen & (1 << (argnum - 1))) { save_args_seen = 0; arg_grp_current++; if (arg_grp_current >= MAX_ARG_GRP) ferr(&ops[j], "out of arg groups (arg%d), f %s\n", - ops[j].p_argnum, pp->name); + argnum, pp->name); } } else if (ops[j].p_argnum == 0) @@ -4530,7 +5045,7 @@ static int collect_call_args_r(struct parsed_op *po, int i, { ops[k].flags |= OPF_RMD | OPF_NOREGS | OPF_DONE; ops[j].flags |= OPF_RMD | OPF_NOREGS | OPF_VAPUSH; - save_args &= ~(1 << arg); + pp->arg[arg].is_saved = 0; reg = -1; } else @@ -4546,23 +5061,27 @@ static int collect_call_args_r(struct parsed_op *po, int i, ops[k].flags |= OPF_RMD | OPF_DONE; ops[j].flags |= OPF_RMD; ops[j].p_argpass = ret + 1; - save_args &= ~(1 << arg); + pp->arg[arg].is_saved = 0; reg = -1; } } } } - *save_arg_vars |= save_args; + if (pp->arg[arg].is_saved) { + ops[j].flags &= ~OPF_RMD; + ops[j].p_argnum = argnum; + } // tracking reg usage if (reg >= 0) *regmask |= 1 << reg; arg++; + argnum++; if (!pp->is_unresolved) { // next arg - for (; arg < pp->argc; arg++) + for (; arg < pp->argc; arg++, argnum++) if (pp->arg[arg].reg == NULL) break; } @@ -4590,19 +5109,17 @@ static int collect_call_args_r(struct parsed_op *po, int i, } static int collect_call_args(struct parsed_op *po, int i, - struct parsed_proto *pp, int *regmask, int *save_arg_vars, - int magic) + struct parsed_proto *pp, int *regmask, int magic) { // arg group is for cases when pushes for // multiple funcs are going on struct parsed_op *po_tmp; - int save_arg_vars_current = 0; int arg_grp = 0; int ret; int a; - ret = collect_call_args_r(po, i, pp, regmask, - &save_arg_vars_current, &arg_grp, 0, magic, 0, 0); + ret = collect_call_args_r(po, i, pp, regmask, &arg_grp, + 0, 1, magic, 0, 0); if (ret < 0) return ret; @@ -4615,14 +5132,10 @@ static int collect_call_args(struct parsed_op *po, int i, po_tmp = pp->arg[a].datap; while (po_tmp != NULL) { po_tmp->p_arggrp = arg_grp; - if (po_tmp->p_argnext > 0) - po_tmp = &ops[po_tmp->p_argnext]; - else - po_tmp = NULL; + po_tmp = po_tmp->p_argnext >= 0 ? &ops[po_tmp->p_argnext] : NULL; } } } - save_arg_vars[arg_grp] |= save_arg_vars_current; if (pp->is_unresolved) { pp->argc += ret; @@ -4641,7 +5154,6 @@ 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; @@ -4693,9 +5205,10 @@ static void reg_use_pass(int i, int opcnt, unsigned char *cbits, flags_set = OPF_RSAVE | OPF_DONE; } - ret = scan_for_pop(i + 1, opcnt, i + opcnt * 3, reg, 0, 0); + ret = scan_for_pop(i + 1, opcnt, i + opcnt * 3, reg, 0, 0, 0); if (ret == 1) { - scan_for_pop(i + 1, opcnt, i + opcnt * 4, reg, 0, flags_set); + scan_for_pop(i + 1, opcnt, i + opcnt * 4, + reg, 0, 0, flags_set); } else { ret = scan_for_pop_ret(i + 1, opcnt, po->operand[0].reg, 0); @@ -4741,20 +5254,15 @@ static void reg_use_pass(int i, int opcnt, unsigned char *cbits, po->regmask_dst &= ~(1 << xAX); } } + + // not "full stack" mode and have something in stack + if (!(regmask_now & mxST7_2) && (regmask_now & mxST1_0)) + ferr(po, "float stack is not empty on func call\n"); } 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 @@ -4787,22 +5295,42 @@ static void reg_use_pass(int i, int opcnt, unsigned char *cbits, } } + if (po->flags & OPF_FPUSH) { + if (regmask_now & mxST1) + regmask_now |= mxSTa; // switch to "full stack" mode + if (regmask_now & mxSTa) + po->flags |= OPF_FSHIFT; + if (!(regmask_now & mxST7_2)) { + regmask_now = + (regmask_now & ~mxST1_0) | ((regmask_now & mxST0) << 1); + } + } + regmask_now |= regmask_op; *regmask |= regmask_now; // released regs if (po->flags & OPF_FPOP) { - mask = mxST0 | mxST1; - if (!(regmask_now & mask)) + if ((regmask_now & mxSTa) == 0) ferr(po, "float pop on empty stack?\n"); - if (regmask_now & mxST1) + if (regmask_now & (mxST7_2 | mxST1)) po->flags |= OPF_FSHIFT; - regmask_now = (regmask_now & ~mask) | ((regmask_now & mxST1) >> 1); + if (!(regmask_now & mxST7_2)) { + regmask_now = + (regmask_now & ~mxST1_0) | ((regmask_now & mxST1) >> 1); + } } if (po->flags & OPF_TAIL) { - if (regmask_now & (mxST0 | mxST1)) - ferr(po, "float regs on tail: %x\n", regmask_now); + if (!(regmask_now & mxST7_2)) { + if (get_pp_arg_regmask_dst(g_func_pp) & mxST0) { + if (!(regmask_now & mxST0)) + ferr(po, "no st0 on float return, mask: %x\n", + regmask_now); + } + else if (regmask_now & mxST1_0) + ferr(po, "float regs on tail: %x\n", regmask_now); + } // there is support for "conditional tailcall", sort of if (!(po->flags & OPF_CC)) @@ -4886,9 +5414,11 @@ static void output_pp(FILE *fout, const struct parsed_proto *pp, for (i = 0; i < pp->argc; i++) { if (i > 0) fprintf(fout, ", "); - if (pp->arg[i].fptr != NULL && !(flags & OPP_SIMPLE_ARGS)) { + if (pp->arg[i].pp != NULL && pp->arg[i].pp->is_func + && !(flags & OPP_SIMPLE_ARGS)) + { // func pointer - output_pp(fout, pp->arg[i].fptr, 0); + output_pp(fout, pp->arg[i].pp, 0); } else if (pp->arg[i].type.is_retreg) { fprintf(fout, "u32 *r_%s", pp->arg[i].reg); @@ -4928,23 +5458,30 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) char buf1[256], buf2[256], buf3[256], cast[64]; struct parsed_proto *pp, *pp_tmp; struct parsed_data *pd; - unsigned int uval; int save_arg_vars[MAX_ARG_GRP] = { 0, }; unsigned char cbits[MAX_OPS / 8]; - int cond_vars = 0; + const char *float_type; + const char *float_st0; + const char *float_st1; + int need_float_stack = 0; + int need_float_sw = 0; // status word int need_tmp_var = 0; int need_tmp64 = 0; + int cond_vars = 0; int had_decl = 0; int label_pending = 0; - int regmask_save = 0; // regs saved/restored in this func + int need_double = 0; + int regmask_save = 0; // used regs saved/restored in this func int regmask_arg; // regs from this function args (fastcall, etc) int regmask_ret; // regs needed on ret int regmask_now; // temp int regmask_init = 0; // regs that need zero initialization int regmask_pp = 0; // regs used in complex push-pop graph + int regmask_ffca = 0; // float function call args int regmask = 0; // used regs int pfomask = 0; int found = 0; + int dead_dst; int no_output; int i, j, l; int arg; @@ -4998,10 +5535,12 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) { pp = process_call_early(i, opcnt, &j); if (pp != NULL) { - if (!(po->flags & OPF_ATAIL)) + if (!(po->flags & OPF_ATAIL)) { // since we know the args, try to collect them - if (collect_call_args_early(po, i, pp, ®mask) != 0) + ret = collect_call_args_early(i, pp, ®mask, ®mask_ffca); + if (ret != 0) pp = NULL; + } } if (pp != NULL) { @@ -5027,8 +5566,11 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) // - process calls, stage 2 // - handle some push/pop pairs // - scan for STD/CLD, propagate DF + // - try to resolve needed x87 status word bits for (i = 0; i < opcnt; i++) { + int mask, z_check; + po = &ops[i]; if (po->flags & OPF_RMD) continue; @@ -5040,8 +5582,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) if (!pp->is_unresolved && !(po->flags & OPF_ATAIL)) { // since we know the args, collect them - collect_call_args(po, i, pp, ®mask, save_arg_vars, - i + opcnt * 2); + collect_call_args(po, i, pp, ®mask, i + opcnt * 2); } // for unresolved, collect after other passes } @@ -5064,16 +5605,39 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) if (po->flags & OPF_DONE) continue; - if (po->op == OP_PUSH && !(po->flags & OPF_FARG) - && !(po->flags & OPF_RSAVE) && po->operand[0].type == OPT_CONST) - { - scan_for_pop_const(i, opcnt, i + opcnt * 12); - } - else if (po->op == OP_POP) + switch (po->op) { + case OP_PUSH: + if (!(po->flags & OPF_FARG) && !(po->flags & OPF_RSAVE) + && po->operand[0].type == OPT_CONST) + { + scan_for_pop_const(i, opcnt, i + opcnt * 12); + } + break; + + case OP_POP: scan_pushes_for_pop(i, opcnt, ®mask_pp); - else if (po->op == OP_STD) { + break; + + case OP_STD: po->flags |= OPF_DF | OPF_RMD | OPF_DONE; scan_propagate_df(i + 1, opcnt); + break; + + case OP_FNSTSW: + need_float_sw = 1; + if (po->operand[0].type != OPT_REG || po->operand[0].reg != xAX) + ferr(po, "TODO: fnstsw to mem\n"); + ret = resolve_used_bits(i + 1, opcnt, xAX, &mask, &z_check); + if (ret != 0) + ferr(po, "fnstsw resolve failed\n"); + ret = adjust_prev_op(i, OP_FCOM, i + opcnt * 21, + (void *)(long)(mask | (z_check << 16))); + if (ret != 1) + ferr(po, "failed to find fcom: %d\n", ret); + break; + + default: + break; } } @@ -5084,10 +5648,13 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) reg_use_pass(0, opcnt, cbits, regmask_init, ®mask, 0, ®mask_save, ®mask_init, regmask_arg); + need_float_stack = !!(regmask & mxST7_2); + // pass7: // - find flag set ops for their users // - do unresolved calls // - declare indirect functions + // - other op specific processing for (i = 0; i < opcnt; i++) { po = &ops[i]; @@ -5098,7 +5665,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) { int setters[16], cnt = 0, branched = 0; - ret = scan_for_flag_set(i, i + opcnt * 6, + ret = scan_for_flag_set(i, opcnt, i + opcnt * 6, &branched, setters, &cnt); if (ret < 0 || cnt <= 0) ferr(po, "unable to trace flag setter(s)\n"); @@ -5152,35 +5719,41 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) cond_vars |= 1 << PFO_C; } - if (po->op == OP_CMPS || po->op == OP_SCAS) { + switch (po->op) { + case OP_CMPS: + case OP_SCAS: cond_vars |= 1 << PFO_Z; - } - else if (po->op == OP_MUL - || (po->op == OP_IMUL && po->operand_cnt == 1)) - { + break; + + case OP_MUL: if (po->operand[0].lmod == OPLM_DWORD) need_tmp64 = 1; - } - else if (po->op == OP_CALL) { + break; + + case OP_IMUL: + if (po->operand_cnt == 1 && po->operand[0].lmod == OPLM_DWORD) + need_tmp64 = 1; + break; + + case OP_CALL: // note: resolved non-reg calls are OPF_DONE already pp = po->pp; ferr_assert(po, pp != NULL); if (pp->is_unresolved) { int regmask_stack = 0; - collect_call_args(po, i, pp, ®mask, save_arg_vars, - i + opcnt * 2); + collect_call_args(po, i, pp, ®mask, i + opcnt * 2); // this is pretty rough guess: // see ecx and edx were pushed (and not their saved versions) for (arg = 0; arg < pp->argc; arg++) { - if (pp->arg[arg].reg != NULL) + if (pp->arg[arg].reg != NULL && !pp->arg[arg].is_saved) continue; tmp_op = pp->arg[arg].datap; if (tmp_op == NULL) ferr(po, "parsed_op missing for arg%d\n", arg); - if (tmp_op->p_argnum == 0 && tmp_op->operand[0].type == OPT_REG) + if (tmp_op->operand[0].type == OPT_REG) regmask_stack |= 1 << tmp_op->operand[0].reg; } @@ -5208,27 +5781,31 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) if (pp->argc_stack > 0) pp->is_stdcall = 1; } - } - else if (po->op == OP_MOV && po->operand[0].pp != NULL - && po->operand[1].pp != NULL) - { - // = offset - if ((po->operand[1].pp->is_func || po->operand[1].pp->is_fptr) - && !IS_START(po->operand[1].name, "off_")) + break; + + case OP_MOV: + if (po->operand[0].pp != NULL && po->operand[1].pp != NULL) { - if (!po->operand[0].pp->is_fptr) - ferr(po, "%s not declared as fptr when it should be\n", - po->operand[0].name); - if (pp_cmp_func(po->operand[0].pp, po->operand[1].pp)) { - pp_print(buf1, sizeof(buf1), po->operand[0].pp); - pp_print(buf2, sizeof(buf2), po->operand[1].pp); - fnote(po, "var: %s\n", buf1); - fnote(po, "func: %s\n", buf2); - ferr(po, "^ mismatch\n"); + // = offset + if ((po->operand[1].pp->is_func || po->operand[1].pp->is_fptr) + && !IS_START(po->operand[1].name, "off_")) + { + if (!po->operand[0].pp->is_fptr) + ferr(po, "%s not declared as fptr when it should be\n", + po->operand[0].name); + if (pp_cmp_func(po->operand[0].pp, po->operand[1].pp)) { + pp_print(buf1, sizeof(buf1), po->operand[0].pp); + pp_print(buf2, sizeof(buf2), po->operand[1].pp); + fnote(po, "var: %s\n", buf1); + fnote(po, "func: %s\n", buf2); + ferr(po, "^ mismatch\n"); + } } } - } - else if (po->op == OP_DIV || po->op == OP_IDIV) { + break; + + case OP_DIV: + case OP_IDIV: if (po->operand[0].lmod == OPLM_DWORD) { // 32bit division is common, look for it if (po->op == OP_DIV) @@ -5242,21 +5819,54 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) } else need_tmp_var = 1; - } - else if (po->op == OP_CLD) + break; + + case OP_CLD: po->flags |= OPF_RMD | OPF_DONE; - else if (po->op == OPP_FTOL) { + break; + + case OP_RCL: + case OP_RCR: + case OP_XCHG: + need_tmp_var = 1; + break; + + case OP_FLD: + if (po->operand[0].lmod == OPLM_QWORD) + need_double = 1; + break; + + case OPP_ALLSHL: + case OPP_ALLSHR: + need_tmp64 = 1; + break; + + case 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; + break; } - if (po->op == OP_RCL || po->op == OP_RCR || po->op == OP_XCHG) - need_tmp_var = 1; + default: + break; + } + + // this might need it's own pass... + if (po->op != OP_FST && po->p_argnum > 0) + save_arg_vars[po->p_arggrp] |= 1 << (po->p_argnum - 1); + + // correct for "full stack" mode late enable + if ((po->flags & (OPF_PPUSH|OPF_FPOP)) && need_float_stack) + po->flags |= OPF_FSHIFT; } + float_type = need_double ? "double" : "float"; + float_st0 = need_float_stack ? "f_st[f_stp & 7]" : "f_st0"; + float_st1 = need_float_stack ? "f_st[(f_stp + 1) & 7]" : "f_st1"; + // output starts here // define userstack size @@ -5413,18 +6023,30 @@ 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 (need_float_stack) { + fprintf(fout, " %s f_st[8];\n", float_type); + fprintf(fout, " int f_stp = 0;\n"); + had_decl = 1; + } + else { + if (regmask_now & 0xff0000) { + for (reg = 16; reg < 24; reg++) { + if (regmask_now & (1 << reg)) { + fprintf(fout, " %s f_st%d", float_type, reg - 16); + if (regmask_init & (1 << reg)) + fprintf(fout, " = 0"); + fprintf(fout, ";\n"); + had_decl = 1; + } } } } + if (need_float_sw) { + fprintf(fout, " u16 f_sw;\n"); + had_decl = 1; + } + if (regmask_save) { for (reg = 0; reg < 8; reg++) { if (regmask_save & (1 << reg)) { @@ -5446,6 +6068,15 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) } } + if (regmask_ffca) { + for (reg = 0; reg < 32; reg++) { + if (regmask_ffca & (1 << reg)) { + fprintf(fout, " %s fs_%d;\n", float_type, reg + 1); + had_decl = 1; + } + } + } + // declare push-pop temporaries if (regmask_pp) { for (reg = 0; reg < 8; reg++) { @@ -5582,32 +6213,6 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) pfomask = po->pfomask; - if (po->flags & (OPF_REPZ|OPF_REPNZ)) { - struct parsed_opr opr = OPR_INIT(OPT_REG, OPLM_DWORD, xCX); - ret = try_resolve_const(i, &opr, opcnt * 7 + i, &uval); - - if (ret != 1 || uval == 0) { - // we need initial flags for ecx=0 case.. - if (i > 0 && ops[i - 1].op == OP_XOR - && IS(ops[i - 1].operand[0].name, - ops[i - 1].operand[1].name)) - { - fprintf(fout, " cond_z = "); - if (pfomask & (1 << PFO_C)) - fprintf(fout, "cond_c = "); - fprintf(fout, "0;\n"); - } - else if (last_arith_dst != NULL) { - out_src_opr_u32(buf3, sizeof(buf3), po, last_arith_dst); - out_test_for_cc(buf1, sizeof(buf1), po, PFO_Z, 0, - last_arith_dst->lmod, buf3); - fprintf(fout, " cond_z = %s;\n", buf1); - } - else - ferr(po, "missing initial ZF\n"); - } - } - switch (po->op) { case OP_MOV: @@ -5691,6 +6296,12 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) strcpy(g_comment, "cdq"); break; + case OP_BSWAP: + assert_operand_cnt(1); + out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]); + fprintf(fout, " %s = __builtin_bswap32(%s);", buf1, buf1); + break; + case OP_LODS: if (po->flags & OPF_REP) { assert_operand_cnt(3); @@ -5757,7 +6368,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) if (po->flags & OPF_REP) { assert_operand_cnt(3); fprintf(fout, - " for (; ecx != 0; ecx--) {\n"); + " while (ecx != 0) {\n"); if (pfomask & (1 << PFO_C)) { // ugh.. fprintf(fout, @@ -5768,6 +6379,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) " cond_z = (%sesi == %sedi); esi %c= %d, edi %c= %d;\n", buf1, buf1, l, j, l, j); fprintf(fout, + " ecx--;\n" " if (cond_z %s 0) break;\n", (po->flags & OPF_REPZ) ? "==" : "!="); fprintf(fout, @@ -5795,12 +6407,13 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) if (po->flags & OPF_REP) { assert_operand_cnt(3); fprintf(fout, - " for (; ecx != 0; ecx--) {\n"); + " while (ecx != 0) {\n"); fprintf(fout, " cond_z = (%seax == %sedi); edi %c= %d;\n", lmod_cast_u(po, po->operand[1].lmod), lmod_cast_u_ptr(po, po->operand[1].lmod), l, j); fprintf(fout, + " ecx--;\n" " if (cond_z %s 0) break;\n", (po->flags & OPF_REPZ) ? "==" : "!="); fprintf(fout, @@ -5993,9 +6606,13 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) propagate_lmod(po, &po->operand[0], &po->operand[1]); if (IS(opr_name(po, 0), opr_name(po, 1))) { // special case for XOR - if (pfomask & (1 << PFO_BE)) { // weird, but it happens.. - fprintf(fout, " cond_be = 1;\n"); - pfomask &= ~(1 << PFO_BE); + int z = PFOB_O | PFOB_C | PFOB_S | (1 << PFO_L); + for (j = 0; j <= PFO_LE; j++) { + if (pfomask & (1 << j)) { + fprintf(fout, " cond_%s = %d;\n", + parsed_flag_op_names[j], (1 << j) & z ? 0 : 1); + pfomask &= ~(1 << j); + } } fprintf(fout, " %s = 0;", out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0])); @@ -6031,6 +6648,12 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) delayed_flag_op = NULL; break; } + if (pfomask & (1 << PFO_LE)) { + out_cmp_for_cc(buf1, sizeof(buf1), po, PFO_LE, 0, 1); + fprintf(fout, " cond_%s = %s;\n", + parsed_flag_op_names[PFO_LE], buf1); + pfomask &= ~(1 << PFO_LE); + } goto dualop_arith; case OP_SUB: @@ -6043,7 +6666,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) if (j == PFO_Z || j == PFO_S) continue; - out_cmp_for_cc(buf1, sizeof(buf1), po, j, 0); + out_cmp_for_cc(buf1, sizeof(buf1), po, j, 0, 0); fprintf(fout, " cond_%s = %s;\n", parsed_flag_op_names[j], buf1); pfomask &= ~(1 << j); @@ -6093,7 +6716,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) if (j == PFO_Z || j == PFO_S || j == PFO_C) continue; - out_cmp_for_cc(buf1, sizeof(buf1), po, j, 0); + out_cmp_for_cc(buf1, sizeof(buf1), po, j, 0, 0); fprintf(fout, " cond_%s = %s;\n", parsed_flag_op_names[j], buf1); pfomask &= ~(1 << j); @@ -6127,10 +6750,11 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) lmod_cast_s(po, po->operand[0].lmod), buf2); last_arith_dst = &po->operand[0]; delayed_flag_op = NULL; - if (pfomask & (1 << PFO_C)) { + if (pfomask & PFOB_C) { fprintf(fout, "\n cond_c = (%s != 0);", buf1); - pfomask &= ~(1 << PFO_C); + pfomask &= ~PFOB_C; } + output_std_flags(fout, po, &pfomask, buf1); break; case OP_IMUL: @@ -6322,7 +6946,11 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) fprintf(fout, "(u32)"); } else if (po->regmask_dst & mxST0) { - fprintf(fout, "f_st0 = "); + ferr_assert(po, po->flags & OPF_FPUSH); + if (need_float_stack) + fprintf(fout, "f_st[--f_stp & 7] = "); + else + fprintf(fout, "f_st0 = "); } } @@ -6332,10 +6960,13 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) pp->has_structarg ? "_sa" : ""); if (po->flags & OPF_ATAIL) { - if (pp->argc_stack != g_func_pp->argc_stack - || (pp->argc_stack > 0 - && pp->is_stdcall != g_func_pp->is_stdcall)) - ferr(po, "incompatible tailcall\n"); + int check_compat = + g_func_pp->is_stdcall && g_func_pp->argc_stack > 0; + check_compat |= pp->argc_stack > 0; + if (check_compat + && (pp->argc_stack != g_func_pp->argc_stack + || pp->is_stdcall != g_func_pp->is_stdcall)) + ferr(po, "incompatible arg-reuse tailcall\n"); if (g_func_pp->has_retreg) ferr(po, "TODO: retreg+tailcall\n"); @@ -6373,6 +7004,13 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) if (pp->arg[arg].reg != NULL) { if (pp->arg[arg].type.is_retreg) fprintf(fout, "&%s", pp->arg[arg].reg); + else if (IS(pp->arg[arg].reg, "ebp") + && g_bp_frame && !(po->flags & OPF_EBP_S)) + { + // rare special case + fprintf(fout, "%s(u32)&sf.b[sizeof(sf)]", cast); + strcat(g_comment, " bp_ref"); + } else fprintf(fout, "%s%s", cast, pp->arg[arg].reg); continue; @@ -6386,10 +7024,16 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) if (tmp_op->flags & OPF_VAPUSH) { fprintf(fout, "ap"); } + else if (tmp_op->op == OP_FST) { + fprintf(fout, "fs_%d", tmp_op->p_argnum); + if (tmp_op->operand[0].lmod == OPLM_QWORD) + arg++; + } else if (tmp_op->p_argpass != 0) { fprintf(fout, "a%d", tmp_op->p_argpass); } - else if (tmp_op->p_argnum != 0) { + else if (pp->arg[arg].is_saved) { + ferr_assert(po, tmp_op->p_argnum > 0); fprintf(fout, "%s%s", cast, saved_arg_name(buf1, sizeof(buf1), tmp_op->p_arggrp, tmp_op->p_argnum)); @@ -6462,7 +7106,10 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) g_func_pp->arg[arg].reg, g_func_pp->arg[arg].reg); } - if (!(regmask_ret & (1 << xAX))) { + if (regmask_ret & mxST0) { + fprintf(fout, " return %s;", float_st0); + } + else if (!(regmask_ret & mxAX)) { if (i != opcnt - 1 || label_pending) fprintf(fout, " return;"); } @@ -6541,59 +7188,126 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) no_output = 1; break; + // pseudo ops + case OPP_ALLSHL: + case OPP_ALLSHR: + fprintf(fout, " tmp64 = ((u64)edx << 32) | eax;\n"); + fprintf(fout, " tmp64 = (s64)tmp64 %s LOBYTE(ecx);\n", + po->op == OPP_ALLSHL ? "<<" : ">>"); + fprintf(fout, " edx = tmp64 >> 32; eax = tmp64;"); + strcat(g_comment, po->op == OPP_ALLSHL + ? " allshl" : " allshr"); + 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; + if (need_float_stack) { + out_src_opr_float(buf1, sizeof(buf1), + po, &po->operand[0], 1); + if (po->regmask_src & mxSTa) { + fprintf(fout, " f_st[(f_stp - 1) & 7] = %s; f_stp--;", + buf1); + } + else + fprintf(fout, " f_st[--f_stp & 7] = %s;", buf1); + } + else { + if (po->flags & OPF_FSHIFT) + fprintf(fout, " f_st1 = f_st0;"); + 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], 0)); } - 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)); + out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], + lmod_cast(po, po->operand[0].lmod, 1), 0); + snprintf(buf2, sizeof(buf2), "(%s)%s", float_type, buf1); + if (need_float_stack) { + fprintf(fout, " f_st[--f_stp & 7] = %s;", buf2); + } + else { + if (po->flags & OPF_FSHIFT) + fprintf(fout, " f_st1 = f_st0;"); + fprintf(fout, " f_st0 = %s;", buf2); + } strcat(g_comment, " fild"); break; case OP_FLDc: - if (po->flags & OPF_FSHIFT) - fprintf(fout, " f_st1 = f_st0;\n"); - fprintf(fout, " f_st0 = "); + if (need_float_stack) + fprintf(fout, " f_st[--f_stp & 7] = "); + else { + if (po->flags & OPF_FSHIFT) + fprintf(fout, " f_st1 = f_st0;"); + 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; + case X87_CONST_1: fprintf(fout, "1.0;"); break; + case X87_CONST_LN2: fprintf(fout, "0.693147180559945;"); 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) - { + if (po->flags & OPF_FARG) { + // store to stack as func arg + snprintf(buf1, sizeof(buf1), "fs_%d", po->p_argnum); + dead_dst = 0; + } + else { + out_dst_opr_float(buf1, sizeof(buf1), po, &po->operand[0], + need_float_stack); + dead_dst = po->operand[0].type == OPT_REG + && po->operand[0].reg == xST0; + } + if (!dead_dst) + fprintf(fout, " %s = %s;", buf1, float_st0); + if (po->flags & OPF_FSHIFT) { + if (need_float_stack) + fprintf(fout, " f_stp++;"); + else + fprintf(fout, " f_st0 = f_st1;"); + } + if (dead_dst && !(po->flags & OPF_FSHIFT)) no_output = 1; - break; + else + strcat(g_comment, " fst"); + break; + + case OP_FIST: + fprintf(fout, " %s = %s%s;", + out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]), + lmod_cast(po, po->operand[0].lmod, 1), float_st0); + if (po->flags & OPF_FSHIFT) { + if (need_float_stack) + fprintf(fout, " f_stp++;"); + else + fprintf(fout, " f_st0 = f_st1;"); } - 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"); + strcat(g_comment, " fist"); break; case OP_FADD: case OP_FDIV: case OP_FMUL: case OP_FSUB: + out_dst_opr_float(buf1, sizeof(buf1), po, &po->operand[0], + need_float_stack); + out_src_opr_float(buf2, sizeof(buf2), po, &po->operand[1], + need_float_stack); + dead_dst = (po->flags & OPF_FPOP) + && po->operand[0].type == OPT_REG + && po->operand[0].reg == xST0; switch (po->op) { case OP_FADD: j = '+'; break; case OP_FDIV: j = '/'; break; @@ -6601,27 +7315,55 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) case OP_FSUB: j = '-'; break; default: j = 'x'; break; } - if (po->flags & OPF_FSHIFT) { - fprintf(fout, " f_st0 = f_st1 %c f_st0;", j); + if (need_float_stack) { + if (!dead_dst) + fprintf(fout, " %s %c= %s;", buf1, j, buf2); + if (po->flags & OPF_FSHIFT) + fprintf(fout, " f_stp++;"); } 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])); + if (po->flags & OPF_FSHIFT) { + // note: assumes only 2 regs handled + if (!dead_dst) + fprintf(fout, " f_st0 = f_st1 %c f_st0;", j); + else + fprintf(fout, " f_st0 = f_st1;"); + } + else if (!dead_dst) + fprintf(fout, " %s %c= %s;", buf1, j, buf2); } + no_output = (dead_dst && !(po->flags & OPF_FSHIFT)); 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])); + out_dst_opr_float(buf1, sizeof(buf1), po, &po->operand[0], + need_float_stack); + out_src_opr_float(buf2, sizeof(buf2), po, &po->operand[1], + need_float_stack); + out_src_opr_float(buf3, sizeof(buf3), po, &po->operand[0], + need_float_stack); + dead_dst = (po->flags & OPF_FPOP) + && po->operand[0].type == OPT_REG + && po->operand[0].reg == xST0; + j = po->op == OP_FDIVR ? '/' : '-'; + if (need_float_stack) { + if (!dead_dst) + fprintf(fout, " %s = %s %c %s;", buf1, buf2, j, buf3); + if (po->flags & OPF_FSHIFT) + fprintf(fout, " f_stp++;"); + } + else { + if (po->flags & OPF_FSHIFT) { + if (!dead_dst) + fprintf(fout, " f_st0 = f_st0 %c f_st1;", j); + else + fprintf(fout, " f_st0 = f_st1;"); + } + else if (!dead_dst) + fprintf(fout, " %s = %s %c %s;", buf1, buf2, j, buf3); + } + no_output = (dead_dst && !(po->flags & OPF_FSHIFT)); break; case OP_FIADD: @@ -6635,29 +7377,153 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt) case OP_FISUB: j = '-'; break; default: j = 'x'; break; } - fprintf(fout, " f_st0 %c= (double)%s;", j, + fprintf(fout, " %s %c= (%s)%s;", float_st0, + j, float_type, 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 ? '/' : '-'); + fprintf(fout, " %s = %s %c %s;", float_st0, + out_src_opr_float(buf2, sizeof(buf2), po, &po->operand[1], + need_float_stack), + po->op == OP_FIDIVR ? '/' : '-', float_st0); + break; + + case OP_FCOM: { + int mask, z_check; + ferr_assert(po, po->datap != NULL); + mask = (long)po->datap & 0xffff; + z_check = ((long)po->datap >> 16) & 1; + out_src_opr_float(buf1, sizeof(buf1), po, &po->operand[0], + need_float_stack); + if (mask == 0x0100) { // C0 -> < + fprintf(fout, " f_sw = %s < %s ? 0x0100 : 0;", + float_st0, buf1); + } + else if (mask == 0x4000) { // C3 -> = + fprintf(fout, " f_sw = %s == %s ? 0x4000 : 0;", + float_st0, buf1); + } + else if (mask == 0x4100) { // C3, C0 + if (z_check) { + fprintf(fout, " f_sw = %s <= %s ? 0x4100 : 0;", + float_st0, buf1); + strcat(g_comment, " z_chk_det"); + } + else { + fprintf(fout, " f_sw = %s == %s ? 0x4000 : " + "(%s < %s ? 0x0100 : 0);", + float_st0, buf1, float_st0, buf1); + } + } + else + ferr(po, "unhandled sw mask: %x\n", mask); + if (po->flags & OPF_FSHIFT) { + if (need_float_stack) + fprintf(fout, " f_stp++;"); + else + fprintf(fout, " f_st0 = f_st1;"); + } + break; + } + + case OP_FNSTSW: + fprintf(fout, " %s = f_sw;", + out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0])); + break; + + case OP_FCHS: + fprintf(fout, " %s = -%s;", float_st0, float_st0); + break; + + case OP_FCOS: + fprintf(fout, " %s = cos%s(%s);", float_st0, + need_double ? "" : "f", float_st0); + break; + + case OP_FPATAN: + if (need_float_stack) { + fprintf(fout, " %s = atan%s(%s / %s);", float_st1, + need_double ? "" : "f", float_st1, float_st0); + fprintf(fout, " f_stp++;"); + } + else { + fprintf(fout, " f_st0 = atan%s(f_st1 / f_st0);", + need_double ? "" : "f"); + } + break; + + case OP_FYL2X: + if (need_float_stack) { + fprintf(fout, " %s = %s * log2%s(%s);", float_st1, + float_st1, need_double ? "" : "f", float_st0); + fprintf(fout, " f_stp++;"); + } + else { + fprintf(fout, " f_st0 = f_st1 * log2%s(f_st0);", + need_double ? "" : "f"); + } + strcat(g_comment, " fyl2x"); + break; + + case OP_FSIN: + fprintf(fout, " %s = sin%s(%s);", float_st0, + need_double ? "" : "f", float_st0); + break; + + case OP_FSQRT: + fprintf(fout, " %s = sqrt%s(%s);", float_st0, + need_double ? "" : "f", float_st0); + break; + + case OP_FXCH: + dead_dst = po->operand[0].type == OPT_REG + && po->operand[0].reg == xST0; + if (!dead_dst) { + out_src_opr_float(buf1, sizeof(buf1), po, &po->operand[0], + need_float_stack); + fprintf(fout, " { %s t = %s; %s = %s; %s = t; }", float_type, + float_st0, float_st0, buf1, buf1); + strcat(g_comment, " fxch"); + } + else + no_output = 1; 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;"); + fprintf(fout, " eax = (s32)%s;", float_st0); + if (po->flags & OPF_FSHIFT) { + if (need_float_stack) + fprintf(fout, " f_stp++;"); + else + fprintf(fout, " f_st0 = f_st1;"); + } strcat(g_comment, " ftol"); break; + case OPP_CIPOW: + if (need_float_stack) { + fprintf(fout, " %s = pow%s(%s, %s);", float_st1, + need_double ? "" : "f", float_st1, float_st0); + fprintf(fout, " f_stp++;"); + } + else { + fprintf(fout, " f_st0 = pow%s(f_st1, f_st0);", + need_double ? "" : "f"); + } + strcat(g_comment, " CIpow"); + break; + + case OPP_ABORT: + fprintf(fout, " do_skip_code_abort();"); + break; + // mmx case OP_EMMS: - strcpy(g_comment, " (emms)"); + fprintf(fout, " do_emms();"); break; default: @@ -6774,10 +7640,13 @@ static struct scanned_var { } *hg_vars; static int hg_var_cnt; +static char **hg_refs; +static int hg_ref_cnt; + static void output_hdr_fp(FILE *fout, const struct func_prototype *fp, int count); -struct func_prototype *hg_fp_add(const char *funcn) +static struct func_prototype *hg_fp_add(const char *funcn) { struct func_prototype *fp; @@ -6839,6 +7708,19 @@ static int hg_fp_cmp_id(const void *p1_, const void *p2_) } #endif +static void hg_ref_add(const char *name) +{ + if ((hg_ref_cnt & 0xff) == 0) { + hg_refs = realloc(hg_refs, sizeof(hg_refs[0]) * (hg_ref_cnt + 0x100)); + my_assert_not(hg_refs, NULL); + memset(hg_refs + hg_ref_cnt, 0, sizeof(hg_refs[0]) * 0x100); + } + + hg_refs[hg_ref_cnt] = strdup(name); + my_assert_not(hg_refs[hg_ref_cnt], NULL); + hg_ref_cnt++; +} + // recursive register dep pass // - track saved regs (part 2) // - try to figure out arg-regs @@ -6901,11 +7783,11 @@ static void gen_hdr_dep_pass(int i, int opcnt, unsigned char *cbits, if (po->flags & OPF_DONE) continue; - ret = scan_for_pop(i + 1, opcnt, i + opcnt * 2, reg, 0, 0); + ret = scan_for_pop(i + 1, opcnt, i + opcnt * 2, reg, 0, 0, 0); if (ret == 1) { regmask_save |= 1 << reg; po->flags |= OPF_RMD; - scan_for_pop(i + 1, opcnt, i + opcnt * 3, reg, 0, OPF_RMD); + scan_for_pop(i + 1, opcnt, i + opcnt * 3, reg, 0, 0, OPF_RMD); continue; } } @@ -6915,8 +7797,11 @@ static void gen_hdr_dep_pass(int i, int opcnt, unsigned char *cbits, po->regmask_dst |= 1 << xAX; dep = hg_fp_find_dep(fp, po->operand[0].name); - if (dep != NULL) + if (dep != NULL) { dep->regmask_live = regmask_save | regmask_dst; + if (g_bp_frame && !(po->flags & OPF_EBP_S)) + dep->regmask_live |= 1 << xBP; + } } else if (po->op == OP_RET) { if (po->operand_cnt > 0) { @@ -6979,7 +7864,6 @@ static void gen_hdr_dep_pass(int i, int opcnt, unsigned char *cbits, static void gen_hdr(const char *funcn, int opcnt) { - int save_arg_vars[MAX_ARG_GRP] = { 0, }; unsigned char cbits[MAX_OPS / 8]; const struct parsed_proto *pp_c; struct parsed_proto *pp; @@ -7065,7 +7949,7 @@ static void gen_hdr(const char *funcn, int opcnt) if (pp != NULL) { if (!(po->flags & OPF_ATAIL)) // since we know the args, try to collect them - if (collect_call_args_early(po, i, pp, ®mask_dummy) != 0) + if (collect_call_args_early(i, pp, NULL, NULL) != 0) pp = NULL; } @@ -7110,8 +7994,8 @@ static void gen_hdr(const char *funcn, int opcnt) if (!pp->is_unresolved && !(po->flags & OPF_ATAIL)) { // since we know the args, collect them - ret = collect_call_args(po, i, pp, ®mask_dummy, save_arg_vars, - i + opcnt * 1); + ret = collect_call_args(po, i, pp, ®mask_dummy, + i + opcnt * 1); } } } @@ -7136,7 +8020,7 @@ static void gen_hdr(const char *funcn, int opcnt) // noreturn OS functions break; } - if (ops[i].op != OP_NOP) + if (ops[i].op != OP_NOP && ops[i].op != OPP_ABORT) ferr(&ops[i], "unreachable code\n"); } @@ -7152,7 +8036,7 @@ static void gen_hdr(const char *funcn, int opcnt) fp->argc_stack--; } - fp->regmask_dep = regmask_dep & ~(1 << xSP); + fp->regmask_dep = regmask_dep & ~((1 << xSP) | mxSTa); fp->has_ret = has_ret; #if 0 printf("// has_ret %d, regmask_dep %x\n", @@ -7193,6 +8077,24 @@ static void hg_fp_resolve_deps(struct func_prototype *fp) } } +// make all thiscall/edx arg functions referenced from .data fastcall +static void do_func_refs_from_data(void) +{ + struct func_prototype *fp, fp_s; + int i; + + for (i = 0; i < hg_ref_cnt; i++) { + strcpy(fp_s.name, hg_refs[i]); + fp = bsearch(&fp_s, hg_fp, hg_fp_cnt, + sizeof(hg_fp[0]), hg_fp_cmp_name); + if (fp == NULL) + continue; + + if (fp->argc_stack != 0 && (fp->regmask_dep & (mxCX | mxDX))) + fp->regmask_dep |= mxCX | mxDX; + } +} + static void output_hdr_fp(FILE *fout, const struct func_prototype *fp, int count) { @@ -7338,6 +8240,9 @@ static void output_hdr(FILE *fout) for (i = 0; i < hg_fp_cnt; i++) hg_fp_resolve_deps(&hg_fp[i]); + // adjust functions referenced from data segment + do_func_refs_from_data(); + // note: messes up .proto ptr, don't use //qsort(hg_fp, hg_fp_cnt, sizeof(hg_fp[0]), hg_fp_cmp_id); @@ -7381,7 +8286,7 @@ static char *next_word_s(char *w, size_t wsize, char *s) s = sskip(s); i = 0; - if (*s == '\'') { + if (*s == '\'' && s[1] != '\r' && s[1] != '\n') { w[0] = s[0]; for (i = 1; i < wsize - 1; i++) { if (s[i] == 0) { @@ -7435,7 +8340,7 @@ static int is_xref_needed(char *p, char **rlist, int rlist_len) return 1; } -static int xrefs_show_need(FILE *fasm, char *p, +static int ida_xrefs_show_need(FILE *fasm, char *p, char **rlist, int rlist_len) { int found_need = 0; @@ -7443,10 +8348,14 @@ static int xrefs_show_need(FILE *fasm, char *p, long pos; p = strrchr(p, ';'); - if (p != NULL && *p == ';' && IS_START(p + 2, "DATA XREF: ")) { - p += 13; - if (is_xref_needed(p, rlist, rlist_len)) + if (p != NULL && *p == ';') { + if (IS_START(p + 2, "sctref")) return 1; + if (IS_START(p + 2, "DATA XREF: ")) { + p += 13; + if (is_xref_needed(p, rlist, rlist_len)) + return 1; + } } pos = ftell(fasm); @@ -7465,6 +8374,12 @@ static int xrefs_show_need(FILE *fasm, char *p, p = strrchr(p, ';'); p += 2; + + if (IS_START(p, "sctref")) { + found_need = 1; + break; + } + // it's printed once, but no harm to check again if (IS_START(p, "DATA XREF: ")) p += 11; @@ -7482,7 +8397,8 @@ static void scan_variables(FILE *fasm, char **rlist, int rlist_len) { struct scanned_var *var; char line[256] = { 0, }; - char words[3][256]; + char words[4][256]; + int no_identifier; char *p = NULL; int wordc; int l; @@ -7521,8 +8437,7 @@ static void scan_variables(FILE *fasm, char **rlist, int rlist_len) asmln++; p = line; - if (my_isblank(*p)) - continue; + no_identifier = my_isblank(*p); p = sskip(p); if (*p == 0 || *p == ';') @@ -7542,13 +8457,19 @@ static void scan_variables(FILE *fasm, char **rlist, int rlist_len) if (wordc < 2) continue; + if (no_identifier) { + if (wordc >= 3 && IS(words[0], "dd") && IS(words[1], "offset")) + hg_ref_add(words[2]); + continue; + } + if (IS_START(words[0], "__IMPORT_DESCRIPTOR_")) { // when this starts, we don't need anything from this section break; } // check refs comment(s) - if (!xrefs_show_need(fasm, p, rlist, rlist_len)) + if (!ida_xrefs_show_need(fasm, p, rlist, rlist_len)) continue; if ((hg_var_cnt & 0xff) == 0) { @@ -7578,8 +8499,11 @@ static void scan_variables(FILE *fasm, char **rlist, int rlist_len) continue; } - if (IS(words[1], "dd")) + if (IS(words[1], "dd")) { var->lmod = OPLM_DWORD; + if (wordc >= 4 && IS(words[2], "offset")) + hg_ref_add(words[3]); + } else if (IS(words[1], "dw")) var->lmod = OPLM_WORD; else if (IS(words[1], "db")) { @@ -7649,7 +8573,7 @@ static int cmp_chunks(const void *p1, const void *p2) return strcmp(c1->name, c2->name); } -static void scan_ahead(FILE *fasm) +static void scan_ahead_for_chunks(FILE *fasm) { char words[2][256]; char line[256]; @@ -7730,7 +8654,8 @@ int main(int argc, char *argv[]) char *sctproto = NULL; int in_func = 0; int pending_endp = 0; - int skip_func = 0; + int skip_code = 0; + int skip_code_end = 0; int skip_warned = 0; int eq_alloc; int verbose = 0; @@ -7749,6 +8674,8 @@ int main(int argc, char *argv[]) verbose = 1; else if (IS(argv[arg], "-rf")) g_allow_regfunc = 1; + else if (IS(argv[arg], "-uc")) + g_allow_user_icall = 1; else if (IS(argv[arg], "-m")) multi_seg = 1; else if (IS(argv[arg], "-hdr")) @@ -7763,6 +8690,7 @@ int main(int argc, char *argv[]) "options:\n" " -hdr - header generation mode\n" " -rf - allow unannotated indirect calls\n" + " -uc - allow ind. calls/refs to __usercall\n" " -m - allow multiple .text sections\n" "[rlist] is a file with function names to skip," " one per line\n", @@ -7793,6 +8721,8 @@ int main(int argc, char *argv[]) memset(words, 0, sizeof(words)); for (; arg < argc; arg++) { + int skip_func = 0; + frlist = fopen(argv[arg], "r"); my_assert_not(frlist, NULL); @@ -7824,7 +8754,6 @@ int main(int argc, char *argv[]) } rlist[rlist_len++] = strdup(words[0]); } - skip_func = 0; fclose(frlist); frlist = NULL; @@ -7927,7 +8856,7 @@ int main(int argc, char *argv[]) &g_stack_clear_len, &j); else if (i == 1) // clear_regmask= - ret = sscanf(p, "=%d%n", &g_regmask_init, &j) + 1; + ret = sscanf(p, "=%x%n", &g_regmask_init, &j) + 1; if (ret < 2) { anote("unparsed attr value: %s\n", p); break; @@ -7985,7 +8914,7 @@ int main(int argc, char *argv[]) if (addr > f_addr && !scanned_ahead) { //anote("scan_ahead caused by '%s', addr %lx\n", // g_func, addr); - scan_ahead(fasm); + scan_ahead_for_chunks(fasm); scanned_ahead = 1; func_chunks_sorted = 0; } @@ -8007,7 +8936,12 @@ parse_words: if (*p != 0 && *p != ';') aerr("too many words\n"); - // alow asm patches in comments + if (skip_code_end) { + skip_code_end = 0; + skip_code = 0; + } + + // allow asm patches in comments if (*p == ';') { if (IS_START(p, "; sctpatch:")) { p = sskip(p + 11); @@ -8023,6 +8957,20 @@ parse_words: if (!pending_endp) break; } + else if (IS_START(p, "; sctskip_start")) { + if (in_func && !g_skip_func) { + if (!skip_code) { + ops[pi].op = OPP_ABORT; + ops[pi].asmln = asmln; + pi++; + } + skip_code = 1; + } + } + else if (IS_START(p, "; sctskip_end")) { + if (skip_code) + skip_code_end = 1; + } } if (wordc == 0) { @@ -8091,7 +9039,7 @@ do_pending_endp: if (pd->type == OPT_OFFSET) pd->d[pd->count].u.label = strdup(words[i]); else - pd->d[pd->count].u.val = parse_number(words[i]); + pd->d[pd->count].u.val = parse_number(words[i], 0); pd->d[pd->count].bt_i = -1; pd->count++; } @@ -8162,6 +9110,8 @@ do_pending_endp: if (!IS(g_func, words[0])) aerr("endp '%s' while in_func '%s'?\n", words[0], g_func); + if (skip_code) + aerr("endp '%s' while skipping code\n", words[0]); if ((g_ida_func_attr & IDAFA_THUNK) && pi == 1 && ops[0].op == OP_JMP && ops[0].operand[0].had_ds) @@ -8229,7 +9179,7 @@ do_pending_endp: continue; } - if (!in_func || g_skip_func) { + if (!in_func || g_skip_func || skip_code) { if (!skip_warned && !g_skip_func && g_labels[pi] != NULL) { if (verbose) anote("skipping from '%s'\n", g_labels[pi]); @@ -8268,7 +9218,7 @@ do_pending_endp: else aerr("bad lmod: '%s'\n", words[2]); - g_eqs[g_eqcnt].offset = parse_number(words[4]); + g_eqs[g_eqcnt].offset = parse_number(words[4], 0); g_eqcnt++; continue; }