X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tools%2Ftranslate.c;h=7da8be531ce77180790ea519d49bdce1af16485e;hb=3ebea2cf10a8b0bdddff91b7c639afb1d56e2f0b;hp=fbc8ff6a0e897c6c12b7284d8e06b03e8a85a50d;hpb=1bafb621d8dcb57a672b41258de0a8d36b3a4821;p=ia32rtools.git

diff --git a/tools/translate.c b/tools/translate.c
index fbc8ff6..7da8be5 100644
--- a/tools/translate.c
+++ b/tools/translate.c
@@ -8,11 +8,13 @@
 
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
 #define IS(w, y) !strcmp(w, y)
+#define IS_START(w, y) !strncmp(w, y, strlen(y))
 
 #include "protoparse.h"
 
-const char *asmfn;
+static const char *asmfn;
 static int asmln;
+static FILE *g_fhdr;
 
 #define anote(fmt, ...) \
 	printf("%s:%d: note: " fmt, asmfn, asmln, ##__VA_ARGS__)
@@ -31,8 +33,10 @@ enum op_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 */
-  OPF_RSAVE  = (1 << 7), /* push/pop is local reg save/load */
+  OPF_RSAVE  = (1 << 6), /* push/pop is local reg save/load */
+  OPF_REP    = (1 << 7), /* prefixed by rep */
+  OPF_REPZ   = (1 << 8), /* rep is repe/repz */
+  OPF_REPNZ  = (1 << 9), /* rep is repne/repnz */
 };
 
 enum op_op {
@@ -48,6 +52,7 @@ enum op_op {
 	OP_CDQ,
 	OP_STOS,
 	OP_MOVS,
+	OP_CMPS,
 	OP_RET,
 	OP_ADD,
 	OP_SUB,
@@ -111,6 +116,8 @@ enum opr_lenmod {
 struct parsed_opr {
   enum opr_type type;
   enum opr_lenmod lmod;
+  unsigned int is_ptr:1;   // pointer in C
+  unsigned int is_array:1; // array in C
   int reg;
   unsigned int val;
   char name[256];
@@ -126,8 +133,8 @@ struct parsed_op {
   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
+  int bt_i;               // branch target for branches
+  struct parsed_data *btj;// branch targets for jumptables
   void *datap;
 };
 
@@ -141,6 +148,26 @@ struct parsed_equ {
   int offset;
 };
 
+struct parsed_data {
+  char label[256];
+  enum opr_type type;
+  enum opr_lenmod lmod;
+  int count;
+  int count_alloc;
+  struct {
+    union {
+      char *label;
+      unsigned int val;
+    } u;
+    int bt_i;
+  } *d;
+};
+
+struct label_ref {
+  int i;
+  struct label_ref *next;
+};
+
 enum ida_func_attr {
   IDAFA_BP_FRAME = (1 << 0),
   IDAFA_LIB_FUNC = (1 << 1),
@@ -156,15 +183,18 @@ 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 label_ref g_label_refs[MAX_OPS];
 static struct parsed_proto g_func_pp;
+static struct parsed_data *g_func_pd;
+static int g_func_pd_cnt;
 static char g_func[256];
 static char g_comment[256];
 static int g_bp_frame;
 static int g_sp_frame;
 static int g_stack_fsz;
+static int g_ida_func_attr;
 #define ferr(op_, fmt, ...) do { \
-  printf("error:%s:#%ld: '%s': " fmt, g_func, (op_) - ops, \
+  printf("error:%s:#%zd: '%s': " fmt, g_func, (op_) - ops, \
     dump_op(op_), ##__VA_ARGS__); \
   fcloseall(); \
   exit(1); \
@@ -206,7 +236,8 @@ static int char_array_i(const char *array[], size_t len, const char *s)
   return -1;
 }
 
-static void printf_number(char *buf, size_t buf_size, long number)
+static void printf_number(char *buf, size_t buf_size,
+  unsigned long number)
 {
   // output in C-friendly form
   snprintf(buf, buf_size, number < 10 ? "%lu" : "0x%02lx", number);
@@ -240,14 +271,14 @@ static int parse_reg(enum opr_lenmod *reg_lmod, const char *s)
   return -1;
 }
 
-static long parse_number(const char *number)
+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;
-  long ret;
 
   if (*p == '-') {
     neg = 1;
@@ -256,11 +287,11 @@ static long parse_number(const char *number)
   if (len > 1 && *p == '0')
     p++;
   if (number[len - 1] == 'h') {
-    ret = strtol(p, &endp, 16);
+    ret = strtoul(p, &endp, 16);
     bad = (*endp != 'h');
   }
   else {
-    ret = strtol(p, &endp, 10);
+    ret = strtoul(p, &endp, 10);
     bad = (*endp != 0);
   }
   if (bad)
@@ -294,7 +325,7 @@ static int parse_indmode(char *name, int *regmask, int need_c_cvt)
     *d = 0;
 
     // skip 'ds:' prefix
-    if (!strncmp(s, "ds:", 3))
+    if (IS_START(s, "ds:"))
       s += 3;
 
     s = next_idt(w, sizeof(w), s);
@@ -326,20 +357,56 @@ pass:
   return c;
 }
 
-static const char *parse_stack_el(const char *name)
+static int is_reg_in_str(const char *s)
 {
-  const char *p, *s;
+  int i;
+
+  if (strlen(s) < 3 || (s[3] && !my_issep(s[3]) && !my_isblank(s[3])))
+    return 0;
+
+  for (i = 0; i < ARRAY_SIZE(regs_r32); i++)
+    if (!strncmp(s, regs_r32[i], 3))
+      return 1;
+
+  return 0;
+}
+
+static const char *parse_stack_el(const char *name, char *extra_reg)
+{
+  const char *p, *p2, *s;
   char *endp = NULL;
   char buf[32];
   long val;
   int len;
 
-  if (!strncmp(name, "ebp+", 4)
-      && !('0' <= name[4] && name[4] <= '9'))
-  {
-    return name + 4;
+  p = name;
+  if (IS_START(p + 3, "+ebp+") && is_reg_in_str(p)) {
+    p += 4;
+    if (extra_reg != NULL) {
+      strncpy(extra_reg, name, 3);
+      extra_reg[4] = 0;
+    }
   }
-  if (strncmp(name, "esp+", 4) != 0)
+
+  if (IS_START(p, "ebp+")) {
+    p += 4;
+
+    p2 = strchr(p, '+');
+    if (p2 != NULL && is_reg_in_str(p)) {
+      if (extra_reg != NULL) {
+        strncpy(extra_reg, p, p2 - p);
+        extra_reg[p2 - p] = 0;
+      }
+      p = p2 + 1;
+    }
+
+    if (!('0' <= *p && *p <= '9'))
+      return p;
+
+    return NULL;
+  }
+
+  if (!IS_START(name, "esp+"))
     return NULL;
 
   p = strchr(name + 4, '+');
@@ -390,6 +457,65 @@ static int guess_lmod_from_name(struct parsed_opr *opr)
   return 0;
 }
 
+static int guess_lmod_from_c_type(enum opr_lenmod *lmod,
+  const struct parsed_type *c_type)
+{
+  static const char *dword_types[] = {
+    "int", "_DWORD", "DWORD", "HANDLE", "HWND", "HMODULE",
+  };
+  static const char *word_types[] = {
+    "__int16", "unsigned __int16",
+  };
+  static const char *byte_types[] = {
+    "char", "__int8", "unsigned __int8", "BYTE",
+  };
+  const char *n;
+  int i;
+
+  if (c_type->is_ptr) {
+    *lmod = OPLM_DWORD;
+    return 1;
+  }
+
+  n = skip_type_mod(c_type->name);
+
+  for (i = 0; i < ARRAY_SIZE(dword_types); i++) {
+    if (IS(n, dword_types[i])) {
+      *lmod = OPLM_DWORD;
+      return 1;
+    }
+  }
+
+  for (i = 0; i < ARRAY_SIZE(word_types); i++) {
+    if (IS(n, word_types[i])) {
+      *lmod = OPLM_WORD;
+      return 1;
+    }
+  }
+
+  for (i = 0; i < ARRAY_SIZE(byte_types); i++) {
+    if (IS(n, byte_types[i])) {
+      *lmod = OPLM_BYTE;
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+static enum opr_type lmod_from_directive(const char *d)
+{
+  if (IS(d, "dd"))
+    return OPLM_DWORD;
+  else if (IS(d, "dw"))
+    return OPLM_WORD;
+  else if (IS(d, "db"))
+    return OPLM_BYTE;
+
+  aerr("unhandled directive: '%s'\n", d);
+  return OPLM_UNSPEC;
+}
+
 static void setup_reg_opr(struct parsed_opr *opr, int reg, enum opr_lenmod lmod,
   int *regmask)
 {
@@ -399,16 +525,19 @@ 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 struct parsed_equ *equ_find(struct parsed_op *po, const char *name,
+  int *extra_offs);
 
 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)
 {
+  struct parsed_proto pp;
   enum opr_lenmod tmplmod;
+  unsigned long number;
   int ret, len;
-  long number;
   int wordc_in;
+  char *tmp;
   int i;
 
   if (w >= wordc)
@@ -444,6 +573,8 @@ static int parse_operand(struct parsed_opr *opr,
 
     if (label != NULL) {
       opr->type = OPT_LABEL;
+      if (IS_START(label, "ds:"))
+        label += 3;
       strcpy(opr->name, label);
       return wordc;
     }
@@ -464,16 +595,30 @@ static int parse_operand(struct parsed_opr *opr,
     }
   }
 
-  if (wordc_in == 2 && IS(words[w], "offset")) {
-    opr->type = OPT_OFFSET;
-    strcpy(opr->name, words[w + 1]);
-    return wordc;
+  if (wordc_in == 2) {
+    if (IS(words[w], "offset")) {
+      opr->type = OPT_OFFSET;
+      strcpy(opr->name, words[w + 1]);
+      return wordc;
+    }
+    if (IS(words[w], "(offset")) {
+      char *p = strchr(words[w + 1], ')');
+      if (p == NULL)
+        aerr("parse of bracketed offset failed\n");
+      *p = 0;
+      opr->type = OPT_OFFSET;
+      strcpy(opr->name, words[w + 1]);
+      return wordc;
+    }
   }
 
   if (wordc_in != 1)
     aerr("parse_operand 1 word expected\n");
 
-  strcpy(opr->name, words[w]);
+  tmp = words[w];
+  if (IS_START(tmp, "ds:"))
+    tmp += 3;
+  strcpy(opr->name, tmp);
 
   if (words[w][0] == '[') {
     opr->type = OPT_REGMEM;
@@ -482,10 +627,10 @@ static int parse_operand(struct parsed_opr *opr,
       aerr("[] parse failure\n");
 
     parse_indmode(opr->name, regmask_indirect, 1);
-    if (opr->lmod == OPLM_UNSPEC && parse_stack_el(opr->name)) {
+    if (opr->lmod == OPLM_UNSPEC && parse_stack_el(opr->name, NULL)) {
       // might be an equ
       struct parsed_equ *eq =
-        equ_find(NULL, parse_stack_el(opr->name));
+        equ_find(NULL, parse_stack_el(opr->name, NULL), &i);
       if (eq)
         opr->lmod = eq->lmod;
     }
@@ -517,12 +662,24 @@ static int parse_operand(struct parsed_opr *opr,
 
   // most likely var in data segment
   opr->type = OPT_LABEL;
+
+  ret = proto_parse(g_fhdr, opr->name, &pp);
+  if (ret == 0) {
+    if (pp.is_fptr) {
+      opr->lmod = OPLM_DWORD;
+      opr->is_ptr = 1;
+    }
+    else if (opr->lmod == OPLM_UNSPEC) {
+      if (!guess_lmod_from_c_type(&opr->lmod, &pp.type))
+        anote("unhandled C type '%s' for '%s'\n", pp.type.name, opr->name);
+    }
+    opr->is_ptr = pp.type.is_ptr;
+    opr->is_array = pp.type.is_array;
+  }
+  proto_release(&pp);
+
   if (opr->lmod == OPLM_UNSPEC)
     guess_lmod_from_name(opr);
-  if (opr->lmod != OPLM_UNSPEC)
-    return wordc;
-
-  // TODO: scan data seg to determine type?
   return wordc;
 }
 
@@ -531,6 +688,10 @@ static const struct {
   unsigned int flags;
 } pref_table[] = {
   { "rep",    OPF_REP },
+  { "repe",   OPF_REP|OPF_REPZ },
+  { "repz",   OPF_REP|OPF_REPZ },
+  { "repne",  OPF_REP|OPF_REPNZ },
+  { "repnz",  OPF_REP|OPF_REPNZ },
 };
 
 static const struct {
@@ -555,6 +716,9 @@ static const struct {
   { "movsb",OP_MOVS,   0, 0, OPF_DATA },
   { "movsw",OP_MOVS,   0, 0, OPF_DATA },
   { "movsd",OP_MOVS,   0, 0, OPF_DATA },
+  { "cmpsb",OP_CMPS,   0, 0, OPF_DATA|OPF_FLAGS },
+  { "cmpsw",OP_CMPS,   0, 0, OPF_DATA|OPF_FLAGS },
+  { "cmpsd",OP_CMPS,   0, 0, OPF_DATA|OPF_FLAGS },
   { "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 },
@@ -728,13 +892,14 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc)
     break;
 
   case OP_MOVS:
+  case OP_CMPS:
     if (op->operand_cnt != 0)
       break;
-    if      (IS(words[op_w], "movsb"))
+    if      (words[op_w][4] == 'b')
       lmod = OPLM_BYTE;
-    else if (IS(words[op_w], "movsw"))
+    else if (words[op_w][4] == 'w')
       lmod = OPLM_WORD;
-    else if (IS(words[op_w], "movsd"))
+    else if (words[op_w][4] == 'd')
       lmod = OPLM_DWORD;
     op->operand_cnt = 3;
     setup_reg_opr(&op->operand[0], xDI, lmod, &op->regmask_src);
@@ -775,6 +940,23 @@ static void parse_op(struct parsed_op *op, char words[16][256], int wordc)
       op->operand[1].lmod = OPLM_BYTE;
     break;
 
+  case OP_PUSH:
+    if (op->operand[0].lmod == OPLM_UNSPEC
+        && (op->operand[0].type == OPT_CONST
+         || op->operand[0].type == OPT_OFFSET
+         || op->operand[0].type == OPT_LABEL))
+      op->operand[0].lmod = OPLM_DWORD;
+    break;
+
+  // alignment
+  case OP_MOV:
+    if (op->operand[0].type == OPT_REG && op->operand[1].type == OPT_REG
+     && op->operand[0].reg == xDI && op->operand[1].reg == xDI)
+    {
+      op->flags |= OPF_RMD;
+    }
+    break;
+
   default:
     break;
   }
@@ -798,6 +980,9 @@ static const char *dump_op(struct parsed_op *po)
   char *p = out;
   int i;
 
+  if (po == NULL)
+    return "???";
+
   snprintf(out, sizeof(out), "%s", op_name(po->op));
   for (i = 0; i < po->operand_cnt; i++) {
     p += strlen(p);
@@ -811,6 +996,22 @@ static const char *dump_op(struct parsed_op *po)
   return out;
 }
 
+static const char *lmod_type_u(struct parsed_op *po,
+  enum opr_lenmod lmod)
+{
+  switch (lmod) {
+  case OPLM_DWORD:
+    return "u32";
+  case OPLM_WORD:
+    return "u16";
+  case OPLM_BYTE:
+    return "u8";
+  default:
+    ferr(po, "invalid lmod: %d\n", lmod);
+    return "(_invalid_)";
+  }
+}
+
 static const char *lmod_cast_u(struct parsed_op *po,
   enum opr_lenmod lmod)
 {
@@ -905,12 +1106,33 @@ static const char *opr_reg_p(struct parsed_op *po, struct parsed_opr *popr)
   return regs_r32[popr->reg];
 }
 
-static struct parsed_equ *equ_find(struct parsed_op *po, const char *name)
+static struct parsed_equ *equ_find(struct parsed_op *po, const char *name,
+  int *extra_offs)
 {
+  const char *p;
+  char *endp;
+  int namelen;
   int i;
 
+  *extra_offs = 0;
+  namelen = strlen(name);
+
+  p = strchr(name, '+');
+  if (p != NULL) {
+    namelen = p - name;
+    if (namelen <= 0)
+      ferr(po, "equ parse failed for '%s'\n", name);
+
+    if (IS_START(p, "0x"))
+      p += 2;
+    *extra_offs = strtol(p, &endp, 16);
+    if (*endp != 0)
+      ferr(po, "equ parse failed for '%s'\n", name);
+  }
+
   for (i = 0; i < g_eqcnt; i++)
-    if (IS(g_eqs[i].name, name))
+    if (strncmp(g_eqs[i].name, name, namelen) == 0
+     && g_eqs[i].name[namelen] == 0)
       break;
   if (i >= g_eqcnt) {
     if (po != NULL)
@@ -923,32 +1145,39 @@ static struct parsed_equ *equ_find(struct parsed_op *po, const char *name)
 
 static void stack_frame_access(struct parsed_op *po,
   enum opr_lenmod lmod, char *buf, size_t buf_size,
-  const char *name, int is_src, int is_lea)
+  const char *name, const char *cast, int is_src, int is_lea)
 {
+  enum opr_lenmod tmp_lmod = OPLM_UNSPEC;
   const char *prefix = "";
+  char ofs_reg[16] = { 0, };
   struct parsed_equ *eq;
   int i, arg_i, arg_s;
   const char *bp_arg;
   int stack_ra = 0;
+  int offset = 0;
   int sf_ofs;
 
-  bp_arg = parse_stack_el(name);
+  bp_arg = parse_stack_el(name, ofs_reg);
   snprintf(g_comment, sizeof(g_comment), "%s", bp_arg);
-  eq = equ_find(po, bp_arg);
+  eq = equ_find(po, bp_arg, &offset);
   if (eq == NULL)
     ferr(po, "detected but missing eq\n");
 
+  offset += eq->offset;
+
   if (!strncmp(name, "ebp", 3))
     stack_ra = 4;
 
-  if (stack_ra <= eq->offset && eq->offset < stack_ra + 4)
-    ferr(po, "reference to ra? %d %d\n", eq->offset, stack_ra);
+  if (stack_ra <= offset && offset < stack_ra + 4)
+    ferr(po, "reference to ra? %d %d\n", offset, stack_ra);
 
-  if (eq->offset > stack_ra) {
-    arg_i = (eq->offset - stack_ra - 4) / 4;
+  if (offset > stack_ra) {
+    arg_i = (offset - stack_ra - 4) / 4;
     if (arg_i < 0 || arg_i >= g_func_pp.argc_stack)
       ferr(po, "offset %d (%s) doesn't map to any arg\n",
-        eq->offset, bp_arg);
+        offset, bp_arg);
+    if (ofs_reg[0] != 0)
+      ferr(po, "offset reg on arg access?\n");
 
     for (i = arg_s = 0; i < g_func_pp.argc; i++) {
       if (g_func_pp.arg[i].reg != NULL)
@@ -962,43 +1191,114 @@ static void stack_frame_access(struct parsed_op *po,
     if (is_lea)
       ferr(po, "lea to arg?\n");
 
-    snprintf(buf, buf_size, "%sa%d", is_src ? "(u32)" : "", i + 1);
+    switch (lmod)
+    {
+    case OPLM_BYTE:
+      if (is_src && (offset & 3) == 0)
+        snprintf(buf, buf_size, "(u8)a%d", i + 1);
+      else
+        snprintf(buf, buf_size, "BYTE%d(a%d)", offset & 3, i + 1);
+      break;
+
+    case OPLM_WORD:
+      if (offset & 1)
+        ferr(po, "unaligned arg access\n");
+      if (is_src && (offset & 2) == 0)
+        snprintf(buf, buf_size, "(u16)a%d", i + 1);
+      else
+        snprintf(buf, buf_size, "%sWORD(a%d)",
+          (offset & 2) ? "HI" : "LO", i + 1);
+      break;
+
+    case OPLM_DWORD:
+      if (offset & 3)
+        ferr(po, "unaligned arg access\n");
+      if (cast[0])
+        prefix = cast;
+      else if (is_src)
+        prefix = "(u32)";
+      snprintf(buf, buf_size, "%sa%d", prefix, i + 1);
+      break;
+
+    default:
+      ferr(po, "bp_arg bad lmod: %d\n", lmod);
+    }
+
+    // common problem
+    guess_lmod_from_c_type(&tmp_lmod, &g_func_pp.arg[i].type);
+    if ((offset & 3) && tmp_lmod != OPLM_DWORD)
+      ferr(po, "bp_arg arg/w offset %d and type '%s'\n",
+        offset, g_func_pp.arg[i].type.name);
   }
   else {
     if (g_stack_fsz == 0)
       ferr(po, "stack var access without stackframe\n");
 
-    sf_ofs = g_stack_fsz + eq->offset;
+    sf_ofs = g_stack_fsz + offset;
     if (sf_ofs < 0)
-      ferr(po, "bp_stack offset %d/%d\n", eq->offset, g_stack_fsz);
+      ferr(po, "bp_stack offset %d/%d\n", offset, g_stack_fsz);
 
     if (is_lea)
       prefix = "(u32)&";
+    else
+      prefix = cast;
 
     switch (lmod)
     {
     case OPLM_BYTE:
-      snprintf(buf, buf_size, "%ssf.b[%d]", prefix, sf_ofs);
+      snprintf(buf, buf_size, "%ssf.b[%d%s%s]",
+        prefix, sf_ofs, ofs_reg[0] ? "+" : "", ofs_reg);
       break;
+
     case OPLM_WORD:
+      if ((sf_ofs & 1) || ofs_reg[0] != 0) {
+        // known unaligned or possibly unaligned
+        strcat(g_comment, " unaligned");
+        if (prefix[0] == 0)
+          prefix = "*(u16 *)&";
+        snprintf(buf, buf_size, "%ssf.b[%d%s%s]",
+          prefix, sf_ofs, ofs_reg[0] ? "+" : "", ofs_reg);
+        break;
+      }
       snprintf(buf, buf_size, "%ssf.w[%d]", prefix, sf_ofs / 2);
       break;
+
     case OPLM_DWORD:
+      if ((sf_ofs & 3) || ofs_reg[0] != 0) {
+        // known unaligned or possibly unaligned
+        strcat(g_comment, " unaligned");
+        if (prefix[0] == 0)
+          prefix = "*(u32 *)&";
+        snprintf(buf, buf_size, "%ssf.b[%d%s%s]",
+          prefix, sf_ofs, ofs_reg[0] ? "+" : "", ofs_reg);
+        break;
+      }
       snprintf(buf, buf_size, "%ssf.d[%d]", prefix, sf_ofs / 4);
       break;
+
     default:
       ferr(po, "bp_stack bad lmod: %d\n", lmod);
     }
   }
 }
 
+static void check_label_read_ref(struct parsed_op *po, const char *name)
+{
+  if (IS_START(name, "sub_"))
+    ferr(po, "func reference?\n");
+}
+
 static char *out_src_opr(char *buf, size_t buf_size,
-	struct parsed_op *po, struct parsed_opr *popr, int is_lea)
+	struct parsed_op *po, struct parsed_opr *popr, const char *cast,
+  int is_lea)
 {
   char tmp1[256], tmp2[256];
   char expr[256];
   int ret;
 
+  if (cast == NULL)
+    cast = "";
+
   switch (popr->type) {
   case OPT_REG:
     if (is_lea)
@@ -1006,7 +1306,7 @@ static char *out_src_opr(char *buf, size_t buf_size,
 
     switch (popr->lmod) {
     case OPLM_DWORD:
-      snprintf(buf, buf_size, "%s", opr_reg_p(po, popr));
+      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));
@@ -1023,9 +1323,9 @@ static char *out_src_opr(char *buf, size_t buf_size,
     break;
 
   case OPT_REGMEM:
-    if (parse_stack_el(popr->name)) {
+    if (parse_stack_el(popr->name, NULL)) {
       stack_frame_access(po, popr->lmod, buf, buf_size,
-        popr->name, 1, is_lea);
+        popr->name, cast, 1, is_lea);
       break;
     }
 
@@ -1044,28 +1344,38 @@ static char *out_src_opr(char *buf, size_t buf_size,
       break;
     }
 
-    snprintf(buf, buf_size, "%s(%s)",
-      lmod_cast_u_ptr(po, popr->lmod), expr);
+    if (cast[0] == 0)
+      cast = lmod_cast_u_ptr(po, popr->lmod);
+    snprintf(buf, buf_size, "%s(%s)", cast, expr);
     break;
 
   case OPT_LABEL:
+    check_label_read_ref(po, popr->name);
+    if (cast[0] == 0 && popr->is_ptr)
+      cast = "(u32)";
     if (is_lea)
       snprintf(buf, buf_size, "(u32)&%s", popr->name);
     else
-      snprintf(buf, buf_size, "(u32)%s", popr->name);
+      snprintf(buf, buf_size, "%s%s%s", cast, popr->name,
+        popr->is_array ? "[0]" : "");
     break;
 
   case OPT_OFFSET:
+    check_label_read_ref(po, popr->name);
+    if (cast[0] == 0)
+      cast = "(u32)";
     if (is_lea)
       ferr(po, "lea an offset?\n");
-    snprintf(buf, buf_size, "(u32)&%s", popr->name);
+    snprintf(buf, buf_size, "%s&%s", cast, popr->name);
     break;
 
   case OPT_CONST:
     if (is_lea)
       ferr(po, "lea from const?\n");
 
-    printf_number(buf, buf_size, popr->val);
+    snprintf(buf, buf_size, "%s", cast);
+    ret = strlen(buf);
+    printf_number(buf + ret, buf_size - ret, popr->val);
     break;
 
   default:
@@ -1101,16 +1411,17 @@ static char *out_dst_opr(char *buf, size_t buf_size,
     break;
 
   case OPT_REGMEM:
-    if (parse_stack_el(popr->name)) {
+    if (parse_stack_el(popr->name, NULL)) {
       stack_frame_access(po, popr->lmod, buf, buf_size,
-        popr->name, 0, 0);
+        popr->name, "", 0, 0);
       break;
     }
 
-    return out_src_opr(buf, buf_size, po, popr, 0);
+    return out_src_opr(buf, buf_size, po, popr, NULL, 0);
 
   case OPT_LABEL:
-    snprintf(buf, buf_size, "%s", popr->name);
+    snprintf(buf, buf_size, "%s%s", popr->name,
+      popr->is_array ? "[0]" : "");
     break;
 
   default:
@@ -1120,6 +1431,12 @@ static char *out_dst_opr(char *buf, size_t buf_size,
   return buf;
 }
 
+static char *out_src_opr_u32(char *buf, size_t buf_size,
+	struct parsed_op *po, struct parsed_opr *popr)
+{
+  return out_src_opr(buf, buf_size, po, popr, NULL, 0);
+}
+
 static enum parsed_flag_op split_cond(struct parsed_op *po,
   enum op_op op, int *is_inv)
 {
@@ -1265,19 +1582,19 @@ static void out_cmp_test(char *buf, size_t buf_size,
 
   if (po->op == OP_TEST) {
     if (IS(opr_name(po, 0), opr_name(po, 1))) {
-      out_src_opr(buf3, sizeof(buf3), po, &po->operand[0], 0);
+      out_src_opr_u32(buf3, sizeof(buf3), po, &po->operand[0]);
     }
     else {
-      out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], 0);
-      out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], 0);
+      out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]);
+      out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]);
       snprintf(buf3, sizeof(buf3), "(%s & %s)", buf1, buf2);
     }
     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_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);
   }
@@ -1343,6 +1660,7 @@ static int scan_for_pop(int i, int opcnt, const char *reg,
 {
   struct parsed_op *po;
   int ret = 0;
+  int j;
 
   for (; i < opcnt; i++) {
     po = &ops[i];
@@ -1358,6 +1676,19 @@ static int scan_for_pop(int i, int opcnt, const char *reg,
       continue;
 
     if ((po->flags & OPF_JMP) && po->op != OP_CALL) {
+      if (po->btj != NULL) {
+        // jumptable
+        for (j = 0; j < po->btj->count - 1; j++) {
+          ret |= scan_for_pop(po->btj->d[j].bt_i, opcnt, reg, magic,
+                   depth, maxdepth, do_flags);
+          if (ret < 0)
+            return ret; // dead end
+        }
+        // follow last jumptable entry
+        i = po->btj->d[j].bt_i - 1;
+        continue;
+      }
+
       if (po->bt_i < 0) {
         ferr(po, "dead branch\n");
         return -1;
@@ -1527,22 +1858,48 @@ static int scan_for_cdq_edx(int i)
   return -1;
 }
 
+static int scan_for_reg_clear(int i, int reg)
+{
+  for (; i >= 0; i--) {
+    if (ops[i].op == OP_XOR
+     && ops[i].operand[0].lmod == OPLM_DWORD
+     && ops[i].operand[0].reg == ops[i].operand[1].reg
+     && ops[i].operand[0].reg == reg)
+      return i;
+
+    if (ops[i].regmask_dst & (1 << reg))
+      return -1;
+    if (g_labels[i][0] != 0)
+      return -1;
+  }
+
+  return -1;
+}
+
 // scan for positive, constant esp adjust
 static int scan_for_esp_adjust(int i, int opcnt, int *adj)
 {
+  struct parsed_op *po;
+  *adj = 0;
+
   for (; i < opcnt; i++) {
-    if (ops[i].op == OP_ADD && ops[i].operand[0].reg == xSP) {
-      if (ops[i].operand[1].type != OPT_CONST)
+    po = &ops[i];
+
+    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");
-      *adj = ops[i].operand[1].val;
+      *adj += po->operand[1].val;
       if (*adj & 3)
         ferr(&ops[i], "unaligned esp adjust: %x\n", *adj);
       return i;
     }
-
-    if ((ops[i].flags & (OPF_JMP|OPF_TAIL))
-         || ops[i].op == OP_PUSH || ops[i].op == OP_POP)
+    else if (po->op == OP_PUSH)
+      *adj -= lmod_bytes(po, po->operand[0].lmod);
+    else if (po->op == OP_POP)
+      *adj += lmod_bytes(po, po->operand[0].lmod);
+    else if ((po->flags & (OPF_JMP|OPF_TAIL)) && po->op != OP_CALL)
       return -1;
+
     if (g_labels[i][0] != 0)
       return -1;
   }
@@ -1550,27 +1907,44 @@ static int scan_for_esp_adjust(int i, int opcnt, int *adj)
   return -1;
 }
 
+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->next = lr_new;
+}
+
 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];
+  char buf1[256], buf2[256], buf3[256], cast[64];
   struct parsed_proto *pp, *pp_tmp;
+  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 had_decl = 0;
+  int label_pending = 0;
   int regmask_save = 0;
   int regmask_arg = 0;
   int regmask = 0;
   int pfomask = 0;
+  int found = 0;
   int depth = 0;
   int no_output;
+  int i, j, l;
   int dummy;
   int arg;
-  int i, j;
   int reg;
   int ret;
 
@@ -1580,11 +1954,11 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
   if (ret)
     ferr(ops, "proto_parse failed for '%s'\n", funcn);
 
-  fprintf(fout, "%s %s(", g_func_pp.ret_type, funcn);
+  fprintf(fout, "%s %s(", g_func_pp.ret_type.name, funcn);
   for (i = 0; i < g_func_pp.argc; i++) {
     if (i > 0)
       fprintf(fout, ", ");
-    fprintf(fout, "%s a%d", g_func_pp.arg[i].type, i + 1);
+    fprintf(fout, "%s a%d", g_func_pp.arg[i].type.name, i + 1);
   }
   fprintf(fout, ")\n{\n");
 
@@ -1600,10 +1974,12 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
     g_bp_frame = 1;
     ops[0].flags |= OPF_RMD;
     ops[1].flags |= OPF_RMD;
+    i = 2;
 
     if (ops[2].op == OP_SUB && IS(opr_name(&ops[2], 0), "esp")) {
       g_stack_fsz = opr_const(&ops[2], 1);
       ops[2].flags |= OPF_RMD;
+      i++;
     }
     else {
       // another way msvc builds stack frame..
@@ -1614,13 +1990,28 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         ecx_push++;
         i++;
       }
+      // and another way..
+      if (i == 2 && ops[i].op == OP_MOV && ops[i].operand[0].reg == xAX
+          && ops[i].operand[1].type == OPT_CONST
+          && ops[i + 1].op == OP_CALL
+          && IS(opr_name(&ops[i + 1], 0), "__alloca_probe"))
+      {
+        g_stack_fsz += ops[i].operand[1].val;
+        ops[i].flags |= OPF_RMD;
+        i++;
+        ops[i].flags |= OPF_RMD;
+        i++;
+      }
     }
 
-    i = 2;
+    found = 0;
     do {
       for (; i < opcnt; i++)
         if (ops[i].op == OP_RET)
           break;
+      if (i == opcnt && (ops[i - 1].flags & OPF_JMP) && found)
+        break;
+
       if (ops[i - 1].op != OP_POP || !IS(opr_name(&ops[i - 1], 0), "ebp"))
         ferr(&ops[i - 1], "'pop ebp' expected\n");
       ops[i - 1].flags |= OPF_RMD;
@@ -1641,6 +2032,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         }
       }
 
+      found = 1;
       i++;
     } while (i < opcnt);
   }
@@ -1683,25 +2075,65 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
   for (i = 0; i < opcnt; i++) {
     po = &ops[i];
     po->bt_i = -1;
+    po->btj = NULL;
 
     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;
+    if (po->operand[0].type == OPT_REGMEM) {
+      char *p = strchr(po->operand[0].name, '[');
+      if (p == NULL)
+        ferr(po, "unhandled indirect branch\n");
+      ret = p - po->operand[0].name;
+      strncpy(buf1, po->operand[0].name, ret);
+      buf1[ret] = 0;
+
+      for (j = 0, pd = NULL; j < g_func_pd_cnt; j++) {
+        if (IS(g_func_pd[j].label, buf1)) {
+          pd = &g_func_pd[j];
+          break;
+        }
+      }
+      if (pd == NULL)
+        ferr(po, "label '%s' not parsed?\n", buf1);
+      if (pd->type != OPT_OFFSET)
+        ferr(po, "label '%s' with non-offset data?\n", buf1);
+
+      // find all labels, link
+      for (j = 0; j < pd->count; j++) {
+        for (l = 0; l < opcnt; l++) {
+          if (g_labels[l][0] && IS(g_labels[l], pd->d[j].u.label)) {
+            add_label_ref(&g_label_refs[l], i);
+            pd->d[j].bt_i = l;
+            break;
+          }
+        }
+      }
+
+      po->btj = pd;
+      continue;
+    }
+
+    for (l = 0; l < opcnt; l++) {
+      if (g_labels[l][0] && IS(po->operand[0].name, g_labels[l])) {
+        add_label_ref(&g_label_refs[l], i);
+        po->bt_i = l;
         break;
       }
     }
 
-    if (po->bt_i == -1) {
+    if (po->bt_i != -1)
+      continue;
+
+    if (po->operand[0].type == OPT_LABEL) {
       // assume tail call
       po->op = OP_CALL;
       po->flags |= OPF_TAIL;
+      continue;
     }
+
+    ferr(po, "unhandled branch\n");
   }
 
   // pass3:
@@ -1725,10 +2157,10 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         j /= 4;
         if (j > ARRAY_SIZE(pp->arg))
           ferr(po, "esp adjust too large?\n");
-        pp->ret_type = "int";
+        pp->ret_type.name = strdup("int");
         pp->argc = pp->argc_stack = j;
         for (arg = 0; arg < pp->argc; arg++)
-          pp->arg[arg].type = "int";
+          pp->arg[arg].type.name = strdup("int");
       }
       else {
         ret = proto_parse(fhdr, tmpname, pp);
@@ -1736,14 +2168,48 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
           ferr(po, "proto_parse failed for call '%s'\n", tmpname);
       }
 
-      ret = scan_for_esp_adjust(i + 1, opcnt, &j);
+      // look for and make use of esp adjust
+      ret = -1;
+      if (!pp->is_stdcall)
+        ret = scan_for_esp_adjust(i + 1, opcnt, &j);
       if (ret >= 0) {
+        if (pp->is_vararg) {
+          if (j / 4 < pp->argc_stack)
+            ferr(po, "esp adjust is too small: %x < %x\n",
+              j, pp->argc_stack * 4);
+          // modify pp to make it have varargs as normal args
+          arg = pp->argc;
+          pp->argc += j / 4 - pp->argc_stack;
+          for (; arg < pp->argc; arg++) {
+            pp->arg[arg].type.name = strdup("int");
+            pp->argc_stack++;
+          }
+          if (pp->argc > ARRAY_SIZE(pp->arg))
+            ferr(po, "too many args\n");
+        }
         if (pp->argc_stack != j / 4)
           ferr(po, "stack tracking failed: %x %x\n",
-            pp->argc_stack, j);
+            pp->argc_stack * 4, j);
+
         ops[ret].flags |= OPF_RMD;
+        // a bit of a hack, but deals with use of
+        // single adj for multiple calls
+        ops[ret].operand[1].val -= j;
+      }
+      else if (pp->is_vararg)
+        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].fptr != NULL) {
+          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);
+        }
       }
 
+      // collect all stack args
       for (arg = 0; arg < pp->argc; arg++)
         if (pp->arg[arg].reg == NULL)
           break;
@@ -1755,11 +2221,11 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
             || (ops[j - 1].flags & (OPF_JMP|OPF_CC)) == OPF_JMP))
           {
             // follow the branch in reverse
-            if (g_label_refs[j] == NULL)
+            if (g_label_refs[j].i == -1)
               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;
+            if (g_label_refs[j].next != NULL)
+              ferr(po, "unhandled multiple refs to '%s'\n", g_labels[j]);
+            j = g_label_refs[j].i + 1;
             continue;
           }
           break;
@@ -1800,7 +2266,8 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         }
       }
       if (arg < pp->argc)
-        ferr(po, "arg collect failed for '%s'\n", tmpname);
+        ferr(po, "arg collect failed for '%s': %d/%d\n",
+          tmpname, arg, pp->argc);
       po->datap = pp;
     }
   }
@@ -1870,6 +2337,9 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         if (scan_for_mod(tmp_op, ret + 1, i) >= 0)
           pfomask = 1 << pfo;
       }
+      else if (tmp_op->op == OP_CMPS) {
+        pfomask = 1 << PFO_Z;
+      }
       else {
         if ((pfo != PFO_Z && pfo != PFO_S && pfo != PFO_P)
             || scan_for_mod_opr0(tmp_op, ret + 1, i) >= 0)
@@ -1892,16 +2362,42 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
     else if (po->op == OP_CALL && po->operand[0].type != OPT_LABEL) {
       pp = po->datap;
       my_assert_not(pp, NULL);
-      fprintf(fout, "  %s (*icall%d)(", pp->ret_type, i);
+      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, j + 1);
+        fprintf(fout, "%s a%d", pp->arg[j].type.name, j + 1);
       }
       fprintf(fout, ");\n");
     }
   }
 
