X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tools%2Ftranslate.c;h=6c432dde9aa699e5bb1f5318dd8e531f8e0f76cb;hb=66bdb2b07a1f50833ad79ea71a378dafd79030e6;hp=b18650d57a0f3cccabe3ae876f7d47e98ebe7ec3;hpb=30c8c549ab171e7682e6426f2757dc08faaa9e33;p=ia32rtools.git

diff --git a/tools/translate.c b/tools/translate.c
index b18650d..6c432dd 100644
--- a/tools/translate.c
+++ b/tools/translate.c
@@ -57,6 +57,7 @@ enum op_flags {
   OPF_LOCK   = (1 << 17), /* op has lock prefix */
   OPF_VAPUSH = (1 << 18), /* vararg ptr push (as call arg) */
   OPF_DONE   = (1 << 19), /* already fully handled by analysis */
+  OPF_PPUSH  = (1 << 20), /* part of complex push-pop graph */
 };
 
 enum op_op {
@@ -176,9 +177,10 @@ struct parsed_op {
 };
 
 // datap:
-// OP_CALL - parser proto hint (str)
+// OP_CALL  - parser proto hint (str)
 // (OPF_CC) - points to one of (OPF_FLAGS) that affects cc op
-// OP_POP - points to OP_PUSH in push/pop pair
+// OP_PUSH  - points to OP_POP in complex push/pop graph
+// OP_POP   - points to OP_PUSH in simple push/pop pair
 
 struct parsed_equ {
   char name[64];
@@ -2139,6 +2141,10 @@ static void op_set_clear_flag(struct parsed_op *po,
   || ((ops[_i].flags & (OPF_JMP|OPF_CJMP|OPF_RMD)) == OPF_JMP \
       && ops[_i].op != OP_CALL))
 
+#define check_i(po, i) \
+  if ((i) < 0) \
+    ferr(po, "bad " #i ": %d\n", i)
+
 static int scan_for_pop(int i, int opcnt, const char *reg,
   int magic, int depth, int *maxdepth, int do_flags)
 {
@@ -2171,6 +2177,7 @@ static int scan_for_pop(int i, int opcnt, const char *reg,
       if (po->btj != NULL) {
         // jumptable
         for (j = 0; j < po->btj->count; j++) {
+          check_i(po, po->btj->d[j].bt_i);
           ret |= scan_for_pop(po->btj->d[j].bt_i, opcnt, reg, magic,
                    depth, maxdepth, do_flags);
           if (ret < 0)
@@ -2179,11 +2186,7 @@ static int scan_for_pop(int i, int opcnt, const char *reg,
         return ret;
       }
 
-      if (po->bt_i < 0) {
-        ferr(po, "dead branch\n");
-        return -1;
-      }
-
+      check_i(po, po->bt_i);
       if (po->flags & OPF_CJMP) {
         ret |= scan_for_pop(po->bt_i, opcnt, reg, magic,
                  depth, maxdepth, do_flags);
@@ -2261,22 +2264,44 @@ static int scan_for_pop_ret(int i, int opcnt, const char *reg,
   return found ? 0 : -1;
 }
 
-static void scan_for_pop_const(int i, int opcnt)
+static void scan_for_pop_const(int i, int opcnt, int *regmask_pp)
 {
+  struct parsed_op *po;
+  int is_multipath = 0;
   int j;
 
   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] != NULL)
+    po = &ops[j];
+
+    if (po->op == OP_JMP && po->btj == NULL) {
+      ferr_assert(po, po->bt_i >= 0);
+      j = po->bt_i - 1;
+      continue;
+    }
+
+    if ((po->flags & (OPF_JMP|OPF_TAIL|OPF_RSAVE))
+      || po->op == OP_PUSH)
     {
       break;
     }
 
-    if (ops[j].op == OP_POP && !(ops[j].flags & (OPF_RMD|OPF_DONE)))
+    if (g_labels[j] != NULL)
+      is_multipath = 1;
+
+    if (po->op == OP_POP && !(po->flags & OPF_RMD))
     {
-      ops[i].flags |= OPF_RMD | OPF_DONE;
-      ops[j].flags |= OPF_DONE;
-      ops[j].datap = &ops[i];
+      is_multipath |= !!(po->flags & OPF_PPUSH);
+      if (is_multipath) {
+        ops[i].flags |= OPF_PPUSH | OPF_DONE;
+        ops[i].datap = po;
+        po->flags |= OPF_PPUSH | OPF_DONE;
+        *regmask_pp |= 1 << po->operand[0].reg;
+      }
+      else {
+        ops[i].flags |= OPF_RMD | OPF_DONE;
+        po->flags |= OPF_DONE;
+        po->datap = &ops[i];
+      }
       break;
     }
   }
@@ -2299,16 +2324,14 @@ static void scan_propagate_df(int i, int opcnt)
     if (po->flags & OPF_JMP) {
       if (po->btj != NULL) {
         // jumptable
-        for (j = 0; j < po->btj->count; j++)
+        for (j = 0; j < po->btj->count; j++) {
+          check_i(po, po->btj->d[j].bt_i);
           scan_propagate_df(po->btj->d[j].bt_i, opcnt);
+        }
         return;
       }
 
-      if (po->bt_i < 0) {
-        ferr(po, "dead branch\n");
-        return;
-      }
-
+      check_i(po, po->bt_i);
       if (po->flags & OPF_CJMP)
         scan_propagate_df(po->bt_i, opcnt);
       else
@@ -2328,13 +2351,57 @@ static void scan_propagate_df(int i, int opcnt)
   ferr(po, "missing DF clear?\n");
 }
 
+// is operand 'opr' referenced by parsed_op 'po'?
+static int is_opr_referenced(const struct parsed_opr *opr,
+  const struct parsed_op *po)
+{
+  int i, mask;
+
+  if (opr->type == OPT_REG) {
+    mask = po->regmask_dst | po->regmask_src;
+    if (po->op == OP_CALL)
+      mask |= (1 << xAX) | (1 << xCX) | (1 << xDX);
+    if ((1 << opr->reg) & mask)
+      return 1;
+    else
+      return 0;
+  }
+
+  for (i = 0; i < po->operand_cnt; i++)
+    if (IS(po->operand[0].name, opr->name))
+      return 1;
+
+  return 0;
+}
+
+// is operand 'opr' read by parsed_op 'po'?
+static int is_opr_read(const struct parsed_opr *opr,
+  const struct parsed_op *po)
+{
+  int mask;
+
+  if (opr->type == OPT_REG) {
+    mask = po->regmask_src;
+    if (po->op == OP_CALL)
+      // assume worst case
+      mask |= (1 << xAX) | (1 << xCX) | (1 << xDX);
+    if ((1 << opr->reg) & mask)
+      return 1;
+    else
+      return 0;
+  }
+
+  // yes I'm lazy
+  return 0;
+}
+
 // 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))
+  if (!(po->flags & OPF_DATA))
     return 0;
 
   if (opr->type == OPT_REG) {
@@ -2417,10 +2484,6 @@ static int scan_for_mod_opr0(struct parsed_op *po_test,
   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)
 {
@@ -2714,7 +2777,8 @@ static const struct parsed_proto *try_recover_pp(
 }
 
 static void scan_for_call_type(int i, const struct parsed_opr *opr,
-  int magic, const struct parsed_proto **pp_found, int *multi)
+  int magic, const struct parsed_proto **pp_found, int *pp_i,
+  int *multi)
 {
   const struct parsed_proto *pp = NULL;
   struct parsed_op *po;
@@ -2727,7 +2791,7 @@ static void scan_for_call_type(int i, const struct parsed_opr *opr,
       lr = &g_label_refs[i];
       for (; lr != NULL; lr = lr->next) {
         check_i(&ops[i], lr->i);
-        scan_for_call_type(lr->i, opr, magic, pp_found, multi);
+        scan_for_call_type(lr->i, opr, magic, pp_found, pp_i, multi);
       }
       if (i > 0 && LAST_OP(i - 1))
         return;
@@ -2792,24 +2856,176 @@ static void scan_for_call_type(int i, const struct parsed_opr *opr,
     }
     *multi = 1;
   }
-  if (pp != NULL)
+  if (pp != NULL) {
     *pp_found = pp;
+    *pp_i = po - ops;
+  }
 }
 
-// early check for tail call or branch back
-static int is_like_tailjmp(int j)
+static void add_label_ref(struct label_ref *lr, int op_i)
 {
-  if (!(ops[j].flags & OPF_JMP))
-    return 0;
+  struct label_ref *lr_new;
 
-  if (ops[j].op == OP_JMP && !ops[j].operand[0].had_ds)
-    // probably local branch back..
-    return 1;
-  if (ops[j].op == OP_CALL)
-    // probably noreturn call..
-    return 1;
+  if (lr->i == -1) {
+    lr->i = op_i;
+    return;
+  }
 
-  return 0;
+  lr_new = calloc(1, sizeof(*lr_new));
+  lr_new->i = op_i;
+  lr_new->next = lr->next;
+  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] != NULL && 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 clear_labels(int count)
+{
+  int i;
+
+  for (i = 0; i < count; i++) {
+    if (g_labels[i] != NULL) {
+      free(g_labels[i]);
+      g_labels[i] = NULL;
+    }
+  }
+}
+
+static void resolve_branches_parse_calls(int opcnt)
+{
+  const struct parsed_proto *pp_c;
+  struct parsed_proto *pp;
+  struct parsed_data *pd;
+  struct parsed_op *po;
+  const char *tmpname;
+  int i, l, ret;
+
+  for (i = 0; i < opcnt; i++)
+  {
+    po = &ops[i];
+    po->bt_i = -1;
+    po->btj = NULL;
+
+    if (po->op == OP_CALL) {
+      pp = NULL;
+
+      if (po->operand[0].type == OPT_LABEL) {
+        tmpname = opr_name(po, 0);
+        if (IS_START(tmpname, "loc_"))
+          ferr(po, "call to loc_*\n");
+        pp_c = proto_parse(g_fhdr, tmpname, g_header_mode);
+        if (!g_header_mode && pp_c == NULL)
+          ferr(po, "proto_parse failed for call '%s'\n", tmpname);
+
+        if (pp_c != NULL) {
+          pp = proto_clone(pp_c);
+          my_assert_not(pp, NULL);
+        }
+      }
+      else if (po->datap != NULL) {
+        pp = calloc(1, sizeof(*pp));
+        my_assert_not(pp, NULL);
+
+        ret = parse_protostr(po->datap, pp);
+        if (ret < 0)
+          ferr(po, "bad protostr supplied: %s\n", (char *)po->datap);
+        free(po->datap);
+        po->datap = NULL;
+      }
+
+      if (pp != NULL) {
+        if (pp->is_fptr)
+          check_func_pp(po, pp, "fptr var call");
+        if (pp->is_noreturn)
+          po->flags |= OPF_TAIL;
+      }
+      po->pp = pp;
+      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] != NULL
+          && IS(po->operand[0].name, g_labels[l]))
+      {
+        if (l == i + 1 && po->op == OP_JMP) {
+          // yet another alignment type..
+          po->flags |= OPF_RMD|OPF_DONE;
+          break;
+        }
+        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
+  }
 }
 
 static void scan_prologue_epilogue(int opcnt)
@@ -2859,12 +3075,13 @@ static void scan_prologue_epilogue(int opcnt)
     found = 0;
     do {
       for (; i < opcnt; i++)
-        if (ops[i].op == OP_RET)
+        if (ops[i].flags & OPF_TAIL)
           break;
       j = i - 1;
       if (i == opcnt && (ops[j].flags & OPF_JMP)) {
-        if (found && is_like_tailjmp(j))
-            break;
+        if (ops[j].bt_i != -1 || ops[j].btj != NULL)
+          break;
+        i--;
         j--;
       }
 
@@ -2873,6 +3090,14 @@ static void scan_prologue_epilogue(int opcnt)
       {
         ops[j].flags |= OPF_RMD | OPF_DONE;
       }
+      else if (ops[i].op == OP_CALL && ops[i].pp != NULL
+        && ops[i].pp->is_noreturn)
+      {
+        // on noreturn, msvc sometimes cleans stack, sometimes not
+        i++;
+        found = 1;
+        continue;
+      }
       else if (!(g_ida_func_attr & IDAFA_NORETURN))
         ferr(&ops[j], "'pop ebp' expected\n");
 
@@ -2900,6 +3125,8 @@ static void scan_prologue_epilogue(int opcnt)
       i++;
     } while (i < opcnt);
 
+    if (!found)
+      ferr(ops, "missing ebp epilogue\n");
     return;
   }
 
@@ -2965,12 +3192,13 @@ static void scan_prologue_epilogue(int opcnt)
     i++;
     do {
       for (; i < opcnt; i++)
-        if (ops[i].op == OP_RET)
+        if (ops[i].flags & OPF_TAIL)
           break;
       j = i - 1;
       if (i == opcnt && (ops[j].flags & OPF_JMP)) {
-        if (found && is_like_tailjmp(j))
-            break;
+        if (ops[j].bt_i != -1 || ops[j].btj != NULL)
+          break;
+        i--;
         j--;
       }
 
@@ -3011,16 +3239,20 @@ static void scan_prologue_epilogue(int opcnt)
 
       i++;
     } while (i < opcnt);
+
+    if (!found)
+      ferr(ops, "missing esp epilogue\n");
   }
 }
 
 static const struct parsed_proto *resolve_icall(int i, int opcnt,
-  int *multi_src)
+  int *pp_i, int *multi_src)
 {
   const struct parsed_proto *pp = NULL;
   int search_advice = 0;
 
   *multi_src = 0;
+  *pp_i = -1;
 
   switch (ops[i].operand[0].type) {
   case OPT_REGMEM:
@@ -3032,7 +3264,7 @@ static const struct parsed_proto *resolve_icall(int i, int opcnt,
     // fallthrough
   default:
     scan_for_call_type(i, &ops[i].operand[0], i + opcnt * 9, &pp,
-      multi_src);
+      pp_i, multi_src);
     break;
   }
 
@@ -3040,7 +3272,7 @@ static const struct parsed_proto *resolve_icall(int i, int opcnt,
 }
 
 // find an instruction that changed opr before i op
-// *op_i must be set to -1 by caller
+// *op_i must be set to -1 by the 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,
@@ -3092,6 +3324,110 @@ static int resolve_origin(int i, const struct parsed_opr *opr,
   }
 }
 
+// find an instruction that previously referenced opr
+// if multiple results are found - fail
+// *op_i must be set to -1 by the caller
+// returns 1 if found, *op_i is then set to referencer insn
+static int resolve_last_ref(int i, const struct parsed_opr *opr,
+  int magic, int *op_i)
+{
+  struct label_ref *lr;
+  int ret = 0;
+
+  if (ops[i].cc_scratch == magic)
+    return 0;
+  ops[i].cc_scratch = magic;
+
+  while (1) {
+    if (g_labels[i] != NULL) {
+      lr = &g_label_refs[i];
+      for (; lr != NULL; lr = lr->next) {
+        check_i(&ops[i], lr->i);
+        ret |= resolve_last_ref(lr->i, opr, magic, op_i);
+      }
+      if (i > 0 && LAST_OP(i - 1))
+        return ret;
+    }
+
+    i--;
+    if (i < 0)
+      return -1;
+
+    if (ops[i].cc_scratch == magic)
+      return 0;
+    ops[i].cc_scratch = magic;
+
+    if (!is_opr_referenced(opr, &ops[i]))
+      continue;
+
+    if (*op_i >= 0)
+      return -1;
+
+    *op_i = i;
+    return 1;
+  }
+}
+
+// find next instruction that reads opr
+// if multiple results are found - fail
+// *op_i must be set to -1 by the caller
+// returns 1 if found, *op_i is then set to referencer insn
+static int find_next_read(int i, int opcnt,
+  const struct parsed_opr *opr, int magic, int *op_i)
+{
+  struct parsed_op *po;
+  int j, ret = 0;
+
+  for (; i < opcnt; i++)
+  {
+    if (ops[i].cc_scratch == magic)
+      return 0;
+    ops[i].cc_scratch = magic;
+
+    po = &ops[i];
+    if ((po->flags & OPF_JMP) && po->op != OP_CALL) {
+      if (po->btj != NULL) {
+        // jumptable
+        for (j = 0; j < po->btj->count; j++) {
+          check_i(po, po->btj->d[j].bt_i);
+          ret |= find_next_read(po->btj->d[j].bt_i, opcnt, opr,
+                   magic, op_i);
+        }
+        return ret;
+      }
+
+      if (po->flags & OPF_RMD)
+        continue;
+      check_i(po, po->bt_i);
+      if (po->flags & OPF_CJMP) {
+        ret = find_next_read(po->bt_i, opcnt, opr, magic, op_i);
+        if (ret < 0)
+          return ret;
+      }
+
+      i = po->bt_i - 1;
+      continue;
+    }
+
+    if (!is_opr_read(opr, po)) {
+      if (is_opr_modified(opr, po))
+        // it's overwritten
+        return 0;
+      if (po->flags & OPF_TAIL)
+        return 0;
+      continue;
+    }
+
+    if (*op_i >= 0)
+      return -1;
+
+    *op_i = i;
+    return 1;
+  }
+
+  return 0;
+}
+
 static int try_resolve_const(int i, const struct parsed_opr *opr,
   int magic, unsigned int *val)
 {
@@ -3149,6 +3485,7 @@ static struct parsed_proto *process_call(int i, int opcnt)
   const struct parsed_proto *pp_c;
   struct parsed_proto *pp;
   const char *tmpname;
+  int call_i = -1, ref_i = -1;
   int adj = 0, multipath = 0;
   int ret, arg;
 
@@ -3157,7 +3494,7 @@ static struct parsed_proto *process_call(int i, int opcnt)
   if (pp == NULL)
   {
     // indirect call
-    pp_c = resolve_icall(i, opcnt, &multipath);
+    pp_c = resolve_icall(i, opcnt, &call_i, &multipath);
     if (pp_c != NULL) {
       if (!pp_c->is_func && !pp_c->is_fptr)
         ferr(po, "call to non-func: %s\n", pp_c->name);
@@ -3171,6 +3508,23 @@ static struct parsed_proto *process_call(int i, int opcnt)
       case OPT_REG:
         // we resolved this call and no longer need the register
         po->regmask_src &= ~(1 << po->operand[0].reg);
+
+        if (!multipath && i != call_i && ops[call_i].op == OP_MOV
+          && ops[call_i].operand[1].type == OPT_LABEL)
+        {
+          // no other source users?
+          ret = resolve_last_ref(i, &po->operand[0], opcnt * 10,
+                  &ref_i);
+          if (ret == 1 && call_i == ref_i) {
+            // and nothing uses it after us?
+            ref_i = -1;
+            ret = find_next_read(i + 1, opcnt, &po->operand[0],
+                    opcnt * 11, &ref_i);
+            if (ret != 1)
+              // then also don't need the source mov
+              ops[call_i].flags |= OPF_RMD;
+          }
+        }
         break;
       case OPT_REGMEM:
         pp->is_fptr = 1;
@@ -3581,111 +3935,42 @@ static int collect_call_args(struct parsed_op *po, int i,
       po_tmp = pp->arg[a].datap;
       while (po_tmp != NULL) {
         po_tmp->p_arggrp = arg_grp;
-        if (po_tmp->p_argnext > 0)
-          po_tmp = &ops[po_tmp->p_argnext];
-        else
-          po_tmp = NULL;
-      }
-    }
-  }
-  save_arg_vars[arg_grp] |= save_arg_vars_current;
-
-  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;
-
-  if (lr->i == -1) {
-    lr->i = op_i;
-    return;
-  }
-
-  lr_new = calloc(1, sizeof(*lr_new));
-  lr_new->i = op_i;
-  lr_new->next = lr->next;
-  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] != NULL && IS(g_labels[l], pd->d[j].u.label)) {
-        add_label_ref(&g_label_refs[l], i);
-        pd->d[j].bt_i = l;
-        break;
+        if (po_tmp->p_argnext > 0)
+          po_tmp = &ops[po_tmp->p_argnext];
+        else
+          po_tmp = NULL;
       }
     }
   }
+  save_arg_vars[arg_grp] |= save_arg_vars_current;
 
-  return pd;
+  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 clear_labels(int count)
+static void pp_insert_reg_arg(struct parsed_proto *pp, const char *reg)
 {
   int i;
 
-  for (i = 0; i < count; i++) {
-    if (g_labels[i] != NULL) {
-      free(g_labels[i]);
-      g_labels[i] = NULL;
-    }
-  }
+  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 output_std_flags(FILE *fout, struct parsed_op *po,
@@ -3804,10 +4089,8 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
   struct parsed_op *po, *delayed_flag_op = NULL, *tmp_op;
   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_data *pd;
-  const char *tmpname;
   unsigned int uval;
   int save_arg_vars[MAX_ARG_GRP] = { 0, };
   int cond_vars = 0;
@@ -3815,11 +4098,12 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
   int need_tmp64 = 0;
   int had_decl = 0;
   int label_pending = 0;
-  int regmask_save = 0;
-  int regmask_arg = 0;
-  int regmask_now = 0;
-  int regmask_init = 0;
-  int regmask = 0;
+  int regmask_save = 0; // regs saved/restored in this func
+  int regmask_arg = 0;  // regs carrying function args (fastcall, etc)
+  int regmask_now;      // temp
+  int regmask_init = 0; // regs that need zero initialization
+  int regmask_pp = 0;   // regs used in complex push-pop graph
+  int regmask = 0;      // used regs
   int pfomask = 0;
   int found = 0;
   int depth = 0;
@@ -3839,110 +4123,28 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
   regmask_arg = get_pp_arg_regmask(g_func_pp);
 
   // pass1:
-  // - handle ebp/esp frame, remove ops related to it
-  scan_prologue_epilogue(opcnt);
-
-  // pass2:
-  // - parse calls with labels
   // - resolve all branches
-  for (i = 0; i < opcnt; i++)
-  {
-    po = &ops[i];
-    po->bt_i = -1;
-    po->btj = NULL;
-
-    if (po->flags & (OPF_RMD|OPF_DONE))
-      continue;
-
-    if (po->op == OP_CALL) {
-      pp = NULL;
-
-      if (po->operand[0].type == OPT_LABEL) {
-        tmpname = opr_name(po, 0);
-        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);
-
-        pp = proto_clone(pp_c);
-        my_assert_not(pp, NULL);
-      }
-      else if (po->datap != NULL) {
-        pp = calloc(1, sizeof(*pp));
-        my_assert_not(pp, NULL);
-
-        ret = parse_protostr(po->datap, pp);
-        if (ret < 0)
-          ferr(po, "bad protostr supplied: %s\n", (char *)po->datap);
-        free(po->datap);
-        po->datap = NULL;
-      }
-
-      if (pp != NULL) {
-        if (pp->is_fptr)
-          check_func_pp(po, pp, "fptr var call");
-        if (pp->is_noreturn)
-          po->flags |= OPF_TAIL;
-      }
-      po->pp = pp;
-      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] != NULL
-          && IS(po->operand[0].name, g_labels[l]))
-      {
-        if (l == i + 1 && po->op == OP_JMP) {
-          // yet another alignment type..
-          po->flags |= OPF_RMD|OPF_DONE;
-          break;
-        }
-        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");
+  // - parse calls with labels
+  resolve_branches_parse_calls(opcnt);
 
-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:
+  // - handle ebp/esp frame, remove ops related to it
+  scan_prologue_epilogue(opcnt);
 
   // pass3:
   // - remove dead labels
-  // - process trivial calls
   for (i = 0; i < opcnt; i++)
   {
     if (g_labels[i] != NULL && g_label_refs[i].i == -1) {
       free(g_labels[i]);
       g_labels[i] = NULL;
     }
+  }
 
+  // pass4:
+  // - process trivial calls
+  for (i = 0; i < opcnt; i++)
+  {
     po = &ops[i];
     if (po->flags & (OPF_RMD|OPF_DONE))
       continue;
@@ -3975,7 +4177,7 @@ tailcall:
     }
   }
 
-  // pass4:
+  // pass5:
   // - process calls
   // - handle push <const>/pop pairs
   for (i = 0; i < opcnt; i++)
@@ -3999,10 +4201,10 @@ tailcall:
     }
     else if (po->op == OP_PUSH && !(po->flags & OPF_FARG)
       && !(po->flags & OPF_RSAVE) && po->operand[0].type == OPT_CONST)
-        scan_for_pop_const(i, opcnt);
+        scan_for_pop_const(i, opcnt, &regmask_pp);
   }
 
