X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tools%2Ftranslate.c;h=1fa3d95fdb686bb2129bfdba0479becf0d9e2727;hb=9ea60b8d585086fa64f7a8cd298ec1cd698ad56d;hp=a894f17d0137d1ee306af98009963a186c112a08;hpb=db63af5172f159c5a1983579b081b3bac7f03f0e;p=ia32rtools.git

diff --git a/tools/translate.c b/tools/translate.c
index a894f17..1fa3d95 100644
--- a/tools/translate.c
+++ b/tools/translate.c
@@ -13,6 +13,7 @@
 
 #include "my_assert.h"
 #include "my_str.h"
+#include "common.h"
 
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
 #define IS(w, y) !strcmp(w, y)
@@ -2862,20 +2863,170 @@ static void scan_for_call_type(int i, const struct parsed_opr *opr,
   }
 }
 
-// early check for tail call or branch back
-static int is_like_tailjmp(int j)
+static void add_label_ref(struct label_ref *lr, int op_i)
 {
-  if (!(ops[j].flags & OPF_JMP))
-    return 0;
+  struct label_ref *lr_new;
 
-  if (ops[j].op == OP_JMP && !ops[j].operand[0].had_ds)
-    // probably local branch back..
-    return 1;
-  if (ops[j].op == OP_CALL)
-    // probably noreturn call..
-    return 1;
+  if (lr->i == -1) {
+    lr->i = op_i;
+    return;
+  }
 
-  return 0;
+  lr_new = calloc(1, sizeof(*lr_new));
+  lr_new->i = op_i;
+  lr_new->next = lr->next;
+  lr->next = lr_new;
+}
+
+static struct parsed_data *try_resolve_jumptab(int i, int opcnt)
+{
+  struct parsed_op *po = &ops[i];
+  struct parsed_data *pd;
+  char label[NAMELEN], *p;
+  int len, j, l;
+
+  p = strchr(po->operand[0].name, '[');
+  if (p == NULL)
+    return NULL;
+
+  len = p - po->operand[0].name;
+  strncpy(label, po->operand[0].name, len);
+  label[len] = 0;
+
+  for (j = 0, pd = NULL; j < g_func_pd_cnt; j++) {
+    if (IS(g_func_pd[j].label, label)) {
+      pd = &g_func_pd[j];
+      break;
+    }
+  }
+  if (pd == NULL)
+    //ferr(po, "label '%s' not parsed?\n", label);
+    return NULL;
+
+  if (pd->type != OPT_OFFSET)
+    ferr(po, "label '%s' with non-offset data?\n", label);
+
+  // find all labels, link
+  for (j = 0; j < pd->count; j++) {
+    for (l = 0; l < opcnt; l++) {
+      if (g_labels[l] != NULL && IS(g_labels[l], pd->d[j].u.label)) {
+        add_label_ref(&g_label_refs[l], i);
+        pd->d[j].bt_i = l;
+        break;
+      }
+    }
+  }
+
+  return pd;
+}
+
+static void clear_labels(int count)
+{
+  int i;
+
+  for (i = 0; i < count; i++) {
+    if (g_labels[i] != NULL) {
+      free(g_labels[i]);
+      g_labels[i] = NULL;
+    }
+  }
+}
+
+static void resolve_branches_parse_calls(int opcnt)
+{
+  const struct parsed_proto *pp_c;
+  struct parsed_proto *pp;
+  struct parsed_data *pd;
+  struct parsed_op *po;
+  const char *tmpname;
+  int i, l, ret;
+
+  for (i = 0; i < opcnt; i++)
+  {
+    po = &ops[i];
+    po->bt_i = -1;
+    po->btj = NULL;
+
+    if (po->op == OP_CALL) {
+      pp = NULL;
+
+      if (po->operand[0].type == OPT_LABEL) {
+        tmpname = opr_name(po, 0);
+        if (IS_START(tmpname, "loc_"))
+          ferr(po, "call to loc_*\n");
+        pp_c = proto_parse(g_fhdr, tmpname, g_header_mode);
+        if (!g_header_mode && pp_c == NULL)
+          ferr(po, "proto_parse failed for call '%s'\n", tmpname);
+
+        if (pp_c != NULL) {
+          pp = proto_clone(pp_c);
+          my_assert_not(pp, NULL);
+        }
+      }
+      else if (po->datap != NULL) {
+        pp = calloc(1, sizeof(*pp));
+        my_assert_not(pp, NULL);
+
+        ret = parse_protostr(po->datap, pp);
+        if (ret < 0)
+          ferr(po, "bad protostr supplied: %s\n", (char *)po->datap);
+        free(po->datap);
+        po->datap = NULL;
+      }
+
+      if (pp != NULL) {
+        if (pp->is_fptr)
+          check_func_pp(po, pp, "fptr var call");
+        if (pp->is_noreturn)
+          po->flags |= OPF_TAIL;
+      }
+      po->pp = pp;
+      continue;
+    }
+
+    if (!(po->flags & OPF_JMP) || po->op == OP_RET)
+      continue;
+
+    if (po->operand[0].type == OPT_REGMEM) {
+      pd = try_resolve_jumptab(i, opcnt);
+      if (pd == NULL)
+        goto tailcall;
+
+      po->btj = pd;
+      continue;
+    }
+
+    for (l = 0; l < opcnt; l++) {
+      if (g_labels[l] != NULL
+          && IS(po->operand[0].name, g_labels[l]))
+      {
+        if (l == i + 1 && po->op == OP_JMP) {
+          // yet another alignment type..
+          po->flags |= OPF_RMD|OPF_DONE;
+          break;
+        }
+        add_label_ref(&g_label_refs[l], i);
+        po->bt_i = l;
+        break;
+      }
+    }
+
+    if (po->bt_i != -1 || (po->flags & OPF_RMD))
+      continue;
+
+    if (po->operand[0].type == OPT_LABEL)
+      // assume tail call
+      goto tailcall;
+
+    ferr(po, "unhandled branch\n");
+
+tailcall:
+    po->op = OP_CALL;
+    po->flags |= OPF_TAIL;
+    if (i > 0 && ops[i - 1].op == OP_POP)
+      po->flags |= OPF_ATAIL;
+    i--; // reprocess
+  }
 }
 
 static void scan_prologue_epilogue(int opcnt)