+  // output LUTs/jumptables
+  for (i = 0; i < g_func_pd_cnt; i++) {
+    pd = &g_func_pd[i];
+    fprintf(fout, "  static const ");
+    if (pd->type == OPT_OFFSET) {
+      fprintf(fout, "void *jt_%s[] =\n    { ", pd->label);
+
+      for (j = 0; j < pd->count; j++) {
+        if (j > 0)
+          fprintf(fout, ", ");
+        fprintf(fout, "&&%s", pd->d[j].u.label);
+      }
+    }
+    else {
+      fprintf(fout, "%s %s[] =\n    { ",
+        lmod_type_u(ops, pd->lmod), pd->label);
+
+      for (j = 0; j < pd->count; j++) {
+        if (j > 0)
+          fprintf(fout, ", ");
+        fprintf(fout, "%u", pd->d[j].u.val);
+      }
+    }
+    fprintf(fout, " };\n");
+  }
+
   // declare stack frame
   if (g_stack_fsz)
     fprintf(fout, "  union { u32 d[%d]; u16 w[%d]; u8 b[%d]; } sf;\n",
@@ -1923,7 +2419,9 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
   }
 
   // declare other regs - special case for eax
-  if (!((regmask | regmask_arg) & 1) && !IS(g_func_pp.ret_type, "void")) {
+  if (!((regmask | regmask_arg) & 1)
+   && !IS(g_func_pp.ret_type.name, "void"))
+  {
     fprintf(fout, "  u32 eax = 0;\n");
     had_decl = 1;
   }
@@ -1979,8 +2477,10 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
   // output ops
   for (i = 0; i < opcnt; i++)
   {
-    if (g_labels[i][0] != 0 && g_label_refs[i] != NULL)
+    if (g_labels[i][0] != 0 && g_label_refs[i].i != -1) {
       fprintf(fout, "\n%s:\n", g_labels[i]);
+      label_pending = 1;
+    }
 
     po = &ops[i];
     if (po->flags & OPF_RMD)
@@ -2010,13 +2510,13 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
       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_src_opr_u32(buf3, sizeof(buf3), po, last_arith_dst);
         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
+        // use preprocessed flag calc results
         tmp_op = po->datap;
         if (!tmp_op || !(tmp_op->pfomask & (1 << pfo)))
           ferr(po, "not prepared for pfo %d\n", pfo);
@@ -2055,7 +2555,8 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         propagate_lmod(po, &po->operand[0], &po->operand[1]);
         fprintf(fout, "  %s = %s;",
             out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
-            out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], 0));
+            out_src_opr(buf2, sizeof(buf2), po, &po->operand[1],
+              po->operand[0].is_ptr ? "(void *)" : "", 0));
         break;
 
       case OP_LEA:
@@ -2063,14 +2564,15 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         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));
+            out_src_opr(buf2, sizeof(buf2), po, &po->operand[1],
+              NULL, 1));
         break;
 
       case OP_MOVZX:
         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], 0));
+            out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
         break;
 
       case OP_MOVSX:
@@ -2088,7 +2590,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         fprintf(fout, "  %s = %s%s;",
             out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
             buf3,
-            out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], 0));
+            out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
         break;
 
       case OP_NOT:
@@ -2101,7 +2603,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         assert_operand_cnt(2);
         fprintf(fout, "  %s = (s32)%s >> 31;",
             out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
-            out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], 0));
+            out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
         strcpy(g_comment, "cdq");
         break;
 
@@ -2143,6 +2645,35 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         }
         break;
 
+      case OP_CMPS:
+        // assumes DF=0
+        // repe ~ repeat while ZF=1
+        assert_operand_cnt(3);
+        j = lmod_bytes(po, po->operand[0].lmod);
+        strcpy(buf1, lmod_cast_u_ptr(po, po->operand[0].lmod));
+        if (po->flags & OPF_REP) {
+          fprintf(fout,
+            "  for (; ecx != 0; ecx--, edi += %d, esi += %d)\n",
+            j, j);
+          fprintf(fout,
+            "    if ((cond_z = (%sedi == %sesi)) %s 0)\n",
+              buf1, buf1, (po->flags & OPF_REPZ) ? "==" : "!=");
+          fprintf(fout,
+            "      break;");
+          snprintf(g_comment, sizeof(g_comment), "rep%s cmps",
+            (po->flags & OPF_REPZ) ? "e" : "ne");
+        }
+        else {
+          fprintf(fout,
+            "    cond_z = (%sedi = %sesi); edi += %d; esi += %d;",
+            buf1, buf1, j, j);
+          strcpy(g_comment, "cmps");
+        }
+        pfomask &= ~(1 << PFO_Z);
+        last_arith_dst = NULL;
+        delayed_flag_op = NULL;
+        break;
+
       // arithmetic w/flags
       case OP_ADD:
       case OP_SUB:
@@ -2157,7 +2688,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         fprintf(fout, "  %s %s= %s;",
             out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
             op_to_c(po),
-            out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], 0));
+            out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
         last_arith_dst = &po->operand[0];
         delayed_flag_op = NULL;
         break;
@@ -2167,7 +2698,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
         fprintf(fout, "  %s = %s%s >> %s;", buf1,
           lmod_cast_s(po, po->operand[0].lmod), buf1,
-          out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], 0));
+          out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
         last_arith_dst = &po->operand[0];
         delayed_flag_op = NULL;
         break;
@@ -2211,7 +2742,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         fprintf(fout, "  %s %s= %s + cond_c;",
             out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
             op_to_c(po),
-            out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], 0));
+            out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
         last_arith_dst = &po->operand[0];
         delayed_flag_op = NULL;
         break;
@@ -2233,7 +2764,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
 
       case OP_NEG:
         out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
-        out_src_opr(buf2, sizeof(buf2), po, &po->operand[0], 0);
+        out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[0]);
         fprintf(fout, "  %s = -%s%s;", buf1,
           lmod_cast_s(po, po->operand[0].lmod), buf2);
         last_arith_dst = &po->operand[0];
@@ -2254,7 +2785,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         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));
+          out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[0]));
         fprintf(fout, "  edx = mul_tmp >> 32;\n");
         fprintf(fout, "  eax = mul_tmp;");
         last_arith_dst = NULL;