-  // pass5:
+  // pass6:
   // - find POPs for PUSHes, rm both
   // - scan for STD/CLD, propagate DF
   // - scan for all used registers
@@ -4247,7 +4449,7 @@ tailcall:
     }
   }
 
-  // pass6:
+  // pass7:
   // - confirm regmask_save, it might have been reduced
   if (regmask_save != 0)
   {
@@ -4385,6 +4587,7 @@ tailcall:
     }
   }
 
+  // declare normal registers
   regmask_now = regmask & ~regmask_arg;
   regmask_now &= ~(1 << xSP);
   if (regmask_now & 0x00ff) {
@@ -4431,6 +4634,16 @@ tailcall:
     }
   }
 
+  // declare push-pop temporaries
+  if (regmask_pp) {
+    for (reg = 0; reg < 8; reg++) {
+      if (regmask_pp & (1 << reg)) {
+        fprintf(fout, "  u32 pp_%s;\n", regs_r32[reg]);
+        had_decl = 1;
+      }
+    }
+  }
+
   if (cond_vars) {
     for (i = 0; i < 8; i++) {
       if (cond_vars & (1 << i)) {
@@ -4768,6 +4981,19 @@ tailcall:
 
       // arithmetic w/flags
       case OP_AND:
+        if (po->operand[1].type == OPT_CONST && !po->operand[1].val) {
+          // deal with complex dst clear
+          assert_operand_cnt(2);
+          fprintf(fout, "  %s = %s;",
+            out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
+            out_src_opr(buf2, sizeof(buf2), po, &po->operand[1],
+             default_cast_to(buf3, sizeof(buf3), &po->operand[0]), 0));
+          output_std_flags(fout, po, &pfomask, buf1);
+          last_arith_dst = &po->operand[0];
+          delayed_flag_op = NULL;
+          break;
+        }
+        // fallthrough
       case OP_OR:
         propagate_lmod(po, &po->operand[0], &po->operand[1]);
         // fallthrough
@@ -5370,6 +5596,13 @@ tailcall:
           fprintf(fout, "  s_%s = %s;", buf1, buf1);
           break;
         }
+        else if (po->flags & OPF_PPUSH) {
+          tmp_op = po->datap;
+          ferr_assert(po, tmp_op != NULL);
+          out_dst_opr(buf2, sizeof(buf2), po, &tmp_op->operand[0]);
+          fprintf(fout, "  pp_%s = %s;", buf2, buf1);
+          break;
+        }
         else if (g_func_pp->is_userstack) {
           fprintf(fout, "  *(--esp) = %s;", buf1);
           break;
@@ -5380,15 +5613,20 @@ tailcall:
         break;
 
       case OP_POP:
+        out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
         if (po->flags & OPF_RSAVE) {
-          out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
           fprintf(fout, "  %s = s_%s;", buf1, buf1);
           break;
         }
+        else if (po->flags & OPF_PPUSH) {
+          // push/pop graph
+          ferr_assert(po, po->datap == NULL);
+          fprintf(fout, "  %s = pp_%s;", buf1, buf1);
+          break;
+        }
         else if (po->datap != NULL) {
           // push/pop pair
           tmp_op = po->datap;
-          out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
           fprintf(fout, "  %s = %s;", buf1,
             out_src_opr(buf2, sizeof(buf2),
               tmp_op, &tmp_op->operand[0],
@@ -5396,8 +5634,7 @@ tailcall:
           break;
         }
         else if (g_func_pp->is_userstack) {
-          fprintf(fout, "  %s = *esp++;",
-            out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]));
+          fprintf(fout, "  %s = *esp++;", buf1);
           break;
         }
         else
@@ -5601,17 +5838,14 @@ static void gen_hdr_dep_pass(int i, int opcnt, unsigned char *cbits,
       if (po->btj != NULL) {
         // jumptable
         for (j = 0; j < po->btj->count; j++) {
+          check_i(po, po->btj->d[j].bt_i);
           gen_hdr_dep_pass(po->btj->d[j].bt_i, opcnt, cbits, fp,
             regmask_save, regmask_dst, regmask_dep, has_ret);
         }
         return;
       }
 
-      if (po->bt_i < 0) {
-        ferr(po, "dead branch\n");
-        return;
-      }
-
+      check_i(po, po->bt_i);
       if (po->flags & OPF_CJMP) {
         gen_hdr_dep_pass(po->bt_i, opcnt, cbits, fp,
           regmask_save, regmask_dst, regmask_dep, has_ret);
@@ -5720,17 +5954,14 @@ static void gen_hdr(const char *funcn, int opcnt)
 {
   int save_arg_vars[MAX_ARG_GRP] = { 0, };
   unsigned char cbits[MAX_OPS / 8];
-  const struct parsed_proto *pp_c;
   struct parsed_proto *pp;
   struct func_prototype *fp;
-  struct parsed_data *pd;
   struct parsed_op *po;
-  const char *tmpname;
   int regmask_dummy = 0;
   int regmask_dep;
   int max_bp_offset = 0;
   int has_ret;
-  int i, j, l, ret;
+  int i, j, ret;
 
   if ((hg_fp_cnt & 0xff) == 0) {
     hg_fp = realloc(hg_fp, sizeof(hg_fp[0]) * (hg_fp_cnt + 0x100));
@@ -5758,89 +5989,37 @@ static void gen_hdr(const char *funcn, int opcnt)
   g_stack_frame_used = 0;
 
   // pass1:
+  // - resolve all branches
+  // - parse calls with labels
+  resolve_branches_parse_calls(opcnt);
+
+  // pass2:
   // - handle ebp/esp frame, remove ops related to it
   scan_prologue_epilogue(opcnt);
 
-  // pass2:
+  // pass3:
+  // - remove dead labels
   // - collect calls
-  // - resolve all branches
   for (i = 0; i < opcnt; i++)
   {
-    po = &ops[i];
-    po->bt_i = -1;
-    po->btj = NULL;
+    if (g_labels[i] != NULL && g_label_refs[i].i == -1) {
+      free(g_labels[i]);
+      g_labels[i] = NULL;
+    }
 
+    po = &ops[i];
     if (po->flags & (OPF_RMD|OPF_DONE))
       continue;
 
     if (po->op == OP_CALL) {
-      tmpname = opr_name(po, 0);
-      pp = NULL;
-      if (po->operand[0].type == OPT_LABEL) {
-        hg_fp_add_dep(fp, tmpname);
-
-        // perhaps a call to already known func?
-        pp_c = proto_parse(g_fhdr, tmpname, 1);
-        if (pp_c != NULL)
-          pp = proto_clone(pp_c);
-      }
-      else if (po->datap != NULL) {
-        pp = calloc(1, sizeof(*pp));
-        my_assert_not(pp, NULL);
-
-        ret = parse_protostr(po->datap, pp);
-        if (ret < 0)
-          ferr(po, "bad protostr supplied: %s\n", (char *)po->datap);
-        free(po->datap);
-        po->datap = NULL;
-      }
-      if (pp != NULL && pp->is_noreturn)
-        po->flags |= OPF_TAIL;
-
-      po->pp = pp;
-      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] != NULL
-          && IS(po->operand[0].name, g_labels[l]))
-      {
-        add_label_ref(&g_label_refs[l], i);
-        po->bt_i = l;
-        break;
-      }
+      if (po->operand[0].type == OPT_LABEL)
+        hg_fp_add_dep(fp, opr_name(po, 0));
+      else if (po->pp != NULL)
+        hg_fp_add_dep(fp, po->pp->name);
     }
-
-    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
   }
 
-  // pass3:
+  // pass4:
   // - remove dead labels
   // - handle push <const>/pop pairs
   for (i = 0; i < opcnt; i++)
@@ -5855,10 +6034,10 @@ tailcall:
       continue;
 
     if (po->op == OP_PUSH && po->operand[0].type == OPT_CONST)
-      scan_for_pop_const(i, opcnt);
+      scan_for_pop_const(i, opcnt, &regmask_dummy);
   }
 
-  // pass4:
+  // pass5:
   // - process trivial calls
   for (i = 0; i < opcnt; i++)
   {
@@ -5891,7 +6070,7 @@ tailcall:
     }
   }
 
-  // pass5:
+  // pass6:
   // - track saved regs (simple)
   // - process calls
   for (i = 0; i < opcnt; i++)
@@ -5921,7 +6100,7 @@ tailcall:
     }
   }
 
-  // pass6
+  // pass7
   memset(cbits, 0, sizeof(cbits));
   regmask_dep = 0;
   has_ret = -1;
@@ -6034,17 +6213,8 @@ static void output_hdr_fp(FILE *fout, const struct func_prototype *fp,
       continue;
 
     if (fp->pp != NULL) {
-      // prefer fp for common style,
-      // only use output_pp if args are complex
-      for (j = 0; j < fp->pp->argc; j++) {
-        if (fp->pp->arg[j].fptr != NULL)
-          break;
-      }
-      if (j != fp->pp->argc) {
-        output_pp(fout, fp->pp, OPP_ALIGN);
-        fprintf(fout, ";\n");
-        continue;
-      }
+      // part of seed, output later
+      continue;
     }
 
     regmask_dep = fp->regmask_dep;
@@ -6132,11 +6302,9 @@ static void output_hdr(FILE *fout)
   for (i = 0; i < hg_var_cnt; i++) {
     var = &hg_vars[i];
 
-    if (var->pp != NULL && var->pp->is_fptr) {
-      fprintf(fout, "extern ");
-      output_pp(fout, var->pp, 0);
-      fprintf(fout, ";");
-    }
+    if (var->pp != NULL)
+      // part of seed
+      continue;
     else if (var->is_c_str)
       fprintf(fout, "extern %-8s %s[];", "char", var->name);
     else
@@ -6153,14 +6321,12 @@ static void output_hdr(FILE *fout)
   // output function prototypes
   output_hdr_fp(fout, hg_fp, hg_fp_cnt);
 
-  // include passthrough
-  fprintf(fout, "\n// for translate\n");
+  // seed passthrough
+  fprintf(fout, "\n// - seed -\n");
 
   rewind(g_fhdr);
-  while (fgets(line, sizeof(line), g_fhdr)) {
-    if (IS_START(line, "//#"))
-      fwrite(line, 1, strlen(line), fout);
-  }
+  while (fgets(line, sizeof(line), g_fhdr))
+    fwrite(line, 1, strlen(line), fout);
 }
 
 // read a line, truncating it if it doesn't fit