X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tools%2Ftranslate.c;h=43d6997655706bdb8bd4352a176587123725cb19;hb=89ff3147d22160eb8345fd0475b93d5343a3303d;hp=d34d4905af6b0131054ff9cce9dc2530b18fce7e;hpb=94d447fbb6ab6c7c01b3734457920a648292ddc5;p=ia32rtools.git

diff --git a/tools/translate.c b/tools/translate.c
index d34d490..43d6997 100644
--- a/tools/translate.c
+++ b/tools/translate.c
@@ -26,6 +26,8 @@ static FILE *g_fhdr;
 	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 */
@@ -197,8 +199,10 @@ static char g_func[256];
 static char g_comment[256];
 static int g_bp_frame;
 static int g_sp_frame;
+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__); \
@@ -280,36 +284,6 @@ static int parse_reg(enum opr_lenmod *reg_lmod, const char *s)
   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;
@@ -475,12 +449,12 @@ static int guess_lmod_from_c_type(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;
@@ -549,9 +523,10 @@ static int parse_operand(struct parsed_opr *opr,
   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)
@@ -616,7 +591,7 @@ static int parse_operand(struct parsed_opr *opr,
       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;
@@ -629,10 +604,9 @@ static int parse_operand(struct parsed_opr *opr,
   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;
@@ -652,11 +626,13 @@ static int parse_operand(struct parsed_opr *opr,
   }
   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] == '-')
@@ -676,10 +652,11 @@ static int parse_operand(struct parsed_opr *opr,
 
   // 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;
     }
@@ -993,6 +970,11 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc)
     }
     break;
 
+  case OP_CALL:
+    // trashed regs must be explicitly detected later
+    op->regmask_dst = 0;
+    break;
+
   default:
     break;
   }
@@ -1142,6 +1124,48 @@ static const char *opr_reg_p(struct parsed_op *po, struct parsed_opr *popr)
   return regs_r32[popr->reg];
 }
 