@@ -2268,8 +2799,12 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
           ferr(po, "unhandled lmod %d\n", po->operand[0].lmod);
 
         // 32bit division is common, look for it
-        if (scan_for_cdq_edx(i - 1) >= 0) {
-          out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], 0);
+        if (po->op == OP_DIV)
+          ret = scan_for_reg_clear(i - 1, xDX);
+        else
+          ret = scan_for_cdq_edx(i - 1);
+        if (ret >= 0) {
+          out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]);
           strcpy(buf2, lmod_cast(po, po->operand[0].lmod,
             po->op == OP_IDIV));
           fprintf(fout, "  edx = %seax %% %s%s;\n", buf2, buf2, buf1);
@@ -2296,6 +2831,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         }
         else
           no_output = 1;
+        last_arith_dst = NULL;
         delayed_flag_op = po;
         break;
 
@@ -2308,8 +2844,17 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
 
       case OP_JMP:
         assert_operand_cnt(1);
-        if (po->operand[0].type != OPT_LABEL)
-          ferr(po, "unhandled call type\n");
+        if (po->operand[0].type == OPT_REGMEM) {
+          ret = sscanf(po->operand[0].name, "%[^[][%[^*]*4]",
+                  buf1, buf2);
+          if (ret != 2)
+            ferr(po, "parse failure for jmp '%s'\n",
+              po->operand[0].name);
+          fprintf(fout, "  goto *jt_%s[%s];", buf1, buf2);
+          break;
+        }
+        else if (po->operand[0].type != OPT_LABEL)
+          ferr(po, "unhandled jmp type\n");
 
         fprintf(fout, "  goto %s;", po->operand[0].name);
         break;