@@ -2925,12 +3076,13 @@ static void scan_prologue_epilogue(int opcnt)
     found = 0;
     do {
       for (; i < opcnt; i++)
-        if (ops[i].op == OP_RET)
+        if (ops[i].flags & OPF_TAIL)
           break;
       j = i - 1;
       if (i == opcnt && (ops[j].flags & OPF_JMP)) {
-        if (found && is_like_tailjmp(j))
-            break;
+        if (ops[j].bt_i != -1 || ops[j].btj != NULL)
+          break;
+        i--;
         j--;
       }
 
@@ -2939,6 +3091,14 @@ static void scan_prologue_epilogue(int opcnt)
       {
         ops[j].flags |= OPF_RMD | OPF_DONE;
       }
+      else if (ops[i].op == OP_CALL && ops[i].pp != NULL
+        && ops[i].pp->is_noreturn)
+      {
+        // on noreturn, msvc sometimes cleans stack, sometimes not
+        i++;
+        found = 1;
+        continue;
+      }
       else if (!(g_ida_func_attr & IDAFA_NORETURN))
         ferr(&ops[j], "'pop ebp' expected\n");
 
@@ -2966,6 +3126,8 @@ static void scan_prologue_epilogue(int opcnt)
       i++;
     } while (i < opcnt);
 
+    if (!found)
+      ferr(ops, "missing ebp epilogue\n");
     return;
   }
 
@@ -3031,12 +3193,13 @@ static void scan_prologue_epilogue(int opcnt)
     i++;
     do {
       for (; i < opcnt; i++)
-        if (ops[i].op == OP_RET)
+        if (ops[i].flags & OPF_TAIL)
           break;
       j = i - 1;
       if (i == opcnt && (ops[j].flags & OPF_JMP)) {
-        if (found && is_like_tailjmp(j))
-            break;
+        if (ops[j].bt_i != -1 || ops[j].btj != NULL)
+          break;
+        i--;
         j--;
       }
 
@@ -3077,6 +3240,9 @@ static void scan_prologue_epilogue(int opcnt)
 
       i++;
     } while (i < opcnt);