+// cast1 is the "final" cast
+static const char *simplify_cast(const char *cast1, const char *cast2)
+{
+  static char buf[256];
+
+  if (cast1[0] == 0)
+    return cast2;
+  if (cast2[0] == 0)
+    return cast1;
+  if (IS(cast1, cast2))
+    return cast1;
+  if (IS(cast1, "(s8)") && IS(cast2, "(u8)"))
+    return cast1;
+  if (IS(cast1, "(s16)") && IS(cast2, "(u16)"))
+    return cast1;
+  if (IS(cast1, "(u8)") && IS_START(cast2, "*(u8 *)"))
+    return cast2;
+  if (IS(cast1, "(u16)") && IS_START(cast2, "*(u16 *)"))
+    return cast2;
+  if (strchr(cast1, '*') && IS_START(cast2, "(u32)"))
+    return cast1;
+
+  snprintf(buf, sizeof(buf), "%s%s", cast1, cast2);
+  return buf;
+}
+
+static const char *simplify_cast_num(const char *cast, unsigned int val)
+{
+  if (IS(cast, "(u8)") && val < 0x100)
+    return "";
+  if (IS(cast, "(s8)") && val < 0x80)
+    return "";
+  if (IS(cast, "(u16)") && val < 0x10000)
+    return "";
+  if (IS(cast, "(s16)") && val < 0x8000)
+    return "";
+  if (IS(cast, "(s32)") && val < 0x80000000)
+    return "";
+
+  return cast;
+}
+
 static struct parsed_equ *equ_find(struct parsed_op *po, const char *name,
   int *extra_offs)
 {
@@ -1179,26 +1203,26 @@ static struct parsed_equ *equ_find(struct parsed_op *po, const char *name,
   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'))
@@ -1227,6 +1251,32 @@ static void stack_frame_access(struct parsed_op *po,
   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;
@@ -1265,9 +1315,11 @@ static void stack_frame_access(struct parsed_op *po,
       if (is_lea)
         ferr(po, "lea/byte to arg?\n");
       if (is_src && (offset & 3) == 0)
-        snprintf(buf, buf_size, "(u8)a%d", i + 1);
+        snprintf(buf, buf_size, "%sa%d",
+          simplify_cast(cast, "(u8)"), i + 1);
       else
-        snprintf(buf, buf_size, "BYTE%d(a%d)", offset & 3, i + 1);
+        snprintf(buf, buf_size, "%sBYTE%d(a%d)",
+          cast, offset & 3, i + 1);
       break;
 
     case OPLM_WORD:
@@ -1278,16 +1330,18 @@ static void stack_frame_access(struct parsed_op *po,
         if (!is_src) {
           if (offset & 2)
             ferr(po, "problematic arg store\n");
-          snprintf(buf, buf_size, "*(u16 *)((char *)&a%d + 1)", i + 1);
+          snprintf(buf, buf_size, "%s((char *)&a%d + 1)",
+            simplify_cast(cast, "*(u16 *)"), i + 1);
         }
         else
           ferr(po, "unaligned arg word load\n");
       }
       else if (is_src && (offset & 2) == 0)
-        snprintf(buf, buf_size, "(u16)a%d", i + 1);
+        snprintf(buf, buf_size, "%sa%d",
+          simplify_cast(cast, "(u16)"), i + 1);
       else
-        snprintf(buf, buf_size, "%sWORD(a%d)",
-          (offset & 2) ? "HI" : "LO", i + 1);
+        snprintf(buf, buf_size, "%s%sWORD(a%d)",
+          cast, (offset & 2) ? "HI" : "LO", i + 1);
       break;
 
     case OPLM_DWORD:
@@ -1324,14 +1378,20 @@ static void stack_frame_access(struct parsed_op *po,
 
     // common problem
     guess_lmod_from_c_type(&tmp_lmod, &g_func_pp->arg[i].type);
-    if (unaligned && tmp_lmod != OPLM_DWORD)
-      ferr(po, "bp_arg arg/w offset %d and type '%s'\n",
-        offset, g_func_pp->arg[i].type.name);
+    if (tmp_lmod != OPLM_DWORD
+      && (unaligned || (!is_src && tmp_lmod < popr->lmod)))
+    {
+      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
   {
     if (g_stack_fsz == 0)
       ferr(po, "stack var access without stackframe\n");
+    g_stack_frame_used = 1;
 
     sf_ofs = g_stack_fsz + offset;
     lim = (ofs_reg[0] != 0) ? -4 : 0;
@@ -1382,17 +1442,28 @@ static void stack_frame_access(struct parsed_op *po,
   }
 }
 
+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,
@@ -1401,6 +1472,7 @@ static char *out_src_opr(char *buf, size_t buf_size,
 {
   char tmp1[256], tmp2[256];
   char expr[256];
+  char *p;
   int ret;
 
   if (cast == NULL)
@@ -1416,13 +1488,16 @@ static char *out_src_opr(char *buf, size_t buf_size,
       snprintf(buf, buf_size, "%s%s", cast, opr_reg_p(po, popr));
       break;
     case OPLM_WORD:
-      snprintf(buf, buf_size, "(u16)%s", opr_reg_p(po, popr));
+      snprintf(buf, buf_size, "%s%s",
+        simplify_cast(cast, "(u16)"), opr_reg_p(po, popr));
       break;
     case OPLM_BYTE:
       if (popr->name[1] == 'h') // XXX..
-        snprintf(buf, buf_size, "(u8)(%s >> 8)", opr_reg_p(po, popr));
+        snprintf(buf, buf_size, "%s(%s >> 8)",
+          simplify_cast(cast, "(u8)"), opr_reg_p(po, popr));
       else
-        snprintf(buf, buf_size, "(u8)%s", opr_reg_p(po, popr));
+        snprintf(buf, buf_size, "%s%s",
+          simplify_cast(cast, "(u8)"), opr_reg_p(po, popr));
       break;
     default:
       ferr(po, "invalid src lmod: %d\n", popr->lmod);
@@ -1430,10 +1505,7 @@ 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;
@@ -1445,6 +1517,14 @@ static char *out_src_opr(char *buf, size_t buf_size,
       ret = sscanf(expr, "%[^[][%[^]]]", tmp1, tmp2);
       if (ret != 2)
         ferr(po, "parse failure for '%s'\n", expr);
+      if (tmp1[0] == '(') {
+        // (off_4FFF50+3)[eax]
+        p = strchr(tmp1 + 1, ')');
+        if (p == NULL || p[1] != 0)
+          ferr(po, "parse failure (2) for '%s'\n", expr);
+        *p = 0;
+        memmove(tmp1, tmp1 + 1, strlen(tmp1));
+      }
       snprintf(expr, sizeof(expr), "(u32)&%s + %s", tmp1, tmp2);
     }
 
@@ -1454,9 +1534,8 @@ static char *out_src_opr(char *buf, size_t buf_size,
       break;
     }
 
-    if (cast[0] == 0)
-      cast = lmod_cast_u_ptr(po, popr->lmod);
-    snprintf(buf, buf_size, "%s(%s)", cast, expr);
+    snprintf(buf, buf_size, "%s(%s)",
+      simplify_cast(cast, lmod_cast_u_ptr(po, popr->lmod)), expr);
     break;
 
   case OPT_LABEL:
@@ -1489,9 +1568,9 @@ static char *out_src_opr(char *buf, size_t buf_size,
     if (is_lea)
       ferr(po, "lea from const?\n");
 
-    snprintf(buf, buf_size, "%s", cast);
-    ret = strlen(buf);
-    printf_number(buf + ret, buf_size - ret, popr->val);
+    printf_number(tmp1, sizeof(tmp1), popr->val);
+    snprintf(buf, buf_size, "%s%s",
+      simplify_cast_num(cast, popr->val), tmp1);
     break;
 
   default:
@@ -1528,10 +1607,7 @@ static char *out_dst_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, "", 0, 0);
       break;
@@ -1653,50 +1729,85 @@ static void out_test_for_cc(char *buf, size_t buf_size,
 }
 
 static void out_cmp_for_cc(char *buf, size_t buf_size,
-  struct parsed_op *po, enum parsed_flag_op pfo, int is_inv,
-  enum opr_lenmod lmod, const char *expr1, const char *expr2)
+  struct parsed_op *po, enum parsed_flag_op pfo, int is_inv)
 {
-  const char *cast, *scast;
+  const char *cast, *scast, *cast_use;
+  char buf1[256], buf2[256];
+  enum opr_lenmod lmod;
+
+  if (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;
 
   cast = lmod_cast_u(po, lmod);
   scast = lmod_cast_s(po, lmod);
 
+  switch (pfo) {
+  case PFO_C:
+  case PFO_Z:
+  case PFO_BE: // !a
+    cast_use = cast;
+    break;
+
+  case PFO_S:
+  case PFO_L: // !ge
+  case PFO_LE:
+    cast_use = scast;
+    break;
+
+  default:
+    ferr(po, "%s: unhandled parsed_flag_op: %d\n", __func__, pfo);
+  }
+
+  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);
+
   switch (pfo) {
   case PFO_C:
     // note: must be unsigned compare
-    snprintf(buf, buf_size, "(%s%s %s %s%s)",
-      cast, expr1, is_inv ? ">=" : "<", cast, expr2);
+    snprintf(buf, buf_size, "(%s %s %s)",
+      buf1, is_inv ? ">=" : "<", buf2);
     break;
 
   case PFO_Z:
-    snprintf(buf, buf_size, "(%s%s %s %s%s)",
-      cast, expr1, is_inv ? "!=" : "==", cast, expr2);
+    snprintf(buf, buf_size, "(%s %s %s)",
+      buf1, is_inv ? "!=" : "==", buf2);
     break;
 
   case PFO_BE: // !a
     // note: must be unsigned compare
-    snprintf(buf, buf_size, "(%s%s %s %s%s)",
-      cast, expr1, is_inv ? ">" : "<=", cast, expr2);
+    snprintf(buf, buf_size, "(%s %s %s)",
+      buf1, is_inv ? ">" : "<=", buf2);
+
+    // annoying case
+    if (is_inv && lmod == OPLM_BYTE
+      && po->operand[1].type == OPT_CONST
+      && po->operand[1].val == 0xff)
+    {
+      snprintf(g_comment, sizeof(g_comment), "if %s", buf);
+      snprintf(buf, buf_size, "(0)");
+    }
     break;
 
   // note: must be signed compare
   case PFO_S:
     snprintf(buf, buf_size, "(%s(%s - %s) %s 0)",
-      scast, expr1, expr2, is_inv ? ">=" : "<");
+      scast, buf1, buf2, is_inv ? ">=" : "<");
     break;
 
   case PFO_L: // !ge
-    snprintf(buf, buf_size, "(%s%s %s %s%s)",
-      scast, expr1, is_inv ? ">=" : "<", scast, expr2);
+    snprintf(buf, buf_size, "(%s %s %s)",
+      buf1, is_inv ? ">=" : "<", buf2);
     break;
 
   case PFO_LE:
-    snprintf(buf, buf_size, "(%s%s %s %s%s)",
-      scast, expr1, is_inv ? ">" : "<=", scast, expr2);
+    snprintf(buf, buf_size, "(%s %s %s)",
+      buf1, is_inv ? ">" : "<=", buf2);
     break;
 
   default:
-    ferr(po, "%s: unhandled parsed_flag_op: %d\n", __func__, pfo);
+    break;
   }
 }
 
@@ -1718,10 +1829,7 @@ static void out_cmp_test(char *buf, size_t buf_size,
       po->operand[0].lmod, buf3);
   }
   else if (po->op == OP_CMP) {
-    out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[0]);
-    out_src_opr_u32(buf3, sizeof(buf3), po, &po->operand[1]);
-    out_cmp_for_cc(buf, buf_size, po, pfo, is_inv,
-      po->operand[0].lmod, buf2, buf3);
+    out_cmp_for_cc(buf, buf_size, po, pfo, is_inv);
   }
   else
     ferr(po, "%s: unhandled op: %d\n", __func__, po->op);
@@ -1798,6 +1906,7 @@ static void op_set_clear_flag(struct parsed_op *po,
 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;
@@ -1808,8 +1917,15 @@ static int scan_for_pop(int i, int opcnt, const char *reg,
       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
@@ -1908,18 +2024,30 @@ static int scan_for_pop_ret(int i, int opcnt, const char *reg,
   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);
@@ -1927,8 +2055,9 @@ static int is_opr_modified(const struct parsed_opr *opr,
 
 // 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))
@@ -1942,9 +2071,12 @@ static int is_any_opr_modified(const struct parsed_op *po_test,
 
   // 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++)
@@ -1955,13 +2087,14 @@ static int is_any_opr_modified(const struct parsed_op *po_test,
 }
 
 // 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;
   }
 
@@ -2087,12 +2220,17 @@ static int scan_for_reg_clear(int i, int reg)
 // 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 first_pop = -1;
   *adj = 0;
 
   for (; i < opcnt; i++) {
     po = &ops[i];
 
+    if (g_labels[i][0] != 0)
+      break;
+
     if (po->op == OP_ADD && po->operand[0].reg == xSP) {
       if (po->operand[1].type != OPT_CONST)
         ferr(&ops[i], "non-const esp adjust?\n");
@@ -2101,20 +2239,33 @@ static int scan_for_esp_adjust(int i, int opcnt, int *adj)
         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)
-        return -1;
+        break;
       if (po->operand[0].type != OPT_LABEL)
-        return -1;
-      // TODO: should only allow combining __cdecl calls..
+        break;
+      pp = po->datap;
+      if (pp != NULL && pp->is_stdcall)
+        break;
     }
+  }
 
-    if (g_labels[i][0] != 0)
-      return -1;
+  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 first_pop;
   }
 
   return -1;
@@ -2152,8 +2303,161 @@ static void scan_fwd_set_flags(int i, int opcnt, int magic, int flags)
   }
 }
 
-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;
@@ -2163,7 +2467,7 @@ static int collect_call_args(struct parsed_op *po, int i,
   int j;
 
   if (i < 0) {
-    ferr(po, "no refs for '%s'?\n", g_labels[i]);
+    ferr(po, "dead label encountered\n");
     return -1;
   }
 
@@ -2172,7 +2476,7 @@ static int collect_call_args(struct parsed_op *po, int i,
       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) {
@@ -2185,14 +2489,14 @@ static int collect_call_args(struct parsed_op *po, int i,
     }
     ops[j].cc_scratch = magic;
 
-    if (g_labels[j][0] != 0) {
+    if (g_labels[j][0] != 0 && g_label_refs[j].i != -1) {
       lr = &g_label_refs[j];
       if (lr->next != NULL)
         need_op_saving = 1;
       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;
@@ -2206,7 +2510,7 @@ static int collect_call_args(struct parsed_op *po, int i,
         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;
@@ -2215,6 +2519,9 @@ static int collect_call_args(struct parsed_op *po, int i,
 
     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",
@@ -2224,22 +2531,34 @@ static int collect_call_args(struct parsed_op *po, int i,
           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) {
@@ -2262,22 +2581,71 @@ static int collect_call_args(struct parsed_op *po, int i,
       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;
@@ -2314,14 +2682,13 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
   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 had_decl = 0;
   int label_pending = 0;
   int regmask_save = 0;
@@ -2339,8 +2706,9 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
   int ret;
 
   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);
 
@@ -2373,6 +2741,13 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
     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)
@@ -2507,7 +2882,9 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
     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)
@@ -2525,7 +2902,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
     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;
@@ -2581,9 +2958,13 @@ tailcall:
   }
 
   // pass3:
+  // - remove dead labels
   // - process calls
   for (i = 0; i < opcnt; i++)
   {
+    if (g_labels[i][0] != 0 && g_label_refs[i].i == -1)
+      g_labels[i][0] = 0;
+
     po = &ops[i];
     if (po->flags & OPF_RMD)
       continue;
@@ -2595,18 +2976,33 @@ tailcall:
       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;
       }
 
@@ -2642,22 +3038,33 @@ tailcall:
         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, &regmask, &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;
     }
   }
 
@@ -2665,6 +3072,7 @@ tailcall:
   // - 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];
@@ -2748,7 +3156,7 @@ tailcall:
         // 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) {
@@ -2778,17 +3186,50 @@ tailcall:
     {
       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, &regmask_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 && !IS(g_func_pp->ret_type.name, "void"))
+      regmask |= 1 << xAX;
   }
 
   // output LUTs/jumptables
@@ -2830,29 +3271,22 @@ tailcall:
     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
-   && !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;
       }
@@ -2903,7 +3337,7 @@ tailcall:
   // output ops
   for (i = 0; i < opcnt; i++)
   {
-    if (g_labels[i][0] != 0 && g_label_refs[i].i != -1) {
+    if (g_labels[i][0] != 0) {
       fprintf(fout, "\n%s:\n", g_labels[i]);
       label_pending = 1;
 
@@ -3018,10 +3452,10 @@ tailcall:
         default:
           ferr(po, "invalid src lmod: %d\n", po->operand[1].lmod);
         }
-        fprintf(fout, "  %s = %s%s;",
+        fprintf(fout, "  %s = %s;",
             out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
-            buf3,
-            out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
+            out_src_opr(buf2, sizeof(buf2), po, &po->operand[1],
+              buf3, 0));
         break;
 
       case OP_NOT:
@@ -3202,21 +3636,20 @@ tailcall:
       case OP_SBB:
         assert_operand_cnt(2);
         propagate_lmod(po, &po->operand[0], &po->operand[1]);
+        out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
         if (po->op == OP_SBB
           && IS(po->operand[0].name, po->operand[1].name))
         {
           // avoid use of unitialized var
-          fprintf(fout, "  %s = -cond_c;",
-            out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]));
+          fprintf(fout, "  %s = -cond_c;", buf1);
           // carry remains what it was
           pfomask &= ~(1 << PFO_C);
         }
         else {
-          fprintf(fout, "  %s %s= %s + cond_c;",
-            out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
-            op_to_c(po),
+          fprintf(fout, "  %s %s= %s + cond_c;", buf1, op_to_c(po),
             out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
         }
+        output_std_flags(fout, po, &pfomask, buf1);
         last_arith_dst = &po->operand[0];
         delayed_flag_op = NULL;
         break;
@@ -3232,6 +3665,7 @@ tailcall:
           strcpy(buf2, po->op == OP_INC ? "+" : "-");
           fprintf(fout, "  %s %s= 1;", buf1, buf2);
         }
+        output_std_flags(fout, po, &pfomask, buf1);
         last_arith_dst = &po->operand[0];
         delayed_flag_op = NULL;
         break;
@@ -3341,12 +3775,12 @@ tailcall:
       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")) {
@@ -3362,14 +3796,14 @@ tailcall:
                 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 {
@@ -3413,8 +3847,13 @@ tailcall:
           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;
@@ -3425,9 +3864,13 @@ tailcall:
           // else already handled as 'return f()'
 
           if (ret) {
+            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;
@@ -3509,7 +3952,7 @@ tailcall:
 
     // 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;
     }
 
@@ -3521,6 +3964,9 @@ tailcall:
     label_pending = 0;
   }
 
+  if (g_stack_fsz && !g_stack_frame_used)
+    fprintf(fout, "  (void)sf;\n");
+
   fprintf(fout, "}\n\n");
 
   // cleanup
@@ -3691,7 +4137,7 @@ int main(int argc, char *argv[])
   int func_chunk_ret_ln = 0;
   int scanned_ahead = 0;
   char line[256];
-  char words[16][256];
+  char words[20][256];
   enum opr_lenmod lmod;
   int in_func = 0;
   int pending_endp = 0;
@@ -3700,20 +4146,24 @@ int main(int argc, char *argv[])
   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;
   }
@@ -3738,13 +4188,27 @@ int main(int argc, char *argv[])
   func_chunks = malloc(func_chunk_alloc * sizeof(func_chunks[0]));
   my_assert_not(func_chunks, NULL);
 
+  memset(words, 0, sizeof(words));
+
   for (; arg < argc; arg++) {
     frlist = fopen(argv[arg], "r");
     my_assert_not(frlist, NULL);
 
     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);
@@ -3758,6 +4222,7 @@ int main(int argc, char *argv[])
       }
       rlist[rlist_len++] = strdup(words[0]);
     }
+    skip_func = 0;
 
     fclose(frlist);
     frlist = NULL;
@@ -3885,7 +4350,8 @@ int main(int argc, char *argv[])
     } // *p == ';'
 
 parse_words:
-    memset(words, 0, sizeof(words));
+    for (i = wordc; i < ARRAY_SIZE(words); i++)
+      words[i][0] = 0;
     for (wordc = 0; wordc < ARRAY_SIZE(words); wordc++) {
       p = sskip(next_word_s(words[wordc], sizeof(words[0]), p));
       if (*p == 0 || *p == ';') {
@@ -3893,6 +4359,8 @@ parse_words:
         break;
       }
     }
+    if (*p != 0 && *p != ';')
+      aerr("too many words\n");
 
     // alow asm patches in comments
     if (*p == ';' && IS_START(p, "; sctpatch:")) {
@@ -4055,6 +4523,9 @@ do_pending_endp:
       continue;
     }
 
+    if (wordc == 2 && IS(words[1], "ends"))
+      break;
+
     p = strchr(words[0], ':');
     if (p != NULL) {
       set_label(pi, words[0]);