@@ -2322,31 +2867,37 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
 
         if (po->operand[0].type != OPT_LABEL)
           fprintf(fout, "  icall%d = (void *)%s;\n", i,
-            out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], 0));
+            out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]));
 
         fprintf(fout, "  ");
-        if (!IS(pp->ret_type, "void")) {
+        if (!IS(pp->ret_type.name, "void")) {
           if (po->flags & OPF_TAIL)
             fprintf(fout, "return ");
           else
             fprintf(fout, "eax = ");
-          if (strchr(pp->ret_type, '*'))
+          if (pp->ret_type.is_ptr)
             fprintf(fout, "(u32)");
         }
 
-        if (po->operand[0].type != OPT_LABEL)
+        if (po->operand[0].type != OPT_LABEL) {
           fprintf(fout, "icall%d(", i);
-        else
-          fprintf(fout, "%s(", opr_name(po, 0));
+        }
+        else {
+          if (pp->name[0] == 0)
+            ferr(po, "missing pp->name\n");
+          fprintf(fout, "%s(", pp->name);
+        }
+
         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);
+          cast[0] = 0;
+          if (pp->arg[arg].type.is_ptr)
+            snprintf(cast, sizeof(cast), "(%s)", pp->arg[arg].type.name);
 
           if (pp->arg[arg].reg != NULL) {
-            fprintf(fout, "%s", pp->arg[arg].reg);
+            fprintf(fout, "%s%s", cast, pp->arg[arg].reg);
             continue;
           }
 