+
+    if (!found)
+      ferr(ops, "missing esp epilogue\n");
   }
 }
 
@@ -3139,7 +3305,7 @@ static int resolve_origin(int i, const struct parsed_opr *opr,
     }
 
     if (ops[i].cc_scratch == magic)
-      return 0;
+      return ret;
     ops[i].cc_scratch = magic;
 
     if (!(ops[i].flags & OPF_DATA))
@@ -3149,13 +3315,14 @@ static int resolve_origin(int i, const struct parsed_opr *opr,
 
     if (*op_i >= 0) {
       if (*op_i == i)
-        return 1;
+        return ret | 1;
+
       // XXX: could check if the other op does the same
       return -1;
     }
 
     *op_i = i;
-    return 1;
+    return ret | 1;
   }
 }
 
@@ -3808,75 +3975,6 @@ static void pp_insert_reg_arg(struct parsed_proto *pp, const char *reg)
   pp->argc_reg++;
 }
 
-static void add_label_ref(struct label_ref *lr, int op_i)
-{
-  struct label_ref *lr_new;
-
-  if (lr->i == -1) {
-    lr->i = op_i;
-    return;
-  }
-
-  lr_new = calloc(1, sizeof(*lr_new));
-  lr_new->i = op_i;
-  lr_new->next = lr->next;
-  lr->next = lr_new;
-}
-
-static struct parsed_data *try_resolve_jumptab(int i, int opcnt)
-{
-  struct parsed_op *po = &ops[i];
-  struct parsed_data *pd;
-  char label[NAMELEN], *p;
-  int len, j, l;
-
-  p = strchr(po->operand[0].name, '[');
-  if (p == NULL)
-    return NULL;
-
-  len = p - po->operand[0].name;
-  strncpy(label, po->operand[0].name, len);
-  label[len] = 0;
-
-  for (j = 0, pd = NULL; j < g_func_pd_cnt; j++) {
-    if (IS(g_func_pd[j].label, label)) {
-      pd = &g_func_pd[j];
-      break;
-    }
-  }
-  if (pd == NULL)
-    //ferr(po, "label '%s' not parsed?\n", label);
-    return NULL;
-
-  if (pd->type != OPT_OFFSET)
-    ferr(po, "label '%s' with non-offset data?\n", label);
-
-  // find all labels, link
-  for (j = 0; j < pd->count; j++) {
-    for (l = 0; l < opcnt; l++) {
-      if (g_labels[l] != NULL && IS(g_labels[l], pd->d[j].u.label)) {
-        add_label_ref(&g_label_refs[l], i);
-        pd->d[j].bt_i = l;
-        break;
-      }
-    }
-  }
-
-  return pd;
-}
-
-static void clear_labels(int count)
-{
-  int i;
-
-  for (i = 0; i < count; i++) {
-    if (g_labels[i] != NULL) {
-      free(g_labels[i]);
-      g_labels[i] = NULL;
-    }
-  }
-}
-
 static void output_std_flags(FILE *fout, struct parsed_op *po,
   int *pfomask, const char *dst_opr_text)
 {
@@ -3993,10 +4091,8 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
   struct parsed_op *po, *delayed_flag_op = NULL, *tmp_op;
   struct parsed_opr *last_arith_dst = NULL;
   char buf1[256], buf2[256], buf3[256], cast[64];
-  const struct parsed_proto *pp_c;
   struct parsed_proto *pp, *pp_tmp;
   struct parsed_data *pd;
-  const char *tmpname;
   unsigned int uval;
   int save_arg_vars[MAX_ARG_GRP] = { 0, };
   int cond_vars = 0;
@@ -4029,110 +4125,28 @@ static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
   regmask_arg = get_pp_arg_regmask(g_func_pp);
 
   // pass1:
-  // - handle ebp/esp frame, remove ops related to it
-  scan_prologue_epilogue(opcnt);
-
-  // pass2:
-  // - parse calls with labels
   // - resolve all branches
-  for (i = 0; i < opcnt; i++)
-  {
-    po = &ops[i];
-    po->bt_i = -1;
-    po->btj = NULL;
-
-    if (po->flags & (OPF_RMD|OPF_DONE))
-      continue;
-
-    if (po->op == OP_CALL) {
-      pp = NULL;
-
-      if (po->operand[0].type == OPT_LABEL) {
-        tmpname = opr_name(po, 0);
-        if (IS_START(tmpname, "loc_"))
-          ferr(po, "call to loc_*\n");
-        pp_c = proto_parse(fhdr, tmpname, 0);
-        if (pp_c == NULL)
-          ferr(po, "proto_parse failed for call '%s'\n", tmpname);
-
-        pp = proto_clone(pp_c);
-        my_assert_not(pp, NULL);
-      }
-      else if (po->datap != NULL) {
-        pp = calloc(1, sizeof(*pp));
-        my_assert_not(pp, NULL);
-
-        ret = parse_protostr(po->datap, pp);
-        if (ret < 0)
-          ferr(po, "bad protostr supplied: %s\n", (char *)po->datap);
-        free(po->datap);
-        po->datap = NULL;
-      }
-
-      if (pp != NULL) {
-        if (pp->is_fptr)
-          check_func_pp(po, pp, "fptr var call");
-        if (pp->is_noreturn)
-          po->flags |= OPF_TAIL;
-      }
-      po->pp = pp;
-      continue;
-    }
-
-    if (!(po->flags & OPF_JMP) || po->op == OP_RET)
-      continue;
-
-    if (po->operand[0].type == OPT_REGMEM) {
-      pd = try_resolve_jumptab(i, opcnt);
-      if (pd == NULL)
-        goto tailcall;
-
-      po->btj = pd;
-      continue;
-    }
-
-    for (l = 0; l < opcnt; l++) {
-      if (g_labels[l] != NULL
-          && IS(po->operand[0].name, g_labels[l]))
-      {
-        if (l == i + 1 && po->op == OP_JMP) {
-          // yet another alignment type..
-          po->flags |= OPF_RMD|OPF_DONE;
-          break;
-        }
-        add_label_ref(&g_label_refs[l], i);
-        po->bt_i = l;
-        break;
-      }
-    }
-
-    if (po->bt_i != -1 || (po->flags & OPF_RMD))
-      continue;
-
-    if (po->operand[0].type == OPT_LABEL)
-      // assume tail call
-      goto tailcall;
-
-    ferr(po, "unhandled branch\n");
+  // - parse calls with labels
+  resolve_branches_parse_calls(opcnt);
 
-tailcall:
-    po->op = OP_CALL;
-    po->flags |= OPF_TAIL;
-    if (i > 0 && ops[i - 1].op == OP_POP)
-      po->flags |= OPF_ATAIL;
-    i--; // reprocess
-  }
+  // pass2:
+  // - handle ebp/esp frame, remove ops related to it
+  scan_prologue_epilogue(opcnt);
 
   // pass3:
   // - remove dead labels
-  // - process trivial calls
   for (i = 0; i < opcnt; i++)
   {
     if (g_labels[i] != NULL && g_label_refs[i].i == -1) {
       free(g_labels[i]);
       g_labels[i] = NULL;
     }
+  }
 
+  // pass4:
+  // - process trivial calls
+  for (i = 0; i < opcnt; i++)
+  {
     po = &ops[i];
     if (po->flags & (OPF_RMD|OPF_DONE))
       continue;
@@ -4165,7 +4179,7 @@ tailcall:
     }
   }
 
