rep stosd and stuff
[ia32rtools.git] / tools / translate.c
index b606ff7..dd7ccb1 100644 (file)
@@ -1,3 +1,4 @@
+#define _GNU_SOURCE
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 const char *asmfn;
 static int asmln;
 
+#define anote(fmt, ...) \
+       printf("%s:%d: note: " fmt, asmfn, asmln, ##__VA_ARGS__)
 #define awarn(fmt, ...) \
-       printf("warning:%s:%d: " fmt, asmfn, asmln, ##__VA_ARGS__)
+       printf("%s:%d: warning: " fmt, asmfn, asmln, ##__VA_ARGS__)
 #define aerr(fmt, ...) do { \
-       printf("error:%s:%d: " fmt, asmfn, asmln, ##__VA_ARGS__); \
+       printf("%s:%d: error: " fmt, asmfn, asmln, ##__VA_ARGS__); \
+  fcloseall(); \
        exit(1); \
 } while (0)
 
 enum op_flags {
-       OPF_RMD    = (1 << 0), /* removed or optimized out */
-       OPF_DATA   = (1 << 1), /* data processing - writes to dst opr */
-       OPF_FLAGS  = (1 << 2), /* sets flags */
-       OPF_JMP    = (1 << 3), /* branches, ret and call */
-       OPF_CC     = (1 << 4), /* uses flags */
+  OPF_RMD    = (1 << 0), /* removed or optimized out */
+  OPF_DATA   = (1 << 1), /* data processing - writes to dst opr */
+  OPF_FLAGS  = (1 << 2), /* sets flags */
+  OPF_JMP    = (1 << 3), /* branches, ret and call */
+  OPF_CC     = (1 << 4), /* uses flags */
+  OPF_TAIL   = (1 << 5), /* ret or tail call */
+  OPF_REP    = (1 << 6), /* prefixed by rep */
 };
 
 enum op_op {
        OP_INVAL,
+       OP_NOP,
        OP_PUSH,
        OP_POP,
        OP_MOV,
@@ -38,6 +45,7 @@ enum op_op {
        OP_MOVSX,
        OP_NOT,
        OP_CDQ,
+       OP_STOS,
        OP_RET,
        OP_ADD,
        OP_SUB,
@@ -79,12 +87,12 @@ enum op_op {
 };
 
 enum opr_type {
-       OPT_UNSPEC,
-       OPT_REG,
-       OPT_REGMEM,
-       OPT_LABEL,
+  OPT_UNSPEC,
+  OPT_REG,
+  OPT_REGMEM,
+  OPT_LABEL,
   OPT_OFFSET,
-       OPT_CONST,
+  OPT_CONST,
 };
 
 enum opr_lenmod {
@@ -111,12 +119,15 @@ struct parsed_op {
   int operand_cnt;
   int regmask_src;        // all referensed regs
   int regmask_dst;
-  int pfomask;            // parsed_flag_op that can't be delayed
+  int pfomask;            // flagop: parsed_flag_op that can't be delayed
+  int argmask;            // push: args that are altered before call
+  int cc_scratch;         // scratch storage during analysis
+  int bt_i;               // branch target (for branches)
+  struct parsed_op *lrl;  // label reference list entry
   void *datap;
 };
 
 // datap:
-// OP_PUSH - arg number if arg is altered before call
 // OP_CALL - ptr to parsed_proto
 // (OPF_CC) - point to corresponding (OPF_FLAGS)
 
@@ -132,6 +143,7 @@ static struct parsed_op ops[MAX_OPS];
 static struct parsed_equ *g_eqs;
 static int g_eqcnt;
 static char g_labels[MAX_OPS][32];
+static struct parsed_op *g_label_refs[MAX_OPS];
 static struct parsed_proto g_func_pp;
 static char g_func[256];
 static char g_comment[256];
@@ -140,6 +152,7 @@ static int g_bp_stack;
 #define ferr(op_, fmt, ...) do { \
   printf("error:%s:#%ld: '%s': " fmt, g_func, (op_) - ops, \
     dump_op(op_), ##__VA_ARGS__); \
+  fcloseall(); \
   exit(1); \
 } while (0)
 
@@ -266,6 +279,10 @@ static int parse_indmode(char *name, int *regmask, int need_c_cvt)
       s++;
     *d = 0;
 
+    // skip 'ds:' prefix
+    if (!strncmp(s, "ds:", 3))
+      s += 3;
+
     s = next_idt(w, sizeof(w), s);
     if (w[0] == 0)
       break;
@@ -321,6 +338,8 @@ static void setup_reg_opr(struct parsed_opr *opr, int reg, enum opr_lenmod lmod,
   *regmask |= 1 << reg;
 }
 
+static struct parsed_equ *equ_find(struct parsed_op *po, const char *name);
+
 static int parse_operand(struct parsed_opr *opr,
   int *regmask, int *regmask_indirect,
        char words[16][256], int wordc, int w, unsigned int op_flags)
@@ -391,8 +410,14 @@ static int parse_operand(struct parsed_opr *opr,
     ret = sscanf(words[w], "[%[^]]]", opr->name);
     if (ret != 1)
       aerr("[] parse failure\n");
-    // only need the regmask
+
     parse_indmode(opr->name, regmask_indirect, 1);
+    if (opr->lmod == OPLM_UNSPEC && !strncmp(opr->name, "ebp+", 4)) {
+      // might be an equ
+      struct parsed_equ *eq = equ_find(NULL, opr->name + 4);
+      if (eq)
+        opr->lmod = eq->lmod;
+    }
     return wordc;
   }
   else if (strchr(words[w], '[')) {
@@ -430,6 +455,13 @@ static int parse_operand(struct parsed_opr *opr,
   return wordc;
 }
 
+static const struct {
+  const char *name;
+  unsigned int flags;
+} pref_table[] = {
+  { "rep",    OPF_REP },
+};
+
 static const struct {
   const char *name;
   enum op_op op;
@@ -437,6 +469,7 @@ static const struct {
   unsigned int maxopr;
   unsigned int flags;
 } op_table[] = {
+  { "nop",  OP_NOP,    0, 0, 0 },
   { "push", OP_PUSH,   1, 1, 0 },
   { "pop",  OP_POP,    1, 1, OPF_DATA },
   { "mov" , OP_MOV,    2, 2, OPF_DATA },
@@ -445,6 +478,9 @@ static const struct {
   { "movsx",OP_MOVSX,  2, 2, OPF_DATA },
   { "not",  OP_NOT,    1, 1, OPF_DATA },
   { "cdq",  OP_CDQ,    0, 0, OPF_DATA },
+  { "stosb",OP_STOS,   0, 0, OPF_DATA },
+  { "stosw",OP_STOS,   0, 0, OPF_DATA },
+  { "stosd",OP_STOS,   0, 0, OPF_DATA },
   { "add",  OP_ADD,    2, 2, OPF_DATA|OPF_FLAGS },
   { "sub",  OP_SUB,    2, 2, OPF_DATA|OPF_FLAGS },
   { "and",  OP_AND,    2, 2, OPF_DATA|OPF_FLAGS },
@@ -465,14 +501,15 @@ static const struct {
   { "idiv", OP_IDIV,   1, 1, OPF_DATA|OPF_FLAGS },
   { "test", OP_TEST,   2, 2, OPF_FLAGS },
   { "cmp",  OP_CMP,    2, 2, OPF_FLAGS },
-  { "retn", OP_RET,    0, 1, OPF_JMP },
-  { "call", OP_CALL,   1, 1, OPF_JMP },
+  { "retn", OP_RET,    0, 1, OPF_JMP|OPF_TAIL },
+  { "call", OP_CALL,   1, 1, OPF_JMP|OPF_FLAGS },
   { "jmp",  OP_JMP,    1, 1, OPF_JMP },
   { "jo",   OP_JO,     1, 1, OPF_JMP|OPF_CC }, // 70 OF=1
   { "jno",  OP_JNO,    1, 1, OPF_JMP|OPF_CC }, // 71 OF=0
   { "jc",   OP_JC,     1, 1, OPF_JMP|OPF_CC }, // 72 CF=1
   { "jb",   OP_JC,     1, 1, OPF_JMP|OPF_CC }, // 72
   { "jnc",  OP_JNC,    1, 1, OPF_JMP|OPF_CC }, // 73 CF=0
+  { "jnb",  OP_JNC,    1, 1, OPF_JMP|OPF_CC }, // 73
   { "jae",  OP_JNC,    1, 1, OPF_JMP|OPF_CC }, // 73
   { "jz",   OP_JZ,     1, 1, OPF_JMP|OPF_CC }, // 74 ZF=1
   { "je",   OP_JZ,     1, 1, OPF_JMP|OPF_CC }, // 74
@@ -528,22 +565,40 @@ static const struct {
 
 static void parse_op(struct parsed_op *op, char words[16][256], int wordc)
 {
+  enum opr_lenmod lmod;
+  int prefix_flags = 0;
   int regmask_ind;
   int regmask;
+  int op_w = 0;
   int opr = 0;
-  int w = 1;
+  int w = 0;
   int i;
 
+  for (i = 0; i < ARRAY_SIZE(pref_table); i++) {
+    if (IS(words[w], pref_table[i].name)) {
+      prefix_flags = pref_table[i].flags;
+      break;
+    }
+  }
+
+  if (prefix_flags) {
+    if (wordc <= 1)
+      aerr("lone prefix: '%s'\n", words[0]);
+    w++;
+  }
+
+  op_w = w;
   for (i = 0; i < ARRAY_SIZE(op_table); i++) {
-    if (IS(words[0], op_table[i].name))
+    if (IS(words[w], op_table[i].name))
       break;
   }
 
   if (i == ARRAY_SIZE(op_table))
     aerr("unhandled op: '%s'\n", words[0]);
+  w++;
 
   op->op = op_table[i].op;
-  op->flags = op_table[i].flags;
+  op->flags = op_table[i].flags | prefix_flags;
   op->regmask_src = op->regmask_dst = 0;
 
   for (opr = 0; opr < op_table[i].minopr; opr++) {
@@ -580,6 +635,21 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc)
     setup_reg_opr(&op->operand[1], xAX, OPLM_DWORD, &op->regmask_src);
     break;
 
+  case OP_STOS:
+    if (op->operand_cnt != 0)
+      break;
+    if      (IS(words[op_w], "stosb"))
+      lmod = OPLM_BYTE;
+    else if (IS(words[op_w], "stosw"))
+      lmod = OPLM_WORD;
+    else if (IS(words[op_w], "stosd"))
+      lmod = OPLM_DWORD;
+    op->operand_cnt = 3;
+    setup_reg_opr(&op->operand[0], xDI, lmod, &op->regmask_dst);
+    setup_reg_opr(&op->operand[1], xCX, OPLM_DWORD, &op->regmask_dst);
+    setup_reg_opr(&op->operand[2], xAX, OPLM_DWORD, &op->regmask_src);
+    break;
+
   case OP_IMUL:
     if (op->operand_cnt != 1)
       break;
@@ -676,8 +746,11 @@ static struct parsed_equ *equ_find(struct parsed_op *po, const char *name)
   for (i = 0; i < g_eqcnt; i++)
     if (IS(g_eqs[i].name, name))
       break;
-  if (i >= g_eqcnt)
-    ferr(po, "unresolved equ name: '%s'\n", name);
+  if (i >= g_eqcnt) {
+    if (po != NULL)
+      ferr(po, "unresolved equ name: '%s'\n", name);
+    return NULL;
+  }
 
   return &g_eqs[i];
 }
@@ -723,7 +796,7 @@ static void bg_frame_access(struct parsed_op *po, enum opr_lenmod lmod,
       ferr(po, "bp_stack offset %d/%d\n", eq->offset, g_bp_stack);
 
     if (is_lea)
-      prefix = "&";
+      prefix = "(u32)&";
 
     switch (lmod)
     {
@@ -786,7 +859,7 @@ 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);
-      snprintf(expr, sizeof(expr), "(u32)%s + %s", tmp1, tmp2);
+      snprintf(expr, sizeof(expr), "(u32)&%s + %s", tmp1, tmp2);
     }
 
     // XXX: do we need more parsing?
@@ -815,7 +888,7 @@ static char *out_src_opr(char *buf, size_t buf_size,
     if (is_lea)
       snprintf(buf, buf_size, "(u32)&%s", popr->name);
     else
-      snprintf(buf, buf_size, "%s", popr->name);
+      snprintf(buf, buf_size, "(u32)%s", popr->name);
     break;
 
   case OPT_OFFSET:
@@ -906,7 +979,7 @@ static const char *lmod_cast_s(struct parsed_op *po,
   case OPLM_BYTE:
     return "(s8)";
   default:
-    ferr(po, "invalid lmod: %d\n", lmod);
+    ferr(po, "%s: invalid lmod: %d\n", __func__, lmod);
     return "(_invalid_)";
   }
 }
@@ -919,10 +992,25 @@ static const char *lmod_cast(struct parsed_op *po,
     lmod_cast_u(po, lmod);
 }
 
+static int lmod_bytes(struct parsed_op *po, enum opr_lenmod lmod)
+{
+  switch (lmod) {
+  case OPLM_DWORD:
+    return 4;
+  case OPLM_WORD:
+    return 2;
+  case OPLM_BYTE:
+    return 1;
+  default:
+    ferr(po, "%s: invalid lmod: %d\n", __func__, lmod);
+    return 0;
+  }
+}
+
 static enum parsed_flag_op split_cond(struct parsed_op *po,
-  enum op_op op, int *is_neg)
+  enum op_op op, int *is_inv)
 {
-  *is_neg = 0;
+  *is_inv = 0;
 
   switch (op) {
   case OP_JO:
@@ -943,28 +1031,28 @@ static enum parsed_flag_op split_cond(struct parsed_op *po,
     return PFO_LE;
 
   case OP_JNO:
-    *is_neg = 1;
+    *is_inv = 1;
     return PFO_O;
   case OP_JNC:
-    *is_neg = 1;
+    *is_inv = 1;
     return PFO_C;
   case OP_JNZ:
-    *is_neg = 1;
+    *is_inv = 1;
     return PFO_Z;
   case OP_JA:
-    *is_neg = 1;
+    *is_inv = 1;
     return PFO_BE;
   case OP_JNS:
-    *is_neg = 1;
+    *is_inv = 1;
     return PFO_S;
   case OP_JNP:
-    *is_neg = 1;
+    *is_inv = 1;
     return PFO_P;
   case OP_JGE:
-    *is_neg = 1;
+    *is_inv = 1;
     return PFO_L;
   case OP_JG:
-    *is_neg = 1;
+    *is_inv = 1;
     return PFO_LE;
 
   case OP_ADC:
@@ -978,7 +1066,7 @@ static enum parsed_flag_op split_cond(struct parsed_op *po,
 }
 
 static void out_test_for_cc(char *buf, size_t buf_size,
-  struct parsed_op *po, enum parsed_flag_op pfo, int is_neg,
+  struct parsed_op *po, enum parsed_flag_op pfo, int is_inv,
   enum opr_lenmod lmod, const char *expr)
 {
   const char *cast, *scast;
@@ -988,19 +1076,20 @@ static void out_test_for_cc(char *buf, size_t buf_size,
 
   switch (pfo) {
   case PFO_Z:
+  case PFO_BE: // CF=1||ZF=1; CF=0
     snprintf(buf, buf_size, "(%s%s %s 0)",
-      cast, expr, is_neg ? "!=" : "==");
+      cast, expr, is_inv ? "!=" : "==");
     break;
 
   case PFO_S:
   case PFO_L: // SF!=OF; OF=0
     snprintf(buf, buf_size, "(%s%s %s 0)",
-      scast, expr, is_neg ? ">=" : "<");
+      scast, expr, is_inv ? ">=" : "<");
     break;
 
-  case PFO_LE: // ZF=1||SF!=OF; OF=0 after test
+  case PFO_LE: // ZF=1||SF!=OF; OF=0
     snprintf(buf, buf_size, "(%s%s %s 0)",
-      scast, expr, is_neg ? ">" : "<=");
+      scast, expr, is_inv ? ">" : "<=");
     break;
 
   default:
@@ -1009,7 +1098,7 @@ 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_neg,
+  struct parsed_op *po, enum parsed_flag_op pfo, int is_inv,
   enum opr_lenmod lmod, const char *expr1, const char *expr2)
 {
   const char *cast, *scast;
@@ -1021,34 +1110,34 @@ static void out_cmp_for_cc(char *buf, size_t buf_size,
   case PFO_C:
     // note: must be unsigned compare
     snprintf(buf, buf_size, "(%s%s %s %s%s)",
-      cast, expr1, is_neg ? ">=" : "<", cast, expr2);
+      cast, expr1, is_inv ? ">=" : "<", cast, expr2);
     break;
 
   case PFO_Z:
     snprintf(buf, buf_size, "(%s%s %s %s%s)",
-      cast, expr1, is_neg ? "!=" : "==", cast, expr2);
+      cast, expr1, is_inv ? "!=" : "==", cast, expr2);
     break;
 
   case PFO_BE: // !a
     // note: must be unsigned compare
     snprintf(buf, buf_size, "(%s%s %s %s%s)",
-      cast, expr1, is_neg ? ">" : "<=", cast, expr2);
+      cast, expr1, is_inv ? ">" : "<=", cast, expr2);
     break;
 
   // note: must be signed compare
   case PFO_S:
     snprintf(buf, buf_size, "(%s(%s - %s) %s 0)",
-      scast, expr1, expr2, is_neg ? ">=" : "<");
+      scast, expr1, expr2, is_inv ? ">=" : "<");
     break;
 
   case PFO_L: // !ge
     snprintf(buf, buf_size, "(%s%s %s %s%s)",
-      scast, expr1, is_neg ? ">=" : "<", scast, expr2);
+      scast, expr1, is_inv ? ">=" : "<", scast, expr2);
     break;
 
   case PFO_LE:
     snprintf(buf, buf_size, "(%s%s %s %s%s)",
-      scast, expr1, is_neg ? ">" : "<=", scast, expr2);
+      scast, expr1, is_inv ? ">" : "<=", scast, expr2);
     break;
 
   default:
@@ -1057,7 +1146,7 @@ static void out_cmp_for_cc(char *buf, size_t buf_size,
 }
 
 static void out_cmp_test(char *buf, size_t buf_size,
-  struct parsed_op *po, enum parsed_flag_op pfo, int is_neg)
+  struct parsed_op *po, enum parsed_flag_op pfo, int is_inv)
 {
   char buf1[256], buf2[256], buf3[256];
 
@@ -1070,13 +1159,13 @@ static void out_cmp_test(char *buf, size_t buf_size,
       out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], 0);
       snprintf(buf3, sizeof(buf3), "(%s & %s)", buf1, buf2);
     }
-    out_test_for_cc(buf, buf_size, po, pfo, is_neg,
+    out_test_for_cc(buf, buf_size, po, pfo, is_inv,
       po->operand[0].lmod, buf3);
   }
   else if (po->op == OP_CMP) {
     out_src_opr(buf2, sizeof(buf2), po, &po->operand[0], 0);
     out_src_opr(buf3, sizeof(buf3), po, &po->operand[1], 0);
-    out_cmp_for_cc(buf, buf_size, po, pfo, is_neg,
+    out_cmp_for_cc(buf, buf_size, po, pfo, is_inv,
       po->operand[0].lmod, buf2, buf3);
   }
   else
@@ -1086,20 +1175,6 @@ static void out_cmp_test(char *buf, size_t buf_size,
 static void propagate_lmod(struct parsed_op *po, struct parsed_opr *popr1,
        struct parsed_opr *popr2)
 {
-  struct parsed_equ *eq;
-
-  if (popr1->lmod == OPLM_UNSPEC && popr2->lmod == OPLM_UNSPEC) {
-    // lmod could be specified by equ..
-    if (!strncmp(popr1->name, "ebp+", 4)) {
-      eq = equ_find(po, popr1->name + 4);
-      popr1->lmod = eq->lmod;
-    }
-    if (!strncmp(popr2->name, "ebp+", 4)) {
-      eq = equ_find(po, popr2->name + 4);
-      popr2->lmod = eq->lmod;
-    }
-  }
-
   if (popr1->lmod == OPLM_UNSPEC && popr2->lmod == OPLM_UNSPEC)
     ferr(po, "missing lmod for both operands\n");
 
@@ -1139,21 +1214,51 @@ static const char *op_to_c(struct parsed_op *po)
   }
 }
 
-static int scan_for_pop(int i, int opcnt, const char *reg)
+static int scan_for_pop(int i, int opcnt, const char *reg,
+  int magic, int do_patch)
 {
+  struct parsed_op *po;
+  int ret = 0;
+
   for (; i < opcnt; i++) {
-    if (ops[i].flags & OPF_RMD)
+    po = &ops[i];
+    if (po->cc_scratch == magic)
+      break; // already checked
+    po->cc_scratch = magic;
+
+    if (po->flags & OPF_TAIL)
+      return -1; // deadend
+
+    if (po->flags & OPF_RMD)
       continue;
 
-    if ((ops[i].flags & OPF_JMP) || g_labels[i][0] != 0)
-      return -1;
+    if ((po->flags & OPF_JMP) && po->op != OP_CALL) {
+      if (po->bt_i < 0) {
+        ferr(po, "dead branch\n");
+        return -1;
+      }
 
-    if (ops[i].op == OP_POP && ops[i].operand[0].type == OPT_REG
-        && IS(ops[i].operand[0].name, reg))
-      return i;
+      if (po->flags & OPF_CC) {
+        ret |= scan_for_pop(po->bt_i, opcnt, reg, magic, do_patch);
+        if (ret < 0)
+          return ret; // dead end
+      }
+      else {
+        i = po->bt_i - 1;
+      }
+      continue;
+    }
+
+    if (po->op == OP_POP && po->operand[0].type == OPT_REG
+        && IS(po->operand[0].name, reg))
+    {
+      if (do_patch)
+        po->flags |= OPF_RMD;
+      return 1;
+    }
   }
 
-  return -1;
+  return ret;
 }
 
 // scan for pop starting from 'ret' op (all paths)
@@ -1163,7 +1268,7 @@ static int scan_for_pop_ret(int i, int opcnt, const char *reg, int do_patch)
   int j;
 
   for (; i < opcnt; i++) {
-    if (ops[i].op != OP_RET)
+    if (!(ops[i].flags & OPF_TAIL))
       continue;
 
     for (j = i - 1; j >= 0; j--) {
@@ -1225,7 +1330,7 @@ static int is_any_opr_modified(const struct parsed_op *po_test,
   return 0;
 }
 
-// scan for po_test operand modification in range given
+// scan for any po_test operand modification in range given
 static int scan_for_mod(struct parsed_op *po_test, int i, int opcnt)
 {
   for (; i < opcnt; i++) {
@@ -1236,6 +1341,18 @@ static int scan_for_mod(struct parsed_op *po_test, int i, int opcnt)
   return -1;
 }
 
+// scan for po_test operand[0] modification in range given
+static int scan_for_mod_opr0(struct parsed_op *po_test,
+  int i, int opcnt)
+{
+  for (; i < opcnt; i++) {
+    if (is_opr_modified(&po_test->operand[0], &ops[i]))
+      return i;
+  }
+
+  return -1;
+}
+
 static int scan_for_flag_set(int i)
 {
   for (; i >= 0; i--) {
@@ -1272,13 +1389,16 @@ 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];
-  struct parsed_proto *pp;
+  struct parsed_proto *pp, *pp_tmp;
   const char *tmpname;
+  enum parsed_flag_op pfo;
   int save_arg_vars = 0;
   int cmp_result_vars = 0;
+  int need_mul_var = 0;
   int had_decl = 0;
   int regmask_arg = 0;
   int regmask = 0;
+  int pfomask = 0;
   int no_output;
   int dummy;
   int arg;
@@ -1307,6 +1427,8 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
       && IS(opr_name(&ops[1], 0), "ebp")
       && IS(opr_name(&ops[1], 1), "esp"))
   {
+    int ecx_push = 0;
+
     g_bp_frame = 1;
     ops[0].flags |= OPF_RMD;
     ops[1].flags |= OPF_RMD;
@@ -1315,6 +1437,16 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
       g_bp_stack = opr_const(&ops[2], 1);
       ops[2].flags |= OPF_RMD;
     }
+    else {
+      // another way msvc builds stack frame..
+      i = 2;
+      while (ops[i].op == OP_PUSH && IS(opr_name(&ops[i], 0), "ecx")) {
+        g_bp_stack += 4;
+        ops[i].flags |= OPF_RMD;
+        ecx_push++;
+        i++;
+      }
+    }
 
     i = 2;
     do {
@@ -1333,12 +1465,45 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
           ferr(&ops[i - 2], "esp restore expected\n");
         }
         ops[i - 2].flags |= OPF_RMD;
+
+        if (ecx_push && ops[i - 3].op == OP_POP
+          && IS(opr_name(&ops[i - 3], 0), "ecx"))
+        {
+          ferr(&ops[i - 3], "unexpected ecx pop\n");
+        }
       }
+
       i++;
     } while (i < opcnt);
   }
 
   // pass2:
+  // - resolve all branches
+  for (i = 0; i < opcnt; i++) {
+    po = &ops[i];
+    po->bt_i = -1;
+
+    if ((po->flags & OPF_RMD) || !(po->flags & OPF_JMP)
+        || po->op == OP_CALL || po->op == OP_RET)
+      continue;
+
+    for (j = 0; j < opcnt; j++) {
+      if (g_labels[j][0] && IS(po->operand[0].name, g_labels[j])) {
+        po->bt_i = j;
+        po->lrl = g_label_refs[j];
+        g_label_refs[j] = po;
+        break;
+      }
+    }
+
+    if (po->bt_i == -1) {
+      // assume tail call
+      po->op = OP_CALL;
+      po->flags |= OPF_TAIL;
+    }
+  }
+
+  // pass3:
   // - find POPs for PUSHes, rm both
   // - scan for all used registers
   // - find flag set ops for their users
@@ -1352,10 +1517,12 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
       if (po->operand[0].reg < 0)
         ferr(po, "reg not set for push?\n");
       if (!(regmask & (1 << po->operand[0].reg))) { // reg save
-        ret = scan_for_pop(i + 1, opcnt, po->operand[0].name);
-        if (ret >= 0) {
+        ret = scan_for_pop(i + 1, opcnt,
+                po->operand[0].name, i + opcnt, 0);
+        if (ret == 1) {
           po->flags |= OPF_RMD;
-          ops[ret].flags |= OPF_RMD;
+          scan_for_pop(i + 1, opcnt, po->operand[0].name,
+            i + opcnt * 2, 1);
           continue;
         }
         ret = scan_for_pop_ret(i + 1, opcnt, po->operand[0].name, 0);
@@ -1376,11 +1543,24 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         ferr(po, "unable to trace flag setter\n");
 
       tmp_op = &ops[ret]; // flag setter
-      ret = scan_for_mod(tmp_op, ret + 1, i);
-      if (ret >= 0) {
-        ret = 1 << split_cond(po, po->op, &dummy);
-        tmp_op->pfomask |= ret;
-        cmp_result_vars |= ret;
+      pfo = split_cond(po, po->op, &dummy);
+      pfomask = 0;
+
+      // to get nicer code, we try to delay test and cmp;
+      // if we can't because of operand modification, or if we
+      // have math op, make it calculate flags explicitly
+      if (tmp_op->op == OP_TEST || tmp_op->op == OP_CMP) {
+        if (scan_for_mod(tmp_op, ret + 1, i) >= 0)
+          pfomask = 1 << pfo;
+      }
+      else {
+        if ((pfo != PFO_Z && pfo != PFO_S && pfo != PFO_P)
+            || scan_for_mod_opr0(tmp_op, ret + 1, i) >= 0)
+          pfomask = 1 << pfo;
+      }
+      if (pfomask) {
+        tmp_op->pfomask |= pfomask;
+        cmp_result_vars |= pfomask;
         po->datap = tmp_op;
       }
 
@@ -1401,32 +1581,61 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
           break;
 
       for (j = i - 1; j >= 0 && arg < pp->argc; j--) {
-        if (ops[j].flags & OPF_RMD)
-          continue;
-        if (ops[j].op != OP_PUSH)
-          continue;
-        if (g_labels[j + 1][0] != 0)
-          ferr(po, "arg search interrupted by '%s'\n", g_labels[j + 1]);
-
-        pp->arg[arg].datap = &ops[j];
-        ret = scan_for_mod(&ops[j], j + 1, i);
-        if (ret >= 0) {
-          // mark this push as one that needs operand saving
-          ops[j].datap = (void *)(long)(arg + 1);
-          save_arg_vars |= 1 << arg;
+        if (ops[j].op == OP_CALL) {
+          pp_tmp = ops[j].datap;
+          if (pp_tmp == NULL)
+            ferr(po, "arg collect hit unparsed call\n");
+          if (pp_tmp->argc_stack > 0)
+            ferr(po, "arg collect hit '%s' with %d stack args\n",
+              opr_name(&ops[j], 0), pp_tmp->argc_stack);
+        }
+        else if ((ops[j].flags & OPF_TAIL)
+            || (ops[j].flags & (OPF_JMP|OPF_CC)) == OPF_JMP)
+        {
+          break;
+        }
+
+        if (ops[j].op == OP_PUSH) {
+          pp->arg[arg].datap = &ops[j];
+          ret = scan_for_mod(&ops[j], j + 1, i);
+          if (ret >= 0) {
+            // mark this push as one that needs operand saving
+            ops[j].argmask |= 1 << arg;
+            save_arg_vars |= 1 << arg;
+          }
+          else
+            ops[j].flags |= OPF_RMD;
+
+          // next arg
+          for (arg++; arg < pp->argc; arg++)
+            if (pp->arg[arg].reg == NULL)
+              break;
         }
-        else
-          ops[j].flags |= OPF_RMD;
 
-        // next arg
-        for (arg++; arg < pp->argc; arg++)
-          if (pp->arg[arg].reg == NULL)
-            break;
+        if (g_labels[j][0] != 0) {
+          if (j > 0 && ((ops[j - 1].flags & OPF_TAIL)
+            || (ops[j - 1].flags & (OPF_JMP|OPF_CC)) == OPF_JMP))
+          {
+            // follow the branch in reverse
+            if (g_label_refs[j] == NULL)
+              ferr(po, "no refs for '%s'?\n", g_labels[j]);
+            if (g_label_refs[j]->lrl != NULL)
+              ferr(po, "unhandled multiple fefs to '%s'\n", g_labels[j]);
+            j = (g_label_refs[j] - ops) + 1;
+            continue;
+          }
+          break;
+        }
       }
       if (arg < pp->argc)
         ferr(po, "arg collect failed for '%s'\n", tmpname);
       po->datap = pp;
     }
+    else if (po->op == OP_MUL
+      || (po->op == OP_IMUL && po->operand_cnt == 1))
+    {
+      need_mul_var = 1;
+    }
   }
 
   // declare stack frame
@@ -1434,7 +1643,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
     fprintf(fout, "  union { u32 d[%d]; u16 w[%d]; u8 b[%d]; } sf;\n",
       (g_bp_stack + 3) / 4, (g_bp_stack + 1) / 2, g_bp_stack);
 
-  // instantiate arg-registers
+  // declare arg-registers
   for (i = 0; i < g_func_pp.argc; i++) {
     if (g_func_pp.arg[i].reg != NULL) {
       reg = char_array_i(regs_r32,
@@ -1449,7 +1658,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
     }
   }
 
-  // instantiate other regs - special case for eax
+  // declare other regs - special case for eax
   if (!((regmask | regmask_arg) & 1) && !IS(g_func_pp.ret_type, "void")) {
     fprintf(fout, "  u32 eax = 0;\n");
     had_decl = 1;
@@ -1485,6 +1694,11 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
     }
   }
 
+  if (need_mul_var) {
+    fprintf(fout, "  u64 mul_tmp;\n");
+    had_decl = 1;
+  }
+
   if (had_decl)
     fprintf(fout, "\n");
 
@@ -1507,23 +1721,25 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
     // conditional/flag using op?
     if (po->flags & OPF_CC)
     {
-      enum parsed_flag_op pfo;
-      int is_neg = 0;
+      int is_delayed = 0;
+      int is_inv = 0;
 
-      pfo = split_cond(po, po->op, &is_neg);
+      pfo = split_cond(po, po->op, &is_inv);
 
       // we go through all this trouble to avoid using parsed_flag_op,
       // which makes generated code much nicer
       if (delayed_flag_op != NULL)
       {
-        out_cmp_test(buf1, sizeof(buf1), delayed_flag_op, pfo, is_neg);
+        out_cmp_test(buf1, sizeof(buf1), delayed_flag_op, pfo, is_inv);
+        is_delayed = 1;
       }
       else if (last_arith_dst != NULL
         && (pfo == PFO_Z || pfo == PFO_S || pfo == PFO_P))
       {
         out_src_opr(buf3, sizeof(buf3), po, last_arith_dst, 0);
-        out_test_for_cc(buf1, sizeof(buf1), po, pfo, is_neg,
+        out_test_for_cc(buf1, sizeof(buf1), po, pfo, is_inv,
           last_arith_dst->lmod, buf3);
+        is_delayed = 1;
       }
       else if (po->datap != NULL) {
         // use preprocessed results
@@ -1531,9 +1747,9 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         if (!tmp_op || !(tmp_op->pfomask & (1 << pfo)))
           ferr(po, "not prepared for pfo %d\n", pfo);
 
-        // note: is_neg was not yet applied
+        // note: is_inv was not yet applied
         snprintf(buf1, sizeof(buf1), "(%scond_%s)",
-          is_neg ? "!" : "", parsed_flag_op_names[pfo]);
+          is_inv ? "!" : "", parsed_flag_op_names[pfo]);
       }
       else {
         ferr(po, "all methods of finding comparison failed\n");
@@ -1543,7 +1759,9 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         fprintf(fout, "  if %s\n", buf1);
       }
       else if (po->op == OP_ADC || po->op == OP_SBB) {
-        fprintf(fout, "  cond_%s = %s;\n", parsed_flag_op_names[pfo], buf1);
+        if (is_delayed)
+          fprintf(fout, "  cond_%s = %s;\n",
+            parsed_flag_op_names[pfo], buf1);
       }
       else if (po->flags & OPF_DATA) { // SETcc
         out_dst_opr(buf2, sizeof(buf2), po, &po->operand[0]);
@@ -1554,6 +1772,8 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
       }
     }
 
+    pfomask = po->pfomask;
+
     switch (po->op)
     {
       case OP_MOV:
@@ -1566,7 +1786,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
 
       case OP_LEA:
         assert_operand_cnt(2);
-        propagate_lmod(po, &po->operand[0], &po->operand[1]);
+        po->operand[1].lmod = OPLM_DWORD; // always
         fprintf(fout, "  %s = %s;",
             out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
             out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], 1));
@@ -1611,6 +1831,22 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         strcpy(g_comment, "cdq");
         break;
 
+      case OP_STOS:
+        // assumes DF=0
+        assert_operand_cnt(3);
+        if (po->flags & OPF_REP) {
+          fprintf(fout, "  for (; ecx != 0; ecx--, edi += %d)\n",
+            lmod_bytes(po, po->operand[0].lmod));
+          fprintf(fout, "    *(u32 *)edi = eax;");
+          strcpy(g_comment, "rep stos");
+        }
+        else {
+          fprintf(fout, "    *(u32 *)edi = eax; edi += %d;",
+            lmod_bytes(po, po->operand[0].lmod));
+          strcpy(g_comment, "stos");
+        }
+        break;
+
       // arithmetic w/flags
       case OP_ADD:
       case OP_SUB:
@@ -1681,13 +1917,26 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
           lmod_cast_s(po, po->operand[0].lmod), buf2);
         last_arith_dst = &po->operand[0];
         delayed_flag_op = NULL;
+        if (pfomask & (1 << PFO_C)) {
+          fprintf(fout, "\n  cond_c = (%s != 0);", buf1);
+          pfomask &= ~(1 << PFO_C);
+        }
         break;
 
       case OP_IMUL:
         if (po->operand_cnt == 2)
           goto dualop_arith;
-        ferr(po, "TODO imul\n");
-        last_arith_dst = &po->operand[0];
+        if (po->operand_cnt == 3)
+          ferr(po, "TODO imul3\n");
+        // fallthrough
+      case OP_MUL:
+        assert_operand_cnt(1);
+        strcpy(buf1, po->op == OP_IMUL ? "(s64)(s32)" : "(u64)");
+        fprintf(fout, "  mul_tmp = %seax * %s%s;\n", buf1, buf1,
+          out_src_opr(buf2, sizeof(buf2), po, &po->operand[0], 0));
+        fprintf(fout, "  edx = mul_tmp >> 32;\n");
+        fprintf(fout, "  eax = mul_tmp;");
+        last_arith_dst = NULL;
         delayed_flag_op = NULL;
         break;
 
@@ -1707,19 +1956,22 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         }
         else
           ferr(po, "TODO 64bit divident\n");
+        last_arith_dst = NULL;
+        delayed_flag_op = NULL;
         break;
 
       case OP_TEST:
       case OP_CMP:
         propagate_lmod(po, &po->operand[0], &po->operand[1]);
-        if (po->pfomask != 0) {
+        if (pfomask != 0) {
           for (j = 0; j < 8; j++) {
-            if (po->pfomask & (1 << j)) {
+            if (pfomask & (1 << j)) {
               out_cmp_test(buf1, sizeof(buf1), po, j, 0);
               fprintf(fout, "  cond_%s = %s;",
                 parsed_flag_op_names[j], buf1);
             }
           }
+          pfomask = 0;
         }
         else
           no_output = 1;
@@ -1734,6 +1986,10 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         break;
 
       case OP_JMP:
+        assert_operand_cnt(1);
+        if (po->operand[0].type != OPT_LABEL)
+          ferr(po, "unhandled call type\n");
+
         fprintf(fout, "  goto %s;", po->operand[0].name);
         break;
 
@@ -1748,14 +2004,22 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
 
         fprintf(fout, "  ");
         if (!IS(pp->ret_type, "void")) {
-          fprintf(fout, "eax = ");
+          if (po->flags & OPF_TAIL)
+            fprintf(fout, "return ");
+          else
+            fprintf(fout, "eax = ");
           if (strchr(pp->ret_type, '*'))
             fprintf(fout, "(u32)");
         }
+
         fprintf(fout, "%s(", opr_name(po, 0));
         for (arg = 0; arg < pp->argc; arg++) {
           if (arg > 0)
             fprintf(fout, ", ");
+
+          if (strchr(pp->arg[arg].type, '*'))
+            fprintf(fout, "(%s)", pp->arg[arg].type);
+
           if (pp->arg[arg].reg != NULL) {
             fprintf(fout, "%s", pp->arg[arg].reg);
             continue;
@@ -1765,8 +2029,8 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
           tmp_op = pp->arg[arg].datap;
           if (tmp_op == NULL)
             ferr(po, "parsed_op missing for arg%d\n", arg);
-          if (tmp_op->datap) {
-            fprintf(fout, "s_a%ld", (long)tmp_op->datap);
+          if (tmp_op->argmask) {
+            fprintf(fout, "s_a%d", arg + 1);
           }
           else {
             fprintf(fout, "%s",
@@ -1775,6 +2039,14 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
           }
         }
         fprintf(fout, ");");
+
+        if (po->flags & OPF_TAIL) {
+          strcpy(g_comment, "tailcall");
+          if (IS(pp->ret_type, "void"))
+            fprintf(fout, "\n  return;");
+        }
+        delayed_flag_op = NULL;
+        last_arith_dst = NULL;
         break;
 
       case OP_RET:
@@ -1785,10 +2057,14 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         break;
 
       case OP_PUSH:
-        if (po->datap) {
+        if (po->argmask) {
           // special case - saved func arg
-          fprintf(fout, "  s_a%ld = %s;", (long)po->datap,
-            out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], 0));
+          for (j = 0; j < 32; j++) {
+            if (po->argmask & (1 << j)) {
+              fprintf(fout, "  s_a%d = %s;", j + 1,
+                  out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], 0));
+            }
+          }
           break;
         }
         ferr(po, "push encountered\n");
@@ -1798,6 +2074,9 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         ferr(po, "pop encountered\n");
         break;
 
+      case OP_NOP:
+        break;
+
       default:
         no_output = 1;
         ferr(po, "unhandled op type %d, flags %x\n",
@@ -1813,6 +2092,9 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
     if (!no_output)
       fprintf(fout, "\n");
 
+    if (pfomask != 0)
+        ferr(po, "missed flag calc, pfomask=%x\n", pfomask);
+
     // 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))
@@ -1846,6 +2128,7 @@ int main(int argc, char *argv[])
   char line[256];
   char words[16][256];
   int in_func = 0;
+  int skip_warned = 0;
   int eq_alloc;
   int pi = 0;
   int len;
@@ -1922,10 +2205,12 @@ int main(int argc, char *argv[])
           words[0], g_func);
       gen_func(fout, fhdr, g_func, pi);
       in_func = 0;
+      skip_warned = 0;
       g_func[0] = 0;
       if (pi != 0) {
         memset(&ops, 0, pi * sizeof(ops[0]));
         memset(g_labels, 0, pi * sizeof(g_labels[0]));
+        memset(g_label_refs, 0, pi * sizeof(g_label_refs[0]));
         pi = 0;
       }
       g_eqcnt = 0;
@@ -1977,10 +2262,17 @@ int main(int argc, char *argv[])
       continue;
     }
 
+    if (!in_func) {
+      if (!skip_warned && g_labels[pi][0] != 0) {
+        anote("skipping from '%s'\n", g_labels[pi]);
+        skip_warned = 1;
+      }
+      g_labels[pi][0] = 0;
+      continue;
+    }
+
     parse_op(&ops[pi], words, wordc);
     pi++;
-
-    (void)proto_parse;
   }
 
   fclose(fout);