@@ -2355,31 +2906,36 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
           if (tmp_op == NULL)
             ferr(po, "parsed_op missing for arg%d\n", arg);
           if (tmp_op->argmask) {
-            fprintf(fout, "s_a%d", arg + 1);
+            fprintf(fout, "%ss_a%d", cast, arg + 1);
           }
           else {
             fprintf(fout, "%s",
               out_src_opr(buf1, sizeof(buf1),
-                tmp_op, &tmp_op->operand[0], 0));
+                tmp_op, &tmp_op->operand[0], cast, 0));
           }
         }
         fprintf(fout, ");");
 
         if (po->flags & OPF_TAIL) {
           strcpy(g_comment, "tailcall");
-          if (IS(pp->ret_type, "void"))
+          if (IS(pp->ret_type.name, "void")) {
             fprintf(fout, "\n  return;");
+            strcpy(g_comment, "^ tailcall");
+          }
         }
         delayed_flag_op = NULL;
         last_arith_dst = NULL;
         break;
 
       case OP_RET:
-        if (IS(g_func_pp.ret_type, "void"))
-          fprintf(fout, "  return;");
-        else if (strchr(g_func_pp.ret_type, '*'))
+        if (IS(g_func_pp.ret_type.name, "void")) {
+          if (i != opcnt - 1 || label_pending)
+            fprintf(fout, "  return;");
+        }
+        else if (g_func_pp.ret_type.is_ptr) {
           fprintf(fout, "  return (%s)eax;",
-            g_func_pp.ret_type);
+            g_func_pp.ret_type.name);
+        }
         else
           fprintf(fout, "  return eax;");
         break;
@@ -2387,7 +2943,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
       case OP_PUSH:
         if (po->argmask) {
           // special case - saved func arg
-          out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], 0);
+          out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]);
           for (j = 0; j < 32; j++) {
             if (po->argmask & (1 << j))
               fprintf(fout, "  s_a%d = %s;", j + 1, buf1);
@@ -2395,7 +2951,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
           break;
         }
         else if (po->flags & OPF_RSAVE) {
-          out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], 0);
+          out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]);
           fprintf(fout, "  s_%s = %s;", buf1, buf1);
           break;
         }
@@ -2404,7 +2960,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
 
       case OP_POP:
         if (po->flags & OPF_RSAVE) {
-          out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], 0);
+          out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
           fprintf(fout, "  %s = s_%s;", buf1, buf1);
           break;
         }
@@ -2421,6 +2977,13 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
         break;
     }
 
+    // some sanity checking
+    if ((po->flags & OPF_REP) && po->op != OP_STOS
+        && po->op != OP_MOVS && po->op != OP_CMPS)
+      ferr(po, "unexpected rep\n");
+    if ((po->flags & (OPF_REPZ|OPF_REPNZ)) && po->op != OP_CMPS)
+      ferr(po, "unexpected repz/repnz\n");
+
     if (g_comment[0] != 0) {
       fprintf(fout, "  // %s", g_comment);
       g_comment[0] = 0;
@@ -2430,7 +2993,7 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
       fprintf(fout, "\n");
 
     if (pfomask != 0)
-        ferr(po, "missed flag calc, pfomask=%x\n", pfomask);
+      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) {
@@ -2442,12 +3005,25 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
       if (is_opr_modified(last_arith_dst, po))
         last_arith_dst = NULL;
     }