-  // pass4:
+  // pass5:
   // - process calls
   // - handle push <const>/pop pairs
   for (i = 0; i < opcnt; i++)
@@ -4192,7 +4206,7 @@ tailcall:
         scan_for_pop_const(i, opcnt, &regmask_pp);
   }
 
-  // pass5:
+  // pass6:
   // - find POPs for PUSHes, rm both
   // - scan for STD/CLD, propagate DF
   // - scan for all used registers
@@ -4437,7 +4451,7 @@ tailcall:
     }
   }
 
-  // pass6:
+  // pass7:
   // - confirm regmask_save, it might have been reduced
   if (regmask_save != 0)
   {
@@ -4969,6 +4983,19 @@ tailcall:
 
       // arithmetic w/flags
       case OP_AND:
+        if (po->operand[1].type == OPT_CONST && !po->operand[1].val) {
+          // deal with complex dst clear
+          assert_operand_cnt(2);
+          fprintf(fout, "  %s = %s;",
+            out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
+            out_src_opr(buf2, sizeof(buf2), po, &po->operand[1],
+             default_cast_to(buf3, sizeof(buf3), &po->operand[0]), 0));
+          output_std_flags(fout, po, &pfomask, buf1);
+          last_arith_dst = &po->operand[0];
+          delayed_flag_op = NULL;
+          break;
+        }
+        // fallthrough
       case OP_OR:
         propagate_lmod(po, &po->operand[0], &po->operand[1]);
         // fallthrough
@@ -5742,6 +5769,25 @@ static int hg_var_cnt;
 static void output_hdr_fp(FILE *fout, const struct func_prototype *fp,
   int count);
 
+struct func_prototype *hg_fp_add(const char *funcn)
+{
+  struct func_prototype *fp;
+
+  if ((hg_fp_cnt & 0xff) == 0) {
+    hg_fp = realloc(hg_fp, sizeof(hg_fp[0]) * (hg_fp_cnt + 0x100));
+    my_assert_not(hg_fp, NULL);
+    memset(hg_fp + hg_fp_cnt, 0, sizeof(hg_fp[0]) * 0x100);
+  }
+
+  fp = &hg_fp[hg_fp_cnt];
+  snprintf(fp->name, sizeof(fp->name), "%s", funcn);
+  fp->id = hg_fp_cnt;
+  fp->argc_stack = -1;
+  hg_fp_cnt++;
+
+  return fp;
+}
+
 static struct func_proto_dep *hg_fp_find_dep(struct func_prototype *fp,
   const char *name)
 {
@@ -5876,6 +5922,8 @@ static void gen_hdr_dep_pass(int i, int opcnt, unsigned char *cbits,
       }
     }
 
+    // if has_ret is 0, there is uninitialized eax path,
+    // which means it's most likely void func
     if (*has_ret != 0 && (po->flags & OPF_TAIL)) {
       if (po->op == OP_CALL) {
         j = i;
@@ -5890,13 +5938,13 @@ static void gen_hdr_dep_pass(int i, int opcnt, unsigned char *cbits,
         ret = resolve_origin(i, &opr, i + opcnt * 4, &j, &from_caller);
       }
 
-      if (ret == -1 && from_caller) {
+      if (ret != 1 && from_caller) {
         // unresolved eax - probably void func
         *has_ret = 0;
       }
       else {
-        if (ops[j].op == OP_CALL) {
-          dep = hg_fp_find_dep(fp, po->operand[0].name);
+        if (j >= 0 && ops[j].op == OP_CALL) {
+          dep = hg_fp_find_dep(fp, ops[j].operand[0].name);
           if (dep != NULL)
             dep->ret_dep = 1;
           else
@@ -5932,124 +5980,55 @@ static void gen_hdr(const char *funcn, int opcnt)
   const struct parsed_proto *pp_c;
   struct parsed_proto *pp;
   struct func_prototype *fp;
-  struct parsed_data *pd;
   struct parsed_op *po;
-  const char *tmpname;
   int regmask_dummy = 0;
   int regmask_dep;
   int max_bp_offset = 0;
   int has_ret;
-  int i, j, l, ret;
-
-  if ((hg_fp_cnt & 0xff) == 0) {
-    hg_fp = realloc(hg_fp, sizeof(hg_fp[0]) * (hg_fp_cnt + 0x100));
-    my_assert_not(hg_fp, NULL);
-    memset(hg_fp + hg_fp_cnt, 0, sizeof(hg_fp[0]) * 0x100);
-  }
+  int i, j, ret;
 
-  fp = &hg_fp[hg_fp_cnt];
-  snprintf(fp->name, sizeof(fp->name), "%s", funcn);
-  fp->id = hg_fp_cnt;
-  fp->argc_stack = -1;
-  hg_fp_cnt++;
-
-  // perhaps already in seed header?
-  fp->pp = proto_parse(g_fhdr, funcn, 1);
-  if (fp->pp != NULL) {
-    fp->argc_stack = fp->pp->argc_stack;
-    fp->is_stdcall = fp->pp->is_stdcall;
-    fp->regmask_dep = get_pp_arg_regmask(fp->pp);
-    fp->has_ret = !IS(fp->pp->ret_type.name, "void");
+  pp_c = proto_parse(g_fhdr, funcn, 1);
+  if (pp_c != NULL)
+    // already in seed, will add to hg_fp later
     return;
-  }
+
+  fp = hg_fp_add(funcn);
 
   g_bp_frame = g_sp_frame = g_stack_fsz = 0;
   g_stack_frame_used = 0;
 
   // pass1:
+  // - resolve all branches
+  // - parse calls with labels
+  resolve_branches_parse_calls(opcnt);
+
+  // pass2:
   // - handle ebp/esp frame, remove ops related to it
   scan_prologue_epilogue(opcnt);
 
-  // pass2:
+  // pass3:
+  // - remove dead labels
   // - collect calls
-  // - resolve all branches
   for (i = 0; i < opcnt; i++)
   {
-    po = &ops[i];
-    po->bt_i = -1;
-    po->btj = NULL;
+    if (g_labels[i] != NULL && g_label_refs[i].i == -1) {
+      free(g_labels[i]);
+      g_labels[i] = NULL;
+    }
 
+    po = &ops[i];
     if (po->flags & (OPF_RMD|OPF_DONE))
       continue;
 
     if (po->op == OP_CALL) {
-      tmpname = opr_name(po, 0);
-      pp = NULL;
-      if (po->operand[0].type == OPT_LABEL) {
-        hg_fp_add_dep(fp, tmpname);
-
-        // perhaps a call to already known func?
-        pp_c = proto_parse(g_fhdr, tmpname, 1);
-        if (pp_c != NULL)
-          pp = proto_clone(pp_c);
-      }
-      else if (po->datap != NULL) {
-        pp = calloc(1, sizeof(*pp));
-        my_assert_not(pp, NULL);
-
-        ret = parse_protostr(po->datap, pp);
-        if (ret < 0)
-          ferr(po, "bad protostr supplied: %s\n", (char *)po->datap);
-        free(po->datap);
-        po->datap = NULL;
-      }
-      if (pp != NULL && pp->is_noreturn)
-        po->flags |= OPF_TAIL;
-
-      po->pp = pp;
-      continue;
+      if (po->operand[0].type == OPT_LABEL)
+        hg_fp_add_dep(fp, opr_name(po, 0));
+      else if (po->pp != NULL)
+        hg_fp_add_dep(fp, po->pp->name);
     }
-
-    if (!(po->flags & OPF_JMP) || po->op == OP_RET)
-      continue;
-
-    if (po->operand[0].type == OPT_REGMEM) {
-      pd = try_resolve_jumptab(i, opcnt);
-      if (pd == NULL)
-        goto tailcall;
-
-      po->btj = pd;
-      continue;
-    }
-
-    for (l = 0; l < opcnt; l++) {
-      if (g_labels[l] != NULL
-          && IS(po->operand[0].name, g_labels[l]))
-      {
-        add_label_ref(&g_label_refs[l], i);
-        po->bt_i = l;
-        break;
-      }
-    }
-
-    if (po->bt_i != -1 || (po->flags & OPF_RMD))
-      continue;
-
-    if (po->operand[0].type == OPT_LABEL)
-      // assume tail call
-      goto tailcall;
-
-    ferr(po, "unhandled branch\n");
-
-tailcall:
-    po->op = OP_CALL;
-    po->flags |= OPF_TAIL;
-    if (i > 0 && ops[i - 1].op == OP_POP)
-      po->flags |= OPF_ATAIL;
-    i--; // reprocess
   }
 
-  // pass3:
+  // pass4:
   // - remove dead labels
   // - handle push <const>/pop pairs
   for (i = 0; i < opcnt; i++)
@@ -6067,7 +6046,7 @@ tailcall:
       scan_for_pop_const(i, opcnt, &regmask_dummy);
   }
 
-  // pass4:
+  // pass5:
   // - process trivial calls
   for (i = 0; i < opcnt; i++)
   {
@@ -6100,7 +6079,7 @@ tailcall:
     }
   }
 
-  // pass5:
+  // pass6:
   // - track saved regs (simple)
   // - process calls
   for (i = 0; i < opcnt; i++)
@@ -6130,7 +6109,7 @@ tailcall:
     }
   }
 
-  // pass6
+  // pass7
   memset(cbits, 0, sizeof(cbits));
   regmask_dep = 0;
   has_ret = -1;
@@ -6147,9 +6126,6 @@ tailcall:
       ferr(&ops[i], "unreachable code\n");
   }
 
-  if (has_ret == -1 && (regmask_dep & (1 << xAX)))
-    has_ret = 1;
-
   for (i = 0; i < g_eqcnt; i++) {
     if (g_eqs[i].offset > max_bp_offset && g_eqs[i].offset < 4*32)
       max_bp_offset = g_eqs[i].offset;
@@ -6168,7 +6144,7 @@ tailcall:
   printf("// has_ret %d, regmask_dep %x\n",
     fp->has_ret, fp->regmask_dep);
   output_hdr_fp(stdout, fp, 1);
-  if (IS(funcn, "sub_100073FD")) exit(1);
+  if (IS(funcn, "sub_10007F72")) exit(1);
 #endif
 
   gen_x_cleanup(opcnt);
@@ -6197,7 +6173,7 @@ static void hg_fp_resolve_deps(struct func_prototype *fp)
       // printf("dep %s %s |= %x\n", fp->name,
       //   fp->dep_func[i].name, dep);
 
-      if (fp->has_ret == -1)
+      if (fp->has_ret == -1 && fp->dep_func[i].ret_dep)
         fp->has_ret = fp->dep_func[i].proto->has_ret;
     }
   }
@@ -6317,9 +6293,25 @@ static void output_hdr(FILE *fout)
     [OPLM_QWORD] = "uint64_t",
   };
   const struct scanned_var *var;
