+/*
+ * ia32rtools
+ * (C) notaz, 2013,2014
+ *
+ * This work is licensed under the terms of 3-clause BSD license.
+ * See COPYING file in the top-level directory.
+ */
+
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
OPF_ATAIL = (1 << 14), /* tail call with reused arg frame */
OPF_32BIT = (1 << 15), /* 32bit division */
OPF_LOCK = (1 << 16), /* op has lock prefix */
+ OPF_VAPUSH = (1 << 17), /* vararg ptr push (as call arg) */
};
enum op_op {
OP_SHL,
OP_SHR,
OP_SAR,
+ OP_SHRD,
OP_ROL,
OP_ROR,
OP_RCL,
OP_JECXZ,
OP_JCC,
OP_SCC,
+ // x87
+ // mmx
+ OP_EMMS,
};
enum opr_type {
OPLM_BYTE,
OPLM_WORD,
OPLM_DWORD,
+ OPLM_QWORD,
};
#define MAX_OPERANDS 3
+#define NAMELEN 112
struct parsed_opr {
enum opr_type type;
const struct parsed_proto *pp; // for OPT_LABEL
int reg;
unsigned int val;
- char name[112];
+ char name[NAMELEN];
};
struct parsed_op {
unsigned char pfo;
unsigned char pfo_inv;
unsigned char operand_cnt;
- unsigned char pad;
+ unsigned char p_argnum; // push: altered before call arg #
+ unsigned char p_argpass;// push: arg of host func
+ unsigned char pad[3];
int regmask_src; // all referensed regs
int regmask_dst;
int pfomask; // flagop: parsed_flag_op that can't be delayed
- int argnum; // push: altered before call arg #
int cc_scratch; // scratch storage during analysis
int bt_i; // branch target for branches
struct parsed_data *btj;// branch targets for jumptables
static int g_stack_fsz;
static int g_ida_func_attr;
static int g_allow_regfunc;
+static int g_quiet_pp;
+
#define ferr(op_, fmt, ...) do { \
printf("%s:%d: error: [%s] '%s': " fmt, asmfn, (op_)->asmln, g_func, \
dump_op(op_), ##__VA_ARGS__); \
printf("%s:%d: note: [%s] '%s': " fmt, asmfn, (op_)->asmln, g_func, \
dump_op(op_), ##__VA_ARGS__)
-#define MAX_REGS 8
-
-const char *regs_r32[] = { "eax", "ebx", "ecx", "edx", "esi", "edi", "ebp", "esp" };
+const char *regs_r32[] = {
+ "eax", "ebx", "ecx", "edx", "esi", "edi", "ebp", "esp",
+ // not r32, but list here for easy parsing and printing
+ "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
+};
const char *regs_r16[] = { "ax", "bx", "cx", "dx", "si", "di", "bp", "sp" };
const char *regs_r8l[] = { "al", "bl", "cl", "dl" };
const char *regs_r8h[] = { "ah", "bh", "ch", "dh" };
PFO_LE, // e ZF=1||SF!=OF
};
+#define PFOB_O (1 << PFO_O)
+#define PFOB_C (1 << PFO_C)
+#define PFOB_Z (1 << PFO_Z)
+#define PFOB_S (1 << PFO_S)
+
static const char *parsed_flag_op_names[] = {
"o", "c", "z", "be", "s", "p", "l", "le"
};
snprintf(buf, buf_size, number < 10 ? "%lu" : "0x%02lx", number);
}
+static int check_segment_prefix(const char *s)
+{
+ if (s[0] == 0 || s[1] != 's' || s[2] != ':')
+ return 0;
+
+ switch (s[0]) {
+ case 'c': return 1;
+ case 'd': return 2;
+ case 's': return 3;
+ case 'e': return 4;
+ case 'f': return 5;
+ case 'g': return 6;
+ default: return 0;
+ }
+}
+
static int parse_reg(enum opr_lenmod *reg_lmod, const char *s)
{
int reg;
reg = char_array_i(regs_r32, ARRAY_SIZE(regs_r32), s);
+ if (reg >= 8) {
+ *reg_lmod = OPLM_QWORD;
+ return reg;
+ }
if (reg >= 0) {
*reg_lmod = OPLM_DWORD;
return reg;
s++;
*d = 0;
- // skip 'ds:' prefix
- if (IS_START(s, "ds:"))
+ // skip '?s:' prefixes
+ if (check_segment_prefix(s))
s += 3;
s = next_idt(w, sizeof(w), s);
return 0;
}
-static const char *parse_stack_el(const char *name, char *extra_reg)
+static const char *parse_stack_el(const char *name, char *extra_reg,
+ int early_try)
{
const char *p, *p2, *s;
char *endp = NULL;
long val;
int len;
- p = name;
- if (IS_START(p + 3, "+ebp+") && is_reg_in_str(p)) {
- p += 4;
- if (extra_reg != NULL) {
- strncpy(extra_reg, name, 3);
- extra_reg[4] = 0;
+ if (g_bp_frame || early_try)
+ {
+ p = name;
+ if (IS_START(p + 3, "+ebp+") && is_reg_in_str(p)) {
+ p += 4;
+ if (extra_reg != NULL) {
+ strncpy(extra_reg, name, 3);
+ extra_reg[4] = 0;
+ }
}
- }
- if (IS_START(p, "ebp+")) {
- p += 4;
+ if (IS_START(p, "ebp+")) {
+ p += 4;
- p2 = strchr(p, '+');
- if (p2 != NULL && is_reg_in_str(p)) {
- if (extra_reg != NULL) {
- strncpy(extra_reg, p, p2 - p);
- extra_reg[p2 - p] = 0;
+ p2 = strchr(p, '+');
+ if (p2 != NULL && is_reg_in_str(p)) {
+ if (extra_reg != NULL) {
+ strncpy(extra_reg, p, p2 - p);
+ extra_reg[p2 - p] = 0;
+ }
+ p = p2 + 1;
}
- p = p2 + 1;
- }
- if (!('0' <= *p && *p <= '9'))
- return p;
+ if (!('0' <= *p && *p <= '9'))
+ return p;
- return NULL;
+ return NULL;
+ }
}
if (!IS_START(name, "esp+"))
opr->lmod = OPLM_BYTE;
return 1;
}
+ if (!strncmp(opr->name, "qword_", 6)) {
+ opr->lmod = OPLM_QWORD;
+ return 1;
+ }
return 0;
}
static const char *dword_types[] = {
"int", "_DWORD", "UINT_PTR", "DWORD",
"WPARAM", "LPARAM", "UINT", "__int32",
- "LONG", "HIMC",
+ "LONG", "HIMC", "BOOL", "size_t",
+ "float",
};
static const char *word_types[] = {
"uint16_t", "int16_t", "_WORD", "WORD",
int *regmask, int *regmask_indirect,
char words[16][256], int wordc, int w, unsigned int op_flags)
{
- const struct parsed_proto *pp;
+ const struct parsed_proto *pp = NULL;
enum opr_lenmod tmplmod;
unsigned long number;
char buf[256];
if (label != NULL) {
opr->type = OPT_LABEL;
- if (IS_START(label, "ds:")) {
+ ret = check_segment_prefix(label);
+ if (ret != 0) {
+ if (ret >= 5)
+ aerr("fs/gs used\n");
opr->had_ds = 1;
label += 3;
}
opr->lmod = OPLM_WORD;
else if (IS(words[w], "byte"))
opr->lmod = OPLM_BYTE;
+ else if (IS(words[w], "qword"))
+ opr->lmod = OPLM_QWORD;
else
aerr("type parsing failed\n");
w += 2;
if (wordc_in != 1)
aerr("parse_operand 1 word expected\n");
- if (IS_START(words[w], "ds:")) {
+ ret = check_segment_prefix(words[w]);
+ if (ret != 0) {
+ if (ret >= 5)
+ aerr("fs/gs used\n");
opr->had_ds = 1;
memmove(words[w], words[w] + 3, strlen(words[w]) - 2);
}
aerr("[] parse failure\n");
parse_indmode(opr->name, regmask_indirect, 1);
- if (opr->lmod == OPLM_UNSPEC && parse_stack_el(opr->name, NULL)) {
+ if (opr->lmod == OPLM_UNSPEC && parse_stack_el(opr->name, NULL, 1))
+ {
// might be an equ
struct parsed_equ *eq =
- equ_find(NULL, parse_stack_el(opr->name, NULL), &i);
+ equ_find(NULL, parse_stack_el(opr->name, NULL, 1), &i);
if (eq)
opr->lmod = eq->lmod;
}
// 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, g_quiet_pp);
do_label:
if (pp != NULL) {
{ "shr", OP_SHR, 2, 2, OPF_DATA|OPF_FLAGS },
{ "sal", OP_SHL, 2, 2, OPF_DATA|OPF_FLAGS },
{ "sar", OP_SAR, 2, 2, OPF_DATA|OPF_FLAGS },
+ { "shrd", OP_SHRD, 3, 3, OPF_DATA|OPF_FLAGS },
{ "rol", OP_ROL, 2, 2, OPF_DATA|OPF_FLAGS },
{ "ror", OP_ROR, 2, 2, OPF_DATA|OPF_FLAGS },
{ "rcl", OP_RCL, 2, 2, OPF_DATA|OPF_FLAGS|OPF_CC, PFO_C },
{ "setng", OP_SCC, 1, 1, OPF_DATA|OPF_CC, PFO_LE, 0 },
{ "setg", OP_SCC, 1, 1, OPF_DATA|OPF_CC, PFO_LE, 1 },
{ "setnle", OP_SCC, 1, 1, OPF_DATA|OPF_CC, PFO_LE, 1 },
+ // x87
+ // mmx
+ { "emms", OP_EMMS, 0, 0, OPF_DATA },
+ { "movq", OP_MOV, 2, 2, OPF_DATA },
};
static void parse_op(struct parsed_op *op, char words[16][256], int wordc)
op->regmask_src = op->regmask_dst = 0;
op->asmln = asmln;
- for (opr = 0; opr < op_table[i].minopr; opr++) {
+ for (opr = 0; opr < op_table[i].maxopr; opr++) {
+ if (opr >= op_table[i].minopr && w >= wordc)
+ break;
+
regmask = regmask_ind = 0;
w = parse_operand(&op->operand[opr], ®mask, ®mask_ind,
words, wordc, w, op->flags);
if (opr == 0 && (op->flags & OPF_DATA))
op->regmask_dst = regmask;
- // for now, mark dst as src too
- op->regmask_src |= regmask | regmask_ind;
- }
-
- for (; w < wordc && opr < op_table[i].maxopr; opr++) {
- w = parse_operand(&op->operand[opr],
- &op->regmask_src, &op->regmask_src,
- words, wordc, w, op->flags);
+ else
+ op->regmask_src |= regmask;
+ op->regmask_src |= regmask_ind;
}
if (w < wordc)
if (!strncmp(op_table[i].name, "set", 3))
op->operand[0].lmod = OPLM_BYTE;
- // ops with implicit argumets
switch (op->op) {
+ // first operand is not dst
+ case OP_CMP:
+ case OP_TEST:
+ op->regmask_src |= op->regmask_dst;
+ op->regmask_dst = 0;
+ break;
+
+ // first operand is src too
+ case OP_NOT:
+ case OP_ADD:
+ case OP_AND:
+ case OP_OR:
+ case OP_RCL:
+ case OP_RCR:
+ case OP_ADC:
+ case OP_INC:
+ case OP_DEC:
+ case OP_NEG:
+ // more below..
+ op->regmask_src |= op->regmask_dst;
+ break;
+
+ // special
+ case OP_XCHG:
+ op->regmask_src |= op->regmask_dst;
+ op->regmask_dst |= op->regmask_src;
+ goto check_align;
+
+ case OP_SUB:
+ case OP_SBB:
+ case OP_XOR:
+ if (op->operand[0].type == OPT_REG && op->operand[1].type == OPT_REG
+ && op->operand[0].lmod == op->operand[1].lmod
+ && op->operand[0].reg == op->operand[1].reg
+ && IS(op->operand[0].name, op->operand[1].name)) // ! ah, al..
+ {
+ op->regmask_src = 0;
+ }
+ else
+ op->regmask_src |= op->regmask_dst;
+ break;
+
+ // ops with implicit argumets
case OP_CDQ:
op->operand_cnt = 2;
setup_reg_opr(&op->operand[0], xDX, OPLM_DWORD, &op->regmask_dst);
op->regmask_dst = op->regmask_src;
break;
- case OP_XCHG:
- op->regmask_src |= op->regmask_dst;
- op->regmask_dst |= op->regmask_src;
- goto check_align;
-
case OP_JECXZ:
op->operand_cnt = 1;
op->regmask_src = 1 << xCX;
// fallthrough
case OP_MUL:
// singleop mul
+ op->regmask_src |= op->regmask_dst;
op->regmask_dst = (1 << xDX) | (1 << xAX);
- op->regmask_src |= (1 << xAX);
if (op->operand[0].lmod == OPLM_UNSPEC)
op->operand[0].lmod = OPLM_DWORD;
break;
case OP_IDIV:
// we could set up operands for edx:eax, but there is no real need to
// (see is_opr_modified())
- regmask = (1 << xDX) | (1 << xAX);
- op->regmask_dst = regmask;
- op->regmask_src |= regmask;
+ op->regmask_src |= op->regmask_dst;
+ op->regmask_dst = (1 << xDX) | (1 << xAX);
if (op->operand[0].lmod == OPLM_UNSPEC)
op->operand[0].lmod = OPLM_DWORD;
break;
case OP_SAR:
case OP_ROL:
case OP_ROR:
+ op->regmask_src |= op->regmask_dst;
if (op->operand[1].lmod == OPLM_UNSPEC)
op->operand[1].lmod = OPLM_BYTE;
break;
+ case OP_SHRD:
+ op->regmask_src |= op->regmask_dst;
+ if (op->operand[2].lmod == OPLM_UNSPEC)
+ op->operand[2].lmod = OPLM_BYTE;
+ break;
+
case OP_PUSH:
+ op->regmask_src |= op->regmask_dst;
+ op->regmask_dst = 0;
if (op->operand[0].lmod == OPLM_UNSPEC
&& (op->operand[0].type == OPT_CONST
|| op->operand[0].type == OPT_OFFSET
if (op->operand[0].type == OPT_REG && op->operand[1].type == OPT_REG
&& op->operand[0].lmod == op->operand[1].lmod
&& op->operand[0].reg == op->operand[1].reg
- && IS(op->operand[0].name, op->operand[1].name)) // ah, al..
+ && IS(op->operand[0].name, op->operand[1].name)) // ! ah, al..
{
op->flags |= OPF_RMD;
op->regmask_src = op->regmask_dst = 0;
op->regmask_dst = 0;
break;
+ case OP_LEAVE:
+ op->regmask_dst = (1 << xBP) | (1 << xSP);
+ op->regmask_src = 1 << xBP;
+ break;
+
default:
break;
}
enum opr_lenmod lmod)
{
switch (lmod) {
+ case OPLM_QWORD:
+ return "u64";
case OPLM_DWORD:
return "u32";
case OPLM_WORD:
enum opr_lenmod lmod)
{
switch (lmod) {
+ case OPLM_QWORD:
+ return "";
case OPLM_DWORD:
return "";
case OPLM_WORD:
enum opr_lenmod lmod)
{
switch (lmod) {
+ case OPLM_QWORD:
+ return "*(u64 *)";
case OPLM_DWORD:
return "*(u32 *)";
case OPLM_WORD:
enum opr_lenmod lmod)
{
switch (lmod) {
+ case OPLM_QWORD:
+ return "(s64)";
case OPLM_DWORD:
return "(s32)";
case OPLM_WORD:
static int lmod_bytes(struct parsed_op *po, enum opr_lenmod lmod)
{
switch (lmod) {
+ case OPLM_QWORD:
+ return 8;
case OPLM_DWORD:
return 4;
case OPLM_WORD:
static const char *opr_reg_p(struct parsed_op *po, struct parsed_opr *popr)
{
- if ((unsigned int)popr->reg >= MAX_REGS)
+ if ((unsigned int)popr->reg >= ARRAY_SIZE(regs_r32))
ferr(po, "invalid reg: %d\n", popr->reg);
return regs_r32[popr->reg];
}
static int is_stack_access(struct parsed_op *po,
const struct parsed_opr *popr)
{
- return (parse_stack_el(popr->name, NULL)
+ return (parse_stack_el(popr->name, NULL, 0)
|| (g_bp_frame && !(po->flags & OPF_EBP_S)
&& IS_START(popr->name, "ebp")));
}
ferr(po, "ebp- parse of '%s' failed\n", name);
}
else {
- bp_arg = parse_stack_el(name, ofs_reg);
+ bp_arg = parse_stack_el(name, ofs_reg, 0);
snprintf(g_comment, sizeof(g_comment), "%s", bp_arg);
eq = equ_find(po, bp_arg, &offset);
if (eq == NULL)
*bp_arg_out = bp_arg;
}
-static void stack_frame_access(struct parsed_op *po,
+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)
{
int unaligned = 0;
int stack_ra = 0;
int offset = 0;
+ int retval = -1;
int sf_ofs;
int lim;
if (cast[0] == 0)
cast = "(u32)";
snprintf(buf, buf_size, "%sap", cast);
- return;
+ return -1;
}
ferr(po, "offset %d (%s,%d) doesn't map to any arg\n",
offset, bp_arg, arg_i);
ferr(po, "arg %d not in prototype?\n", arg_i);
popr->is_ptr = g_func_pp->arg[i].type.is_ptr;
+ retval = i;
switch (popr->lmod)
{
// common problem
guess_lmod_from_c_type(&tmp_lmod, &g_func_pp->arg[i].type);
if (tmp_lmod != OPLM_DWORD
- && (unaligned || (!is_src && tmp_lmod < popr->lmod)))
+ && (unaligned || (!is_src && lmod_bytes(po, tmp_lmod)
+ < lmod_bytes(po, popr->lmod) + (offset & 3))))
{
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);
ferr(po, "bp_stack bad lmod: %d\n", popr->lmod);
}
}
+
+ return retval;
}
static void check_func_pp(struct parsed_op *po,
const struct parsed_proto *pp, const char *pfx)
{
+ enum opr_lenmod tmp_lmod;
char buf[256];
+ int ret, i;
if (pp->argc_reg != 0) {
if (/*!g_allow_regfunc &&*/ !pp->is_fastcall) {
ferr(po, "%s: %d reg arg(s) with %d stack arg(s)\n",
pfx, pp->argc_reg, pp->argc_stack);
}
+
+ // fptrs must use 32bit args, callsite might have no information and
+ // lack a cast to smaller types, which results in incorrectly masked
+ // args passed (callee may assume masked args, it does on ARM)
+ if (!pp->is_oslib) {
+ for (i = 0; i < pp->argc; i++) {
+ ret = guess_lmod_from_c_type(&tmp_lmod, &pp->arg[i].type);
+ if (ret && tmp_lmod != OPLM_DWORD)
+ ferr(po, "reference to %s with arg%d '%s'\n", pp->name,
+ i + 1, pp->arg[i].type.name);
+ }
+ }
}
static const char *check_label_read_ref(struct parsed_op *po,
ferr(po, "lea from reg?\n");
switch (popr->lmod) {
+ case OPLM_QWORD:
+ snprintf(buf, buf_size, "%s%s.q", cast, opr_reg_p(po, popr));
+ break;
case OPLM_DWORD:
snprintf(buf, buf_size, "%s%s", cast, opr_reg_p(po, popr));
break;
switch (popr->type) {
case OPT_REG:
switch (popr->lmod) {
+ case OPLM_QWORD:
+ snprintf(buf, buf_size, "%s.q", opr_reg_p(po, popr));
+ break;
case OPLM_DWORD:
snprintf(buf, buf_size, "%s", opr_reg_p(po, popr));
break;
char buf1[256], buf2[256];
enum opr_lenmod lmod;
- if (po->operand[0].lmod != po->operand[1].lmod)
+ if (po->op != OP_DEC && po->operand[0].lmod != po->operand[1].lmod)
ferr(po, "%s: lmod mismatch: %d %d\n", __func__,
po->operand[0].lmod, po->operand[1].lmod);
lmod = po->operand[0].lmod;
}
out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], cast_use, 0);
- out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], 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);
switch (pfo) {
case PFO_C:
buf1, is_inv ? ">=" : "<", buf2);
break;
- case PFO_LE:
+ case PFO_LE: // !g
snprintf(buf, buf_size, "(%s %s %s)",
buf1, is_inv ? ">" : "<=", buf2);
break;
if (po->flags & OPF_TAIL) {
if (po->op == OP_CALL) {
- pp = proto_parse(g_fhdr, po->operand[0].name, 0);
+ pp = proto_parse(g_fhdr, po->operand[0].name, g_quiet_pp);
if (pp != NULL && pp->is_noreturn)
// no stack cleanup for noreturn
return ret;
}
if ((po->flags & OPF_RMD)
- || (po->op == OP_PUSH && po->argnum != 0)) // arg push
+ || (po->op == OP_PUSH && po->p_argnum != 0)) // arg push
continue;
if ((po->flags & OPF_JMP) && po->op != OP_CALL) {
return -1;
}
+#define check_i(po, i) \
+ if ((i) < 0) \
+ ferr(po, "bad " #i ": %d\n", i)
+
static int scan_for_flag_set(int i, int magic, int *branched,
int *setters, int *setter_cnt)
{
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,
branched, setters, setter_cnt);
if (ret < 0)
return ret;
}
+ check_i(&ops[i], lr->i);
if (i > 0 && LAST_OP(i - 1)) {
i = lr->i;
continue;
p = strchr(opr->name + 1, '[');
memcpy(buf, opr->name, p - opr->name);
buf[p - opr->name] = 0;
- pp = proto_parse(g_fhdr, buf, 0);
+ pp = proto_parse(g_fhdr, buf, g_quiet_pp);
}
else if (opr->type == OPT_OFFSET || opr->type == OPT_LABEL) {
pp = proto_parse(g_fhdr, opr->name, 0);
while (1) {
if (g_labels[i][0] != 0) {
lr = &g_label_refs[i];
- for (; lr != NULL; lr = lr->next)
+ for (; lr != NULL; lr = lr->next) {
+ check_i(&ops[i], lr->i);
scan_for_call_type(lr->i, opr, magic, pp_found, multi);
+ }
if (i > 0 && LAST_OP(i - 1))
return;
}
return pp;
}
-static int try_resolve_const(int i, const struct parsed_opr *opr,
- int magic, unsigned int *val)
+// find an instruction that changed opr before i op
+// *op_i must be set to -1 by caller
+// *entry is set to 1 if one source is determined to be the caller
+// returns 1 if found, *op_i is then set to origin
+static int resolve_origin(int i, const struct parsed_opr *opr,
+ int magic, int *op_i, int *is_caller)
{
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][0] != 0) {
lr = &g_label_refs[i];
- for (; lr != NULL; lr = lr->next)
- ret |= try_resolve_const(lr->i, opr, magic, val);
+ for (; lr != NULL; lr = lr->next) {
+ check_i(&ops[i], lr->i);
+ ret |= resolve_origin(lr->i, opr, magic, op_i, is_caller);
+ }
if (i > 0 && LAST_OP(i - 1))
return ret;
}
i--;
- if (i < 0)
+ if (i < 0) {
+ if (is_caller != NULL)
+ *is_caller = 1;
return -1;
+ }
if (ops[i].cc_scratch == magic)
return 0;
continue;
if (!is_opr_modified(opr, &ops[i]))
continue;
+
+ if (*op_i >= 0) {
+ if (*op_i == i)
+ return 1;
+ // XXX: could check if the other op does the same
+ return -1;
+ }
+
+ *op_i = i;
+ return 1;
+ }
+}
+
+static int try_resolve_const(int i, const struct parsed_opr *opr,
+ int magic, unsigned int *val)
+{
+ int s_i = -1;
+ int ret;
+
+ ret = resolve_origin(i, opr, magic, &s_i, NULL);
+ if (ret == 1) {
+ i = s_i;
if (ops[i].op != OP_MOV && ops[i].operand[1].type != OPT_CONST)
return -1;
*val = ops[i].operand[1].val;
return 1;
}
+
+ return -1;
}
static int collect_call_args_r(struct parsed_op *po, int i,
struct parsed_proto *pp_tmp;
struct label_ref *lr;
int need_to_save_current;
+ int save_args;
int ret = 0;
- int j;
+ int reg;
+ char buf[32];
+ int j, k;
if (i < 0) {
ferr(po, "dead label encountered\n");
if (lr->next != NULL)
need_op_saving = 1;
for (; lr->next; lr = lr->next) {
+ 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,
return ret;
}
+ check_i(&ops[j], lr->i);
if ((ops[lr->i].flags & (OPF_JMP|OPF_CJMP)) != OPF_JMP)
may_reuse = 1;
if (j > 0 && LAST_OP(j - 1)) {
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);
}
- else if (ops[j].op == OP_ADD && ops[j].operand[0].reg == xSP) {
+ // esp adjust of 0 means we collected it before
+ else if (ops[j].op == OP_ADD && ops[j].operand[0].reg == xSP
+ && (ops[j].operand[1].type != OPT_CONST
+ || ops[j].operand[1].val != 0))
+ {
if (pp->is_unresolved)
break;
- ferr(po, "arg collect %d/%d hit esp adjust\n",
- arg, pp->argc);
+ ferr(po, "arg collect %d/%d hit esp adjust of %d\n",
+ arg, pp->argc, ops[j].operand[1].val);
}
else if (ops[j].op == OP_POP) {
if (pp->is_unresolved)
pp->arg[arg].datap = &ops[j];
need_to_save_current = 0;
+ save_args = 0;
+ reg = -1;
+ if (ops[j].operand[0].type == OPT_REG)
+ reg = ops[j].operand[0].reg;
+
if (!need_op_saving) {
ret = scan_for_mod(&ops[j], j + 1, i, 1);
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].argnum == 0) {
- ops[j].argnum = arg + 1;
- *save_arg_vars |= 1 << arg;
+ 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;
}
- else if (ops[j].argnum < arg + 1)
- ferr(&ops[j], "argnum conflict (%d<%d) for '%s'\n",
- ops[j].argnum, arg + 1, pp->name);
}
- else if (ops[j].argnum == 0)
+ else if (ops[j].p_argnum == 0)
ops[j].flags |= OPF_RMD;
// some PUSHes are reused by different calls on other branches,
ops[j].flags &= ~OPF_RSAVE;
+ // check for __VALIST
+ if (!pp->is_unresolved && pp->arg[arg].type.is_va_list) {
+ k = -1;
+ ret = resolve_origin(j, &ops[j].operand[0],
+ magic + 1, &k, NULL);
+ if (ret == 1 && k >= 0)
+ {
+ if (ops[k].op == OP_LEA) {
+ snprintf(buf, sizeof(buf), "arg_%X",
+ g_func_pp->argc_stack * 4);
+ if (!g_func_pp->is_vararg
+ || strstr(ops[k].operand[1].name, buf))
+ {
+ ops[k].flags |= OPF_RMD;
+ ops[j].flags |= OPF_RMD | OPF_VAPUSH;
+ save_args &= ~(1 << arg);
+ reg = -1;
+ }
+ else
+ ferr(&ops[j], "lea va_list used, but no vararg?\n");
+ }
+ // check for va_list from g_func_pp arg too
+ else if (ops[k].op == OP_MOV
+ && is_stack_access(&ops[k], &ops[k].operand[1]))
+ {
+ ret = stack_frame_access(&ops[k], &ops[k].operand[1],
+ buf, sizeof(buf), ops[k].operand[1].name, "", 1, 0);
+ if (ret >= 0) {
+ ops[k].flags |= OPF_RMD;
+ ops[j].flags |= OPF_RMD;
+ ops[j].p_argpass = ret + 1;
+ save_args &= ~(1 << arg);
+ reg = -1;
+ }
+ }
+ }
+ }
+
+ *save_arg_vars |= save_args;
+
+ // tracking reg usage
+ if (reg >= 0)
+ *regmask |= 1 << reg;
+
arg++;
if (!pp->is_unresolved) {
// next arg
break;
}
magic = (magic & 0xffffff) | (arg << 24);
-
- // tracking reg usage
- if (ops[j].operand[0].type == OPT_REG)
- *regmask |= 1 << ops[j].operand[0].reg;
}
}
lr->next = lr_new;
}
+static struct parsed_data *try_resolve_jumptab(int i, int opcnt)
+{
+ struct parsed_op *po = &ops[i];
+ struct parsed_data *pd;
+ char label[NAMELEN], *p;
+ int len, j, l;
+
+ p = strchr(po->operand[0].name, '[');
+ if (p == NULL)
+ return NULL;
+
+ len = p - po->operand[0].name;
+ strncpy(label, po->operand[0].name, len);
+ label[len] = 0;
+
+ for (j = 0, pd = NULL; j < g_func_pd_cnt; j++) {
+ if (IS(g_func_pd[j].label, label)) {
+ pd = &g_func_pd[j];
+ break;
+ }
+ }
+ if (pd == NULL)
+ //ferr(po, "label '%s' not parsed?\n", label);
+ return NULL;
+
+ if (pd->type != OPT_OFFSET)
+ ferr(po, "label '%s' with non-offset data?\n", label);
+
+ // find all labels, link
+ for (j = 0; j < pd->count; j++) {
+ for (l = 0; l < opcnt; l++) {
+ if (g_labels[l][0] && IS(g_labels[l], pd->d[j].u.label)) {
+ add_label_ref(&g_label_refs[l], i);
+ pd->d[j].bt_i = l;
+ break;
+ }
+ }
+ }
+
+ return pd;
+}
+
static void output_std_flags(FILE *fout, struct parsed_op *po,
int *pfomask, const char *dst_opr_text)
{
} while (i < opcnt);
}
else {
- for (i = 0; i < opcnt; i++) {
+ int ecx_push = 0, esp_sub = 0;
+
+ i = 0;
+ while (ops[i].op == OP_PUSH && IS(opr_name(&ops[i], 0), "ecx")) {
+ ops[i].flags |= OPF_RMD;
+ g_stack_fsz += 4;
+ ecx_push++;
+ i++;
+ }
+
+ for (; i < opcnt; i++) {
if (ops[i].op == OP_PUSH || (ops[i].flags & (OPF_JMP|OPF_TAIL)))
break;
if (ops[i].op == OP_SUB && ops[i].operand[0].reg == xSP
&& ops[i].operand[1].type == OPT_CONST)
{
- g_sp_frame = 1;
+ g_stack_fsz = ops[i].operand[1].val;
+ ops[i].flags |= OPF_RMD;
+ esp_sub = 1;
break;
}
}
found = 0;
- if (g_sp_frame)
+ if (ecx_push || esp_sub)
{
- g_stack_fsz = ops[i].operand[1].val;
- ops[i].flags |= OPF_RMD;
+ g_sp_frame = 1;
i++;
do {
j--;
}
- 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)
- ferr(&ops[j], "'add esp' expected\n");
- ops[j].flags |= OPF_RMD;
+ if (ecx_push > 0) {
+ for (l = 0; l < ecx_push; l++) {
+ if (ops[j].op != OP_POP
+ || !IS(opr_name(&ops[j], 0), "ecx"))
+ {
+ ferr(&ops[j], "'pop ecx' expected\n");
+ }
+ ops[j].flags |= OPF_RMD;
+ j--;
+ }
+
+ found = 1;
+ }
+
+ 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)
+ ferr(&ops[j], "'add esp' expected\n");
+ ops[j].flags |= OPF_RMD;
+
+ found = 1;
+ }
- found = 1;
i++;
} while (i < opcnt);
}
continue;
if (po->operand[0].type == OPT_REGMEM) {
- char *p = strchr(po->operand[0].name, '[');
- if (p == NULL)
- goto tailcall;
- ret = p - po->operand[0].name;
- strncpy(buf1, po->operand[0].name, ret);
- buf1[ret] = 0;
-
- for (j = 0, pd = NULL; j < g_func_pd_cnt; j++) {
- if (IS(g_func_pd[j].label, buf1)) {
- pd = &g_func_pd[j];
- break;
- }
- }
+ pd = try_resolve_jumptab(i, opcnt);
if (pd == NULL)
- //ferr(po, "label '%s' not parsed?\n", buf1);
goto tailcall;
- if (pd->type != OPT_OFFSET)
- ferr(po, "label '%s' with non-offset data?\n", buf1);
-
- // find all labels, link
- for (j = 0; j < pd->count; j++) {
- for (l = 0; l < opcnt; l++) {
- if (g_labels[l][0] && IS(g_labels[l], pd->d[j].u.label)) {
- add_label_ref(&g_label_refs[l], i);
- pd->d[j].bt_i = l;
- break;
- }
- }
- }
po->btj = pd;
continue;
regmask_save |= 1 << reg;
}
- if (po->op == OP_PUSH && po->argnum == 0
+ if (po->op == OP_PUSH && po->p_argnum == 0
&& !(po->flags & OPF_RSAVE) && !g_func_pp->is_userstack)
{
if (po->operand[0].type == OPT_REG)
tmp_op = pp->arg[arg].datap;
if (tmp_op == NULL)
ferr(po, "parsed_op missing for arg%d\n", arg);
- if (tmp_op->argnum == 0 && tmp_op->operand[0].type == OPT_REG)
+ if (tmp_op->p_argnum == 0 && tmp_op->operand[0].type == OPT_REG)
regmask_stack |= 1 << tmp_op->operand[0].reg;
}
regmask_now = regmask & ~regmask_arg;
regmask_now &= ~(1 << xSP);
- if (regmask_now) {
+ if (regmask_now & 0x00ff) {
for (reg = 0; reg < 8; reg++) {
if (regmask_now & (1 << reg)) {
fprintf(fout, " u32 %s", regs_r32[reg]);
}
}
}
+ if (regmask_now & 0xff00) {
+ for (reg = 8; reg < 16; reg++) {
+ if (regmask_now & (1 << reg)) {
+ fprintf(fout, " mmxr %s", regs_r32[reg]);
+ if (regmask_init & (1 << reg))
+ fprintf(fout, " = { 0, }");
+ fprintf(fout, ";\n");
+ had_decl = 1;
+ }
+ }
+ }
if (regmask_save) {
for (reg = 0; reg < 8; reg++) {
delayed_flag_op = NULL;
break;
+ case OP_SHRD:
+ assert_operand_cnt(3);
+ propagate_lmod(po, &po->operand[0], &po->operand[1]);
+ l = lmod_bytes(po, po->operand[0].lmod) * 8;
+ out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
+ out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]);
+ out_src_opr_u32(buf3, sizeof(buf3), po, &po->operand[2]);
+ fprintf(fout, " %s >>= %s; %s |= %s << (%d - %s);",
+ buf1, buf3, buf1, buf2, l, buf3);
+ strcpy(g_comment, "shrd");
+ output_std_flags(fout, po, &pfomask, buf1);
+ last_arith_dst = &po->operand[0];
+ delayed_flag_op = NULL;
+ break;
+
case OP_ROL:
case OP_ROR:
assert_operand_cnt(2);
case OP_SUB:
assert_operand_cnt(2);
propagate_lmod(po, &po->operand[0], &po->operand[1]);
- if (pfomask & (1 << PFO_C)) {
- fprintf(fout, " cond_c = %s < %s;\n",
- out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]),
- out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
- pfomask &= ~(1 << PFO_C);
+ if (pfomask & ~((1 << PFO_Z) | (1 << PFO_S))) {
+ for (j = 0; j <= PFO_LE; j++) {
+ if (!(pfomask & (1 << j)))
+ continue;
+ if (j == PFO_Z || j == PFO_S)
+ continue;
+
+ out_cmp_for_cc(buf1, sizeof(buf1), po, j, 0);
+ fprintf(fout, " cond_%s = %s;\n",
+ parsed_flag_op_names[j], buf1);
+ pfomask &= ~(1 << j);
+ }
}
goto dualop_arith;
strcat(g_comment, "bsf");
break;
- case OP_INC:
case OP_DEC:
+ if (pfomask & ~(PFOB_S | PFOB_S | PFOB_C)) {
+ for (j = 0; j <= PFO_LE; j++) {
+ if (!(pfomask & (1 << j)))
+ continue;
+ if (j == PFO_Z || j == PFO_S || j == PFO_C)
+ continue;
+
+ out_cmp_for_cc(buf1, sizeof(buf1), po, j, 0);
+ fprintf(fout, " cond_%s = %s;\n",
+ parsed_flag_op_names[j], buf1);
+ pfomask &= ~(1 << j);
+ }
+ }
+ // fallthrough
+
+ case OP_INC:
+ if (pfomask & (1 << PFO_C))
+ // carry is unaffected by inc/dec.. wtf?
+ ferr(po, "carry propagation needed\n");
+
out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
if (po->operand[0].type == OPT_REG) {
strcpy(buf2, po->op == OP_INC ? "++" : "--");
tmp_op = pp->arg[arg].datap;
if (tmp_op == NULL)
ferr(po, "parsed_op missing for arg%d\n", arg);
- if (tmp_op->argnum != 0) {
- fprintf(fout, "%ss_a%d", cast, tmp_op->argnum);
+
+ if (tmp_op->flags & OPF_VAPUSH) {
+ fprintf(fout, "ap");
+ }
+ else if (tmp_op->p_argpass != 0) {
+ fprintf(fout, "a%d", tmp_op->p_argpass);
+ }
+ else if (tmp_op->p_argnum != 0) {
+ fprintf(fout, "%ss_a%d", cast, tmp_op->p_argnum);
}
else {
fprintf(fout, "%s",
case OP_PUSH:
out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]);
- if (po->argnum != 0) {
+ if (po->p_argnum != 0) {
// special case - saved func arg
- fprintf(fout, " s_a%d = %s;", po->argnum, buf1);
+ fprintf(fout, " s_a%d = %s;", po->p_argnum, buf1);
break;
}
else if (po->flags & OPF_RSAVE) {
no_output = 1;
break;
+ // mmx
+ case OP_EMMS:
+ strcpy(g_comment, "(emms)");
+ break;
+
default:
no_output = 1;
ferr(po, "unhandled op type %d, flags %x\n",
g_func_pp = NULL;
}
+struct func_proto_dep;
+
+struct func_prototype {
+ char name[NAMELEN];
+ int id;
+ int argc_stack;
+ int regmask_dep;
+ int has_ret:3; // -1, 0, 1: unresolved, no, yes
+ unsigned int dep_resolved:1;
+ unsigned int is_stdcall:1;
+ struct func_proto_dep *dep_func;
+ int dep_func_cnt;
+};
+
+struct func_proto_dep {
+ char *name;
+ struct func_prototype *proto;
+ int regmask_live; // .. at the time of call
+ unsigned int ret_dep:1; // return from this is caller's return
+};
+
+static struct func_prototype *hg_fp;
+static int hg_fp_cnt;
+
+static struct func_proto_dep *hg_fp_find_dep(struct func_prototype *fp,
+ const char *name)
+{
+ int i;
+
+ for (i = 0; i < fp->dep_func_cnt; i++)
+ if (IS(fp->dep_func[i].name, name))
+ return &fp->dep_func[i];
+
+ return NULL;
+}
+
+static void hg_fp_add_dep(struct func_prototype *fp, const char *name)
+{
+ // is it a dupe?
+ if (hg_fp_find_dep(fp, name))
+ return;
+
+ if ((fp->dep_func_cnt & 0xff) == 0) {
+ fp->dep_func = realloc(fp->dep_func,
+ sizeof(fp->dep_func[0]) * (fp->dep_func_cnt + 0x100));
+ my_assert_not(fp->dep_func, NULL);
+ memset(&fp->dep_func[fp->dep_func_cnt], 0,
+ sizeof(fp->dep_func[0]) * 0x100);
+ }
+ fp->dep_func[fp->dep_func_cnt].name = strdup(name);
+ fp->dep_func_cnt++;
+}
+
+static int hg_fp_cmp_name(const void *p1_, const void *p2_)
+{
+ const struct func_prototype *p1 = p1_, *p2 = p2_;
+ return strcmp(p1->name, p2->name);
+}
+
+#if 0
+static int hg_fp_cmp_id(const void *p1_, const void *p2_)
+{
+ const struct func_prototype *p1 = p1_, *p2 = p2_;
+ return p1->id - p2->id;
+}
+#endif
+
+static void gen_hdr(const char *funcn, int opcnt)
+{
+ struct func_prototype *fp;
+ struct func_proto_dep *dep;
+ struct parsed_data *pd;
+ struct parsed_op *po;
+ int regmask_save = 0;
+ int regmask_dst = 0;
+ int regmask_dep = 0;
+ int max_bp_offset = 0;
+ int has_ret = -1;
+ int from_caller = 0;
+ int i, j, l, ret;
+ int depth, reg;
+
+ if ((hg_fp_cnt & 0xff) == 0) {
+ hg_fp = realloc(hg_fp, sizeof(hg_fp[0]) * (hg_fp_cnt + 0x100));
+ my_assert_not(hg_fp, NULL);
+ memset(hg_fp + hg_fp_cnt, 0, sizeof(hg_fp[0]) * 0x100);
+ }
+
+ fp = &hg_fp[hg_fp_cnt];
+ snprintf(fp->name, sizeof(fp->name), "%s", funcn);
+ fp->id = hg_fp_cnt;
+ hg_fp_cnt++;
+
+ // pass1:
+ // - collect calls
+ // - resolve all branches
+ for (i = 0; i < opcnt; i++)
+ {
+ po = &ops[i];
+ po->bt_i = -1;
+ po->btj = NULL;
+
+ if (po->flags & OPF_RMD)
+ continue;
+
+ if (po->op == OP_CALL) {
+ if (po->operand[0].type == OPT_LABEL)
+ hg_fp_add_dep(fp, opr_name(po, 0));
+
+ continue;
+ }
+
+ if (!(po->flags & OPF_JMP) || po->op == OP_RET)
+ continue;
+
+ if (po->operand[0].type == OPT_REGMEM) {
+ pd = try_resolve_jumptab(i, opcnt);
+ if (pd == NULL)
+ goto tailcall;
+
+ po->btj = pd;
+ continue;
+ }
+
+ for (l = 0; l < opcnt; l++) {
+ if (g_labels[l][0] && IS(po->operand[0].name, g_labels[l])) {
+ add_label_ref(&g_label_refs[l], i);
+ po->bt_i = l;
+ break;
+ }
+ }
+
+ if (po->bt_i != -1 || (po->flags & OPF_RMD))
+ continue;
+
+ if (po->operand[0].type == OPT_LABEL)
+ // assume tail call
+ goto tailcall;
+
+ ferr(po, "unhandled branch\n");
+
+tailcall:
+ po->op = OP_CALL;
+ po->flags |= OPF_TAIL;
+ if (i > 0 && ops[i - 1].op == OP_POP)
+ po->flags |= OPF_ATAIL;
+ i--; // reprocess
+ }
+
+ // pass2:
+ // - remove dead labels
+ for (i = 0; i < opcnt; i++)
+ {
+ if (g_labels[i][0] != 0 && g_label_refs[i].i == -1)
+ g_labels[i][0] = 0;
+ }
+
+ // pass3:
+ // - track saved regs
+ // - try to figure out arg-regs
+ for (i = 0; i < opcnt; i++)
+ {
+ po = &ops[i];
+ if (po->flags & OPF_RMD)
+ continue;
+
+ if (po->op == OP_PUSH && po->operand[0].type == OPT_REG)
+ {
+ reg = po->operand[0].reg;
+ if (reg < 0)
+ ferr(po, "reg not set for push?\n");
+
+ depth = 0;
+ ret = scan_for_pop(i + 1, opcnt,
+ po->operand[0].name, i + opcnt * 1, 0, &depth, 0);
+ if (ret == 1) {
+ regmask_save |= 1 << reg;
+ po->flags |= OPF_RMD;
+ scan_for_pop(i + 1, opcnt,
+ po->operand[0].name, i + opcnt * 2, 0, &depth, 1);
+ continue;
+ }
+ ret = scan_for_pop_ret(i + 1, opcnt, po->operand[0].name, 0);
+ if (ret == 0) {
+ regmask_save |= 1 << reg;
+ po->flags |= OPF_RMD;
+ scan_for_pop_ret(i + 1, opcnt, po->operand[0].name, OPF_RMD);
+ continue;
+ }
+ }
+ else if (po->op == OP_PUSH && po->operand[0].type == OPT_CONST) {
+ for (j = i + 1; j < opcnt; j++) {
+ if ((ops[j].flags & (OPF_JMP|OPF_TAIL|OPF_RSAVE))
+ || ops[j].op == OP_PUSH || g_labels[i][0] != 0)
+ {
+ break;
+ }
+
+ if (!(ops[j].flags & OPF_RMD) && ops[j].op == OP_POP)
+ {
+ po->flags |= OPF_RMD;
+ ops[j].datap = po;
+ break;
+ }
+ }
+ continue;
+ }
+ else if (po->op == OP_CALL) {
+ po->regmask_dst |= 1 << xAX;
+
+ dep = hg_fp_find_dep(fp, po->operand[0].name);
+ if (dep != NULL)
+ dep->regmask_live = regmask_save | regmask_dst;
+ }
+ else if (po->op == OP_RET) {
+ if (po->operand_cnt > 0)
+ fp->is_stdcall = 1;
+ }
+
+ if (has_ret != 0 && (po->flags & OPF_TAIL)) {
+ if (po->op == OP_CALL) {
+ j = i;
+ ret = 1;
+ }
+ else {
+ struct parsed_opr opr = { 0, };
+ opr.type = OPT_REG;
+ opr.reg = xAX;
+ j = -1;
+ from_caller = 0;
+ ret = resolve_origin(i, &opr, i + opcnt * 3, &j, &from_caller);
+ }
+
+ if (ret == -1 && from_caller) {
+ // unresolved eax - probably void func
+ has_ret = 0;
+ }
+ else {
+ if (ops[j].op == OP_CALL) {
+ dep = hg_fp_find_dep(fp, po->operand[0].name);
+ if (dep != NULL)
+ dep->ret_dep = 1;
+ else
+ has_ret = 1;
+ }
+ else
+ has_ret = 1;
+ }
+ }
+
+ l = po->regmask_src & ~(regmask_save | regmask_dst);
+#if 0
+ if (l)
+ fnote(po, "dep |= %04x, dst %04x, save %04x\n", l,
+ regmask_dst, regmask_save);
+#endif
+ regmask_dep |= l;
+ regmask_dst |= po->regmask_dst;
+ }
+
+ if (has_ret == -1 && (regmask_dep & (1 << xAX)))
+ has_ret = 1;
+
+ for (i = 0; i < g_eqcnt; i++)
+ if (g_eqs[i].offset > max_bp_offset && g_eqs[i].offset < 4*32)
+ max_bp_offset = g_eqs[i].offset;
+
+ if (max_bp_offset > 0) {
+ max_bp_offset = (max_bp_offset + 3) & ~3;
+ fp->argc_stack = max_bp_offset / 4 - 1;
+ if (!(g_ida_func_attr & IDAFA_BP_FRAME))
+ fp->argc_stack--;
+ }
+
+ fp->regmask_dep = regmask_dep & ~(1 << xSP);
+ fp->has_ret = has_ret;
+}
+
+static void hg_fp_resolve_deps(struct func_prototype *fp)
+{
+ struct func_prototype fp_s;
+ int i;
+
+ // this thing is recursive, so mark first..
+ fp->dep_resolved = 1;
+
+ for (i = 0; i < fp->dep_func_cnt; i++) {
+ strcpy(fp_s.name, fp->dep_func[i].name);
+ fp->dep_func[i].proto = bsearch(&fp_s, hg_fp, hg_fp_cnt,
+ sizeof(hg_fp[0]), hg_fp_cmp_name);
+ if (fp->dep_func[i].proto != NULL) {
+ if (!fp->dep_func[i].proto->dep_resolved)
+ hg_fp_resolve_deps(fp->dep_func[i].proto);
+
+ fp->regmask_dep |= ~fp->dep_func[i].regmask_live
+ & fp->dep_func[i].proto->regmask_dep;
+
+ if (fp->has_ret == -1)
+ fp->has_ret = fp->dep_func[i].proto->has_ret;
+ }
+ }
+}
+
+static void output_hdr(FILE *fout)
+{
+ struct func_prototype *fp;
+ int had_usercall = 0;
+ int regmask_dep;
+ int argc_stack;
+ int i, j, arg;
+
+ // resolve deps
+ qsort(hg_fp, hg_fp_cnt, sizeof(hg_fp[0]), hg_fp_cmp_name);
+ for (i = 0; i < hg_fp_cnt; i++)
+ hg_fp_resolve_deps(&hg_fp[i]);
+
+ // note: messes up .proto ptr, don't use
+ //qsort(hg_fp, hg_fp_cnt, sizeof(hg_fp[0]), hg_fp_cmp_id);
+
+ for (i = 0; i < hg_fp_cnt; i++) {
+ fp = &hg_fp[i];
+ if (fp->has_ret == -1)
+ fprintf(fout, "// ret unresolved\n");
+#if 0
+ fprintf(fout, "// dep:");
+ for (j = 0; j < fp->dep_func_cnt; j++) {
+ fprintf(fout, " %s/", fp->dep_func[j].name);
+ if (fp->dep_func[j].proto != NULL)
+ fprintf(fout, "%04x/%d", fp->dep_func[j].proto->regmask_dep,
+ fp->dep_func[j].proto->has_ret);
+ }
+ fprintf(fout, "\n");
+#endif
+
+ regmask_dep = fp->regmask_dep;
+ argc_stack = fp->argc_stack;
+
+ fprintf(fout, fp->has_ret ? "int " : "void ");
+ if (regmask_dep && (fp->is_stdcall || argc_stack == 0)
+ && (regmask_dep & ~((1 << xCX) | (1 << xDX))) == 0)
+ {
+ fprintf(fout, "__fastcall ");
+ if (had_usercall)
+ fprintf(fout, " "); // align
+ if (!(regmask_dep & (1 << xDX)) && argc_stack == 0)
+ argc_stack = 1;
+ else
+ argc_stack += 2;
+ regmask_dep = 0;
+ }
+ else if (regmask_dep && !fp->is_stdcall) {
+ fprintf(fout, "/*__usercall*/ ");
+ had_usercall = 1;
+ }
+ else if (regmask_dep) {
+ fprintf(fout, "/*__userpurge*/ ");
+ had_usercall = 1;
+ }
+ else if (fp->is_stdcall)
+ fprintf(fout, "__stdcall ");
+ else
+ fprintf(fout, "__cdecl ");
+
+ fprintf(fout, "%s(", fp->name);
+
+ arg = 0;
+ for (j = 0; j < xSP; j++) {
+ if (regmask_dep & (1 << j)) {
+ arg++;
+ if (arg != 1)
+ fprintf(fout, ", ");
+ fprintf(fout, "int a%d/*<%s>*/", arg, regs_r32[j]);
+ }
+ }
+
+ for (j = 0; j < argc_stack; j++) {
+ arg++;
+ if (arg != 1)
+ fprintf(fout, ", ");
+ fprintf(fout, "int a%d", arg);
+ }
+
+ fprintf(fout, ");\n");
+ }
+}
+
static void set_label(int i, const char *name)
{
const char *p;
int pending_endp = 0;
int skip_func = 0;
int skip_warned = 0;
+ int header_mode = 0;
int eq_alloc;
int verbose = 0;
int multi_seg = 0;
g_allow_regfunc = 1;
else if (IS(argv[arg], "-m"))
multi_seg = 1;
+ else if (IS(argv[arg], "-hdr"))
+ header_mode = g_quiet_pp = 1;
else
break;
}
if (argc < arg + 3) {
- printf("usage:\n%s [-v] [-rf] [-m] <.c> <.asm> <hdrf> [rlist]*\n",
- argv[0]);
+ printf("usage:\n%s [-v] [-rf] [-m] <.c> <.asm> <hdrf> [rlist]*\n"
+ "%s -hdr <.h> <.asm> <seed_hdrf> [rlist]*\n",
+ argv[0], argv[0]);
return 1;
}
continue;
}
- if (in_func && !skip_func)
- gen_func(fout, g_fhdr, g_func, pi);
+ if (in_func && !skip_func) {
+ if (header_mode)
+ gen_hdr(g_func, pi);
+ else
+ gen_func(fout, g_fhdr, g_func, pi);
+ }
pending_endp = 0;
in_func = 0;
g_eqs[g_eqcnt].lmod = OPLM_WORD;
else if (IS(words[2], "byte"))
g_eqs[g_eqcnt].lmod = OPLM_BYTE;
+ else if (IS(words[2], "qword"))
+ g_eqs[g_eqcnt].lmod = OPLM_QWORD;
else
aerr("bad lmod: '%s'\n", words[2]);
pi++;
}
+ if (header_mode)
+ output_hdr(fout);
+
fclose(fout);
fclose(fasm);
fclose(g_fhdr);