X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=plugin%2Fsaveasm.cpp;h=3622cc8e0c893f7d4a60d65a4b98b726f141b659;hb=4741fdfeb90852f33f8954f67aaf9c32f2969c7d;hp=ddfb19f2c13e9d84866a93b0375998dbc0a384da;hpb=b587e6ae929c7ec551fc01e873cf4259a3000a94;p=ia32rtools.git

diff --git a/plugin/saveasm.cpp b/plugin/saveasm.cpp
index ddfb19f..3622cc8 100644
--- a/plugin/saveasm.cpp
+++ b/plugin/saveasm.cpp
@@ -42,6 +42,7 @@ static const char *reserved_names[] = {
   "type",
   "offset",
   "aam",
+  "text",
 };
 
 static int is_name_reserved(const char *name)
@@ -80,10 +81,11 @@ static int is_insn_jmp(uint16 itype)
   return itype == NN_jmp || (NN_ja <= itype && itype <= NN_jz);
 }
 
-static void do_def_line(char *buf, size_t buf_size, const char *line)
+static void do_def_line(char *buf, size_t buf_size, const char *line,
+  ea_t ea)
 {
-  char *endp = NULL;
-  ea_t ea, *ea_ret;
+  ea_t *ea_ret;
+  char *p;
   int len;
 
   tag_remove(line, buf, buf_size); // remove color codes
@@ -94,17 +96,17 @@ static void do_def_line(char *buf, size_t buf_size, const char *line)
   }
   memmove(buf, buf + 9, len - 9 + 1); // rm address
 
-  if (IS_START(buf, "loc_")) {
-    ea = strtoul(buf + 4, &endp, 16);
-    if (ea != 0 && *endp == ':') {
-      ea_ret = (ea_t *)bsearch(&ea, nonlocal_bt, nonlocal_bt_cnt,
-        sizeof(nonlocal_bt[0]), nonlocal_bt_cmp);
-      if (ea_ret != 0) {
-        if (endp[1] != ' ')
-          msg("no trailing blank in '%s'\n", buf);
-        else
-          endp[1] = ':';
-      }
+  p = buf;
+  while (*p && *p != ' ' && *p != ':')
+    p++;
+  if (*p == ':') {
+    ea_ret = (ea_t *)bsearch(&ea, nonlocal_bt, nonlocal_bt_cnt,
+      sizeof(nonlocal_bt[0]), nonlocal_bt_cmp);
+    if (ea_ret != 0) {
+      if (p[1] != ' ')
+        msg("no trailing blank in '%s'\n", buf);
+      else
+        p[1] = ':';
     }
   }
 }
@@ -114,10 +116,10 @@ static void idaapi run(int /*arg*/)
   // isEnabled(ea) // address belongs to disassembly
   // ea_t ea = get_screen_ea();
   // foo = DecodeInstruction(ScreenEA());
-  int drop_large, drop_rva;
   FILE *fout = NULL;
   int fout_line = 0;
   char buf[MAXSTR];
+  char buf2[MAXSTR];
   const char *name;
   struc_t *frame;
   func_t *func;
@@ -125,12 +127,26 @@ static void idaapi run(int /*arg*/)
   ea_t tmp_ea, target_ea;
   ea_t ea;
   flags_t ea_flags;
+  uval_t idx;
   int i, o, m, n;
   int ret;
   char *p;
 
   nonlocal_bt_cnt = 0;
 
+  // get rid of structs, masm doesn't understand them
+  idx = get_first_struc_idx();
+  while (idx != BADNODE) {
+    tid_t tid = get_struc_by_idx(idx);
+    struc_t *struc = get_struc(tid);
+    get_struc_name(tid, buf, sizeof(buf));
+    msg("removing struct '%s'\n", buf);
+    //del_struc_members(struc, 0, get_max_offset(struc));
+    del_struc(struc);
+
+    idx = get_first_struc_idx();
+  }
+
   // 1st pass: walk through all funcs
   func = get_func(inf.minEA);
   while (func != NULL)
@@ -159,7 +175,15 @@ static void idaapi run(int /*arg*/)
         if (IS_START(buf, "arg_") || IS_START(buf, "var_"))
           continue;
 
-        if (is_name_reserved(buf)) {
+        // check for dupe names
+        int m1, dupe = 0;
+        for (m1 = 0; m1 < m; m1++) {
+          get_member_name(frame->members[m1].id, buf2, sizeof(buf2));
+          if (stricmp(buf, buf2) == 0)
+            dupe = 1;
+        }
+
+        if (is_name_reserved(buf) || dupe) {
           msg("%x: renaming '%s'\n", ea, buf);
           qstrncat(buf, "_", sizeof(buf));
           ret = set_member_name(frame, frame->members[m].soff, buf);
@@ -222,6 +246,23 @@ static void idaapi run(int /*arg*/)
           }
         }
       }