+  struct func_prototype *fp;
   char line[256] = { 0, };
+  char name[256];
   int i;
 
+  // add stuff from headers
+  for (i = 0; i < pp_cache_size; i++) {
+    if (pp_cache[i].is_cinc && !pp_cache[i].is_stdcall)
+      snprintf(name, sizeof(name), "_%s", pp_cache[i].name);
+    else
+      snprintf(name, sizeof(name), "%s", pp_cache[i].name);
+    fp = hg_fp_add(name);
+    fp->pp = &pp_cache[i];
+    fp->argc_stack = fp->pp->argc_stack;
+    fp->is_stdcall = fp->pp->is_stdcall;
+    fp->regmask_dep = get_pp_arg_regmask(fp->pp);
+    fp->has_ret = !IS(fp->pp->ret_type.name, "void");
+  }
+
   // resolve deps
   qsort(hg_fp, hg_fp_cnt, sizeof(hg_fp[0]), hg_fp_cmp_name);
   for (i = 0; i < hg_fp_cnt; i++)
@@ -6359,30 +6351,6 @@ static void output_hdr(FILE *fout)
     fwrite(line, 1, strlen(line), fout);
 }
 
-// read a line, truncating it if it doesn't fit
-static char *my_fgets(char *s, size_t size, FILE *stream)
-{
-  char *ret, *ret2;
-  char buf[64];
-  int p;
-
-  p = size - 2;
-  if (p >= 0)
-    s[p] = 0;
-
-  ret = fgets(s, size, stream);
-  if (ret != NULL && p >= 0 && s[p] != 0 && s[p] != '\n') {
-    p = sizeof(buf) - 2;
-    do {
-      buf[p] = 0;
-      ret2 = fgets(buf, sizeof(buf), stream);
-    }
-    while (ret2 != NULL && buf[p] != 0 && buf[p] != '\n');
-  }
-
-  return ret;
-}
-
 // '=' needs special treatment
 // also ' quote
 static char *next_word_s(char *w, size_t wsize, char *s)
@@ -6482,6 +6450,11 @@ static void scan_variables(FILE *fasm)
       if (wordc < 2)
         continue;
 
+      if (IS_START(words[0], "__IMPORT_DESCRIPTOR_")) {
+        // when this starts, we don't need anything from this section
+        break;
+      }
+
       if ((hg_var_cnt & 0xff) == 0) {
         hg_vars = realloc(hg_vars, sizeof(hg_vars[0])
                    * (hg_var_cnt + 0x100));