exit(1); \
} while (0)
+#include "masm_tools.h"
+
enum op_flags {
OPF_RMD = (1 << 0), /* removed or optimized out */
OPF_DATA = (1 << 1), /* data processing - writes to dst opr */
static int g_stack_frame_used;
static int g_stack_fsz;
static int g_ida_func_attr;
+static int g_allow_regfunc;
#define ferr(op_, fmt, ...) do { \
printf("error:%s:#%zd: '%s': " fmt, g_func, (op_) - ops, \
dump_op(op_), ##__VA_ARGS__); \
return -1;
}
-static unsigned long parse_number(const char *number)
-{
- int len = strlen(number);
- const char *p = number;
- char *endp = NULL;
- unsigned long ret;
- int neg = 0;
- int bad;
-
- if (*p == '-') {
- neg = 1;
- p++;
- }
- if (len > 1 && *p == '0')
- p++;
- if (number[len - 1] == 'h') {
- ret = strtoul(p, &endp, 16);
- bad = (*endp != 'h');
- }
- else {
- ret = strtoul(p, &endp, 10);
- bad = (*endp != 0);
- }
- if (bad)
- aerr("number parsing failed\n");
- if (neg)
- ret = -ret;
- return ret;
-}
-
static int parse_indmode(char *name, int *regmask, int need_c_cvt)
{
enum opr_lenmod lmod;
"WPARAM", "LPARAM", "UINT",
};
static const char *word_types[] = {
- "uint16_t", "int16_t",
+ "uint16_t", "int16_t", "_WORD",
"unsigned __int16", "__int16",
};
static const char *byte_types[] = {
"uint8_t", "int8_t", "char",
- "unsigned __int8", "__int8", "BYTE",
+ "unsigned __int8", "__int8", "BYTE", "_BYTE",
"_UNKNOWN",
};
const char *n;
const struct parsed_proto *pp;
enum opr_lenmod tmplmod;
unsigned long number;
+ char buf[256];
int ret, len;
int wordc_in;
- char *tmp;
+ char *p;
int i;
if (w >= wordc)
return wordc;
}
if (IS(words[w], "(offset")) {
- char *p = strchr(words[w + 1], ')');
+ p = strchr(words[w + 1], ')');
if (p == NULL)
aerr("parse of bracketed offset failed\n");
*p = 0;
if (wordc_in != 1)
aerr("parse_operand 1 word expected\n");
- tmp = words[w];
- if (IS_START(tmp, "ds:"))
- tmp += 3;
- strcpy(opr->name, tmp);
+ if (IS_START(words[w], "ds:"))
+ memmove(words[w], words[w] + 3, strlen(words[w]) - 2);
+ strcpy(opr->name, words[w]);
if (words[w][0] == '[') {
opr->type = OPT_REGMEM;
}
else if (strchr(words[w], '[')) {
// label[reg] form
+ p = strchr(words[w], '[');
opr->type = OPT_REGMEM;
- if (opr->lmod == OPLM_UNSPEC)
- guess_lmod_from_name(opr);
- parse_indmode(strchr(words[w], '['), regmask_indirect, 0);
- return wordc;
+ parse_indmode(p, regmask_indirect, 0);
+ strncpy(buf, words[w], p - words[w]);
+ buf[p - words[w]] = 0;
+ pp = proto_parse(g_fhdr, buf, 1);
+ goto do_label;
}
else if (('0' <= words[w][0] && words[w][0] <= '9')
|| words[w][0] == '-')
// most likely var in data segment
opr->type = OPT_LABEL;
+ pp = proto_parse(g_fhdr, opr->name, 0);
- pp = proto_parse(g_fhdr, opr->name);
+do_label:
if (pp != NULL) {
- if (pp->is_fptr) {
+ if (pp->is_fptr || pp->is_func) {
opr->lmod = OPLM_DWORD;
opr->is_ptr = 1;
}
}
break;
+ case OP_CALL:
+ // trashed regs must be explicitly detected later
+ op->regmask_dst = 0;
+ break;
+
default:
break;
}
return cast2;
if (IS(cast1, "(u16)") && IS_START(cast2, "*(u16 *)"))
return cast2;
+ if (strchr(cast1, '*') && IS_START(cast2, "(u32)"))
+ return cast1;
snprintf(buf, sizeof(buf), "%s%s", cast1, cast2);
return buf;
return &g_eqs[i];
}
-static void 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)
+static int is_stack_access(struct parsed_op *po,
+ const struct parsed_opr *popr)
{
- enum opr_lenmod tmp_lmod = OPLM_UNSPEC;
- const char *prefix = "";
- const char *bp_arg = NULL;
- char ofs_reg[16] = { 0, };
+ return (parse_stack_el(popr->name, NULL)
+ || (g_bp_frame && !(po->flags & OPF_EBP_S)
+ && IS_START(popr->name, "ebp")));
+}
+
+static void parse_stack_access(struct parsed_op *po,
+ const char *name, char *ofs_reg, int *offset_out,
+ int *stack_ra_out, const char **bp_arg_out)
+{
+ const char *bp_arg = "";
+ const char *p = NULL;
struct parsed_equ *eq;
- const char *p;
char *endp = NULL;
- int i, arg_i, arg_s;
- int unaligned = 0;
int stack_ra = 0;
int offset = 0;
- int sf_ofs;
- int lim;
- if (po->flags & OPF_EBP_S)
- ferr(po, "stack_frame_access while ebp is scratch\n");
+ ofs_reg[0] = 0;
if (IS_START(name, "ebp-")
|| (IS_START(name, "ebp+") && '0' <= name[4] && name[4] <= '9'))
if (ofs_reg[0] == 0 && stack_ra <= offset && offset < stack_ra + 4)
ferr(po, "reference to ra? %d %d\n", offset, stack_ra);
+ *offset_out = offset;
+ *stack_ra_out = stack_ra;
+ if (bp_arg_out)
+ *bp_arg_out = bp_arg;
+}
+
+static void 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)
+{
+ enum opr_lenmod tmp_lmod = OPLM_UNSPEC;
+ const char *prefix = "";
+ const char *bp_arg = NULL;
+ char ofs_reg[16] = { 0, };
+ int i, arg_i, arg_s;
+ int unaligned = 0;
+ int stack_ra = 0;
+ int offset = 0;
+ int sf_ofs;
+ int lim;
+
+ if (po->flags & OPF_EBP_S)
+ ferr(po, "stack_frame_access while ebp is scratch\n");
+
+ parse_stack_access(po, name, ofs_reg, &offset, &stack_ra, &bp_arg);
+
if (offset > stack_ra)
{
arg_i = (offset - stack_ra - 4) / 4;
ferr(po, "bp_arg arg%d/w offset %d and type '%s' is too small\n",
i + 1, offset, g_func_pp->arg[i].type.name);
}
+ if (popr->is_ptr && popr->lmod != OPLM_DWORD)
+ ferr(po, "bp_arg arg%d: non-dword ptr access\n", i + 1);
}
else
{
}
}
+static void check_func_pp(struct parsed_op *po,
+ const struct parsed_proto *pp, const char *pfx)
+{
+ if (pp->argc_reg != 0) {
+ if (!g_allow_regfunc)
+ ferr(po, "%s: reg arg in arg-call unhandled yet\n", pfx);
+ if (pp->argc_stack > 0 && pp->argc_reg != 2)
+ ferr(po, "%s: %d reg arg(s) with %d stack arg(s)\n",
+ pfx, pp->argc_reg, pp->argc_stack);
+ }
+}
+
static void check_label_read_ref(struct parsed_op *po, const char *name)
{
const struct parsed_proto *pp;
- pp = proto_parse(g_fhdr, name);
+ pp = proto_parse(g_fhdr, name, 0);
if (pp == NULL)
ferr(po, "proto_parse failed for ref '%s'\n", name);
- // currently we can take __cdecl and __stdcall
- if (pp->is_func && pp->argc_reg != 0)
- ferr(po, "reg-arg func reference?\n");
+ if (pp->is_func)
+ check_func_pp(po, pp, "ref");
}
static char *out_src_opr(char *buf, size_t buf_size,
break;
case OPT_REGMEM:
- if (parse_stack_el(popr->name, NULL)
- || (g_bp_frame && !(po->flags & OPF_EBP_S)
- && IS_START(popr->name, "ebp")))
- {
+ if (is_stack_access(po, popr)) {
stack_frame_access(po, popr, buf, buf_size,
popr->name, cast, 1, is_lea);
break;
break;
case OPT_REGMEM:
- if (parse_stack_el(popr->name, NULL)
- || (g_bp_frame && !(po->flags & OPF_EBP_S)
- && IS_START(popr->name, "ebp")))
- {
+ if (is_stack_access(po, popr)) {
stack_frame_access(po, popr, buf, buf_size,
popr->name, "", 0, 0);
break;
static int scan_for_pop(int i, int opcnt, const char *reg,
int magic, int depth, int *maxdepth, int do_flags)
{
+ const struct parsed_proto *pp;
struct parsed_op *po;
int ret = 0;
int j;
break; // already checked
po->cc_scratch = magic;
- if (po->flags & OPF_TAIL)
+ if (po->flags & OPF_TAIL) {
+ if (po->op == OP_CALL) {
+ pp = proto_parse(g_fhdr, po->operand[0].name, 0);
+ if (pp != NULL && pp->is_noreturn)
+ // no stack cleanup for noreturn
+ return ret;
+ }
return -1; // deadend
+ }
if ((po->flags & OPF_RMD)
|| (po->op == OP_PUSH && po->argnum != 0)) // arg push
return found ? 0 : -1;
}
-// is operand 'opr modified' by parsed_op 'po'?
+// is operand 'opr' modified by parsed_op 'po'?
static int is_opr_modified(const struct parsed_opr *opr,
const struct parsed_op *po)
{
+ int mask;
+
if ((po->flags & OPF_RMD) || !(po->flags & OPF_DATA))
return 0;
- if (opr->type == OPT_REG && po->operand[0].type == OPT_REG) {
- if (po->regmask_dst & (1 << opr->reg))
- return 1;
- else
- return 0;
+ if (opr->type == OPT_REG) {
+ if (po->op == OP_CALL) {
+ mask = (1 << xAX) | (1 << xCX) | (1 << xDX);
+ if ((1 << opr->reg) & mask)
+ return 1;
+ else
+ return 0;
+ }
+
+ if (po->operand[0].type == OPT_REG) {
+ if (po->regmask_dst & (1 << opr->reg))
+ return 1;
+ else
+ return 0;
+ }
}
return IS(po->operand[0].name, opr->name);
// is any operand of parsed_op 'po_test' modified by parsed_op 'po'?
static int is_any_opr_modified(const struct parsed_op *po_test,
- const struct parsed_op *po)
+ const struct parsed_op *po, int c_mode)
{
+ int mask;
int i;
if ((po->flags & OPF_RMD) || !(po->flags & OPF_DATA))
// in reality, it can wreck any register, but in decompiled C
// version it can only overwrite eax or edx:eax
+ mask = (1 << xAX) | (1 << xDX);
+ if (!c_mode)
+ mask |= 1 << xCX;
+
if (po->op == OP_CALL
- && ((po_test->regmask_src | po_test->regmask_dst)
- & ((1 << xAX)|(1 << xDX))))
+ && ((po_test->regmask_src | po_test->regmask_dst) & mask))
return 1;
for (i = 0; i < po_test->operand_cnt; i++)
}
// scan for any po_test operand modification in range given
-static int scan_for_mod(struct parsed_op *po_test, int i, int opcnt)
+static int scan_for_mod(struct parsed_op *po_test, int i, int opcnt,
+ int c_mode)
{
if (po_test->operand_cnt == 1 && po_test->operand[0].type == OPT_CONST)
return -1;
for (; i < opcnt; i++) {
- if (is_any_opr_modified(po_test, &ops[i]))
+ if (is_any_opr_modified(po_test, &ops[i], c_mode))
return i;
}
// scan for positive, constant esp adjust
static int scan_for_esp_adjust(int i, int opcnt, int *adj)
{
+ const struct parsed_proto *pp;
struct parsed_op *po;
- int i_first = i;
+ int first_pop = -1;
*adj = 0;
for (; i < opcnt; i++) {
ferr(&ops[i], "unaligned esp adjust: %x\n", *adj);
return i;
}
- else if (po->op == OP_PUSH)
+ else if (po->op == OP_PUSH) {
+ if (first_pop == -1)
+ first_pop = -2; // none
*adj -= lmod_bytes(po, po->operand[0].lmod);
- else if (po->op == OP_POP)
+ }
+ else if (po->op == OP_POP) {
+ if (first_pop == -1)
+ first_pop = i;
*adj += lmod_bytes(po, po->operand[0].lmod);
+ }
else if (po->flags & (OPF_JMP|OPF_TAIL)) {
if (po->op != OP_CALL)
break;
if (po->operand[0].type != OPT_LABEL)
break;
- // TODO: should only allow combining __cdecl calls..
+ pp = po->datap;
+ if (pp != NULL && pp->is_stdcall)
+ break;
}
}
- if (*adj == 4 && ops[i_first].op == OP_POP
- && ops[i_first].operand[0].type == OPT_REG
- && ops[i_first].operand[0].reg == xCX)
+ if (*adj == 4 && first_pop >= 0 && ops[first_pop].op == OP_POP
+ && ops[first_pop].operand[0].type == OPT_REG
+ && ops[first_pop].operand[0].reg == xCX)
{
// probably 'pop ecx' was used..
- return i_first;
+ return first_pop;
}
return -1;
}
}
-static int collect_call_args(struct parsed_op *po, int i,
- struct parsed_proto *pp, int *save_arg_vars, int arg,
+static const struct parsed_proto *try_recover_pp(
+ struct parsed_op *po, const struct parsed_opr *opr)
+{
+ const struct parsed_proto *pp = NULL;
+ char buf[256];
+ char *p;
+
+ // maybe an arg of g_func?
+ if (opr->type == OPT_REGMEM && is_stack_access(po, opr))
+ {
+ char ofs_reg[16] = { 0, };
+ int arg, arg_s, arg_i;
+ int stack_ra = 0;
+ int offset = 0;
+
+ parse_stack_access(po, opr->name, ofs_reg,
+ &offset, &stack_ra, NULL);
+ if (ofs_reg[0] != 0)
+ ferr(po, "offset reg on arg access?\n");
+ if (offset <= stack_ra)
+ ferr(po, "stack var call unhandled yet\n");
+
+ arg_i = (offset - stack_ra - 4) / 4;
+ for (arg = arg_s = 0; arg < g_func_pp->argc; arg++) {
+ if (g_func_pp->arg[arg].reg != NULL)
+ continue;
+ if (arg_s == arg_i)
+ break;
+ arg_s++;
+ }
+ 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");
+ }
+ else if (opr->type == OPT_REGMEM && strchr(opr->name + 1, '[')) {
+ // label[index]
+ p = strchr(opr->name + 1, '[');
+ memcpy(buf, opr->name, p - opr->name);
+ buf[p - opr->name] = 0;
+ pp = proto_parse(g_fhdr, buf, 0);
+ }
+ else if (opr->type == OPT_OFFSET || opr->type == OPT_LABEL) {
+ pp = proto_parse(g_fhdr, opr->name, 0);
+ if (pp == NULL)
+ ferr(po, "proto_parse failed for icall from '%s'\n", opr->name);
+ check_func_pp(po, pp, "reg-fptr ref");
+ }
+
+ return pp;
+}
+
+static void scan_for_call_type(int i, struct parsed_opr *opr,
+ int magic, const struct parsed_proto **pp_found, int *multi)
+{
+ const struct parsed_proto *pp = NULL;
+ struct parsed_op *po;
+ struct label_ref *lr;
+
+ while (i >= 0) {
+ if (ops[i].cc_scratch == magic)
+ return;
+ ops[i].cc_scratch = magic;
+
+ if (g_labels[i][0] != 0) {
+ lr = &g_label_refs[i];
+ for (; lr != NULL; lr = lr->next)
+ scan_for_call_type(lr->i, opr, magic, pp_found, multi);
+ if (i > 0 && LAST_OP(i - 1))
+ return;
+ }
+ i--;
+
+ if (!(ops[i].flags & OPF_DATA))
+ continue;
+ if (!is_opr_modified(opr, &ops[i]))
+ continue;
+ if (ops[i].op != OP_MOV && ops[i].op != OP_LEA) {
+ // most probably trashed by some processing
+ *pp_found = NULL;
+ return;
+ }
+
+ opr = &ops[i].operand[1];
+ if (opr->type != OPT_REG)
+ break;
+ }
+
+ po = (i >= 0) ? &ops[i] : ops;
+
+ if (i < 0) {
+ // reached the top - can only be an arg-reg
+ if (opr->type != OPT_REG)
+ return;
+
+ for (i = 0; i < g_func_pp->argc; i++) {
+ if (g_func_pp->arg[i].reg == NULL)
+ continue;
+ if (IS(opr->name, g_func_pp->arg[i].reg))
+ break;
+ }
+ if (i == g_func_pp->argc)
+ return;
+ pp = g_func_pp->arg[i].fptr;
+ 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);
+
+ if (*pp_found != NULL && pp != NULL && *pp_found != pp) {
+ if (!IS((*pp_found)->ret_type.name, pp->ret_type.name)
+ || (*pp_found)->is_stdcall != pp->is_stdcall
+ || (*pp_found)->is_fptr != pp->is_fptr
+ || (*pp_found)->argc != pp->argc
+ || (*pp_found)->argc_reg != pp->argc_reg
+ || (*pp_found)->argc_stack != pp->argc_stack)
+ {
+ ferr(po, "icall: parsed_proto mismatch\n");
+ }
+ *multi = 1;
+ }
+ if (pp != NULL)
+ *pp_found = pp;
+}
+
+static const struct parsed_proto *resolve_icall(int i, int opcnt,
+ int *multi_src)
+{
+ const struct parsed_proto *pp = NULL;
+
+ *multi_src = 0;
+
+ 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]);
+ break;
+ default:
+ scan_for_call_type(i, &ops[i].operand[0], i + opcnt * 9, &pp,
+ multi_src);
+ break;
+ }
+
+ return pp;
+}
+
+static int collect_call_args_r(struct parsed_op *po, int i,
+ struct parsed_proto *pp, int *regmask, int *save_arg_vars, int arg,
int magic, int need_op_saving, int may_reuse)
{
struct parsed_proto *pp_tmp;
break;
magic = (magic & 0xffffff) | (arg << 24);
- for (j = i; j >= 0 && arg < pp->argc; )
+ for (j = i; j >= 0 && (arg < pp->argc || pp->is_unresolved); )
{
if (((ops[j].cc_scratch ^ magic) & 0xffffff) == 0) {
if (ops[j].cc_scratch != magic) {
for (; lr->next; lr = lr->next) {
if ((ops[lr->i].flags & (OPF_JMP|OPF_CC)) != OPF_JMP)
may_reuse = 1;
- ret = collect_call_args(po, lr->i, pp, save_arg_vars,
+ ret = collect_call_args_r(po, lr->i, pp, regmask, save_arg_vars,
arg, magic, need_op_saving, may_reuse);
if (ret < 0)
return ret;
continue;
}
need_op_saving = 1;
- ret = collect_call_args(po, lr->i, pp, save_arg_vars,
+ ret = collect_call_args_r(po, lr->i, pp, regmask, save_arg_vars,
arg, magic, need_op_saving, may_reuse);
if (ret < 0)
return ret;
if (ops[j].op == OP_CALL)
{
+ if (pp->is_unresolved)
+ break;
+
pp_tmp = ops[j].datap;
if (pp_tmp == NULL)
ferr(po, "arg collect hit unparsed call '%s'\n",
arg, pp->argc, opr_name(&ops[j], 0), pp_tmp->argc_stack);
}
else if (ops[j].op == OP_ADD && ops[j].operand[0].reg == xSP) {
+ if (pp->is_unresolved)
+ break;
+
ferr(po, "arg collect %d/%d hit esp adjust\n",
arg, pp->argc);
}
else if (ops[j].op == OP_POP) {
+ if (pp->is_unresolved)
+ break;
+
ferr(po, "arg collect %d/%d hit pop\n", arg, pp->argc);
}
else if ((ops[j].flags & (OPF_JMP|OPF_CC)) == (OPF_JMP|OPF_CC))
{
+ if (pp->is_unresolved)
+ break;
+
may_reuse = 1;
}
else if (ops[j].op == OP_PUSH && !(ops[j].flags & OPF_FARG))
{
+ if (pp->is_unresolved && (ops[j].flags & OPF_RMD))
+ break;
+
pp->arg[arg].datap = &ops[j];
need_to_save_current = 0;
if (!need_op_saving) {
- ret = scan_for_mod(&ops[j], j + 1, i);
+ ret = scan_for_mod(&ops[j], j + 1, i, 1);
need_to_save_current = (ret >= 0);
}
if (need_op_saving || need_to_save_current) {
if (!may_reuse)
ops[j].flags |= OPF_FARG;
- // next arg
- for (arg++; arg < pp->argc; arg++)
- if (pp->arg[arg].reg == NULL)
- break;
+ arg++;
+ if (!pp->is_unresolved) {
+ // next arg
+ for (; arg < pp->argc; arg++)
+ if (pp->arg[arg].reg == NULL)
+ break;
+ }
magic = (magic & 0xffffff) | (arg << 24);
+
+ // tracking reg usage
+ if (ops[j].operand[0].type == OPT_REG)
+ *regmask |= 1 << ops[j].operand[0].reg;
}
}
if (arg < pp->argc) {
ferr(po, "arg collect failed for '%s': %d/%d\n",
pp->name, arg, pp->argc);
- ret = -1;
+ return -1;
}
+
+ return arg;
+}
+
+static int collect_call_args(struct parsed_op *po, int i,
+ struct parsed_proto *pp, int *regmask, int *save_arg_vars,
+ int magic)
+{
+ int ret;
+ int a;
+
+ ret = collect_call_args_r(po, i, pp, regmask, save_arg_vars,
+ 0, magic, 0, 0);
+ if (ret < 0)
+ return ret;
+
+ if (pp->is_unresolved) {
+ pp->argc += ret;
+ pp->argc_stack += ret;
+ for (a = 0; a < pp->argc; a++)
+ if (pp->arg[a].type.name == NULL)
+ pp->arg[a].type.name = strdup("int");
+ }
+
return ret;
}
+static void pp_insert_reg_arg(struct parsed_proto *pp, const char *reg)
+{
+ int i;
+
+ for (i = 0; i < pp->argc; i++)
+ if (pp->arg[i].reg == NULL)
+ break;
+
+ if (pp->argc_stack)
+ memmove(&pp->arg[i + 1], &pp->arg[i],
+ sizeof(pp->arg[0]) * pp->argc_stack);
+ memset(&pp->arg[i], 0, sizeof(pp->arg[i]));
+ pp->arg[i].reg = strdup(reg);
+ pp->arg[i].type.name = strdup("int");
+ pp->argc++;
+ pp->argc_reg++;
+}
+
static void add_label_ref(struct label_ref *lr, int op_i)
{
struct label_ref *lr_new;
struct parsed_opr *last_arith_dst = NULL;
char buf1[256], buf2[256], buf3[256], cast[64];
const struct parsed_proto *pp_c;
- struct parsed_proto *pp, *pp_tmp;
+ struct parsed_proto *pp;
struct parsed_data *pd;
const char *tmpname;
enum parsed_flag_op pfo;
int save_arg_vars = 0;
int cmp_result_vars = 0;
int need_mul_var = 0;
- int have_func_ret = 0;
- int have_normal_ret = 0;
int had_decl = 0;
int label_pending = 0;
int regmask_save = 0;
g_bp_frame = g_sp_frame = g_stack_fsz = 0;
g_stack_frame_used = 0;
- g_func_pp = proto_parse(fhdr, funcn);
+ g_func_pp = proto_parse(fhdr, funcn, 0);
if (g_func_pp == NULL)
ferr(ops, "proto_parse failed for '%s'\n", funcn);
else {
fprintf(fout, "%s a%d", g_func_pp->arg[i].type.name, i + 1);
}
+ if (g_func_pp->arg[i].reg != NULL) {
+ reg = char_array_i(regs_r32,
+ ARRAY_SIZE(regs_r32), g_func_pp->arg[i].reg);
+ if (reg < 0)
+ ferr(ops, "arg '%s' is not a reg?\n", g_func_pp->arg[i].reg);
+ regmask_arg |= 1 << reg;
+ }
}
if (g_func_pp->is_vararg) {
if (i > 0)
if (po->op == OP_CALL) {
if (po->operand[0].type == OPT_LABEL) {
tmpname = opr_name(po, 0);
- pp_c = proto_parse(fhdr, tmpname);
+ if (IS_START(tmpname, "loc_"))
+ ferr(po, "call to loc_*\n");
+ pp_c = proto_parse(fhdr, tmpname, 0);
if (pp_c == NULL)
ferr(po, "proto_parse failed for call '%s'\n", tmpname);
if (pp_c->is_fptr && pp_c->argc_reg != 0)
if (po->operand[0].type == OPT_REGMEM) {
char *p = strchr(po->operand[0].name, '[');
if (p == NULL)
- ferr(po, "unhandled indirect branch\n");
+ goto tailcall;
ret = p - po->operand[0].name;
strncpy(buf1, po->operand[0].name, ret);
buf1[ret] = 0;
if (pp == NULL)
{
// indirect call
- pp = calloc(1, sizeof(*pp));
- my_assert_not(pp, NULL);
- ret = scan_for_esp_adjust(i + 1, opcnt, &j);
- if (ret < 0)
- ferr(po, "non-__cdecl indirect call unhandled yet\n");
- j /= 4;
- if (j > ARRAY_SIZE(pp->arg))
- ferr(po, "esp adjust too large?\n");
- pp->ret_type.name = strdup("int");
- pp->argc = pp->argc_stack = j;
- for (arg = 0; arg < pp->argc; arg++)
- pp->arg[arg].type.name = strdup("int");
+ pp_c = resolve_icall(i, opcnt, &l);
+ if (pp_c != NULL) {
+ pp = proto_clone(pp_c);
+ my_assert_not(pp, NULL);
+ if (l)
+ // not resolved just to single func
+ pp->is_fptr = 1;
+ }
+ if (pp == NULL) {
+ pp = calloc(1, sizeof(*pp));
+ my_assert_not(pp, NULL);
+ pp->is_fptr = 1;
+ ret = scan_for_esp_adjust(i + 1, opcnt, &j);
+ if (ret < 0) {
+ if (!g_allow_regfunc)
+ ferr(po, "non-__cdecl indirect call unhandled yet\n");
+ pp->is_unresolved = 1;
+ j = 0;
+ }
+ j /= 4;
+ if (j > ARRAY_SIZE(pp->arg))
+ ferr(po, "esp adjust too large: %d\n", j);
+ pp->ret_type.name = strdup("int");
+ pp->argc = pp->argc_stack = j;
+ for (arg = 0; arg < pp->argc; arg++)
+ pp->arg[arg].type.name = strdup("int");
+ }
po->datap = pp;
}
ferr(po, "missing esp_adjust for vararg func '%s'\n",
pp->name);
- // can't call functions with non-__cdecl callbacks yet
for (arg = 0; arg < pp->argc; arg++) {
+ if (pp->arg[arg].reg != NULL) {
+ reg = char_array_i(regs_r32,
+ ARRAY_SIZE(regs_r32), pp->arg[arg].reg);
+ if (reg < 0)
+ ferr(ops, "arg '%s' is not a reg?\n", pp->arg[arg].reg);
+ regmask |= 1 << reg;
+ }
+#if 0
if (pp->arg[arg].fptr != NULL) {
+ // can't call functions with non-__cdecl callbacks yet
+ struct parsed_proto *pp_tmp;
pp_tmp = pp->arg[arg].fptr;
- if (pp_tmp->is_stdcall || pp_tmp->argc != pp_tmp->argc_stack)
- ferr(po, "'%s' has a non-__cdecl callback\n", tmpname);
+ if (pp_tmp->argc_reg != 0)
+ ferr(po, "'%s' has a callback with reg-args\n", tmpname);
}
+#endif
}
- collect_call_args(po, i, pp, &save_arg_vars,
- 0, i + opcnt * 2, 0, 0);
+ if (!pp->is_unresolved) {
+ // since we know the args, collect them
+ collect_call_args(po, i, pp, ®mask, &save_arg_vars,
+ i + opcnt * 2);
+ }
if (strstr(pp->ret_type.name, "int64"))
need_mul_var = 1;
- if (!(po->flags & OPF_TAIL) && !IS(pp->ret_type.name, "void"))
- have_func_ret = 1;
}
}
// - find POPs for PUSHes, rm both
// - scan for all used registers
// - find flag set ops for their users
+ // - do unreselved calls
// - declare indirect functions
for (i = 0; i < opcnt; i++) {
po = &ops[i];
// if we can't because of operand modification, or if we
// have math op, or branch, make it calculate flags explicitly
if (tmp_op->op == OP_TEST || tmp_op->op == OP_CMP) {
- if (branched || scan_for_mod(tmp_op, setters[j] + 1, i) >= 0)
+ if (branched || scan_for_mod(tmp_op, setters[j] + 1, i, 0) >= 0)
pfomask = 1 << pfo;
}
else if (tmp_op->op == OP_CMPS) {
{
need_mul_var = 1;
}
- else if (po->op == OP_CALL && po->operand[0].type != OPT_LABEL) {
+ else if (po->op == OP_CALL) {
pp = po->datap;
- my_assert_not(pp, NULL);
- fprintf(fout, " %s (*icall%d)(", pp->ret_type.name, i);
- for (j = 0; j < pp->argc; j++) {
- if (j > 0)
- fprintf(fout, ", ");
- fprintf(fout, "%s a%d", pp->arg[j].type.name, j + 1);
+ if (pp == NULL)
+ ferr(po, "NULL pp\n");
+
+ if (pp->is_unresolved) {
+ int regmask_push = 0;
+ collect_call_args(po, i, pp, ®mask_push, &save_arg_vars,
+ i + opcnt * 2);
+
+ if (!((regmask_push & (1 << xCX))
+ && (regmask_push & (1 << xDX))))
+ {
+ if (pp->argc_stack != 0
+ || ((regmask | regmask_arg) & (1 << xCX)))
+ {
+ pp_insert_reg_arg(pp, "ecx");
+ regmask |= 1 << xCX;
+ }
+ if (pp->argc_stack != 0
+ || ((regmask | regmask_arg) & (1 << xDX)))
+ {
+ pp_insert_reg_arg(pp, "edx");
+ regmask |= 1 << xDX;
+ }
+ }
+ regmask |= regmask_push;
+ }
+
+ if (pp->is_fptr) {
+ fprintf(fout, " %s (", pp->ret_type.name);
+ if (pp->is_stdcall && pp->argc_reg == 0)
+ fprintf(fout, "__stdcall ");
+ fprintf(fout, "*icall%d)(", i);
+ for (j = 0; j < pp->argc; j++) {
+ if (j > 0)
+ fprintf(fout, ", ");
+ fprintf(fout, "%s a%d", pp->arg[j].type.name, j + 1);
+ }
+ fprintf(fout, ");\n");
}
- fprintf(fout, ");\n");
}
- else if (po->op == OP_RET)
- have_normal_ret = 1;
+ else if (po->op == OP_RET && !IS(g_func_pp->ret_type.name, "void"))
+ regmask |= 1 << xAX;
}
// output LUTs/jumptables
if (g_func_pp->arg[i].reg != NULL) {
reg = char_array_i(regs_r32,
ARRAY_SIZE(regs_r32), g_func_pp->arg[i].reg);
- if (reg < 0)
- ferr(ops, "arg '%s' is not a reg?\n", g_func_pp->arg[i].reg);
-
- regmask_arg |= 1 << reg;
- fprintf(fout, " u32 %s = (u32)a%d;\n",
- g_func_pp->arg[i].reg, i + 1);
+ if (regmask & (1 << reg)) {
+ fprintf(fout, " u32 %s = (u32)a%d;\n",
+ g_func_pp->arg[i].reg, i + 1);
+ }
+ else
+ fprintf(fout, " // %s = a%d; // unused\n",
+ g_func_pp->arg[i].reg, i + 1);
had_decl = 1;
}
}
- // declare other regs - special case for eax
- if (!((regmask | regmask_arg) & 1)
- && (have_func_ret || have_normal_ret)
- && !IS(g_func_pp->ret_type.name, "void"))
- {
- fprintf(fout, " u32 eax = 0;\n");
- had_decl = 1;
- }
-
- regmask &= ~regmask_arg;
- regmask &= ~(1 << xSP);
- if (regmask) {
+ regmask_now = regmask & ~regmask_arg;
+ regmask_now &= ~(1 << xSP);
+ if (regmask_now) {
for (reg = 0; reg < 8; reg++) {
- if (regmask & (1 << reg)) {
+ if (regmask_now & (1 << reg)) {
fprintf(fout, " u32 %s;\n", regs_r32[reg]);
had_decl = 1;
}
case OP_CALL:
assert_operand_cnt(1);
pp = po->datap;
- if (pp == NULL)
- ferr(po, "NULL pp\n");
+ my_assert_not(pp, NULL);
- if (po->operand[0].type != OPT_LABEL)
- fprintf(fout, " icall%d = (void *)%s;\n", i,
- out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]));
+ if (pp->is_fptr)
+ fprintf(fout, " icall%d = %s;\n", i,
+ out_src_opr(buf1, sizeof(buf1), po, &po->operand[0],
+ "(void *)", 0));
fprintf(fout, " ");
if (strstr(pp->ret_type.name, "int64")) {
fprintf(fout, "(%s)", g_func_pp->ret_type.name);
}
}
- else {
+ else if (regmask & (1 << xAX)) {
fprintf(fout, "eax = ");
if (pp->ret_type.is_ptr)
fprintf(fout, "(u32)");
}
}
- if (po->operand[0].type != OPT_LABEL) {
+ if (pp->is_fptr) {
fprintf(fout, "icall%d(", i);
}
else {
fprintf(fout, " eax = mul_tmp;");
}
+ if (pp->is_unresolved) {
+ snprintf(buf3, sizeof(buf3), "unresoved %dreg ",
+ pp->argc_reg);
+ strcat(g_comment, buf3);
+ }
+
if (po->flags & OPF_TAIL) {
- strcpy(g_comment, "tailcall");
ret = 0;
if (i == opcnt - 1)
ret = 0;
if (!IS(g_func_pp->ret_type.name, "void"))
ferr(po, "int func -> void func tailcall?\n");
fprintf(fout, "\n return;");
- strcpy(g_comment, "^ tailcall");
+ strcat(g_comment, "^ tailcall");
}
+ else
+ strcat(g_comment, "tailcall");
}
delayed_flag_op = NULL;
last_arith_dst = NULL;
// see is delayed flag stuff is still valid
if (delayed_flag_op != NULL && delayed_flag_op != po) {
- if (is_any_opr_modified(delayed_flag_op, po))
+ if (is_any_opr_modified(delayed_flag_op, po, 0))
delayed_flag_op = NULL;
}
int eq_alloc;
int verbose = 0;
int arg_out;
- int arg = 1;
+ int arg;
int pi = 0;
int i, j;
int ret, len;
char *p;
int wordc;
- if (argv[1] && IS(argv[1], "-v")) {
- verbose = 1;
- arg++;
+ for (arg = 1; arg < argc; arg++) {
+ if (IS(argv[arg], "-v"))
+ verbose = 1;
+ else if (IS(argv[arg], "-rf"))
+ g_allow_regfunc = 1;
+ else
+ break;
}
if (argc < arg + 3) {
- printf("usage:\n%s [-v] <.c> <.asm> <hdrf> [rlist]*\n",
+ printf("usage:\n%s [-v] [-rf] <.c> <.asm> <hdrf> [rlist]*\n",
argv[0]);
return 1;
}
while (fgets(line, sizeof(line), frlist)) {
p = sskip(line);
- if (*p == 0 || *p == ';' || *p == '#')
+ if (*p == 0 || *p == ';')
+ continue;
+ if (*p == '#') {
+ if (IS_START(p, "#if 0")
+ || (g_allow_regfunc && IS_START(p, "#if NO_REGFUNC")))
+ {
+ skip_func = 1;
+ }
+ else if (IS_START(p, "#endif"))
+ skip_func = 0;
+ continue;
+ }
+ if (skip_func)
continue;
p = next_word(words[0], sizeof(words[0]), p);
}
rlist[rlist_len++] = strdup(words[0]);
}
+ skip_func = 0;
fclose(frlist);
frlist = NULL;