+      // detect code alignment
+      else if (cmd.itype == NN_lea) {
+        if (cmd.Operands[0].reg == cmd.Operands[1].reg
+          && cmd.Operands[1].type == o_displ
+          && cmd.Operands[1].addr == 0)
+        {
+          tmp_ea = next_head(ea, inf.maxEA);
+          if ((tmp_ea & 0x03) == 0) {
+            n = calc_max_align(tmp_ea);
+            if (n > 4) // masm doesn't like more..
+              n = 4;
+            msg("%x: align %d\n", ea, 1 << n);
+            do_unknown(ea, DOUNK_SIMPLE);
+            doAlign(ea, tmp_ea - ea, n);
+          }
+        }
+      }
 
       // find non-local branches
       if (is_insn_jmp(cmd.itype) && cmd.Operands[0].type == o_near)
@@ -241,8 +282,10 @@ static void idaapi run(int /*arg*/)
       }
     }
     else { // not code
+      int do_undef = 0;
+      ea_size = get_item_size(ea);
+
       if (func == NULL && isOff0(ea_flags)) {
-        ea_size = get_item_size(ea);
         for (tmp_ea = 0; tmp_ea < ea_size; tmp_ea += 4)
           nonlocal_add(get_long(ea + tmp_ea));
       }
@@ -251,18 +294,31 @@ static void idaapi run(int /*arg*/)
       if (isDouble(ea_flags) || isTbyt(ea_flags)
        || isPackReal(ea_flags))
       {
+        do_undef = 1;
+      }
+      else if (isOwrd(ea_flags)) {
         buf[0] = 0;
         get_name(BADADDR, ea, buf, sizeof(buf));
-        msg("%x: undefining '%s'\n", ea, buf);
+        if (IS_START(buf, "xmm"))
+          do_undef = 1;
+      }
+      // masm doesn't understand IDA's unicode
+      else if (isASCII(ea_flags) && ea_size >= 4
+        && (get_long(ea) & 0xff00ff00) == 0) // lame..
+      {
+        do_undef = 1;
+      }
+      // masm doesn't understand large aligns
+      else if (isAlign(ea_flags) && ea_size > 0x10) {
+        msg("%x: undefining align %d\n", ea, ea_size);
         do_unknown(ea, DOUNK_EXPAND);
       }
-      if (isOwrd(ea_flags)) {
+
+      if (do_undef) {
         buf[0] = 0;
         get_name(BADADDR, ea, buf, sizeof(buf));
-        if (IS_START(buf, "xmm")) {
-          msg("%x: undefining '%s'\n", ea, buf);
-          do_unknown(ea, DOUNK_EXPAND);
-        }
+        msg("%x: undefining '%s'\n", ea, buf);
+        do_unknown(ea, DOUNK_EXPAND);
       }
     }
   }
@@ -277,9 +333,26 @@ static void idaapi run(int /*arg*/)
       continue;
     }
 
-    if (is_name_reserved(name)) {
+    // rename vars with '?@' (funcs are ok)
+    int change_qat = 0;
+    ea_flags = get_flags_novalue(ea);
+    if (!isCode(ea_flags) && strpbrk(name, "?@"))
+      change_qat = 1;
+
+    if (change_qat || is_name_reserved(name)) {
       msg("%x: renaming name '%s'\n", ea, name);
       qsnprintf(buf, sizeof(buf), "%s_g", name);
+
+      if (change_qat) {
+        for (p = buf; *p != 0; p++) {
+          if (*p == '?' || *p == '@') {
+            qsnprintf(buf2, sizeof(buf2), "%02x", (unsigned char)*p);
+            memmove(p + 1, p, strlen(p) + 1);
+            memcpy(p, buf2, 2);
+          }
+        }
+      }
+
       set_name(ea, buf);
     }
   }