+
+    label_pending = 0;
   }
 
   fprintf(fout, "}\n\n");
 
   // cleanup
   for (i = 0; i < opcnt; i++) {
+    struct label_ref *lr, *lr_del;
+
+    lr = g_label_refs[i].next;
+    while (lr != NULL) {
+      lr_del = lr;
+      lr = lr->next;
+      free(lr_del);
+    }
+    g_label_refs[i].i = -1;
+    g_label_refs[i].next = NULL;
+
     if (ops[i].op == OP_CALL) {
       pp = ops[i].datap;
       if (pp) {
@@ -2504,22 +3080,25 @@ static int cmpstringp(const void *p1, const void *p2)
 
 int main(int argc, char *argv[])
 {
-  FILE *fout, *fasm, *fhdr, *frlist;
+  FILE *fout, *fasm, *frlist;
+  struct parsed_data *pd = NULL;
+  int pd_alloc = 0;
+  char **rlist = NULL;
+  int rlist_len = 0;
+  int rlist_alloc = 0;
   char line[256];
   char words[16][256];
-  int ida_func_attr = 0;
+  enum opr_lenmod lmod;
   int in_func = 0;
+  int pending_endp = 0;
   int skip_func = 0;
   int skip_warned = 0;
   int eq_alloc;
-  char **rlist = NULL;
-  int rlist_len = 0;
-  int rlist_alloc = 0;
   int verbose = 0;
   int arg_out;
   int arg = 1;
   int pi = 0;
-  int i, len;
+  int i, j, len;
   char *p;
   int wordc;
 
@@ -2541,8 +3120,8 @@ int main(int argc, char *argv[])
   my_assert_not(fasm, NULL);
 
   hdrfn = argv[arg++];
-  fhdr = fopen(hdrfn, "r");
-  my_assert_not(fhdr, NULL);
+  g_fhdr = fopen(hdrfn, "r");
+  my_assert_not(g_fhdr, NULL);
 
   rlist_alloc = 64;
   rlist = malloc(rlist_alloc * sizeof(rlist[0]));
@@ -2585,8 +3164,14 @@ int main(int argc, char *argv[])
   g_eqs = malloc(eq_alloc * sizeof(g_eqs[0]));
   my_assert_not(g_eqs, NULL);
 
+  for (i = 0; i < ARRAY_SIZE(g_label_refs); i++) {
+    g_label_refs[i].i = -1;
+    g_label_refs[i].next = NULL;
+  }
+
   while (fgets(line, sizeof(line), fasm))
   {
+    wordc = 0;
     asmln++;
 
     p = sskip(line);
@@ -2602,11 +3187,14 @@ int main(int argc, char *argv[])
         "thunk",
         "fpd=",
       };
-      if (p[2] != 'A' || strncmp(p, "; Attributes:", 13) != 0)
+      if (p[2] == '=' && IS_START(p, "; =============== S U B"))
+        goto do_pending_endp; // eww..
+
+      if (p[2] != 'A' || !IS_START(p, "; Attributes:"))
         continue;
 
       // parse IDA's attribute-list comment
-      ida_func_attr = 0;
+      g_ida_func_attr = 0;
       p = sskip(p + 13);
       // get rid of random tabs
       for (i = 0; p[i] != 0; i++)
@@ -2616,7 +3204,7 @@ int main(int argc, char *argv[])
       for (; *p != 0; p = sskip(p)) {
         for (i = 0; i < ARRAY_SIZE(attrs); i++) {
           if (!strncmp(p, attrs[i], strlen(attrs[i]))) {
-            ida_func_attr |= 1 << i;
+            g_ida_func_attr |= 1 << i;
             p += strlen(attrs[i]);
             break;
           }
@@ -2633,6 +3221,7 @@ int main(int argc, char *argv[])
       continue;
     }
 
+parse_words:
     memset(words, 0, sizeof(words));
     for (wordc = 0; wordc < 16; wordc++) {
       p = sskip(next_word_s(words[wordc], sizeof(words[0]), p));
@@ -2642,6 +3231,14 @@ int main(int argc, char *argv[])
       }
     }
 
+    // alow asm patches in comments
+    if (*p == ';' && IS_START(p, "; sctpatch:")) {
+      p = sskip(p + 11);
+      if (*p == 0 || *p == ';')
+        continue;
+      goto parse_words; // lame
+    }
+
     if (wordc == 0) {
       // shouldn't happen
       awarn("wordc == 0?\n");
@@ -2657,12 +3254,95 @@ int main(int argc, char *argv[])
       continue;
     }
 
+do_pending_endp:
+    // do delayed endp processing to collect switch jumptables
+    if (pending_endp) {
+      if (in_func && !skip_func && wordc >= 2
+          && ((words[0][0] == 'd' && words[0][2] == 0)
+              || (words[1][0] == 'd' && words[1][2] == 0)))
+      {
+        i = 1;
+        if (words[1][0] == 'd' && words[1][2] == 0) {
+          // label
+          if (g_func_pd_cnt >= pd_alloc) {
+            pd_alloc = pd_alloc * 2 + 16;
+            g_func_pd = realloc(g_func_pd,
+              sizeof(g_func_pd[0]) * pd_alloc);
+            my_assert_not(g_func_pd, NULL);
+          }
+          pd = &g_func_pd[g_func_pd_cnt];
+          g_func_pd_cnt++;
+          memset(pd, 0, sizeof(*pd));
+          strcpy(pd->label, words[0]);
+          pd->type = OPT_CONST;
+          pd->lmod = lmod_from_directive(words[1]);
+          i = 2;
+        }
+        else {
+          lmod = lmod_from_directive(words[0]);
+          if (lmod != pd->lmod)
+            aerr("lmod change? %d->%d\n", pd->lmod, lmod);
+        }
+
+        if (pd->count_alloc < pd->count + wordc) {
+          pd->count_alloc = pd->count_alloc * 2 + 14 + wordc;
+          pd->d = realloc(pd->d, sizeof(pd->d[0]) * pd->count_alloc);
+          my_assert_not(pd->d, NULL);
+        }
+        for (; i < wordc; i++) {
+          if (IS(words[i], "offset")) {
+            pd->type = OPT_OFFSET;
+            i++;
+          }
+          p = strchr(words[i], ',');
+          if (p != NULL)
+            *p = 0;
+          if (pd->type == OPT_OFFSET)
+            pd->d[pd->count].u.label = strdup(words[i]);
+          else
+            pd->d[pd->count].u.val = parse_number(words[i]);
+          pd->d[pd->count].bt_i = -1;
+          pd->count++;
+        }
+        continue;
+      }
+
+      if (in_func && !skip_func)
+        gen_func(fout, g_fhdr, g_func, pi);
+
+      pending_endp = 0;
+      in_func = 0;
+      g_ida_func_attr = 0;
+      skip_warned = 0;
+      skip_func = 0;
+      g_func[0] = 0;
+      if (pi != 0) {
+        memset(&ops, 0, pi * sizeof(ops[0]));
+        memset(g_labels, 0, pi * sizeof(g_labels[0]));
+        pi = 0;
+      }
+      g_eqcnt = 0;
+      for (i = 0; i < g_func_pd_cnt; i++) {
+        pd = &g_func_pd[i];
+        if (pd->type == OPT_OFFSET) {
+          for (j = 0; j < pd->count; j++)
+            free(pd->d[j].u.label);
+        }
+        free(pd->d);
+        pd->d = NULL;
+      }
+      g_func_pd_cnt = 0;
+      pd = NULL;
+      if (wordc == 0)
+        continue;
+    }
+
     if (IS(words[1], "proc")) {
       if (in_func)
         aerr("proc '%s' while in_func '%s'?\n",
           words[0], g_func);
       p = words[0];
-      if ((ida_func_attr & IDAFA_THUNK)
+      if ((g_ida_func_attr & IDAFA_THUNK)
        || bsearch(&p, rlist, rlist_len, sizeof(rlist[0]), cmpstringp))
         skip_func = 1;
       strcpy(g_func, words[0]);
@@ -2678,21 +3358,7 @@ int main(int argc, char *argv[])
         aerr("endp '%s' while in_func '%s'?\n",
           words[0], g_func);
 
-      if (in_func && !skip_func)
-        gen_func(fout, fhdr, g_func, pi);
-
-      in_func = 0;
-      skip_warned = 0;
-      skip_func = 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;
-      ida_func_attr = 0;
+      pending_endp = 1;
       continue;
     }
 
@@ -2712,7 +3378,7 @@ int main(int argc, char *argv[])
       continue;
     }
 
-    if (IS(words[1], "=")) {
+    if (wordc > 1 && IS(words[1], "=")) {
       if (wordc != 5)
         aerr("unhandled equ, wc=%d\n", wordc);
       if (g_eqcnt >= eq_alloc) {
@@ -2751,7 +3417,7 @@ int main(int argc, char *argv[])
 
   fclose(fout);
   fclose(fasm);
-  fclose(fhdr);
+  fclose(g_fhdr);
 
   return 0;
 }