@@ -310,9 +383,14 @@ static void idaapi run(int /*arg*/)
   ln.set_place(&pl);
   n = ln.get_linecnt();
   for (i = 0; i < n - 1; i++) {
-    do_def_line(buf, sizeof(buf), ln.down());
+    do_def_line(buf, sizeof(buf), ln.down(), ea);
     if (strstr(buf, "include"))
       continue;
+    p = strstr(buf, "assume cs");
+    if (p != NULL) {
+      memmove(p + 1, p, strlen(p) + 1);
+      *p = ';';
+    }
 
     fout_line++;
     qfprintf(fout, "%s\n", buf);
@@ -321,13 +399,22 @@ static void idaapi run(int /*arg*/)
       memcpy(p, ".xmm", 4);
       fout_line++;
       qfprintf(fout, "%s\n", buf);
+      continue;
+    }
+    p = strstr(buf, ".model");
+    if (p != NULL) {
+      qstrncpy(p, "include imports.inc", sizeof(buf) - (p - buf));
+      fout_line++;
+      qfprintf(fout, "\n%s\n", buf);
+      continue;
     }
   }
   pl.lnnum = i;
 
   for (;;)
   {
-    drop_large = drop_rva = 0;
+    int drop_large = 0, drop_rva = 0, set_scale = 0, jmp_near = 0;
+    int word_imm = 0, dword_imm = 0, do_pushf = 0;
 
     if ((ea >> 14) != ui_ea_block) {
       ui_ea_block = ea >> 14;
@@ -346,14 +433,44 @@ static void idaapi run(int /*arg*/)
       if (!decode_insn(ea))
         goto pass;
 
+      if (is_insn_jmp(cmd.itype) && cmd.Operands[0].type == o_near
+        && cmd.Operands[0].dtyp == dt_dword)
+      {
+        jmp_near = 1;
+      }
+      else if ((cmd.itype == NN_pushf || cmd.itype == NN_popf)
+        && natop())
+      {
+        do_pushf = 1;
+      }
+
       for (o = 0; o < UA_MAXOP; o++) {
-        if (cmd.Operands[o].type == o_void)
+        const op_t &opr = cmd.Operands[o];
+        if (opr.type == o_void)
           break;
 
-        if (cmd.Operands[o].type == o_mem
-          && cmd.Operands[o].specval_shorts.high == 0x21) // correct?
-        {
+        // correct?
+        if (opr.type == o_mem && opr.specval_shorts.high == 0x21)
           drop_large = 1;
+        if (opr.hasSIB && x86_scale(opr) == 0
+          && x86_index(opr) != INDEX_NONE)
+        {
+          set_scale = 1;
+        }
+        // annoying alignment variant..
+        if (opr.type == o_imm && opr.dtyp == dt_dword
+          && (opr.value < 0x80 || opr.value > 0xffffff80)
+          && cmd.size >= opr.offb + 4)
+        {
+          if (get_long(ea + opr.offb) == opr.value)
+            dword_imm = 1;
+        }
+        else if (opr.type == o_imm && opr.dtyp == dt_word
+          && (opr.value < 0x80 || opr.value > 0xff80)
+          && cmd.size >= opr.offb + 2)
+        {
+          if (get_word(ea + opr.offb) == (ushort)opr.value)
+            word_imm = 1;
         }
       }
     }
@@ -365,19 +482,81 @@ static void idaapi run(int /*arg*/)
 pass:
     n = ln.get_linecnt();
     for (i = pl.lnnum; i < n; i++) {
-      do_def_line(buf, sizeof(buf), ln.down());
+      do_def_line(buf, sizeof(buf), ln.down(), ea);
+
+      char *fw;
+      for (fw = buf; *fw != 0 && *fw == ' '; )
+        fw++;
 
+      // patches..
       if (drop_large) {
-        p = strstr(buf, "large ");
+        p = strstr(fw, "large ");
         if (p != NULL)
           memmove(p, p + 6, strlen(p + 6) + 1);
       }
       while (drop_rva) {
-        p = strstr(buf, " rva ");
+        p = strstr(fw, " rva ");
         if (p == NULL)
           break;
         memmove(p, p + 4, strlen(p + 4) + 1);
       }
+      if (set_scale) {
+        p = strchr(fw, '[');
+        if (p != NULL)
+          p = strchr(p, '+');
+        if (p != NULL && p[1] == 'e') {
+          p += 4;
+          // scale is 1, must specify it explicitly so that
+          // masm chooses the right scaled reg
+          memmove(p + 2, p, strlen(p) + 1);
+          memcpy(p, "*1", 2);
+        }
+      }
+      else if (jmp_near) {
+        p = strchr(fw, 'j');
+        while (p && *p != ' ')
+          p++;
+        while (p && *p == ' ')
+          p++;
+        if (p != NULL) {
+          memmove(p + 9, p, strlen(p) + 1);
+          memcpy(p, "near ptr ", 9);
+        }
+      }
+      if (word_imm) {
+        p = strstr(fw, ", ");
+        if (p != NULL && '0' <= p[2] && p[2] <= '9') {
+          p += 2;
+          memmove(p + 9, p, strlen(p) + 1);
+          memcpy(p, "word ptr ", 9);
+        }
+      }
+      else if (dword_imm) {
+        p = strstr(fw, ", ");
+        if (p != NULL && '0' <= p[2] && p[2] <= '9') {
+          p += 2;
+          memmove(p + 10, p, strlen(p) + 1);
+          memcpy(p, "dword ptr ", 10);
+        }
+      }
+      else if (do_pushf) {
+        p = strstr(fw, "pushf");
+        if (p == NULL)
+          p = strstr(fw, "popf");
+        if (p != NULL) {
+          p = strchr(p, 'f') + 1;
+          memmove(p + 1, p, strlen(p) + 1);
+          *p = 'd';
+        }
+      }
+
+      if (fw[0] == 'e' && IS_START(fw, "end") && fw[3] == ' ') {
+        fout_line++;
+        qfprintf(fout, "include public.inc\n\n");
+
+        // kill entry point
+        fw[3] = 0;
+      }
 
       fout_line++;
       qfprintf(fout, "%s\n", buf);