tools/translate.c

   1 #define _GNU_SOURCE
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5
   6 #include "my_assert.h"
   7 #include "my_str.h"
   8
   9 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
  10 #define IS(w, y) !strcmp(w, y)
  11 #define IS_START(w, y) !strncmp(w, y, strlen(y))
  12
  13 #include "protoparse.h"
  14
  15 static const char *asmfn;
  16 static int asmln;
  17 static FILE *g_fhdr;
  18
  19 #define anote(fmt, ...) \
  20         printf("%s:%d: note: " fmt, asmfn, asmln, ##__VA_ARGS__)
  21 #define awarn(fmt, ...) \
  22         printf("%s:%d: warning: " fmt, asmfn, asmln, ##__VA_ARGS__)
  23 #define aerr(fmt, ...) do { \
  24         printf("%s:%d: error: " fmt, asmfn, asmln, ##__VA_ARGS__); \
  25   fcloseall(); \
  26         exit(1); \
  27 } while (0)
  28
  29 enum op_flags {
  30   OPF_RMD    = (1 << 0), /* removed or optimized out */
  31   OPF_DATA   = (1 << 1), /* data processing - writes to dst opr */
  32   OPF_FLAGS  = (1 << 2), /* sets flags */
  33   OPF_JMP    = (1 << 3), /* branches, ret and call */
  34   OPF_CC     = (1 << 4), /* uses flags */
  35   OPF_TAIL   = (1 << 5), /* ret or tail call */
  36   OPF_RSAVE  = (1 << 6), /* push/pop is local reg save/load */
  37   OPF_REP    = (1 << 7), /* prefixed by rep */
  38   OPF_REPZ   = (1 << 8), /* rep is repe/repz */
  39   OPF_REPNZ  = (1 << 9), /* rep is repne/repnz */
  40   OPF_FARG   = (1 << 10), /* push collected as func arg (no reuse) */
  41   OPF_EBP_S  = (1 << 11), /* ebp used as scratch, not BP */
  42 };
  43
  44 enum op_op {
  45         OP_INVAL,
  46         OP_NOP,
  47         OP_PUSH,
  48         OP_POP,
  49         OP_MOV,
  50         OP_LEA,
  51         OP_MOVZX,
  52         OP_MOVSX,
  53         OP_NOT,
  54         OP_CDQ,
  55         OP_STOS,
  56         OP_MOVS,
  57         OP_CMPS,
  58         OP_RET,
  59         OP_ADD,
  60         OP_SUB,
  61         OP_AND,
  62         OP_OR,
  63         OP_XOR,
  64         OP_SHL,
  65         OP_SHR,
  66         OP_SAR,
  67         OP_ROL,
  68         OP_ROR,
  69         OP_ADC,
  70         OP_SBB,
  71         OP_INC,
  72         OP_DEC,
  73         OP_NEG,
  74         OP_MUL,
  75         OP_IMUL,
  76         OP_DIV,
  77         OP_IDIV,
  78         OP_TEST,
  79         OP_CMP,
  80         OP_CALL,
  81         OP_JMP,
  82         OP_JO,
  83         OP_JNO,
  84         OP_JC,
  85         OP_JNC,
  86         OP_JZ,
  87         OP_JNZ,
  88         OP_JBE,
  89         OP_JA,
  90         OP_JS,
  91         OP_JNS,
  92         OP_JP,
  93         OP_JNP,
  94         OP_JL,
  95         OP_JGE,
  96         OP_JLE,
  97         OP_JG,
  98 };
  99
 100 enum opr_type {
 101   OPT_UNSPEC,
 102   OPT_REG,
 103   OPT_REGMEM,
 104   OPT_LABEL,
 105   OPT_OFFSET,
 106   OPT_CONST,
 107 };
 108
 109 // must be sorted (larger len must be further in enum)
 110 enum opr_lenmod {
 111         OPLM_UNSPEC,
 112         OPLM_BYTE,
 113         OPLM_WORD,
 114         OPLM_DWORD,
 115 };
 116
 117 #define MAX_OPERANDS 3
 118
 119 struct parsed_opr {
 120   enum opr_type type;
 121   enum opr_lenmod lmod;
 122   unsigned int is_ptr:1;   // pointer in C
 123   unsigned int is_array:1; // array in C
 124   unsigned int type_from_var:1; // .. in header, sometimes wrong
 125   unsigned int size_mismatch:1; // type override differs from C
 126   unsigned int size_lt:1;  // type override is larger than C
 127   int reg;
 128   unsigned int val;
 129   char name[256];
 130 };
 131
 132 struct parsed_op {
 133   enum op_op op;
 134   struct parsed_opr operand[MAX_OPERANDS];
 135   unsigned int flags;
 136   int operand_cnt;
 137   int regmask_src;        // all referensed regs
 138   int regmask_dst;
 139   int pfomask;            // flagop: parsed_flag_op that can't be delayed
 140   int argnum;             // push: altered before call arg #
 141   int cc_scratch;         // scratch storage during analysis
 142   int bt_i;               // branch target for branches
 143   struct parsed_data *btj;// branch targets for jumptables
 144   void *datap;
 145 };
 146
 147 // datap:
 148 // OP_CALL - ptr to parsed_proto
 149 // (OPF_CC) - point to one of (OPF_FLAGS) that affects cc op
 150
 151 struct parsed_equ {
 152   char name[64];
 153   enum opr_lenmod lmod;
 154   int offset;
 155 };
 156
 157 struct parsed_data {
 158   char label[256];
 159   enum opr_type type;
 160   enum opr_lenmod lmod;
 161   int count;
 162   int count_alloc;
 163   struct {
 164     union {
 165       char *label;
 166       unsigned int val;
 167     } u;
 168     int bt_i;
 169   } *d;
 170 };
 171
 172 struct label_ref {
 173   int i;
 174   struct label_ref *next;
 175 };
 176
 177 enum ida_func_attr {
 178   IDAFA_BP_FRAME = (1 << 0),
 179   IDAFA_LIB_FUNC = (1 << 1),
 180   IDAFA_STATIC   = (1 << 2),
 181   IDAFA_NORETURN = (1 << 3),
 182   IDAFA_THUNK    = (1 << 4),
 183   IDAFA_FPD      = (1 << 5),
 184 };
 185
 186 #define MAX_OPS 4096
 187
 188 static struct parsed_op ops[MAX_OPS];
 189 static struct parsed_equ *g_eqs;
 190 static int g_eqcnt;
 191 static char g_labels[MAX_OPS][32];
 192 static struct label_ref g_label_refs[MAX_OPS];
 193 static const struct parsed_proto *g_func_pp;
 194 static struct parsed_data *g_func_pd;
 195 static int g_func_pd_cnt;
 196 static char g_func[256];
 197 static char g_comment[256];
 198 static int g_bp_frame;
 199 static int g_sp_frame;
 200 static int g_stack_frame_used;
 201 static int g_stack_fsz;
 202 static int g_ida_func_attr;
 203 #define ferr(op_, fmt, ...) do { \
 204   printf("error:%s:#%zd: '%s': " fmt, g_func, (op_) - ops, \
 205     dump_op(op_), ##__VA_ARGS__); \
 206   fcloseall(); \
 207   exit(1); \
 208 } while (0)
 209 #define fnote(op_, fmt, ...) \
 210   printf("error:%s:#%zd: '%s': " fmt, g_func, (op_) - ops, \
 211     dump_op(op_), ##__VA_ARGS__)
 212
 213 #define MAX_REGS 8
 214
 215 const char *regs_r32[] = { "eax", "ebx", "ecx", "edx", "esi", "edi", "ebp", "esp" };
 216 const char *regs_r16[] = { "ax", "bx", "cx", "dx", "si", "di", "bp", "sp" };
 217 const char *regs_r8l[] = { "al", "bl", "cl", "dl" };
 218 const char *regs_r8h[] = { "ah", "bh", "ch", "dh" };
 219
 220 enum x86_regs { xUNSPEC = -1, xAX, xBX, xCX, xDX, xSI, xDI, xBP, xSP };
 221
 222 // possible basic comparison types (without inversion)
 223 enum parsed_flag_op {
 224   PFO_O,  // 0 OF=1
 225   PFO_C,  // 2 CF=1
 226   PFO_Z,  // 4 ZF=1
 227   PFO_BE, // 6 CF=1||ZF=1
 228   PFO_S,  // 8 SF=1
 229   PFO_P,  // a PF=1
 230   PFO_L,  // c SF!=OF
 231   PFO_LE, // e ZF=1||SF!=OF
 232 };
 233
 234 static const char *parsed_flag_op_names[] = {
 235   "o", "c", "z", "be", "s", "p", "l", "le"
 236 };
 237
 238 static int char_array_i(const char *array[], size_t len, const char *s)
 239 {
 240   int i;
 241
 242   for (i = 0; i < len; i++)
 243     if (IS(s, array[i]))
 244       return i;
 245
 246   return -1;
 247 }
 248
 249 static void printf_number(char *buf, size_t buf_size,
 250   unsigned long number)
 251 {
 252   // output in C-friendly form
 253   snprintf(buf, buf_size, number < 10 ? "%lu" : "0x%02lx", number);
 254 }
 255
 256 static int parse_reg(enum opr_lenmod *reg_lmod, const char *s)
 257 {
 258   int reg;
 259
 260   reg = char_array_i(regs_r32, ARRAY_SIZE(regs_r32), s);
 261   if (reg >= 0) {
 262     *reg_lmod = OPLM_DWORD;
 263     return reg;
 264   }
 265   reg = char_array_i(regs_r16, ARRAY_SIZE(regs_r16), s);
 266   if (reg >= 0) {
 267     *reg_lmod = OPLM_WORD;
 268     return reg;
 269   }
 270   reg = char_array_i(regs_r8h, ARRAY_SIZE(regs_r8h), s);
 271   if (reg >= 0) {
 272     *reg_lmod = OPLM_BYTE;
 273     return reg;
 274   }
 275   reg = char_array_i(regs_r8l, ARRAY_SIZE(regs_r8l), s);
 276   if (reg >= 0) {
 277     *reg_lmod = OPLM_BYTE;
 278     return reg;
 279   }
 280
 281   return -1;
 282 }
 283
 284 static unsigned long parse_number(const char *number)
 285 {
 286   int len = strlen(number);
 287   const char *p = number;
 288   char *endp = NULL;
 289   unsigned long ret;
 290   int neg = 0;
 291   int bad;
 292
 293   if (*p == '-') {
 294     neg = 1;
 295     p++;
 296   }
 297   if (len > 1 && *p == '0')
 298     p++;
 299   if (number[len - 1] == 'h') {
 300     ret = strtoul(p, &endp, 16);
 301     bad = (*endp != 'h');
 302   }
 303   else {
 304     ret = strtoul(p, &endp, 10);
 305     bad = (*endp != 0);
 306   }
 307   if (bad)
 308     aerr("number parsing failed\n");
 309   if (neg)
 310     ret = -ret;
 311   return ret;
 312 }
 313
 314 static int parse_indmode(char *name, int *regmask, int need_c_cvt)
 315 {
 316   enum opr_lenmod lmod;
 317   char cvtbuf[256];
 318   char *d = cvtbuf;
 319   char *s = name;
 320   char w[64];
 321   long number;
 322   int reg;
 323   int c = 0;
 324
 325   *d = 0;
 326
 327   while (*s != 0) {
 328     d += strlen(d);
 329     while (my_isblank(*s))
 330       s++;
 331     for (; my_issep(*s); d++, s++)
 332       *d = *s;
 333     while (my_isblank(*s))
 334       s++;
 335     *d = 0;
 336
 337     // skip 'ds:' prefix
 338     if (IS_START(s, "ds:"))
 339       s += 3;
 340
 341     s = next_idt(w, sizeof(w), s);
 342     if (w[0] == 0)
 343       break;
 344     c++;
 345
 346     reg = parse_reg(&lmod, w);
 347     if (reg >= 0) {
 348       *regmask |= 1 << reg;
 349       goto pass;
 350     }
 351
 352     if ('0' <= w[0] && w[0] <= '9') {
 353       number = parse_number(w);
 354       printf_number(d, sizeof(cvtbuf) - (d - cvtbuf), number);
 355       continue;
 356     }
 357
 358     // probably some label/identifier - pass
 359
 360 pass:
 361     snprintf(d, sizeof(cvtbuf) - (d - cvtbuf), "%s", w);
 362   }
 363
 364   if (need_c_cvt)
 365     strcpy(name, cvtbuf);
 366
 367   return c;
 368 }
 369
 370 static int is_reg_in_str(const char *s)
 371 {
 372   int i;
 373
 374   if (strlen(s) < 3 || (s[3] && !my_issep(s[3]) && !my_isblank(s[3])))
 375     return 0;
 376
 377   for (i = 0; i < ARRAY_SIZE(regs_r32); i++)
 378     if (!strncmp(s, regs_r32[i], 3))
 379       return 1;
 380
 381   return 0;
 382 }
 383
 384 static const char *parse_stack_el(const char *name, char *extra_reg)
 385 {
 386   const char *p, *p2, *s;
 387   char *endp = NULL;
 388   char buf[32];
 389   long val;
 390   int len;
 391
 392   p = name;
 393   if (IS_START(p + 3, "+ebp+") && is_reg_in_str(p)) {
 394     p += 4;
 395     if (extra_reg != NULL) {
 396       strncpy(extra_reg, name, 3);
 397       extra_reg[4] = 0;
 398     }
 399   }
 400
 401   if (IS_START(p, "ebp+")) {
 402     p += 4;
 403
 404     p2 = strchr(p, '+');
 405     if (p2 != NULL && is_reg_in_str(p)) {
 406       if (extra_reg != NULL) {
 407         strncpy(extra_reg, p, p2 - p);
 408         extra_reg[p2 - p] = 0;
 409       }
 410       p = p2 + 1;
 411     }
 412
 413     if (!('0' <= *p && *p <= '9'))
 414       return p;
 415
 416     return NULL;
 417   }
 418
 419   if (!IS_START(name, "esp+"))
 420     return NULL;
 421
 422   p = strchr(name + 4, '+');
 423   if (p) {
 424     // must be a number after esp+, already converted to 0x..
 425     s = name + 4;
 426     if (!('0' <= *s && *s <= '9')) {
 427                   aerr("%s nan?\n", __func__);
 428       return NULL;
 429     }
 430     if (s[0] == '0' && s[1] == 'x')
 431       s += 2;
 432     len = p - s;
 433     if (len < sizeof(buf) - 1) {
 434       strncpy(buf, s, len);
 435       buf[len] = 0;
 436       val = strtol(buf, &endp, 16);
 437       if (val == 0 || *endp != 0) {
 438         aerr("%s num parse fail for '%s'\n", __func__, buf);
 439         return NULL;
 440       }
 441     }
 442     p++;
 443   }
 444   else
 445     p = name + 4;
 446
 447   if ('0' <= *p && *p <= '9')
 448     return NULL;
 449
 450   return p;
 451 }
 452
 453 static int guess_lmod_from_name(struct parsed_opr *opr)
 454 {
 455   if (!strncmp(opr->name, "dword_", 6)) {
 456     opr->lmod = OPLM_DWORD;
 457     return 1;
 458   }
 459   if (!strncmp(opr->name, "word_", 5)) {
 460     opr->lmod = OPLM_WORD;
 461     return 1;
 462   }
 463   if (!strncmp(opr->name, "byte_", 5)) {
 464     opr->lmod = OPLM_BYTE;
 465     return 1;
 466   }
 467   return 0;
 468 }
 469
 470 static int guess_lmod_from_c_type(enum opr_lenmod *lmod,
 471   const struct parsed_type *c_type)
 472 {
 473   static const char *dword_types[] = {
 474     "int", "_DWORD", "UINT_PTR",
 475     "DWORD", "HANDLE", "HWND", "HMODULE",
 476     "WPARAM", "LPARAM", "UINT",
 477   };
 478   static const char *word_types[] = {
 479     "uint16_t", "int16_t",
 480     "unsigned __int16", "__int16",
 481   };
 482   static const char *byte_types[] = {
 483     "uint8_t", "int8_t", "char",
 484     "unsigned __int8", "__int8", "BYTE",
 485     "_UNKNOWN",
 486   };
 487   const char *n;
 488   int i;
 489
 490   if (c_type->is_ptr) {
 491     *lmod = OPLM_DWORD;
 492     return 1;
 493   }
 494
 495   n = skip_type_mod(c_type->name);
 496
 497   for (i = 0; i < ARRAY_SIZE(dword_types); i++) {
 498     if (IS(n, dword_types[i])) {
 499       *lmod = OPLM_DWORD;
 500       return 1;
 501     }
 502   }
 503
 504   for (i = 0; i < ARRAY_SIZE(word_types); i++) {
 505     if (IS(n, word_types[i])) {
 506       *lmod = OPLM_WORD;
 507       return 1;
 508     }
 509   }
 510
 511   for (i = 0; i < ARRAY_SIZE(byte_types); i++) {
 512     if (IS(n, byte_types[i])) {
 513       *lmod = OPLM_BYTE;
 514       return 1;
 515     }
 516   }
 517
 518   return 0;
 519 }
 520
 521 static enum opr_type lmod_from_directive(const char *d)
 522 {
 523   if (IS(d, "dd"))
 524     return OPLM_DWORD;
 525   else if (IS(d, "dw"))
 526     return OPLM_WORD;
 527   else if (IS(d, "db"))
 528     return OPLM_BYTE;
 529
 530   aerr("unhandled directive: '%s'\n", d);
 531   return OPLM_UNSPEC;
 532 }
 533
 534 static void setup_reg_opr(struct parsed_opr *opr, int reg, enum opr_lenmod lmod,
 535   int *regmask)
 536 {
 537   opr->type = OPT_REG;
 538   opr->reg = reg;
 539   opr->lmod = lmod;
 540   *regmask |= 1 << reg;
 541 }
 542
 543 static struct parsed_equ *equ_find(struct parsed_op *po, const char *name,
 544   int *extra_offs);
 545
 546 static int parse_operand(struct parsed_opr *opr,
 547   int *regmask, int *regmask_indirect,
 548   char words[16][256], int wordc, int w, unsigned int op_flags)
 549 {
 550   const struct parsed_proto *pp;
 551   enum opr_lenmod tmplmod;
 552   unsigned long number;
 553   int ret, len;
 554   int wordc_in;
 555   char *tmp;
 556   int i;
 557
 558   if (w >= wordc)
 559     aerr("parse_operand w %d, wordc %d\n", w, wordc);
 560
 561   opr->reg = xUNSPEC;
 562
 563   for (i = w; i < wordc; i++) {
 564     len = strlen(words[i]);
 565     if (words[i][len - 1] == ',') {
 566       words[i][len - 1] = 0;
 567       wordc = i + 1;
 568       break;
 569     }
 570   }
 571
 572   wordc_in = wordc - w;
 573
 574   if ((op_flags & OPF_JMP) && wordc_in > 0
 575       && !('0' <= words[w][0] && words[w][0] <= '9'))
 576   {
 577     const char *label = NULL;
 578
 579     if (wordc_in == 3 && !strncmp(words[w], "near", 4)
 580      && IS(words[w + 1], "ptr"))
 581       label = words[w + 2];
 582     else if (wordc_in == 2 && IS(words[w], "short"))
 583       label = words[w + 1];
 584     else if (wordc_in == 1
 585           && strchr(words[w], '[') == NULL
 586           && parse_reg(&tmplmod, words[w]) < 0)
 587       label = words[w];
 588
 589     if (label != NULL) {
 590       opr->type = OPT_LABEL;
 591       if (IS_START(label, "ds:"))
 592         label += 3;
 593       strcpy(opr->name, label);
 594       return wordc;
 595     }
 596   }
 597
 598   if (wordc_in >= 3) {
 599     if (IS(words[w + 1], "ptr")) {
 600       if (IS(words[w], "dword"))
 601         opr->lmod = OPLM_DWORD;
 602       else if (IS(words[w], "word"))
 603         opr->lmod = OPLM_WORD;
 604       else if (IS(words[w], "byte"))
 605         opr->lmod = OPLM_BYTE;
 606       else
 607         aerr("type parsing failed\n");
 608       w += 2;
 609       wordc_in = wordc - w;
 610     }
 611   }
 612
 613   if (wordc_in == 2) {
 614     if (IS(words[w], "offset")) {
 615       opr->type = OPT_OFFSET;
 616       strcpy(opr->name, words[w + 1]);
 617       return wordc;
 618     }
 619     if (IS(words[w], "(offset")) {
 620       char *p = strchr(words[w + 1], ')');
 621       if (p == NULL)
 622         aerr("parse of bracketed offset failed\n");
 623       *p = 0;
 624       opr->type = OPT_OFFSET;
 625       strcpy(opr->name, words[w + 1]);
 626       return wordc;
 627     }
 628   }
 629
 630   if (wordc_in != 1)
 631     aerr("parse_operand 1 word expected\n");
 632
 633   tmp = words[w];
 634   if (IS_START(tmp, "ds:"))
 635     tmp += 3;
 636   strcpy(opr->name, tmp);
 637
 638   if (words[w][0] == '[') {
 639     opr->type = OPT_REGMEM;
 640     ret = sscanf(words[w], "[%[^]]]", opr->name);
 641     if (ret != 1)
 642       aerr("[] parse failure\n");
 643
 644     parse_indmode(opr->name, regmask_indirect, 1);
 645     if (opr->lmod == OPLM_UNSPEC && parse_stack_el(opr->name, NULL)) {
 646       // might be an equ
 647       struct parsed_equ *eq =
 648         equ_find(NULL, parse_stack_el(opr->name, NULL), &i);
 649       if (eq)
 650         opr->lmod = eq->lmod;
 651     }
 652     return wordc;
 653   }
 654   else if (strchr(words[w], '[')) {
 655     // label[reg] form
 656     opr->type = OPT_REGMEM;
 657     if (opr->lmod == OPLM_UNSPEC)
 658       guess_lmod_from_name(opr);
 659     parse_indmode(strchr(words[w], '['), regmask_indirect, 0);
 660     return wordc;
 661   }
 662   else if (('0' <= words[w][0] && words[w][0] <= '9')
 663     || words[w][0] == '-')
 664   {
 665     number = parse_number(words[w]);
 666     opr->type = OPT_CONST;
 667     opr->val = number;
 668     printf_number(opr->name, sizeof(opr->name), number);
 669     return wordc;
 670   }
 671
 672   ret = parse_reg(&tmplmod, opr->name);
 673   if (ret >= 0) {
 674     setup_reg_opr(opr, ret, tmplmod, regmask);
 675     return wordc;
 676   }
 677
 678   // most likely var in data segment
 679   opr->type = OPT_LABEL;
 680
 681   pp = proto_parse(g_fhdr, opr->name);
 682   if (pp != NULL) {
 683     if (pp->is_fptr || pp->is_func) {
 684       opr->lmod = OPLM_DWORD;
 685       opr->is_ptr = 1;
 686     }
 687     else {
 688       tmplmod = OPLM_UNSPEC;
 689       if (!guess_lmod_from_c_type(&tmplmod, &pp->type))
 690         anote("unhandled C type '%s' for '%s'\n",
 691           pp->type.name, opr->name);
 692
 693       if (opr->lmod == OPLM_UNSPEC) {
 694         opr->lmod = tmplmod;
 695         opr->type_from_var = 1;
 696       }
 697       else if (opr->lmod != tmplmod) {
 698         opr->size_mismatch = 1;
 699         if (tmplmod < opr->lmod)
 700           opr->size_lt = 1;
 701       }
 702       opr->is_ptr = pp->type.is_ptr;
 703     }
 704     opr->is_array = pp->type.is_array;
 705   }
 706
 707   if (opr->lmod == OPLM_UNSPEC)
 708     guess_lmod_from_name(opr);
 709   return wordc;
 710 }
 711
 712 static const struct {
 713   const char *name;
 714   unsigned int flags;
 715 } pref_table[] = {
 716   { "rep",    OPF_REP },
 717   { "repe",   OPF_REP|OPF_REPZ },
 718   { "repz",   OPF_REP|OPF_REPZ },
 719   { "repne",  OPF_REP|OPF_REPNZ },
 720   { "repnz",  OPF_REP|OPF_REPNZ },
 721 };
 722
 723 static const struct {
 724   const char *name;
 725   enum op_op op;
 726   unsigned int minopr;
 727   unsigned int maxopr;
 728   unsigned int flags;
 729 } op_table[] = {
 730   { "nop",  OP_NOP,    0, 0, 0 },
 731   { "push", OP_PUSH,   1, 1, 0 },
 732   { "pop",  OP_POP,    1, 1, OPF_DATA },
 733   { "mov" , OP_MOV,    2, 2, OPF_DATA },
 734   { "lea",  OP_LEA,    2, 2, OPF_DATA },
 735   { "movzx",OP_MOVZX,  2, 2, OPF_DATA },
 736   { "movsx",OP_MOVSX,  2, 2, OPF_DATA },
 737   { "not",  OP_NOT,    1, 1, OPF_DATA },
 738   { "cdq",  OP_CDQ,    0, 0, OPF_DATA },
 739   { "stosb",OP_STOS,   0, 0, OPF_DATA },
 740   { "stosw",OP_STOS,   0, 0, OPF_DATA },
 741   { "stosd",OP_STOS,   0, 0, OPF_DATA },
 742   { "movsb",OP_MOVS,   0, 0, OPF_DATA },
 743   { "movsw",OP_MOVS,   0, 0, OPF_DATA },
 744   { "movsd",OP_MOVS,   0, 0, OPF_DATA },
 745   { "cmpsb",OP_CMPS,   0, 0, OPF_DATA|OPF_FLAGS },
 746   { "cmpsw",OP_CMPS,   0, 0, OPF_DATA|OPF_FLAGS },
 747   { "cmpsd",OP_CMPS,   0, 0, OPF_DATA|OPF_FLAGS },
 748   { "add",  OP_ADD,    2, 2, OPF_DATA|OPF_FLAGS },
 749   { "sub",  OP_SUB,    2, 2, OPF_DATA|OPF_FLAGS },
 750   { "and",  OP_AND,    2, 2, OPF_DATA|OPF_FLAGS },
 751   { "or",   OP_OR,     2, 2, OPF_DATA|OPF_FLAGS },
 752   { "xor",  OP_XOR,    2, 2, OPF_DATA|OPF_FLAGS },
 753   { "shl",  OP_SHL,    2, 2, OPF_DATA|OPF_FLAGS },
 754   { "shr",  OP_SHR,    2, 2, OPF_DATA|OPF_FLAGS },
 755   { "sal",  OP_SHL,    2, 2, OPF_DATA|OPF_FLAGS },
 756   { "sar",  OP_SAR,    2, 2, OPF_DATA|OPF_FLAGS },
 757   { "rol",  OP_ROL,    2, 2, OPF_DATA|OPF_FLAGS },
 758   { "ror",  OP_ROR,    2, 2, OPF_DATA|OPF_FLAGS },
 759   { "adc",  OP_ADC,    2, 2, OPF_DATA|OPF_FLAGS|OPF_CC },
 760   { "sbb",  OP_SBB,    2, 2, OPF_DATA|OPF_FLAGS|OPF_CC },
 761   { "inc",  OP_INC,    1, 1, OPF_DATA|OPF_FLAGS },
 762   { "dec",  OP_DEC,    1, 1, OPF_DATA|OPF_FLAGS },
 763   { "neg",  OP_NEG,    1, 1, OPF_DATA|OPF_FLAGS },
 764   { "mul",  OP_MUL,    1, 1, OPF_DATA|OPF_FLAGS },
 765   { "imul", OP_IMUL,   1, 3, OPF_DATA|OPF_FLAGS },
 766   { "div",  OP_DIV,    1, 1, OPF_DATA|OPF_FLAGS },
 767   { "idiv", OP_IDIV,   1, 1, OPF_DATA|OPF_FLAGS },
 768   { "test", OP_TEST,   2, 2, OPF_FLAGS },
 769   { "cmp",  OP_CMP,    2, 2, OPF_FLAGS },
 770   { "retn", OP_RET,    0, 1, OPF_TAIL },
 771   { "call", OP_CALL,   1, 1, OPF_JMP|OPF_DATA|OPF_FLAGS },
 772   { "jmp",  OP_JMP,    1, 1, OPF_JMP },
 773   { "jo",   OP_JO,     1, 1, OPF_JMP|OPF_CC }, // 70 OF=1
 774   { "jno",  OP_JNO,    1, 1, OPF_JMP|OPF_CC }, // 71 OF=0
 775   { "jc",   OP_JC,     1, 1, OPF_JMP|OPF_CC }, // 72 CF=1
 776   { "jb",   OP_JC,     1, 1, OPF_JMP|OPF_CC }, // 72
 777   { "jnc",  OP_JNC,    1, 1, OPF_JMP|OPF_CC }, // 73 CF=0
 778   { "jnb",  OP_JNC,    1, 1, OPF_JMP|OPF_CC }, // 73
 779   { "jae",  OP_JNC,    1, 1, OPF_JMP|OPF_CC }, // 73
 780   { "jz",   OP_JZ,     1, 1, OPF_JMP|OPF_CC }, // 74 ZF=1
 781   { "je",   OP_JZ,     1, 1, OPF_JMP|OPF_CC }, // 74
 782   { "jnz",  OP_JNZ,    1, 1, OPF_JMP|OPF_CC }, // 75 ZF=0
 783   { "jne",  OP_JNZ,    1, 1, OPF_JMP|OPF_CC }, // 75
 784   { "jbe",  OP_JBE,    1, 1, OPF_JMP|OPF_CC }, // 76 CF=1 || ZF=1
 785   { "jna",  OP_JBE,    1, 1, OPF_JMP|OPF_CC }, // 76
 786   { "ja",   OP_JA,     1, 1, OPF_JMP|OPF_CC }, // 77 CF=0 && ZF=0
 787   { "jnbe", OP_JA,     1, 1, OPF_JMP|OPF_CC }, // 77
 788   { "js",   OP_JS,     1, 1, OPF_JMP|OPF_CC }, // 78 SF=1
 789   { "jns",  OP_JNS,    1, 1, OPF_JMP|OPF_CC }, // 79 SF=0
 790   { "jp",   OP_JP,     1, 1, OPF_JMP|OPF_CC }, // 7a PF=1
 791   { "jpe",  OP_JP,     1, 1, OPF_JMP|OPF_CC }, // 7a
 792   { "jnp",  OP_JNP,    1, 1, OPF_JMP|OPF_CC }, // 7b PF=0
 793   { "jpo",  OP_JNP,    1, 1, OPF_JMP|OPF_CC }, // 7b
 794   { "jl",   OP_JL,     1, 1, OPF_JMP|OPF_CC }, // 7c SF!=OF
 795   { "jnge", OP_JL,     1, 1, OPF_JMP|OPF_CC }, // 7c
 796   { "jge",  OP_JGE,    1, 1, OPF_JMP|OPF_CC }, // 7d SF=OF
 797   { "jnl",  OP_JGE,    1, 1, OPF_JMP|OPF_CC }, // 7d
 798   { "jle",  OP_JLE,    1, 1, OPF_JMP|OPF_CC }, // 7e ZF=1 || SF!=OF
 799   { "jng",  OP_JLE,    1, 1, OPF_JMP|OPF_CC }, // 7e
 800   { "jg",   OP_JG,     1, 1, OPF_JMP|OPF_CC }, // 7f ZF=0 && SF=OF
 801   { "jnle", OP_JG,     1, 1, OPF_JMP|OPF_CC }, // 7f
 802   { "seto",   OP_JO,   1, 1, OPF_DATA|OPF_CC },
 803   { "setno",  OP_JNO,  1, 1, OPF_DATA|OPF_CC },
 804   { "setc",   OP_JC,   1, 1, OPF_DATA|OPF_CC },
 805   { "setb",   OP_JC,   1, 1, OPF_DATA|OPF_CC },
 806   { "setnc",  OP_JNC,  1, 1, OPF_DATA|OPF_CC },
 807   { "setae",  OP_JNC,  1, 1, OPF_DATA|OPF_CC },
 808   { "setz",   OP_JZ,   1, 1, OPF_DATA|OPF_CC },
 809   { "sete",   OP_JZ,   1, 1, OPF_DATA|OPF_CC },
 810   { "setnz",  OP_JNZ,  1, 1, OPF_DATA|OPF_CC },
 811   { "setne",  OP_JNZ,  1, 1, OPF_DATA|OPF_CC },
 812   { "setbe",  OP_JBE,  1, 1, OPF_DATA|OPF_CC },
 813   { "setna",  OP_JBE,  1, 1, OPF_DATA|OPF_CC },
 814   { "seta",   OP_JA,   1, 1, OPF_DATA|OPF_CC },
 815   { "setnbe", OP_JA,   1, 1, OPF_DATA|OPF_CC },
 816   { "sets",   OP_JS,   1, 1, OPF_DATA|OPF_CC },
 817   { "setns",  OP_JNS,  1, 1, OPF_DATA|OPF_CC },
 818   { "setp",   OP_JP,   1, 1, OPF_DATA|OPF_CC },
 819   { "setpe",  OP_JP,   1, 1, OPF_DATA|OPF_CC },
 820   { "setnp",  OP_JNP,  1, 1, OPF_DATA|OPF_CC },
 821   { "setpo",  OP_JNP,  1, 1, OPF_DATA|OPF_CC },
 822   { "setl",   OP_JL,   1, 1, OPF_DATA|OPF_CC },
 823   { "setnge", OP_JL,   1, 1, OPF_DATA|OPF_CC },
 824   { "setge",  OP_JGE,  1, 1, OPF_DATA|OPF_CC },
 825   { "setnl",  OP_JGE,  1, 1, OPF_DATA|OPF_CC },
 826   { "setle",  OP_JLE,  1, 1, OPF_DATA|OPF_CC },
 827   { "setng",  OP_JLE,  1, 1, OPF_DATA|OPF_CC },
 828   { "setg",   OP_JG,   1, 1, OPF_DATA|OPF_CC },
 829   { "setnle", OP_JG,   1, 1, OPF_DATA|OPF_CC },
 830 };
 831
 832 static void parse_op(struct parsed_op *op, char words[16][256], int wordc)
 833 {
 834   enum opr_lenmod lmod = OPLM_UNSPEC;
 835   int prefix_flags = 0;
 836   int regmask_ind;
 837   int regmask;
 838   int op_w = 0;
 839   int opr = 0;
 840   int w = 0;
 841   int i;
 842
 843   for (i = 0; i < ARRAY_SIZE(pref_table); i++) {
 844     if (IS(words[w], pref_table[i].name)) {
 845       prefix_flags = pref_table[i].flags;
 846       break;
 847     }
 848   }
 849
 850   if (prefix_flags) {
 851     if (wordc <= 1)
 852       aerr("lone prefix: '%s'\n", words[0]);
 853     w++;
 854   }
 855
 856   op_w = w;
 857   for (i = 0; i < ARRAY_SIZE(op_table); i++) {
 858     if (IS(words[w], op_table[i].name))
 859       break;
 860   }
 861
 862   if (i == ARRAY_SIZE(op_table))
 863     aerr("unhandled op: '%s'\n", words[0]);
 864   w++;
 865
 866   op->op = op_table[i].op;
 867   op->flags = op_table[i].flags | prefix_flags;
 868   op->regmask_src = op->regmask_dst = 0;
 869
 870   for (opr = 0; opr < op_table[i].minopr; opr++) {
 871     regmask = regmask_ind = 0;
 872     w = parse_operand(&op->operand[opr], &regmask, &regmask_ind,
 873       words, wordc, w, op->flags);
 874
 875     if (opr == 0 && (op->flags & OPF_DATA))
 876       op->regmask_dst = regmask;
 877     // for now, mark dst as src too
 878     op->regmask_src |= regmask | regmask_ind;
 879   }
 880
 881   for (; w < wordc && opr < op_table[i].maxopr; opr++) {
 882     w = parse_operand(&op->operand[opr],
 883       &op->regmask_src, &op->regmask_src,
 884       words, wordc, w, op->flags);
 885   }
 886
 887   if (w < wordc)
 888     aerr("parse_op %s incomplete: %d/%d\n",
 889       words[0], w, wordc);
 890
 891   // special cases
 892   op->operand_cnt = opr;
 893   if (!strncmp(op_table[i].name, "set", 3))
 894     op->operand[0].lmod = OPLM_BYTE;
 895
 896   // ops with implicit argumets
 897   switch (op->op) {
 898   case OP_CDQ:
 899     op->operand_cnt = 2;
 900     setup_reg_opr(&op->operand[0], xDX, OPLM_DWORD, &op->regmask_dst);
 901     setup_reg_opr(&op->operand[1], xAX, OPLM_DWORD, &op->regmask_src);
 902     break;
 903
 904   case OP_STOS:
 905     if (op->operand_cnt != 0)
 906       break;
 907     if      (IS(words[op_w], "stosb"))
 908       lmod = OPLM_BYTE;
 909     else if (IS(words[op_w], "stosw"))
 910       lmod = OPLM_WORD;
 911     else if (IS(words[op_w], "stosd"))
 912       lmod = OPLM_DWORD;
 913     op->operand_cnt = 3;
 914     setup_reg_opr(&op->operand[0], xDI, lmod, &op->regmask_src);
 915     setup_reg_opr(&op->operand[1], xCX, OPLM_DWORD, &op->regmask_src);
 916     op->regmask_dst = op->regmask_src;
 917     setup_reg_opr(&op->operand[2], xAX, OPLM_DWORD, &op->regmask_src);
 918     break;
 919
 920   case OP_MOVS:
 921   case OP_CMPS:
 922     if (op->operand_cnt != 0)
 923       break;
 924     if      (words[op_w][4] == 'b')
 925       lmod = OPLM_BYTE;
 926     else if (words[op_w][4] == 'w')
 927       lmod = OPLM_WORD;
 928     else if (words[op_w][4] == 'd')
 929       lmod = OPLM_DWORD;
 930     op->operand_cnt = 3;
 931     setup_reg_opr(&op->operand[0], xDI, lmod, &op->regmask_src);
 932     setup_reg_opr(&op->operand[1], xSI, OPLM_DWORD, &op->regmask_src);
 933     setup_reg_opr(&op->operand[2], xCX, OPLM_DWORD, &op->regmask_src);
 934     op->regmask_dst = op->regmask_src;
 935     break;
 936
 937   case OP_IMUL:
 938     if (op->operand_cnt != 1)
 939       break;
 940     // fallthrough
 941   case OP_MUL:
 942     // singleop mul
 943     op->regmask_dst = (1 << xDX) | (1 << xAX);
 944     op->regmask_src |= (1 << xAX);
 945     if (op->operand[0].lmod == OPLM_UNSPEC)
 946       op->operand[0].lmod = OPLM_DWORD;
 947     break;
 948
 949   case OP_DIV:
 950   case OP_IDIV:
 951     // we could set up operands for edx:eax, but there is no real need to
 952     // (see is_opr_modified())
 953     regmask = (1 << xDX) | (1 << xAX);
 954     op->regmask_dst = regmask;
 955     op->regmask_src |= regmask;
 956     if (op->operand[0].lmod == OPLM_UNSPEC)
 957       op->operand[0].lmod = OPLM_DWORD;
 958     break;
 959
 960   case OP_SHL:
 961   case OP_SHR:
 962   case OP_SAR:
 963   case OP_ROL:
 964   case OP_ROR:
 965     if (op->operand[1].lmod == OPLM_UNSPEC)
 966       op->operand[1].lmod = OPLM_BYTE;
 967     break;
 968
 969   case OP_PUSH:
 970     if (op->operand[0].lmod == OPLM_UNSPEC
 971         && (op->operand[0].type == OPT_CONST
 972          || op->operand[0].type == OPT_OFFSET
 973          || op->operand[0].type == OPT_LABEL))
 974       op->operand[0].lmod = OPLM_DWORD;
 975     break;
 976
 977   // alignment
 978   case OP_MOV:
 979     if (op->operand[0].type == OPT_REG && op->operand[1].type == OPT_REG
 980      && op->operand[0].reg == xDI && op->operand[1].reg == xDI)
 981     {
 982       op->flags |= OPF_RMD;
 983     }
 984     break;
 985
 986   case OP_LEA:
 987     if (op->operand[0].type == OPT_REG
 988      && op->operand[1].type == OPT_REGMEM)
 989     {
 990       char buf[16];
 991       snprintf(buf, sizeof(buf), "%s+0", op->operand[0].name);
 992       if (IS(buf, op->operand[1].name))
 993         op->flags |= OPF_RMD;
 994     }
 995     break;
 996
 997   default:
 998     break;
 999   }
1000 }
1001
1002 static const char *op_name(enum op_op op)
1003 {
1004   int i;
1005
1006   for (i = 0; i < ARRAY_SIZE(op_table); i++)
1007     if (op_table[i].op == op)
1008       return op_table[i].name;
1009
1010   return "???";
1011 }
1012
1013 // debug
1014 static const char *dump_op(struct parsed_op *po)
1015 {
1016   static char out[128];
1017   char *p = out;
1018   int i;
1019
1020   if (po == NULL)
1021     return "???";
1022
1023   snprintf(out, sizeof(out), "%s", op_name(po->op));
1024   for (i = 0; i < po->operand_cnt; i++) {
1025     p += strlen(p);
1026     if (i > 0)
1027       *p++ = ',';
1028     snprintf(p, sizeof(out) - (p - out),
1029       po->operand[i].type == OPT_REGMEM ? " [%s]" : " %s",
1030       po->operand[i].name);
1031   }
1032
1033   return out;
1034 }
1035
1036 static const char *lmod_type_u(struct parsed_op *po,
1037   enum opr_lenmod lmod)
1038 {
1039   switch (lmod) {
1040   case OPLM_DWORD:
1041     return "u32";
1042   case OPLM_WORD:
1043     return "u16";
1044   case OPLM_BYTE:
1045     return "u8";
1046   default:
1047     ferr(po, "invalid lmod: %d\n", lmod);
1048     return "(_invalid_)";
1049   }
1050 }
1051
1052 static const char *lmod_cast_u(struct parsed_op *po,
1053   enum opr_lenmod lmod)
1054 {
1055   switch (lmod) {
1056   case OPLM_DWORD:
1057     return "";
1058   case OPLM_WORD:
1059     return "(u16)";
1060   case OPLM_BYTE:
1061     return "(u8)";
1062   default:
1063     ferr(po, "invalid lmod: %d\n", lmod);
1064     return "(_invalid_)";
1065   }
1066 }
1067
1068 static const char *lmod_cast_u_ptr(struct parsed_op *po,
1069   enum opr_lenmod lmod)
1070 {
1071   switch (lmod) {
1072   case OPLM_DWORD:
1073     return "*(u32 *)";
1074   case OPLM_WORD:
1075     return "*(u16 *)";
1076   case OPLM_BYTE:
1077     return "*(u8 *)";
1078   default:
1079     ferr(po, "invalid lmod: %d\n", lmod);
1080     return "(_invalid_)";
1081   }
1082 }
1083
1084 static const char *lmod_cast_s(struct parsed_op *po,
1085   enum opr_lenmod lmod)
1086 {
1087   switch (lmod) {
1088   case OPLM_DWORD:
1089     return "(s32)";
1090   case OPLM_WORD:
1091     return "(s16)";
1092   case OPLM_BYTE:
1093     return "(s8)";
1094   default:
1095     ferr(po, "%s: invalid lmod: %d\n", __func__, lmod);
1096     return "(_invalid_)";
1097   }
1098 }
1099
1100 static const char *lmod_cast(struct parsed_op *po,
1101   enum opr_lenmod lmod, int is_signed)
1102 {
1103   return is_signed ?
1104     lmod_cast_s(po, lmod) :
1105     lmod_cast_u(po, lmod);
1106 }
1107
1108 static int lmod_bytes(struct parsed_op *po, enum opr_lenmod lmod)
1109 {
1110   switch (lmod) {
1111   case OPLM_DWORD:
1112     return 4;
1113   case OPLM_WORD:
1114     return 2;
1115   case OPLM_BYTE:
1116     return 1;
1117   default:
1118     ferr(po, "%s: invalid lmod: %d\n", __func__, lmod);
1119     return 0;
1120   }
1121 }
1122
1123 static const char *opr_name(struct parsed_op *po, int opr_num)
1124 {
1125   if (opr_num >= po->operand_cnt)
1126     ferr(po, "opr OOR: %d/%d\n", opr_num, po->operand_cnt);
1127   return po->operand[opr_num].name;
1128 }
1129
1130 static unsigned int opr_const(struct parsed_op *po, int opr_num)
1131 {
1132   if (opr_num >= po->operand_cnt)
1133     ferr(po, "opr OOR: %d/%d\n", opr_num, po->operand_cnt);
1134   if (po->operand[opr_num].type != OPT_CONST)
1135     ferr(po, "opr %d: const expected\n", opr_num);
1136   return po->operand[opr_num].val;
1137 }
1138
1139 static const char *opr_reg_p(struct parsed_op *po, struct parsed_opr *popr)
1140 {
1141   if ((unsigned int)popr->reg >= MAX_REGS)
1142     ferr(po, "invalid reg: %d\n", popr->reg);
1143   return regs_r32[popr->reg];
1144 }
1145
1146 // cast1 is the "final" cast
1147 static const char *simplify_cast(const char *cast1, const char *cast2)
1148 {
1149   static char buf[256];
1150
1151   if (cast1[0] == 0)
1152     return cast2;
1153   if (cast2[0] == 0)
1154     return cast1;
1155   if (IS(cast1, cast2))
1156     return cast1;
1157   if (IS(cast1, "(s8)") && IS(cast2, "(u8)"))
1158     return cast1;
1159   if (IS(cast1, "(s16)") && IS(cast2, "(u16)"))
1160     return cast1;
1161   if (IS(cast1, "(u8)") && IS_START(cast2, "*(u8 *)"))
1162     return cast2;
1163   if (IS(cast1, "(u16)") && IS_START(cast2, "*(u16 *)"))
1164     return cast2;
1165   if (strchr(cast1, '*') && IS_START(cast2, "(u32)"))
1166     return cast1;
1167
1168   snprintf(buf, sizeof(buf), "%s%s", cast1, cast2);
1169   return buf;
1170 }
1171
1172 static const char *simplify_cast_num(const char *cast, unsigned int val)
1173 {
1174   if (IS(cast, "(u8)") && val < 0x100)
1175     return "";
1176   if (IS(cast, "(s8)") && val < 0x80)
1177     return "";
1178   if (IS(cast, "(u16)") && val < 0x10000)
1179     return "";
1180   if (IS(cast, "(s16)") && val < 0x8000)
1181     return "";
1182   if (IS(cast, "(s32)") && val < 0x80000000)
1183     return "";
1184
1185   return cast;
1186 }
1187
1188 static struct parsed_equ *equ_find(struct parsed_op *po, const char *name,
1189   int *extra_offs)
1190 {
1191   const char *p;
1192   char *endp;
1193   int namelen;
1194   int i;
1195
1196   *extra_offs = 0;
1197   namelen = strlen(name);
1198
1199   p = strchr(name, '+');
1200   if (p != NULL) {
1201     namelen = p - name;
1202     if (namelen <= 0)
1203       ferr(po, "equ parse failed for '%s'\n", name);
1204
1205     if (IS_START(p, "0x"))
1206       p += 2;
1207     *extra_offs = strtol(p, &endp, 16);
1208     if (*endp != 0)
1209       ferr(po, "equ parse failed for '%s'\n", name);
1210   }
1211
1212   for (i = 0; i < g_eqcnt; i++)
1213     if (strncmp(g_eqs[i].name, name, namelen) == 0
1214      && g_eqs[i].name[namelen] == 0)
1215       break;
1216   if (i >= g_eqcnt) {
1217     if (po != NULL)
1218       ferr(po, "unresolved equ name: '%s'\n", name);
1219     return NULL;
1220   }
1221
1222   return &g_eqs[i];
1223 }
1224
1225 static int is_stack_access(struct parsed_op *po,
1226   const struct parsed_opr *popr)
1227 {
1228   return (parse_stack_el(popr->name, NULL)
1229     || (g_bp_frame && !(po->flags & OPF_EBP_S)
1230         && IS_START(popr->name, "ebp")));
1231 }
1232
1233 static void parse_stack_access(struct parsed_op *po,
1234   const char *name, char *ofs_reg, int *offset_out,
1235   int *stack_ra_out, const char **bp_arg_out)
1236 {
1237   const char *bp_arg = "";
1238   const char *p = NULL;
1239   struct parsed_equ *eq;
1240   char *endp = NULL;
1241   int stack_ra = 0;
1242   int offset = 0;
1243
1244   ofs_reg[0] = 0;
1245
1246   if (IS_START(name, "ebp-")
1247    || (IS_START(name, "ebp+") && '0' <= name[4] && name[4] <= '9'))
1248   {
1249     p = name + 4;
1250     if (IS_START(p, "0x"))
1251       p += 2;
1252     offset = strtoul(p, &endp, 16);
1253     if (name[3] == '-')
1254       offset = -offset;
1255     if (*endp != 0)
1256       ferr(po, "ebp- parse of '%s' failed\n", name);
1257   }
1258   else {
1259     bp_arg = parse_stack_el(name, ofs_reg);
1260     snprintf(g_comment, sizeof(g_comment), "%s", bp_arg);
1261     eq = equ_find(po, bp_arg, &offset);
1262     if (eq == NULL)
1263       ferr(po, "detected but missing eq\n");
1264     offset += eq->offset;
1265   }
1266
1267   if (!strncmp(name, "ebp", 3))
1268     stack_ra = 4;
1269
1270   if (ofs_reg[0] == 0 && stack_ra <= offset && offset < stack_ra + 4)
1271     ferr(po, "reference to ra? %d %d\n", offset, stack_ra);
1272
1273   *offset_out = offset;
1274   *stack_ra_out = stack_ra;
1275   if (bp_arg_out)
1276     *bp_arg_out = bp_arg;
1277 }
1278
1279 static void stack_frame_access(struct parsed_op *po,
1280   struct parsed_opr *popr, char *buf, size_t buf_size,
1281   const char *name, const char *cast, int is_src, int is_lea)
1282 {
1283   enum opr_lenmod tmp_lmod = OPLM_UNSPEC;
1284   const char *prefix = "";
1285   const char *bp_arg = NULL;
1286   char ofs_reg[16] = { 0, };
1287   int i, arg_i, arg_s;
1288   int unaligned = 0;
1289   int stack_ra = 0;
1290   int offset = 0;
1291   int sf_ofs;
1292   int lim;
1293
1294   if (po->flags & OPF_EBP_S)
1295     ferr(po, "stack_frame_access while ebp is scratch\n");
1296
1297   parse_stack_access(po, name, ofs_reg, &offset, &stack_ra, &bp_arg);
1298
1299   if (offset > stack_ra)
1300   {
1301     arg_i = (offset - stack_ra - 4) / 4;
1302     if (arg_i < 0 || arg_i >= g_func_pp->argc_stack)
1303     {
1304       if (g_func_pp->is_vararg
1305           && arg_i == g_func_pp->argc_stack && is_lea)
1306       {
1307         // should be va_list
1308         if (cast[0] == 0)
1309           cast = "(u32)";
1310         snprintf(buf, buf_size, "%sap", cast);
1311         return;
1312       }
1313       ferr(po, "offset %d (%s,%d) doesn't map to any arg\n",
1314         offset, bp_arg, arg_i);
1315     }
1316     if (ofs_reg[0] != 0)
1317       ferr(po, "offset reg on arg access?\n");
1318
1319     for (i = arg_s = 0; i < g_func_pp->argc; i++) {
1320       if (g_func_pp->arg[i].reg != NULL)
1321         continue;
1322       if (arg_s == arg_i)
1323         break;
1324       arg_s++;
1325     }
1326     if (i == g_func_pp->argc)
1327       ferr(po, "arg %d not in prototype?\n", arg_i);
1328
1329     popr->is_ptr = g_func_pp->arg[i].type.is_ptr;
1330
1331     switch (popr->lmod)
1332     {
1333     case OPLM_BYTE:
1334       if (is_lea)
1335         ferr(po, "lea/byte to arg?\n");
1336       if (is_src && (offset & 3) == 0)
1337         snprintf(buf, buf_size, "%sa%d",
1338           simplify_cast(cast, "(u8)"), i + 1);
1339       else
1340         snprintf(buf, buf_size, "%sBYTE%d(a%d)",
1341           cast, offset & 3, i + 1);
1342       break;
1343
1344     case OPLM_WORD:
1345       if (is_lea)
1346         ferr(po, "lea/word to arg?\n");
1347       if (offset & 1) {
1348         unaligned = 1;
1349         if (!is_src) {
1350           if (offset & 2)
1351             ferr(po, "problematic arg store\n");
1352           snprintf(buf, buf_size, "%s((char *)&a%d + 1)",
1353             simplify_cast(cast, "*(u16 *)"), i + 1);
1354         }
1355         else
1356           ferr(po, "unaligned arg word load\n");
1357       }
1358       else if (is_src && (offset & 2) == 0)
1359         snprintf(buf, buf_size, "%sa%d",
1360           simplify_cast(cast, "(u16)"), i + 1);
1361       else
1362         snprintf(buf, buf_size, "%s%sWORD(a%d)",
1363           cast, (offset & 2) ? "HI" : "LO", i + 1);
1364       break;
1365
1366     case OPLM_DWORD:
1367       if (cast[0])
1368         prefix = cast;
1369       else if (is_src)
1370         prefix = "(u32)";
1371
1372       if (offset & 3) {
1373         unaligned = 1;
1374         if (is_lea)
1375           snprintf(buf, buf_size, "(u32)&a%d + %d",
1376             i + 1, offset & 3);
1377         else if (!is_src)
1378           ferr(po, "unaligned arg store\n");
1379         else {
1380           // mov edx, [ebp+arg_4+2]; movsx ecx, dx
1381           snprintf(buf, buf_size, "%s(a%d >> %d)",
1382             prefix, i + 1, (offset & 3) * 8);
1383         }
1384       }
1385       else {
1386         snprintf(buf, buf_size, "%s%sa%d",
1387           prefix, is_lea ? "&" : "", i + 1);
1388       }
1389       break;
1390
1391     default:
1392       ferr(po, "bp_arg bad lmod: %d\n", popr->lmod);
1393     }
1394
1395     if (unaligned)
1396       snprintf(g_comment, sizeof(g_comment), "%s unaligned", bp_arg);
1397
1398     // common problem
1399     guess_lmod_from_c_type(&tmp_lmod, &g_func_pp->arg[i].type);
1400     if (tmp_lmod != OPLM_DWORD
1401       && (unaligned || (!is_src && tmp_lmod < popr->lmod)))
1402     {
1403       ferr(po, "bp_arg arg%d/w offset %d and type '%s' is too small\n",
1404         i + 1, offset, g_func_pp->arg[i].type.name);
1405     }
1406   }
1407   else
1408   {
1409     if (g_stack_fsz == 0)
1410       ferr(po, "stack var access without stackframe\n");
1411     g_stack_frame_used = 1;
1412
1413     sf_ofs = g_stack_fsz + offset;
1414     lim = (ofs_reg[0] != 0) ? -4 : 0;
1415     if (offset > 0 || sf_ofs < lim)
1416       ferr(po, "bp_stack offset %d/%d\n", offset, g_stack_fsz);
1417
1418     if (is_lea)
1419       prefix = "(u32)&";
1420     else
1421       prefix = cast;
1422
1423     switch (popr->lmod)
1424     {
1425     case OPLM_BYTE:
1426       snprintf(buf, buf_size, "%ssf.b[%d%s%s]",
1427         prefix, sf_ofs, ofs_reg[0] ? "+" : "", ofs_reg);
1428       break;
1429
1430     case OPLM_WORD:
1431       if ((sf_ofs & 1) || ofs_reg[0] != 0) {
1432         // known unaligned or possibly unaligned
1433         strcat(g_comment, " unaligned");
1434         if (prefix[0] == 0)
1435           prefix = "*(u16 *)&";
1436         snprintf(buf, buf_size, "%ssf.b[%d%s%s]",
1437           prefix, sf_ofs, ofs_reg[0] ? "+" : "", ofs_reg);
1438         break;
1439       }
1440       snprintf(buf, buf_size, "%ssf.w[%d]", prefix, sf_ofs / 2);
1441       break;
1442
1443     case OPLM_DWORD:
1444       if ((sf_ofs & 3) || ofs_reg[0] != 0) {
1445         // known unaligned or possibly unaligned
1446         strcat(g_comment, " unaligned");
1447         if (prefix[0] == 0)
1448           prefix = "*(u32 *)&";
1449         snprintf(buf, buf_size, "%ssf.b[%d%s%s]",
1450           prefix, sf_ofs, ofs_reg[0] ? "+" : "", ofs_reg);
1451         break;
1452       }
1453       snprintf(buf, buf_size, "%ssf.d[%d]", prefix, sf_ofs / 4);
1454       break;
1455
1456     default:
1457       ferr(po, "bp_stack bad lmod: %d\n", popr->lmod);
1458     }
1459   }
1460 }
1461
1462 static void check_label_read_ref(struct parsed_op *po, const char *name)
1463 {
1464   const struct parsed_proto *pp;
1465
1466   pp = proto_parse(g_fhdr, name);
1467   if (pp == NULL)
1468     ferr(po, "proto_parse failed for ref '%s'\n", name);
1469
1470   // currently we can take __cdecl and __stdcall
1471   if (pp->is_func && pp->argc_reg != 0)
1472     ferr(po, "reg-arg func reference?\n");
1473 }
1474
1475 static char *out_src_opr(char *buf, size_t buf_size,
1476         struct parsed_op *po, struct parsed_opr *popr, const char *cast,
1477   int is_lea)
1478 {
1479   char tmp1[256], tmp2[256];
1480   char expr[256];
1481   char *p;
1482   int ret;
1483
1484   if (cast == NULL)
1485     cast = "";
1486
1487   switch (popr->type) {
1488   case OPT_REG:
1489     if (is_lea)
1490       ferr(po, "lea from reg?\n");
1491
1492     switch (popr->lmod) {
1493     case OPLM_DWORD:
1494       snprintf(buf, buf_size, "%s%s", cast, opr_reg_p(po, popr));
1495       break;
1496     case OPLM_WORD:
1497       snprintf(buf, buf_size, "%s%s",
1498         simplify_cast(cast, "(u16)"), opr_reg_p(po, popr));
1499       break;
1500     case OPLM_BYTE:
1501       if (popr->name[1] == 'h') // XXX..
1502         snprintf(buf, buf_size, "%s(%s >> 8)",
1503           simplify_cast(cast, "(u8)"), opr_reg_p(po, popr));
1504       else
1505         snprintf(buf, buf_size, "%s%s",
1506           simplify_cast(cast, "(u8)"), opr_reg_p(po, popr));
1507       break;
1508     default:
1509       ferr(po, "invalid src lmod: %d\n", popr->lmod);
1510     }
1511     break;
1512
1513   case OPT_REGMEM:
1514     if (is_stack_access(po, popr)) {
1515       stack_frame_access(po, popr, buf, buf_size,
1516         popr->name, cast, 1, is_lea);
1517       break;
1518     }
1519
1520     strcpy(expr, popr->name);
1521     if (strchr(expr, '[')) {
1522       // special case: '[' can only be left for label[reg] form
1523       ret = sscanf(expr, "%[^[][%[^]]]", tmp1, tmp2);
1524       if (ret != 2)
1525         ferr(po, "parse failure for '%s'\n", expr);
1526       if (tmp1[0] == '(') {
1527         // (off_4FFF50+3)[eax]
1528         p = strchr(tmp1 + 1, ')');
1529         if (p == NULL || p[1] != 0)
1530           ferr(po, "parse failure (2) for '%s'\n", expr);
1531         *p = 0;
1532         memmove(tmp1, tmp1 + 1, strlen(tmp1));
1533       }
1534       snprintf(expr, sizeof(expr), "(u32)&%s + %s", tmp1, tmp2);
1535     }
1536
1537     // XXX: do we need more parsing?
1538     if (is_lea) {
1539       snprintf(buf, buf_size, "%s", expr);
1540       break;
1541     }
1542
1543     snprintf(buf, buf_size, "%s(%s)",
1544       simplify_cast(cast, lmod_cast_u_ptr(po, popr->lmod)), expr);
1545     break;
1546
1547   case OPT_LABEL:
1548     check_label_read_ref(po, popr->name);
1549     if (cast[0] == 0 && popr->is_ptr)
1550       cast = "(u32)";
1551
1552     if (is_lea)
1553       snprintf(buf, buf_size, "(u32)&%s", popr->name);
1554     else if (popr->size_lt)
1555       snprintf(buf, buf_size, "%s%s%s%s", cast,
1556         lmod_cast_u_ptr(po, popr->lmod),
1557         popr->is_array ? "" : "&",
1558         popr->name);
1559     else
1560       snprintf(buf, buf_size, "%s%s%s", cast, popr->name,
1561         popr->is_array ? "[0]" : "");
1562     break;
1563
1564   case OPT_OFFSET:
1565     check_label_read_ref(po, popr->name);
1566     if (cast[0] == 0)
1567       cast = "(u32)";
1568     if (is_lea)
1569       ferr(po, "lea an offset?\n");
1570     snprintf(buf, buf_size, "%s&%s", cast, popr->name);
1571     break;
1572
1573   case OPT_CONST:
1574     if (is_lea)
1575       ferr(po, "lea from const?\n");
1576
1577     printf_number(tmp1, sizeof(tmp1), popr->val);
1578     snprintf(buf, buf_size, "%s%s",
1579       simplify_cast_num(cast, popr->val), tmp1);
1580     break;
1581
1582   default:
1583     ferr(po, "invalid src type: %d\n", popr->type);
1584   }
1585
1586   return buf;
1587 }
1588
1589 // note: may set is_ptr (we find that out late for ebp frame..)
1590 static char *out_dst_opr(char *buf, size_t buf_size,
1591         struct parsed_op *po, struct parsed_opr *popr)
1592 {
1593   switch (popr->type) {
1594   case OPT_REG:
1595     switch (popr->lmod) {
1596     case OPLM_DWORD:
1597       snprintf(buf, buf_size, "%s", opr_reg_p(po, popr));
1598       break;
1599     case OPLM_WORD:
1600       // ugh..
1601       snprintf(buf, buf_size, "LOWORD(%s)", opr_reg_p(po, popr));
1602       break;
1603     case OPLM_BYTE:
1604       // ugh..
1605       if (popr->name[1] == 'h') // XXX..
1606         snprintf(buf, buf_size, "BYTE1(%s)", opr_reg_p(po, popr));
1607       else
1608         snprintf(buf, buf_size, "LOBYTE(%s)", opr_reg_p(po, popr));
1609       break;
1610     default:
1611       ferr(po, "invalid dst lmod: %d\n", popr->lmod);
1612     }
1613     break;
1614
1615   case OPT_REGMEM:
1616     if (is_stack_access(po, popr)) {
1617       stack_frame_access(po, popr, buf, buf_size,
1618         popr->name, "", 0, 0);
1619       break;
1620     }
1621
1622     return out_src_opr(buf, buf_size, po, popr, NULL, 0);
1623
1624   case OPT_LABEL:
1625     if (popr->size_mismatch)
1626       snprintf(buf, buf_size, "%s%s%s",
1627         lmod_cast_u_ptr(po, popr->lmod),
1628         popr->is_array ? "" : "&", popr->name);
1629     else
1630       snprintf(buf, buf_size, "%s%s", popr->name,
1631         popr->is_array ? "[0]" : "");
1632     break;
1633
1634   default:
1635     ferr(po, "invalid dst type: %d\n", popr->type);
1636   }
1637
1638   return buf;
1639 }
1640
1641 static char *out_src_opr_u32(char *buf, size_t buf_size,
1642         struct parsed_op *po, struct parsed_opr *popr)
1643 {
1644   return out_src_opr(buf, buf_size, po, popr, NULL, 0);
1645 }
1646
1647 static enum parsed_flag_op split_cond(struct parsed_op *po,
1648   enum op_op op, int *is_inv)
1649 {
1650   *is_inv = 0;
1651
1652   switch (op) {
1653   case OP_JO:
1654     return PFO_O;
1655   case OP_JC:
1656     return PFO_C;
1657   case OP_JZ:
1658     return PFO_Z;
1659   case OP_JBE:
1660     return PFO_BE;
1661   case OP_JS:
1662     return PFO_S;
1663   case OP_JP:
1664     return PFO_P;
1665   case OP_JL:
1666     return PFO_L;
1667   case OP_JLE:
1668     return PFO_LE;
1669
1670   case OP_JNO:
1671     *is_inv = 1;
1672     return PFO_O;
1673   case OP_JNC:
1674     *is_inv = 1;
1675     return PFO_C;
1676   case OP_JNZ:
1677     *is_inv = 1;
1678     return PFO_Z;
1679   case OP_JA:
1680     *is_inv = 1;
1681     return PFO_BE;
1682   case OP_JNS:
1683     *is_inv = 1;
1684     return PFO_S;
1685   case OP_JNP:
1686     *is_inv = 1;
1687     return PFO_P;
1688   case OP_JGE:
1689     *is_inv = 1;
1690     return PFO_L;
1691   case OP_JG:
1692     *is_inv = 1;
1693     return PFO_LE;
1694
1695   case OP_ADC:
1696   case OP_SBB:
1697     return PFO_C;
1698
1699   default:
1700     ferr(po, "split_cond: bad op %d\n", op);
1701     return -1;
1702   }
1703 }
1704
1705 static void out_test_for_cc(char *buf, size_t buf_size,
1706   struct parsed_op *po, enum parsed_flag_op pfo, int is_inv,
1707   enum opr_lenmod lmod, const char *expr)
1708 {
1709   const char *cast, *scast;
1710
1711   cast = lmod_cast_u(po, lmod);
1712   scast = lmod_cast_s(po, lmod);
1713
1714   switch (pfo) {
1715   case PFO_Z:
1716   case PFO_BE: // CF=1||ZF=1; CF=0
1717     snprintf(buf, buf_size, "(%s%s %s 0)",
1718       cast, expr, is_inv ? "!=" : "==");
1719     break;
1720
1721   case PFO_S:
1722   case PFO_L: // SF!=OF; OF=0
1723     snprintf(buf, buf_size, "(%s%s %s 0)",
1724       scast, expr, is_inv ? ">=" : "<");
1725     break;
1726
1727   case PFO_LE: // ZF=1||SF!=OF; OF=0
1728     snprintf(buf, buf_size, "(%s%s %s 0)",
1729       scast, expr, is_inv ? ">" : "<=");
1730     break;
1731
1732   default:
1733     ferr(po, "%s: unhandled parsed_flag_op: %d\n", __func__, pfo);
1734   }
1735 }
1736
1737 static void out_cmp_for_cc(char *buf, size_t buf_size,
1738   struct parsed_op *po, enum parsed_flag_op pfo, int is_inv)
1739 {
1740   const char *cast, *scast, *cast_use;
1741   char buf1[256], buf2[256];
1742   enum opr_lenmod lmod;
1743
1744   if (po->operand[0].lmod != po->operand[1].lmod)
1745     ferr(po, "%s: lmod mismatch: %d %d\n", __func__,
1746       po->operand[0].lmod, po->operand[1].lmod);
1747   lmod = po->operand[0].lmod;
1748
1749   cast = lmod_cast_u(po, lmod);
1750   scast = lmod_cast_s(po, lmod);
1751
1752   switch (pfo) {
1753   case PFO_C:
1754   case PFO_Z:
1755   case PFO_BE: // !a
1756     cast_use = cast;
1757     break;
1758
1759   case PFO_S:
1760   case PFO_L: // !ge
1761   case PFO_LE:
1762     cast_use = scast;
1763     break;
1764
1765   default:
1766     ferr(po, "%s: unhandled parsed_flag_op: %d\n", __func__, pfo);
1767   }
1768
1769   out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], cast_use, 0);
1770   out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], cast_use, 0);
1771
1772   switch (pfo) {
1773   case PFO_C:
1774     // note: must be unsigned compare
1775     snprintf(buf, buf_size, "(%s %s %s)",
1776       buf1, is_inv ? ">=" : "<", buf2);
1777     break;
1778
1779   case PFO_Z:
1780     snprintf(buf, buf_size, "(%s %s %s)",
1781       buf1, is_inv ? "!=" : "==", buf2);
1782     break;
1783
1784   case PFO_BE: // !a
1785     // note: must be unsigned compare
1786     snprintf(buf, buf_size, "(%s %s %s)",
1787       buf1, is_inv ? ">" : "<=", buf2);
1788
1789     // annoying case
1790     if (is_inv && lmod == OPLM_BYTE
1791       && po->operand[1].type == OPT_CONST
1792       && po->operand[1].val == 0xff)
1793     {
1794       snprintf(g_comment, sizeof(g_comment), "if %s", buf);
1795       snprintf(buf, buf_size, "(0)");
1796     }
1797     break;
1798
1799   // note: must be signed compare
1800   case PFO_S:
1801     snprintf(buf, buf_size, "(%s(%s - %s) %s 0)",
1802       scast, buf1, buf2, is_inv ? ">=" : "<");
1803     break;
1804
1805   case PFO_L: // !ge
1806     snprintf(buf, buf_size, "(%s %s %s)",
1807       buf1, is_inv ? ">=" : "<", buf2);
1808     break;
1809
1810   case PFO_LE:
1811     snprintf(buf, buf_size, "(%s %s %s)",
1812       buf1, is_inv ? ">" : "<=", buf2);
1813     break;
1814
1815   default:
1816     break;
1817   }
1818 }
1819
1820 static void out_cmp_test(char *buf, size_t buf_size,
1821   struct parsed_op *po, enum parsed_flag_op pfo, int is_inv)
1822 {
1823   char buf1[256], buf2[256], buf3[256];
1824
1825   if (po->op == OP_TEST) {
1826     if (IS(opr_name(po, 0), opr_name(po, 1))) {
1827       out_src_opr_u32(buf3, sizeof(buf3), po, &po->operand[0]);
1828     }
1829     else {
1830       out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]);
1831       out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]);
1832       snprintf(buf3, sizeof(buf3), "(%s & %s)", buf1, buf2);
1833     }
1834     out_test_for_cc(buf, buf_size, po, pfo, is_inv,
1835       po->operand[0].lmod, buf3);
1836   }
1837   else if (po->op == OP_CMP) {
1838     out_cmp_for_cc(buf, buf_size, po, pfo, is_inv);
1839   }
1840   else
1841     ferr(po, "%s: unhandled op: %d\n", __func__, po->op);
1842 }
1843
1844 static void propagate_lmod(struct parsed_op *po, struct parsed_opr *popr1,
1845         struct parsed_opr *popr2)
1846 {
1847   if (popr1->lmod == OPLM_UNSPEC && popr2->lmod == OPLM_UNSPEC)
1848     ferr(po, "missing lmod for both operands\n");
1849
1850   if (popr1->lmod == OPLM_UNSPEC)
1851     popr1->lmod = popr2->lmod;
1852   else if (popr2->lmod == OPLM_UNSPEC)
1853     popr2->lmod = popr1->lmod;
1854   else if (popr1->lmod != popr2->lmod) {
1855     if (popr1->type_from_var) {
1856       popr1->size_mismatch = 1;
1857       if (popr1->lmod < popr2->lmod)
1858         popr1->size_lt = 1;
1859       popr1->lmod = popr2->lmod;
1860     }
1861     else if (popr2->type_from_var) {
1862       popr2->size_mismatch = 1;
1863       if (popr2->lmod < popr1->lmod)
1864         popr2->size_lt = 1;
1865       popr2->lmod = popr1->lmod;
1866     }
1867     else
1868       ferr(po, "conflicting lmods: %d vs %d\n",
1869         popr1->lmod, popr2->lmod);
1870   }
1871 }
1872
1873 static const char *op_to_c(struct parsed_op *po)
1874 {
1875   switch (po->op)
1876   {
1877     case OP_ADD:
1878     case OP_ADC:
1879       return "+";
1880     case OP_SUB:
1881     case OP_SBB:
1882       return "-";
1883     case OP_AND:
1884       return "&";
1885     case OP_OR:
1886       return "|";
1887     case OP_XOR:
1888       return "^";
1889     case OP_SHL:
1890       return "<<";
1891     case OP_SHR:
1892       return ">>";
1893     case OP_MUL:
1894     case OP_IMUL:
1895       return "*";
1896     default:
1897       ferr(po, "op_to_c was supplied with %d\n", po->op);
1898   }
1899 }
1900
1901 static void op_set_clear_flag(struct parsed_op *po,
1902   enum op_flags flag_set, enum op_flags flag_clear)
1903 {
1904   po->flags |= flag_set;
1905   po->flags &= ~flag_clear;
1906 }
1907
1908 // last op in stream - unconditional branch or ret
1909 #define LAST_OP(_i) ((ops[_i].flags & OPF_TAIL) \
1910   || (ops[_i].flags & (OPF_JMP|OPF_CC)) == OPF_JMP)
1911
1912 static int scan_for_pop(int i, int opcnt, const char *reg,
1913   int magic, int depth, int *maxdepth, int do_flags)
1914 {
1915   struct parsed_op *po;
1916   int ret = 0;
1917   int j;
1918
1919   for (; i < opcnt; i++) {
1920     po = &ops[i];
1921     if (po->cc_scratch == magic)
1922       break; // already checked
1923     po->cc_scratch = magic;
1924
1925     if (po->flags & OPF_TAIL)
1926       return -1; // deadend
1927
1928     if ((po->flags & OPF_RMD)
1929         || (po->op == OP_PUSH && po->argnum != 0)) // arg push
1930       continue;
1931
1932     if ((po->flags & OPF_JMP) && po->op != OP_CALL) {
1933       if (po->btj != NULL) {
1934         // jumptable
1935         for (j = 0; j < po->btj->count - 1; j++) {
1936           ret |= scan_for_pop(po->btj->d[j].bt_i, opcnt, reg, magic,
1937                    depth, maxdepth, do_flags);
1938           if (ret < 0)
1939             return ret; // dead end
1940         }
1941         // follow last jumptable entry
1942         i = po->btj->d[j].bt_i - 1;
1943         continue;
1944       }
1945
1946       if (po->bt_i < 0) {
1947         ferr(po, "dead branch\n");
1948         return -1;
1949       }
1950
1951       if (po->flags & OPF_CC) {
1952         ret |= scan_for_pop(po->bt_i, opcnt, reg, magic,
1953                  depth, maxdepth, do_flags);
1954         if (ret < 0)
1955           return ret; // dead end
1956       }
1957       else {
1958         i = po->bt_i - 1;
1959       }
1960       continue;
1961     }
1962
1963     if ((po->op == OP_POP || po->op == OP_PUSH)
1964         && po->operand[0].type == OPT_REG
1965         && IS(po->operand[0].name, reg))
1966     {
1967       if (po->op == OP_PUSH) {
1968         depth++;
1969         if (depth > *maxdepth)
1970           *maxdepth = depth;
1971         if (do_flags)
1972           op_set_clear_flag(po, OPF_RSAVE, OPF_RMD);
1973       }
1974       else if (depth == 0) {
1975         if (do_flags)
1976           op_set_clear_flag(po, OPF_RMD, OPF_RSAVE);
1977         return 1;
1978       }
1979       else {
1980         depth--;
1981         if (depth < 0) // should not happen
1982           ferr(po, "fail with depth\n");
1983         if (do_flags)
1984           op_set_clear_flag(po, OPF_RSAVE, OPF_RMD);
1985       }
1986     }
1987   }
1988
1989   return ret;
1990 }
1991
1992 // scan for pop starting from 'ret' op (all paths)
1993 static int scan_for_pop_ret(int i, int opcnt, const char *reg,
1994   int flag_set)
1995 {
1996   int found = 0;
1997   int j;
1998
1999   for (; i < opcnt; i++) {
2000     if (!(ops[i].flags & OPF_TAIL))
2001       continue;
2002
2003     for (j = i - 1; j >= 0; j--) {
2004       if (ops[j].flags & OPF_RMD)
2005         continue;
2006       if (ops[j].flags & OPF_JMP)
2007         return -1;
2008
2009       if (ops[j].op == OP_POP && ops[j].operand[0].type == OPT_REG
2010           && IS(ops[j].operand[0].name, reg))
2011       {
2012         found = 1;
2013         ops[j].flags |= flag_set;
2014         break;
2015       }
2016
2017       if (g_labels[j][0] != 0)
2018         return -1;
2019     }
2020   }
2021
2022   return found ? 0 : -1;
2023 }
2024
2025 // is operand 'opr' modified by parsed_op 'po'?
2026 static int is_opr_modified(const struct parsed_opr *opr,
2027   const struct parsed_op *po)
2028 {
2029   if ((po->flags & OPF_RMD) || !(po->flags & OPF_DATA))
2030     return 0;
2031
2032   if (opr->type == OPT_REG && po->operand[0].type == OPT_REG) {
2033     if (po->regmask_dst & (1 << opr->reg))
2034       return 1;
2035     else
2036       return 0;
2037   }
2038
2039   return IS(po->operand[0].name, opr->name);
2040 }
2041
2042 // is any operand of parsed_op 'po_test' modified by parsed_op 'po'?
2043 static int is_any_opr_modified(const struct parsed_op *po_test,
2044   const struct parsed_op *po)
2045 {
2046   int i;
2047
2048   if ((po->flags & OPF_RMD) || !(po->flags & OPF_DATA))
2049     return 0;
2050
2051   if (po_test->operand_cnt == 1 && po_test->operand[0].type == OPT_CONST)
2052     return 0;
2053
2054   if ((po_test->regmask_src | po_test->regmask_dst) & po->regmask_dst)
2055     return 1;
2056
2057   // in reality, it can wreck any register, but in decompiled C
2058   // version it can only overwrite eax or edx:eax
2059   if (po->op == OP_CALL
2060    && ((po_test->regmask_src | po_test->regmask_dst)
2061        & ((1 << xAX)|(1 << xDX))))
2062     return 1;
2063
2064   for (i = 0; i < po_test->operand_cnt; i++)
2065     if (IS(po_test->operand[i].name, po->operand[0].name))
2066       return 1;
2067
2068   return 0;
2069 }
2070
2071 // scan for any po_test operand modification in range given
2072 static int scan_for_mod(struct parsed_op *po_test, int i, int opcnt)
2073 {
2074   if (po_test->operand_cnt == 1 && po_test->operand[0].type == OPT_CONST)
2075     return -1;
2076
2077   for (; i < opcnt; i++) {
2078     if (is_any_opr_modified(po_test, &ops[i]))
2079       return i;
2080   }
2081
2082   return -1;
2083 }
2084
2085 // scan for po_test operand[0] modification in range given
2086 static int scan_for_mod_opr0(struct parsed_op *po_test,
2087   int i, int opcnt)
2088 {
2089   for (; i < opcnt; i++) {
2090     if (is_opr_modified(&po_test->operand[0], &ops[i]))
2091       return i;
2092   }
2093
2094   return -1;
2095 }
2096
2097 static int scan_for_flag_set(int i, int magic, int *branched,
2098   int *setters, int *setter_cnt)
2099 {
2100   struct label_ref *lr;
2101   int ret;
2102
2103   while (i >= 0) {
2104     if (ops[i].cc_scratch == magic) {
2105       ferr(&ops[i], "%s looped\n", __func__);
2106       return -1;
2107     }
2108     ops[i].cc_scratch = magic;
2109
2110     if (g_labels[i][0] != 0) {
2111       *branched = 1;
2112
2113       lr = &g_label_refs[i];
2114       for (; lr->next; lr = lr->next) {
2115         ret = scan_for_flag_set(lr->i, magic,
2116                 branched, setters, setter_cnt);
2117         if (ret < 0)
2118           return ret;
2119       }
2120
2121       if (i > 0 && LAST_OP(i - 1)) {
2122         i = lr->i;
2123         continue;
2124       }
2125       ret = scan_for_flag_set(lr->i, magic,
2126               branched, setters, setter_cnt);
2127       if (ret < 0)
2128         return ret;
2129     }
2130     i--;
2131
2132     if (ops[i].flags & OPF_FLAGS) {
2133       setters[*setter_cnt] = i;
2134       (*setter_cnt)++;
2135       return 0;
2136     }
2137
2138     if ((ops[i].flags & OPF_JMP) && !(ops[i].flags & OPF_CC))
2139       return -1;
2140   }
2141
2142   return -1;
2143 }
2144
2145 // scan back for cdq, if anything modifies edx, fail
2146 static int scan_for_cdq_edx(int i)
2147 {
2148   while (i >= 0) {
2149     if (g_labels[i][0] != 0) {
2150       if (g_label_refs[i].next != NULL)
2151         return -1;
2152       if (i > 0 && LAST_OP(i - 1)) {
2153         i = g_label_refs[i].i;
2154         continue;
2155       }
2156       return -1;
2157     }
2158     i--;
2159
2160     if (ops[i].op == OP_CDQ)
2161       return i;
2162
2163     if (ops[i].regmask_dst & (1 << xDX))
2164       return -1;
2165     if (g_labels[i][0] != 0)
2166       return -1;
2167   }
2168
2169   return -1;
2170 }
2171
2172 static int scan_for_reg_clear(int i, int reg)
2173 {
2174   while (i >= 0) {
2175     if (g_labels[i][0] != 0) {
2176       if (g_label_refs[i].next != NULL)
2177         return -1;
2178       if (i > 0 && LAST_OP(i - 1)) {
2179         i = g_label_refs[i].i;
2180         continue;
2181       }
2182       return -1;
2183     }
2184     i--;
2185
2186     if (ops[i].op == OP_XOR
2187      && ops[i].operand[0].lmod == OPLM_DWORD
2188      && ops[i].operand[0].reg == ops[i].operand[1].reg
2189      && ops[i].operand[0].reg == reg)
2190       return i;
2191
2192     if (ops[i].regmask_dst & (1 << reg))
2193       return -1;
2194     if (g_labels[i][0] != 0)
2195       return -1;
2196   }
2197
2198   return -1;
2199 }
2200
2201 // scan for positive, constant esp adjust
2202 static int scan_for_esp_adjust(int i, int opcnt, int *adj)
2203 {
2204   struct parsed_op *po;
2205   int i_first = i;
2206   *adj = 0;
2207
2208   for (; i < opcnt; i++) {
2209     po = &ops[i];
2210
2211     if (g_labels[i][0] != 0)
2212       break;
2213
2214     if (po->op == OP_ADD && po->operand[0].reg == xSP) {
2215       if (po->operand[1].type != OPT_CONST)
2216         ferr(&ops[i], "non-const esp adjust?\n");
2217       *adj += po->operand[1].val;
2218       if (*adj & 3)
2219         ferr(&ops[i], "unaligned esp adjust: %x\n", *adj);
2220       return i;
2221     }
2222     else if (po->op == OP_PUSH)
2223       *adj -= lmod_bytes(po, po->operand[0].lmod);
2224     else if (po->op == OP_POP)
2225       *adj += lmod_bytes(po, po->operand[0].lmod);
2226     else if (po->flags & (OPF_JMP|OPF_TAIL)) {
2227       if (po->op != OP_CALL)
2228         break;
2229       if (po->operand[0].type != OPT_LABEL)
2230         break;
2231       // TODO: should only allow combining __cdecl calls..
2232     }
2233   }
2234
2235   if (*adj == 4 && ops[i_first].op == OP_POP
2236     && ops[i_first].operand[0].type == OPT_REG
2237     && ops[i_first].operand[0].reg == xCX)
2238   {
2239     // probably 'pop ecx' was used..
2240     return i_first;
2241   }
2242
2243   return -1;
2244 }
2245
2246 static void scan_fwd_set_flags(int i, int opcnt, int magic, int flags)
2247 {
2248   struct parsed_op *po;
2249   int j;
2250
2251   if (i < 0)
2252     ferr(ops, "%s: followed bad branch?\n", __func__);
2253
2254   for (; i < opcnt; i++) {
2255     po = &ops[i];
2256     if (po->cc_scratch == magic)
2257       return;
2258     po->cc_scratch = magic;
2259     po->flags |= flags;
2260
2261     if ((po->flags & OPF_JMP) && po->op != OP_CALL) {
2262       if (po->btj != NULL) {
2263         // jumptable
2264         for (j = 0; j < po->btj->count; j++)
2265           scan_fwd_set_flags(po->btj->d[j].bt_i, opcnt, magic, flags);
2266         return;
2267       }
2268
2269       scan_fwd_set_flags(po->bt_i, opcnt, magic, flags);
2270       if (!(po->flags & OPF_CC))
2271         return;
2272     }
2273     if (po->flags & OPF_TAIL)
2274       return;
2275   }
2276 }
2277
2278 static const struct parsed_proto *try_recover_pp(
2279   struct parsed_op *po, const struct parsed_opr *opr)
2280 {
2281   const struct parsed_proto *pp = NULL;
2282
2283   // maybe an arg of g_func?
2284   if (opr->type == OPT_REGMEM && is_stack_access(po, opr))
2285   {
2286     char ofs_reg[16] = { 0, };
2287     int arg, arg_s, arg_i;
2288     int stack_ra = 0;
2289     int offset = 0;
2290
2291     parse_stack_access(po, opr->name, ofs_reg,
2292       &offset, &stack_ra, NULL);
2293     if (ofs_reg[0] != 0)
2294       ferr(po, "offset reg on arg access?\n");
2295     if (offset <= stack_ra)
2296       ferr(po, "stack var call unhandled yet\n");
2297
2298     arg_i = (offset - stack_ra - 4) / 4;
2299     for (arg = arg_s = 0; arg < g_func_pp->argc; arg++) {
2300       if (g_func_pp->arg[arg].reg != NULL)
2301         continue;
2302       if (arg_s == arg_i)
2303         break;
2304       arg_s++;
2305     }
2306     if (arg == g_func_pp->argc)
2307       ferr(po, "stack arg %d not in prototype?\n", arg_i);
2308
2309     pp = g_func_pp->arg[arg].fptr;
2310     if (pp == NULL)
2311       ferr(po, "icall: arg%d is not a fptr?\n", arg + 1);
2312     if (pp->argc_reg != 0)
2313       ferr(po, "icall: reg arg in arg-call unhandled yet\n");
2314   }
2315   else if (opr->type == OPT_OFFSET || opr->type == OPT_LABEL) {
2316     pp = proto_parse(g_fhdr, opr->name);
2317     if (pp == NULL)
2318       ferr(po, "proto_parse failed for icall from '%s'\n", opr->name);
2319     if (pp->argc_reg != 0)
2320       ferr(po, "arg-call unhandled yet for '%s'\n", opr->name);
2321   }
2322
2323   return pp;
2324 }
2325
2326 static void scan_for_call_type(int i, struct parsed_opr *opr,
2327   int magic, const struct parsed_proto **pp_found)
2328 {
2329   const struct parsed_proto *pp = NULL;
2330   struct parsed_op *po;
2331   struct label_ref *lr;
2332
2333   while (i >= 0) {
2334     if (ops[i].cc_scratch == magic)
2335       return;
2336     ops[i].cc_scratch = magic;
2337
2338     if (g_labels[i][0] != 0) {
2339       lr = &g_label_refs[i];
2340       for (; lr != NULL; lr = lr->next)
2341         scan_for_call_type(lr->i, opr, magic, pp_found);
2342       if (i > 0) {
2343         if (LAST_OP(i - 1))
2344           return;
2345         scan_for_call_type(i - 1, opr, magic, pp_found);
2346       }
2347       return;
2348     }
2349     i--;
2350
2351     if (!(ops[i].flags & OPF_DATA))
2352       continue;
2353     if (!is_opr_modified(opr, &ops[i]))
2354       continue;
2355     if (ops[i].op != OP_MOV && ops[i].op != OP_LEA) {
2356       // most probably trashed by some processing
2357       *pp_found = NULL;
2358       return;
2359     }
2360
2361     opr = &ops[i].operand[1];
2362     if (opr->type != OPT_REG)
2363       break;
2364   }
2365
2366   po = (i >= 0) ? &ops[i] : ops;
2367
2368   if (i < 0) {
2369     // reached the top - can only be an arg-reg
2370     if (opr->type != OPT_REG)
2371       return;
2372
2373     for (i = 0; i < g_func_pp->argc; i++) {
2374       if (g_func_pp->arg[i].reg == NULL)
2375         continue;
2376       if (IS(opr->name, g_func_pp->arg[i].reg))
2377         break;
2378     }
2379     if (i == g_func_pp->argc)
2380       return;
2381     pp = g_func_pp->arg[i].fptr;
2382     if (pp == NULL)
2383       ferr(po, "icall: arg%d is not a fptr?\n", i + 1);
2384     if (pp->argc_reg != 0)
2385       ferr(po, "icall: reg arg in arg-call unhandled yet\n");
2386   }
2387   else
2388     pp = try_recover_pp(po, opr);
2389
2390   if (*pp_found != NULL && pp != NULL) {
2391     if (!IS((*pp_found)->ret_type.name, pp->ret_type.name)
2392       || (*pp_found)->is_stdcall != pp->is_stdcall
2393       || (*pp_found)->argc != pp->argc
2394       || (*pp_found)->argc_reg != pp->argc_reg
2395       || (*pp_found)->argc_stack != pp->argc_stack)
2396     {
2397       ferr(po, "icall: parsed_proto mismatch\n");
2398     }
2399   }
2400   if (pp != NULL)
2401     *pp_found = pp;
2402 }
2403
2404 static const struct parsed_proto *resolve_call(int i, int opcnt)
2405 {
2406   const struct parsed_proto *pp = NULL;
2407
2408   switch (ops[i].operand[0].type) {
2409   case OPT_REGMEM:
2410   case OPT_LABEL:
2411   case OPT_OFFSET:
2412     pp = try_recover_pp(&ops[i], &ops[i].operand[0]);
2413     break;
2414   default:
2415     scan_for_call_type(i, &ops[i].operand[0], i + opcnt * 9, &pp);
2416     break;
2417   }
2418
2419   return pp;
2420 }
2421
2422 static int collect_call_args(struct parsed_op *po, int i,
2423   struct parsed_proto *pp, int *save_arg_vars, int arg,
2424   int magic, int need_op_saving, int may_reuse)
2425 {
2426   struct parsed_proto *pp_tmp;
2427   struct label_ref *lr;
2428   int need_to_save_current;
2429   int ret = 0;
2430   int j;
2431
2432   if (i < 0) {
2433     ferr(po, "dead label encountered\n");
2434     return -1;
2435   }
2436
2437   for (; arg < pp->argc; arg++)
2438     if (pp->arg[arg].reg == NULL)
2439       break;
2440   magic = (magic & 0xffffff) | (arg << 24);
2441
2442   for (j = i; j >= 0 && arg < pp->argc; )
2443   {
2444     if (((ops[j].cc_scratch ^ magic) & 0xffffff) == 0) {
2445       if (ops[j].cc_scratch != magic) {
2446         ferr(&ops[j], "arg collect hit same path with diff args for %s\n",
2447            pp->name);
2448         return -1;
2449       }
2450       // ok: have already been here
2451       return 0;
2452     }
2453     ops[j].cc_scratch = magic;
2454
2455     if (g_labels[j][0] != 0 && g_label_refs[j].i != -1) {
2456       lr = &g_label_refs[j];
2457       if (lr->next != NULL)
2458         need_op_saving = 1;
2459       for (; lr->next; lr = lr->next) {
2460         if ((ops[lr->i].flags & (OPF_JMP|OPF_CC)) != OPF_JMP)
2461           may_reuse = 1;
2462         ret = collect_call_args(po, lr->i, pp, save_arg_vars,
2463                 arg, magic, need_op_saving, may_reuse);
2464         if (ret < 0)
2465           return ret;
2466       }
2467
2468       if ((ops[lr->i].flags & (OPF_JMP|OPF_CC)) != OPF_JMP)
2469         may_reuse = 1;
2470       if (j > 0 && LAST_OP(j - 1)) {
2471         // follow last branch in reverse
2472         j = lr->i;
2473         continue;
2474       }
2475       need_op_saving = 1;
2476       ret = collect_call_args(po, lr->i, pp, save_arg_vars,
2477                arg, magic, need_op_saving, may_reuse);
2478       if (ret < 0)
2479         return ret;
2480     }
2481     j--;
2482
2483     if (ops[j].op == OP_CALL)
2484     {
2485       pp_tmp = ops[j].datap;
2486       if (pp_tmp == NULL)
2487         ferr(po, "arg collect hit unparsed call '%s'\n",
2488           ops[j].operand[0].name);
2489       if (may_reuse && pp_tmp->argc_stack > 0)
2490         ferr(po, "arg collect %d/%d hit '%s' with %d stack args\n",
2491           arg, pp->argc, opr_name(&ops[j], 0), pp_tmp->argc_stack);
2492     }
2493     else if (ops[j].op == OP_ADD && ops[j].operand[0].reg == xSP) {
2494       ferr(po, "arg collect %d/%d hit esp adjust\n",
2495         arg, pp->argc);
2496     }
2497     else if (ops[j].op == OP_POP) {
2498       ferr(po, "arg collect %d/%d hit pop\n", arg, pp->argc);
2499     }
2500     else if ((ops[j].flags & (OPF_JMP|OPF_CC)) == (OPF_JMP|OPF_CC))
2501     {
2502       may_reuse = 1;
2503     }
2504     else if (ops[j].op == OP_PUSH && !(ops[j].flags & OPF_FARG))
2505     {
2506       pp->arg[arg].datap = &ops[j];
2507       need_to_save_current = 0;
2508       if (!need_op_saving) {
2509         ret = scan_for_mod(&ops[j], j + 1, i);
2510         need_to_save_current = (ret >= 0);
2511       }
2512       if (need_op_saving || need_to_save_current) {
2513         // mark this push as one that needs operand saving
2514         ops[j].flags &= ~OPF_RMD;
2515         if (ops[j].argnum == 0) {
2516           ops[j].argnum = arg + 1;
2517           *save_arg_vars |= 1 << arg;
2518         }
2519         else if (ops[j].argnum < arg + 1)
2520           ferr(&ops[j], "argnum conflict (%d<%d) for '%s'\n",
2521             ops[j].argnum, arg + 1, pp->name);
2522       }
2523       else if (ops[j].argnum == 0)
2524         ops[j].flags |= OPF_RMD;
2525
2526       // some PUSHes are reused by different calls on other branches,
2527       // but that can't happen if we didn't branch, so they
2528       // can be removed from future searches (handles nested calls)
2529       if (!may_reuse)
2530         ops[j].flags |= OPF_FARG;
2531
2532       // next arg
2533       for (arg++; arg < pp->argc; arg++)
2534         if (pp->arg[arg].reg == NULL)
2535           break;
2536       magic = (magic & 0xffffff) | (arg << 24);
2537     }
2538   }
2539
2540   if (arg < pp->argc) {
2541     ferr(po, "arg collect failed for '%s': %d/%d\n",
2542       pp->name, arg, pp->argc);
2543     ret = -1;
2544   }
2545   return ret;
2546 }
2547
2548 static void add_label_ref(struct label_ref *lr, int op_i)
2549 {
2550   struct label_ref *lr_new;
2551
2552   if (lr->i == -1) {
2553     lr->i = op_i;
2554     return;
2555   }
2556
2557   lr_new = calloc(1, sizeof(*lr_new));
2558   lr_new->i = op_i;
2559   lr_new->next = lr->next;
2560   lr->next = lr_new;
2561 }
2562
2563 static void output_std_flags(FILE *fout, struct parsed_op *po,
2564   int *pfomask, const char *dst_opr_text)
2565 {
2566   if (*pfomask & (1 << PFO_Z)) {
2567     fprintf(fout, "\n  cond_z = (%s%s == 0);",
2568       lmod_cast_u(po, po->operand[0].lmod), dst_opr_text);
2569     *pfomask &= ~(1 << PFO_Z);
2570   }
2571   if (*pfomask & (1 << PFO_S)) {
2572     fprintf(fout, "\n  cond_s = (%s%s < 0);",
2573       lmod_cast_s(po, po->operand[0].lmod), dst_opr_text);
2574     *pfomask &= ~(1 << PFO_S);
2575   }
2576 }
2577
2578 static void gen_func(FILE *fout, FILE *fhdr, const char *funcn, int opcnt)
2579 {
2580   struct parsed_op *po, *delayed_flag_op = NULL, *tmp_op;
2581   struct parsed_opr *last_arith_dst = NULL;
2582   char buf1[256], buf2[256], buf3[256], cast[64];
2583   const struct parsed_proto *pp_c;
2584   struct parsed_proto *pp, *pp_tmp;
2585   struct parsed_data *pd;
2586   const char *tmpname;
2587   enum parsed_flag_op pfo;
2588   int save_arg_vars = 0;
2589   int cmp_result_vars = 0;
2590   int need_mul_var = 0;
2591   int have_func_ret = 0;
2592   int have_normal_ret = 0;
2593   int had_decl = 0;
2594   int label_pending = 0;
2595   int regmask_save = 0;
2596   int regmask_arg = 0;
2597   int regmask_now = 0;
2598   int regmask = 0;
2599   int pfomask = 0;
2600   int found = 0;
2601   int depth = 0;
2602   int no_output;
2603   int i, j, l;
2604   int dummy;
2605   int arg;
2606   int reg;
2607   int ret;
2608
2609   g_bp_frame = g_sp_frame = g_stack_fsz = 0;
2610   g_stack_frame_used = 0;
2611
2612   g_func_pp = proto_parse(fhdr, funcn);
2613   if (g_func_pp == NULL)
2614     ferr(ops, "proto_parse failed for '%s'\n", funcn);
2615
2616   fprintf(fout, "%s ", g_func_pp->ret_type.name);
2617   if (g_func_pp->is_stdcall && g_func_pp->argc_reg == 0)
2618     fprintf(fout, "__stdcall ");
2619   if (g_ida_func_attr & IDAFA_NORETURN)
2620     fprintf(fout, "noreturn ");
2621   fprintf(fout, "%s(", funcn);
2622
2623   for (i = 0; i < g_func_pp->argc; i++) {
2624     if (i > 0)
2625       fprintf(fout, ", ");
2626     if (g_func_pp->arg[i].fptr != NULL) {
2627       // func pointer..
2628       pp = g_func_pp->arg[i].fptr;
2629       fprintf(fout, "%s (", pp->ret_type.name);
2630       if (pp->is_stdcall && pp->argc_reg == 0)
2631         fprintf(fout, "__stdcall ");
2632       fprintf(fout, "*a%d)(", i + 1);
2633       for (j = 0; j < pp->argc; j++) {
2634         if (j > 0)
2635           fprintf(fout, ", ");
2636         if (pp->arg[j].fptr)
2637           ferr(ops, "nested fptr\n");
2638         fprintf(fout, "%s", pp->arg[j].type.name);
2639       }
2640       fprintf(fout, ")");
2641     }
2642     else {
2643       fprintf(fout, "%s a%d", g_func_pp->arg[i].type.name, i + 1);
2644     }
2645   }
2646   if (g_func_pp->is_vararg) {
2647     if (i > 0)
2648       fprintf(fout, ", ");
2649     fprintf(fout, "...");
2650   }
2651
2652   fprintf(fout, ")\n{\n");
2653
2654   // pass1:
2655   // - handle ebp/esp frame, remove ops related to it
2656   if (ops[0].op == OP_PUSH && IS(opr_name(&ops[0], 0), "ebp")
2657       && ops[1].op == OP_MOV
2658       && IS(opr_name(&ops[1], 0), "ebp")
2659       && IS(opr_name(&ops[1], 1), "esp"))
2660   {
2661     int ecx_push = 0;
2662
2663     g_bp_frame = 1;
2664     ops[0].flags |= OPF_RMD;
2665     ops[1].flags |= OPF_RMD;
2666     i = 2;
2667
2668     if (ops[2].op == OP_SUB && IS(opr_name(&ops[2], 0), "esp")) {
2669       g_stack_fsz = opr_const(&ops[2], 1);
2670       ops[2].flags |= OPF_RMD;
2671       i++;
2672     }
2673     else {
2674       // another way msvc builds stack frame..
2675       i = 2;
2676       while (ops[i].op == OP_PUSH && IS(opr_name(&ops[i], 0), "ecx")) {
2677         g_stack_fsz += 4;
2678         ops[i].flags |= OPF_RMD;
2679         ecx_push++;
2680         i++;
2681       }
2682       // and another way..
2683       if (i == 2 && ops[i].op == OP_MOV && ops[i].operand[0].reg == xAX
2684           && ops[i].operand[1].type == OPT_CONST
2685           && ops[i + 1].op == OP_CALL
2686           && IS(opr_name(&ops[i + 1], 0), "__alloca_probe"))
2687       {
2688         g_stack_fsz += ops[i].operand[1].val;
2689         ops[i].flags |= OPF_RMD;
2690         i++;
2691         ops[i].flags |= OPF_RMD;
2692         i++;
2693       }
2694     }
2695
2696     found = 0;
2697     do {
2698       for (; i < opcnt; i++)
2699         if (ops[i].op == OP_RET)
2700           break;
2701       if (i == opcnt && (ops[i - 1].flags & OPF_JMP) && found)
2702         break;
2703
2704       if (ops[i - 1].op == OP_POP && IS(opr_name(&ops[i - 1], 0), "ebp"))
2705         ops[i - 1].flags |= OPF_RMD;
2706       else if (!(g_ida_func_attr & IDAFA_NORETURN))
2707         ferr(&ops[i - 1], "'pop ebp' expected\n");
2708
2709       if (g_stack_fsz != 0) {
2710         if (ops[i - 2].op == OP_MOV
2711             && IS(opr_name(&ops[i - 2], 0), "esp")
2712             && IS(opr_name(&ops[i - 2], 1), "ebp"))
2713         {
2714           ops[i - 2].flags |= OPF_RMD;
2715         }
2716         else if (!(g_ida_func_attr & IDAFA_NORETURN))
2717           ferr(&ops[i - 2], "esp restore expected\n");
2718
2719         if (ecx_push && ops[i - 3].op == OP_POP
2720           && IS(opr_name(&ops[i - 3], 0), "ecx"))
2721         {
2722           ferr(&ops[i - 3], "unexpected ecx pop\n");
2723         }
2724       }
2725
2726       found = 1;
2727       i++;
2728     } while (i < opcnt);
2729   }
2730   else {
2731     for (i = 0; i < opcnt; i++) {
2732       if (ops[i].op == OP_PUSH || (ops[i].flags & (OPF_JMP|OPF_TAIL)))
2733         break;
2734       if (ops[i].op == OP_SUB && ops[i].operand[0].reg == xSP
2735         && ops[i].operand[1].type == OPT_CONST)
2736       {
2737         g_sp_frame = 1;
2738         break;
2739       }
2740     }
2741
2742     if (g_sp_frame)
2743     {
2744       g_stack_fsz = ops[i].operand[1].val;
2745       ops[i].flags |= OPF_RMD;
2746
2747       i++;
2748       do {
2749         for (; i < opcnt; i++)
2750           if (ops[i].op == OP_RET)
2751             break;
2752         if (ops[i - 1].op != OP_ADD
2753             || !IS(opr_name(&ops[i - 1], 0), "esp")
2754             || ops[i - 1].operand[1].type != OPT_CONST
2755             || ops[i - 1].operand[1].val != g_stack_fsz)
2756           ferr(&ops[i - 1], "'add esp' expected\n");
2757         ops[i - 1].flags |= OPF_RMD;
2758
2759         i++;
2760       } while (i < opcnt);
2761     }
2762   }
2763
2764   // pass2:
2765   // - parse calls with labels
2766   // - resolve all branches
2767   for (i = 0; i < opcnt; i++)
2768   {
2769     po = &ops[i];
2770     po->bt_i = -1;
2771     po->btj = NULL;
2772
2773     if (po->flags & OPF_RMD)
2774       continue;
2775
2776     if (po->op == OP_CALL) {
2777       if (po->operand[0].type == OPT_LABEL) {
2778         tmpname = opr_name(po, 0);
2779         pp_c = proto_parse(fhdr, tmpname);
2780         if (pp_c == NULL)
2781           ferr(po, "proto_parse failed for call '%s'\n", tmpname);
2782         if (pp_c->is_fptr && pp_c->argc_reg != 0)
2783           ferr(po, "fptr call with reg arg\n");
2784         pp = proto_clone(pp_c);
2785         my_assert_not(pp, NULL);
2786         po->datap = pp;
2787       }
2788       continue;
2789     }
2790
2791     if (!(po->flags & OPF_JMP) || po->op == OP_RET)
2792       continue;
2793
2794     if (po->operand[0].type == OPT_REGMEM) {
2795       char *p = strchr(po->operand[0].name, '[');
2796       if (p == NULL)
2797         ferr(po, "unhandled indirect branch\n");
2798       ret = p - po->operand[0].name;
2799       strncpy(buf1, po->operand[0].name, ret);
2800       buf1[ret] = 0;
2801
2802       for (j = 0, pd = NULL; j < g_func_pd_cnt; j++) {
2803         if (IS(g_func_pd[j].label, buf1)) {
2804           pd = &g_func_pd[j];
2805           break;
2806         }
2807       }
2808       if (pd == NULL)
2809         //ferr(po, "label '%s' not parsed?\n", buf1);
2810         goto tailcall;
2811       if (pd->type != OPT_OFFSET)
2812         ferr(po, "label '%s' with non-offset data?\n", buf1);
2813
2814       // find all labels, link
2815       for (j = 0; j < pd->count; j++) {
2816         for (l = 0; l < opcnt; l++) {
2817           if (g_labels[l][0] && IS(g_labels[l], pd->d[j].u.label)) {
2818             add_label_ref(&g_label_refs[l], i);
2819             pd->d[j].bt_i = l;
2820             break;
2821           }
2822         }
2823       }
2824
2825       po->btj = pd;
2826       continue;
2827     }
2828
2829     for (l = 0; l < opcnt; l++) {
2830       if (g_labels[l][0] && IS(po->operand[0].name, g_labels[l])) {
2831         add_label_ref(&g_label_refs[l], i);
2832         po->bt_i = l;
2833         break;
2834       }
2835     }
2836
2837     if (po->bt_i != -1)
2838       continue;
2839
2840     if (po->operand[0].type == OPT_LABEL)
2841       // assume tail call
2842       goto tailcall;
2843
2844     ferr(po, "unhandled branch\n");
2845
2846 tailcall:
2847     po->op = OP_CALL;
2848     po->flags |= OPF_TAIL;
2849     i--; // reprocess
2850   }
2851
2852   // pass3:
2853   // - remove dead labels
2854   // - process calls
2855   for (i = 0; i < opcnt; i++)
2856   {
2857     if (g_labels[i][0] != 0 && g_label_refs[i].i == -1)
2858       g_labels[i][0] = 0;
2859
2860     po = &ops[i];
2861     if (po->flags & OPF_RMD)
2862       continue;
2863
2864     if (po->op == OP_CALL)
2865     {
2866       tmpname = opr_name(po, 0);
2867       pp = po->datap;
2868       if (pp == NULL)
2869       {
2870         // indirect call
2871         pp_c = resolve_call(i, opcnt);
2872         if (pp_c != NULL)
2873           pp = proto_clone(pp_c);
2874         if (pp == NULL) {
2875           pp = calloc(1, sizeof(*pp));
2876           my_assert_not(pp, NULL);
2877           ret = scan_for_esp_adjust(i + 1, opcnt, &j);
2878           if (ret < 0)
2879             ferr(po, "non-__cdecl indirect call unhandled yet\n");
2880           j /= 4;
2881           if (j > ARRAY_SIZE(pp->arg))
2882             ferr(po, "esp adjust too large?\n");
2883           pp->ret_type.name = strdup("int");
2884           pp->argc = pp->argc_stack = j;
2885           for (arg = 0; arg < pp->argc; arg++)
2886             pp->arg[arg].type.name = strdup("int");
2887         }
2888         po->datap = pp;
2889       }
2890
2891       // look for and make use of esp adjust
2892       ret = -1;
2893       if (!pp->is_stdcall && pp->argc_stack > 0)
2894         ret = scan_for_esp_adjust(i + 1, opcnt, &j);
2895       if (ret >= 0) {
2896         if (pp->is_vararg) {
2897           if (j / 4 < pp->argc_stack)
2898             ferr(po, "esp adjust is too small: %x < %x\n",
2899               j, pp->argc_stack * 4);
2900           // modify pp to make it have varargs as normal args
2901           arg = pp->argc;
2902           pp->argc += j / 4 - pp->argc_stack;
2903           for (; arg < pp->argc; arg++) {
2904             pp->arg[arg].type.name = strdup("int");
2905             pp->argc_stack++;
2906           }
2907           if (pp->argc > ARRAY_SIZE(pp->arg))
2908             ferr(po, "too many args for '%s'\n", tmpname);
2909         }
2910         if (pp->argc_stack != j / 4)
2911           ferr(po, "stack tracking failed for '%s': %x %x\n",
2912             tmpname, pp->argc_stack * 4, j);
2913
2914         ops[ret].flags |= OPF_RMD;
2915         // a bit of a hack, but deals with use of
2916         // single adj for multiple calls
2917         ops[ret].operand[1].val -= j;
2918       }
2919       else if (pp->is_vararg)
2920         ferr(po, "missing esp_adjust for vararg func '%s'\n",
2921           pp->name);
2922
2923       // can't call functions with non-__cdecl callbacks yet
2924       for (arg = 0; arg < pp->argc; arg++) {
2925         if (pp->arg[arg].fptr != NULL) {
2926           pp_tmp = pp->arg[arg].fptr;
2927           if (pp_tmp->argc_reg != 0)
2928             ferr(po, "'%s' has a callback with reg-args\n", tmpname);
2929         }
2930       }
2931
2932       collect_call_args(po, i, pp, &save_arg_vars,
2933         0, i + opcnt * 2, 0, 0);
2934
2935       if (strstr(pp->ret_type.name, "int64"))
2936         need_mul_var = 1;
2937       if (!(po->flags & OPF_TAIL) && !IS(pp->ret_type.name, "void"))
2938         have_func_ret = 1;
2939     }
2940   }
2941
2942   // pass4:
2943   // - find POPs for PUSHes, rm both
2944   // - scan for all used registers
2945   // - find flag set ops for their users
2946   // - declare indirect functions
2947   for (i = 0; i < opcnt; i++) {
2948     po = &ops[i];
2949     if (po->flags & OPF_RMD)
2950       continue;
2951
2952     if (po->op == OP_PUSH && (po->flags & OPF_RSAVE)) {
2953       reg = po->operand[0].reg;
2954       if (!(regmask & (1 << reg)))
2955         // not a reg save after all, rerun scan_for_pop
2956         po->flags &= ~OPF_RSAVE;
2957       else
2958         regmask_save |= 1 << reg;
2959     }
2960
2961     if (po->op == OP_PUSH
2962         && po->argnum == 0 && !(po->flags & OPF_RSAVE)
2963         && po->operand[0].type == OPT_REG)
2964     {
2965       reg = po->operand[0].reg;
2966       if (reg < 0)
2967         ferr(po, "reg not set for push?\n");
2968
2969       depth = 0;
2970       ret = scan_for_pop(i + 1, opcnt,
2971               po->operand[0].name, i + opcnt * 3, 0, &depth, 0);
2972       if (ret == 1) {
2973         if (depth > 1)
2974           ferr(po, "too much depth: %d\n", depth);
2975
2976         po->flags |= OPF_RMD;
2977         scan_for_pop(i + 1, opcnt, po->operand[0].name,
2978           i + opcnt * 4, 0, &depth, 1);
2979         continue;
2980       }
2981       ret = scan_for_pop_ret(i + 1, opcnt, po->operand[0].name, 0);
2982       if (ret == 0) {
2983         arg = OPF_RMD;
2984         if (regmask & (1 << reg)) {
2985           if (regmask_save & (1 << reg))
2986             ferr(po, "%s already saved?\n", po->operand[0].name);
2987           arg = OPF_RSAVE;
2988         }
2989         po->flags |= arg;
2990         scan_for_pop_ret(i + 1, opcnt, po->operand[0].name, arg);
2991         continue;
2992       }
2993     }
2994
2995     regmask_now = po->regmask_src | po->regmask_dst;
2996     if (regmask_now & (1 << xBP)) {
2997       if (g_bp_frame && !(po->flags & OPF_EBP_S)) {
2998         if (po->regmask_dst & (1 << xBP))
2999           // compiler decided to drop bp frame and use ebp as scratch
3000           scan_fwd_set_flags(i, opcnt, i + opcnt * 5, OPF_EBP_S);
3001         else
3002           regmask_now &= ~(1 << xBP);
3003       }
3004     }
3005
3006     regmask |= regmask_now;
3007
3008     if (po->flags & OPF_CC)
3009     {
3010       int setters[16], cnt = 0, branched = 0;
3011
3012       ret = scan_for_flag_set(i, i + opcnt * 6,
3013               &branched, setters, &cnt);
3014       if (ret < 0 || cnt <= 0)
3015         ferr(po, "unable to trace flag setter(s)\n");
3016       if (cnt > ARRAY_SIZE(setters))
3017         ferr(po, "too many flag setters\n");
3018
3019       pfo = split_cond(po, po->op, &dummy);
3020       for (j = 0; j < cnt; j++)
3021       {
3022         tmp_op = &ops[setters[j]]; // flag setter
3023         pfomask = 0;
3024
3025         // to get nicer code, we try to delay test and cmp;
3026         // if we can't because of operand modification, or if we
3027         // have math op, or branch, make it calculate flags explicitly
3028         if (tmp_op->op == OP_TEST || tmp_op->op == OP_CMP) {
3029           if (branched || scan_for_mod(tmp_op, setters[j] + 1, i) >= 0)
3030             pfomask = 1 << pfo;
3031         }
3032         else if (tmp_op->op == OP_CMPS) {
3033           pfomask = 1 << PFO_Z;
3034         }
3035         else {
3036           // see if we'll be able to handle based on op result
3037           if ((tmp_op->op != OP_AND && tmp_op->op != OP_OR
3038                && pfo != PFO_Z && pfo != PFO_S && pfo != PFO_P)
3039               || branched
3040               || scan_for_mod_opr0(tmp_op, setters[j] + 1, i) >= 0)
3041             pfomask = 1 << pfo;
3042         }
3043         if (pfomask) {
3044           tmp_op->pfomask |= pfomask;
3045           cmp_result_vars |= pfomask;
3046         }
3047         // note: may overwrite, currently not a problem
3048         po->datap = tmp_op;
3049       }
3050
3051       if (po->op == OP_ADC || po->op == OP_SBB)
3052         cmp_result_vars |= 1 << PFO_C;
3053     }
3054     else if (po->op == OP_MUL
3055       || (po->op == OP_IMUL && po->operand_cnt == 1))
3056     {
3057       need_mul_var = 1;
3058     }
3059     else if (po->op == OP_CALL && po->operand[0].type != OPT_LABEL) {
3060       pp = po->datap;
3061       my_assert_not(pp, NULL);
3062       fprintf(fout, "  %s (", pp->ret_type.name);
3063       if (pp->is_stdcall && pp->argc_reg == 0)
3064         fprintf(fout, "__stdcall ");
3065       fprintf(fout, "*icall%d)(", i);
3066       for (j = 0; j < pp->argc; j++) {
3067         if (j > 0)
3068           fprintf(fout, ", ");
3069         fprintf(fout, "%s a%d", pp->arg[j].type.name, j + 1);
3070       }
3071       fprintf(fout, ");\n");
3072     }
3073     else if (po->op == OP_RET)
3074       have_normal_ret = 1;
3075   }
3076
3077   // output LUTs/jumptables
3078   for (i = 0; i < g_func_pd_cnt; i++) {
3079     pd = &g_func_pd[i];
3080     fprintf(fout, "  static const ");
3081     if (pd->type == OPT_OFFSET) {
3082       fprintf(fout, "void *jt_%s[] =\n    { ", pd->label);
3083
3084       for (j = 0; j < pd->count; j++) {
3085         if (j > 0)
3086           fprintf(fout, ", ");
3087         fprintf(fout, "&&%s", pd->d[j].u.label);
3088       }
3089     }
3090     else {
3091       fprintf(fout, "%s %s[] =\n    { ",
3092         lmod_type_u(ops, pd->lmod), pd->label);
3093
3094       for (j = 0; j < pd->count; j++) {
3095         if (j > 0)
3096           fprintf(fout, ", ");
3097         fprintf(fout, "%u", pd->d[j].u.val);
3098       }
3099     }
3100     fprintf(fout, " };\n");
3101   }
3102
3103   // declare stack frame, va_arg
3104   if (g_stack_fsz)
3105     fprintf(fout, "  union { u32 d[%d]; u16 w[%d]; u8 b[%d]; } sf;\n",
3106       (g_stack_fsz + 3) / 4, (g_stack_fsz + 1) / 2, g_stack_fsz);
3107
3108   if (g_func_pp->is_vararg)
3109     fprintf(fout, "  va_list ap;\n");
3110
3111   // declare arg-registers
3112   for (i = 0; i < g_func_pp->argc; i++) {
3113     if (g_func_pp->arg[i].reg != NULL) {
3114       reg = char_array_i(regs_r32,
3115               ARRAY_SIZE(regs_r32), g_func_pp->arg[i].reg);
3116       if (reg < 0)
3117         ferr(ops, "arg '%s' is not a reg?\n", g_func_pp->arg[i].reg);
3118
3119       regmask_arg |= 1 << reg;
3120       fprintf(fout, "  u32 %s = (u32)a%d;\n",
3121         g_func_pp->arg[i].reg, i + 1);
3122       had_decl = 1;
3123     }
3124   }
3125
3126   // declare other regs - special case for eax
3127   if (!((regmask | regmask_arg) & 1)
3128    && (have_func_ret || have_normal_ret)
3129    && !IS(g_func_pp->ret_type.name, "void"))
3130   {
3131     fprintf(fout, "  u32 eax = 0;\n");
3132     had_decl = 1;
3133   }
3134
3135   regmask &= ~regmask_arg;
3136   regmask &= ~(1 << xSP);
3137   if (regmask) {
3138     for (reg = 0; reg < 8; reg++) {
3139       if (regmask & (1 << reg)) {
3140         fprintf(fout, "  u32 %s;\n", regs_r32[reg]);
3141         had_decl = 1;
3142       }
3143     }
3144   }
3145
3146   if (regmask_save) {
3147     for (reg = 0; reg < 8; reg++) {
3148       if (regmask_save & (1 << reg)) {
3149         fprintf(fout, "  u32 s_%s;\n", regs_r32[reg]);
3150         had_decl = 1;
3151       }
3152     }
3153   }
3154
3155   if (save_arg_vars) {
3156     for (reg = 0; reg < 32; reg++) {
3157       if (save_arg_vars & (1 << reg)) {
3158         fprintf(fout, "  u32 s_a%d;\n", reg + 1);
3159         had_decl = 1;
3160       }
3161     }
3162   }
3163
3164   if (cmp_result_vars) {
3165     for (i = 0; i < 8; i++) {
3166       if (cmp_result_vars & (1 << i)) {
3167         fprintf(fout, "  u32 cond_%s;\n", parsed_flag_op_names[i]);
3168         had_decl = 1;
3169       }
3170     }
3171   }
3172
3173   if (need_mul_var) {
3174     fprintf(fout, "  u64 mul_tmp;\n");
3175     had_decl = 1;
3176   }
3177
3178   if (had_decl)
3179     fprintf(fout, "\n");
3180
3181   if (g_func_pp->is_vararg) {
3182     if (g_func_pp->argc_stack == 0)
3183       ferr(ops, "vararg func without stack args?\n");
3184     fprintf(fout, "  va_start(ap, a%d);\n", g_func_pp->argc);
3185   }
3186
3187   // output ops
3188   for (i = 0; i < opcnt; i++)
3189   {
3190     if (g_labels[i][0] != 0) {
3191       fprintf(fout, "\n%s:\n", g_labels[i]);
3192       label_pending = 1;
3193
3194       delayed_flag_op = NULL;
3195       last_arith_dst = NULL;
3196     }
3197
3198     po = &ops[i];
3199     if (po->flags & OPF_RMD)
3200       continue;
3201
3202     no_output = 0;
3203
3204     #define assert_operand_cnt(n_) \
3205       if (po->operand_cnt != n_) \
3206         ferr(po, "operand_cnt is %d/%d\n", po->operand_cnt, n_)
3207
3208     // conditional/flag using op?
3209     if (po->flags & OPF_CC)
3210     {
3211       int is_delayed = 0;
3212       int is_inv = 0;
3213
3214       pfo = split_cond(po, po->op, &is_inv);
3215       tmp_op = po->datap;
3216
3217       // we go through all this trouble to avoid using parsed_flag_op,
3218       // which makes generated code much nicer
3219       if (delayed_flag_op != NULL)
3220       {
3221         out_cmp_test(buf1, sizeof(buf1), delayed_flag_op, pfo, is_inv);
3222         is_delayed = 1;
3223       }
3224       else if (last_arith_dst != NULL
3225         && (pfo == PFO_Z || pfo == PFO_S || pfo == PFO_P
3226            || (tmp_op && (tmp_op->op == OP_AND || tmp_op->op == OP_OR))
3227            ))
3228       {
3229         out_src_opr_u32(buf3, sizeof(buf3), po, last_arith_dst);
3230         out_test_for_cc(buf1, sizeof(buf1), po, pfo, is_inv,
3231           last_arith_dst->lmod, buf3);
3232         is_delayed = 1;
3233       }
3234       else if (tmp_op != NULL) {
3235         // use preprocessed flag calc results
3236         if (!(tmp_op->pfomask & (1 << pfo)))
3237           ferr(po, "not prepared for pfo %d\n", pfo);
3238
3239         // note: is_inv was not yet applied
3240         snprintf(buf1, sizeof(buf1), "(%scond_%s)",
3241           is_inv ? "!" : "", parsed_flag_op_names[pfo]);
3242       }
3243       else {
3244         ferr(po, "all methods of finding comparison failed\n");
3245       }
3246
3247       if (po->flags & OPF_JMP) {
3248         fprintf(fout, "  if %s\n", buf1);
3249       }
3250       else if (po->op == OP_ADC || po->op == OP_SBB) {
3251         if (is_delayed)
3252           fprintf(fout, "  cond_%s = %s;\n",
3253             parsed_flag_op_names[pfo], buf1);
3254       }
3255       else if (po->flags & OPF_DATA) { // SETcc
3256         out_dst_opr(buf2, sizeof(buf2), po, &po->operand[0]);
3257         fprintf(fout, "  %s = %s;", buf2, buf1);
3258       }
3259       else {
3260         ferr(po, "unhandled conditional op\n");
3261       }
3262     }
3263
3264     pfomask = po->pfomask;
3265
3266     switch (po->op)
3267     {
3268       case OP_MOV:
3269         assert_operand_cnt(2);
3270         propagate_lmod(po, &po->operand[0], &po->operand[1]);
3271         out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
3272         fprintf(fout, "  %s = %s;", buf1,
3273             out_src_opr(buf2, sizeof(buf2), po, &po->operand[1],
3274               po->operand[0].is_ptr ? "(void *)" : "", 0));
3275         break;
3276
3277       case OP_LEA:
3278         assert_operand_cnt(2);
3279         po->operand[1].lmod = OPLM_DWORD; // always
3280         fprintf(fout, "  %s = %s;",
3281             out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
3282             out_src_opr(buf2, sizeof(buf2), po, &po->operand[1],
3283               NULL, 1));
3284         break;
3285
3286       case OP_MOVZX:
3287         assert_operand_cnt(2);
3288         fprintf(fout, "  %s = %s;",
3289             out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
3290             out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
3291         break;
3292
3293       case OP_MOVSX:
3294         assert_operand_cnt(2);
3295         switch (po->operand[1].lmod) {
3296         case OPLM_BYTE:
3297           strcpy(buf3, "(s8)");
3298           break;
3299         case OPLM_WORD:
3300           strcpy(buf3, "(s16)");
3301           break;
3302         default:
3303           ferr(po, "invalid src lmod: %d\n", po->operand[1].lmod);
3304         }
3305         fprintf(fout, "  %s = %s;",
3306             out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
3307             out_src_opr(buf2, sizeof(buf2), po, &po->operand[1],
3308               buf3, 0));
3309         break;
3310
3311       case OP_NOT:
3312         assert_operand_cnt(1);
3313         out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
3314         fprintf(fout, "  %s = ~%s;", buf1, buf1);
3315         break;
3316
3317       case OP_CDQ:
3318         assert_operand_cnt(2);
3319         fprintf(fout, "  %s = (s32)%s >> 31;",
3320             out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
3321             out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
3322         strcpy(g_comment, "cdq");
3323         break;
3324
3325       case OP_STOS:
3326         // assumes DF=0
3327         assert_operand_cnt(3);
3328         if (po->flags & OPF_REP) {
3329           fprintf(fout, "  for (; ecx != 0; ecx--, edi += %d)\n",
3330             lmod_bytes(po, po->operand[0].lmod));
3331           fprintf(fout, "    %sedi = eax;",
3332             lmod_cast_u_ptr(po, po->operand[0].lmod));
3333           strcpy(g_comment, "rep stos");
3334         }
3335         else {
3336           fprintf(fout, "    %sedi = eax; edi += %d;",
3337             lmod_cast_u_ptr(po, po->operand[0].lmod),
3338             lmod_bytes(po, po->operand[0].lmod));
3339           strcpy(g_comment, "stos");
3340         }
3341         break;
3342
3343       case OP_MOVS:
3344         // assumes DF=0
3345         assert_operand_cnt(3);
3346         j = lmod_bytes(po, po->operand[0].lmod);
3347         strcpy(buf1, lmod_cast_u_ptr(po, po->operand[0].lmod));
3348         if (po->flags & OPF_REP) {
3349           fprintf(fout,
3350             "  for (; ecx != 0; ecx--, edi += %d, esi += %d)\n",
3351             j, j);
3352           fprintf(fout,
3353             "    %sedi = %sesi;", buf1, buf1);
3354           strcpy(g_comment, "rep movs");
3355         }
3356         else {
3357           fprintf(fout, "    %sedi = %sesi; edi += %d; esi += %d;",
3358             buf1, buf1, j, j);
3359           strcpy(g_comment, "movs");
3360         }
3361         break;
3362
3363       case OP_CMPS:
3364         // assumes DF=0
3365         // repe ~ repeat while ZF=1
3366         assert_operand_cnt(3);
3367         j = lmod_bytes(po, po->operand[0].lmod);
3368         strcpy(buf1, lmod_cast_u_ptr(po, po->operand[0].lmod));
3369         if (po->flags & OPF_REP) {
3370           fprintf(fout,
3371             "  for (; ecx != 0; ecx--, edi += %d, esi += %d)\n",
3372             j, j);
3373           fprintf(fout,
3374             "    if ((cond_z = (%sedi == %sesi)) %s 0)\n",
3375               buf1, buf1, (po->flags & OPF_REPZ) ? "==" : "!=");
3376           fprintf(fout,
3377             "      break;");
3378           snprintf(g_comment, sizeof(g_comment), "rep%s cmps",
3379             (po->flags & OPF_REPZ) ? "e" : "ne");
3380         }
3381         else {
3382           fprintf(fout,
3383             "    cond_z = (%sedi = %sesi); edi += %d; esi += %d;",
3384             buf1, buf1, j, j);
3385           strcpy(g_comment, "cmps");
3386         }
3387         pfomask &= ~(1 << PFO_Z);
3388         last_arith_dst = NULL;
3389         delayed_flag_op = NULL;
3390         break;
3391
3392       // arithmetic w/flags
3393       case OP_ADD:
3394       case OP_SUB:
3395       case OP_AND:
3396       case OP_OR:
3397         propagate_lmod(po, &po->operand[0], &po->operand[1]);
3398         // fallthrough
3399       dualop_arith:
3400         assert_operand_cnt(2);
3401         fprintf(fout, "  %s %s= %s;",
3402             out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]),
3403             op_to_c(po),
3404             out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
3405         output_std_flags(fout, po, &pfomask, buf1);
3406         last_arith_dst = &po->operand[0];
3407         delayed_flag_op = NULL;
3408         break;
3409
3410       case OP_SHL:
3411       case OP_SHR:
3412         assert_operand_cnt(2);
3413         out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
3414         if (pfomask & (1 << PFO_C)) {
3415           if (po->operand[1].type == OPT_CONST) {
3416             l = lmod_bytes(po, po->operand[0].lmod) * 8;
3417             j = po->operand[1].val;
3418             j %= l;
3419             if (j != 0) {
3420               if (po->op == OP_SHL)
3421                 j = l - j;
3422               else
3423                 j -= 1;
3424               fprintf(fout, "  cond_c = (%s & 0x%02x) ? 1 : 0;\n",
3425                 buf1, 1 << j);
3426             }
3427             else
3428               ferr(po, "zero shift?\n");
3429           }
3430           else
3431             ferr(po, "TODO\n");
3432           pfomask &= ~(1 << PFO_C);
3433         }
3434         fprintf(fout, "  %s %s= %s;", buf1, op_to_c(po),
3435             out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
3436         output_std_flags(fout, po, &pfomask, buf1);
3437         last_arith_dst = &po->operand[0];
3438         delayed_flag_op = NULL;
3439         break;
3440
3441       case OP_SAR:
3442         assert_operand_cnt(2);
3443         out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
3444         fprintf(fout, "  %s = %s%s >> %s;", buf1,
3445           lmod_cast_s(po, po->operand[0].lmod), buf1,
3446           out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
3447         output_std_flags(fout, po, &pfomask, buf1);
3448         last_arith_dst = &po->operand[0];
3449         delayed_flag_op = NULL;
3450         break;
3451
3452       case OP_ROL:
3453       case OP_ROR:
3454         assert_operand_cnt(2);
3455         out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
3456         if (po->operand[1].type == OPT_CONST) {
3457           j = po->operand[1].val;
3458           j %= lmod_bytes(po, po->operand[0].lmod) * 8;
3459           fprintf(fout, po->op == OP_ROL ?
3460             "  %s = (%s << %d) | (%s >> %d);" :
3461             "  %s = (%s >> %d) | (%s << %d);",
3462             buf1, buf1, j, buf1,
3463             lmod_bytes(po, po->operand[0].lmod) * 8 - j);
3464         }
3465         else
3466           ferr(po, "TODO\n");
3467         output_std_flags(fout, po, &pfomask, buf1);
3468         last_arith_dst = &po->operand[0];
3469         delayed_flag_op = NULL;
3470         break;
3471
3472       case OP_XOR:
3473         assert_operand_cnt(2);
3474         propagate_lmod(po, &po->operand[0], &po->operand[1]);
3475         if (IS(opr_name(po, 0), opr_name(po, 1))) {
3476           // special case for XOR
3477           fprintf(fout, "  %s = 0;",
3478             out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]));
3479           last_arith_dst = &po->operand[0];
3480           delayed_flag_op = NULL;
3481           break;
3482         }
3483         goto dualop_arith;
3484
3485       case OP_ADC:
3486       case OP_SBB:
3487         assert_operand_cnt(2);
3488         propagate_lmod(po, &po->operand[0], &po->operand[1]);
3489         out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
3490         if (po->op == OP_SBB
3491           && IS(po->operand[0].name, po->operand[1].name))
3492         {
3493           // avoid use of unitialized var
3494           fprintf(fout, "  %s = -cond_c;", buf1);
3495           // carry remains what it was
3496           pfomask &= ~(1 << PFO_C);
3497         }
3498         else {
3499           fprintf(fout, "  %s %s= %s + cond_c;", buf1, op_to_c(po),
3500             out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
3501         }
3502         output_std_flags(fout, po, &pfomask, buf1);
3503         last_arith_dst = &po->operand[0];
3504         delayed_flag_op = NULL;
3505         break;
3506
3507       case OP_INC:
3508       case OP_DEC:
3509         out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
3510         if (po->operand[0].type == OPT_REG) {
3511           strcpy(buf2, po->op == OP_INC ? "++" : "--");
3512           fprintf(fout, "  %s%s;", buf1, buf2);
3513         }
3514         else {
3515           strcpy(buf2, po->op == OP_INC ? "+" : "-");
3516           fprintf(fout, "  %s %s= 1;", buf1, buf2);
3517         }
3518         output_std_flags(fout, po, &pfomask, buf1);
3519         last_arith_dst = &po->operand[0];
3520         delayed_flag_op = NULL;
3521         break;
3522
3523       case OP_NEG:
3524         out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
3525         out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[0]);
3526         fprintf(fout, "  %s = -%s%s;", buf1,
3527           lmod_cast_s(po, po->operand[0].lmod), buf2);
3528         last_arith_dst = &po->operand[0];
3529         delayed_flag_op = NULL;
3530         if (pfomask & (1 << PFO_C)) {
3531           fprintf(fout, "\n  cond_c = (%s != 0);", buf1);
3532           pfomask &= ~(1 << PFO_C);
3533         }
3534         break;
3535
3536       case OP_IMUL:
3537         if (po->operand_cnt == 2) {
3538           propagate_lmod(po, &po->operand[0], &po->operand[1]);
3539           goto dualop_arith;
3540         }
3541         if (po->operand_cnt == 3)
3542           ferr(po, "TODO imul3\n");
3543         // fallthrough
3544       case OP_MUL:
3545         assert_operand_cnt(1);
3546         strcpy(buf1, po->op == OP_IMUL ? "(s64)(s32)" : "(u64)");
3547         fprintf(fout, "  mul_tmp = %seax * %s%s;\n", buf1, buf1,
3548           out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[0]));
3549         fprintf(fout, "  edx = mul_tmp >> 32;\n");
3550         fprintf(fout, "  eax = mul_tmp;");
3551         last_arith_dst = NULL;
3552         delayed_flag_op = NULL;
3553         break;
3554
3555       case OP_DIV:
3556       case OP_IDIV:
3557         assert_operand_cnt(1);
3558         if (po->operand[0].lmod != OPLM_DWORD)
3559           ferr(po, "unhandled lmod %d\n", po->operand[0].lmod);
3560
3561         // 32bit division is common, look for it
3562         if (po->op == OP_DIV)
3563           ret = scan_for_reg_clear(i, xDX);
3564         else
3565           ret = scan_for_cdq_edx(i);
3566         if (ret >= 0) {
3567           out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]);
3568           strcpy(buf2, lmod_cast(po, po->operand[0].lmod,
3569             po->op == OP_IDIV));
3570           fprintf(fout, "  edx = %seax %% %s%s;\n", buf2, buf2, buf1);
3571           fprintf(fout, "  eax = %seax / %s%s;", buf2, buf2, buf1);
3572         }
3573         else
3574           ferr(po, "TODO 64bit divident\n");
3575         last_arith_dst = NULL;
3576         delayed_flag_op = NULL;
3577         break;
3578
3579       case OP_TEST:
3580       case OP_CMP:
3581         propagate_lmod(po, &po->operand[0], &po->operand[1]);
3582         if (pfomask != 0) {
3583           for (j = 0; j < 8; j++) {
3584             if (pfomask & (1 << j)) {
3585               out_cmp_test(buf1, sizeof(buf1), po, j, 0);
3586               fprintf(fout, "  cond_%s = %s;",
3587                 parsed_flag_op_names[j], buf1);
3588             }
3589           }
3590           pfomask = 0;
3591         }
3592         else
3593           no_output = 1;
3594         last_arith_dst = NULL;
3595         delayed_flag_op = po;
3596         break;
3597
3598       // note: we reuse OP_Jcc for SETcc, only flags differ
3599       case OP_JO ... OP_JG:
3600         if (po->flags & OPF_JMP)
3601           fprintf(fout, "    goto %s;", po->operand[0].name);
3602         // else SETcc - should already be handled
3603         break;
3604
3605       case OP_JMP:
3606         assert_operand_cnt(1);
3607         last_arith_dst = NULL;
3608         delayed_flag_op = NULL;
3609
3610         if (po->operand[0].type == OPT_REGMEM) {
3611           ret = sscanf(po->operand[0].name, "%[^[][%[^*]*4]",
3612                   buf1, buf2);
3613           if (ret != 2)
3614             ferr(po, "parse failure for jmp '%s'\n",
3615               po->operand[0].name);
3616           fprintf(fout, "  goto *jt_%s[%s];", buf1, buf2);
3617           break;
3618         }
3619         else if (po->operand[0].type != OPT_LABEL)
3620           ferr(po, "unhandled jmp type\n");
3621
3622         fprintf(fout, "  goto %s;", po->operand[0].name);
3623         break;
3624
3625       case OP_CALL:
3626         assert_operand_cnt(1);
3627         pp = po->datap;
3628         if (pp == NULL)
3629           ferr(po, "NULL pp\n");
3630
3631         if (po->operand[0].type != OPT_LABEL)
3632           fprintf(fout, "  icall%d = %s;\n", i,
3633             out_src_opr(buf1, sizeof(buf1), po, &po->operand[0],
3634               "(void *)", 0));
3635
3636         fprintf(fout, "  ");
3637         if (strstr(pp->ret_type.name, "int64")) {
3638           if (po->flags & OPF_TAIL)
3639             ferr(po, "int64 and tail?\n");
3640           fprintf(fout, "mul_tmp = ");
3641         }
3642         else if (!IS(pp->ret_type.name, "void")) {
3643           if (po->flags & OPF_TAIL) {
3644             if (!IS(g_func_pp->ret_type.name, "void")) {
3645               fprintf(fout, "return ");
3646               if (g_func_pp->ret_type.is_ptr != pp->ret_type.is_ptr)
3647                 fprintf(fout, "(%s)", g_func_pp->ret_type.name);
3648             }
3649           }
3650           else {
3651             fprintf(fout, "eax = ");
3652             if (pp->ret_type.is_ptr)
3653               fprintf(fout, "(u32)");
3654           }
3655         }
3656
3657         if (po->operand[0].type != OPT_LABEL) {
3658           fprintf(fout, "icall%d(", i);
3659         }
3660         else {
3661           if (pp->name[0] == 0)
3662             ferr(po, "missing pp->name\n");
3663           fprintf(fout, "%s%s(", pp->name,
3664             pp->has_structarg ? "_sa" : "");
3665         }
3666
3667         for (arg = 0; arg < pp->argc; arg++) {
3668           if (arg > 0)
3669             fprintf(fout, ", ");
3670
3671           cast[0] = 0;
3672           if (pp->arg[arg].type.is_ptr)
3673             snprintf(cast, sizeof(cast), "(%s)", pp->arg[arg].type.name);
3674
3675           if (pp->arg[arg].reg != NULL) {
3676             fprintf(fout, "%s%s", cast, pp->arg[arg].reg);
3677             continue;
3678           }
3679
3680           // stack arg
3681           tmp_op = pp->arg[arg].datap;
3682           if (tmp_op == NULL)
3683             ferr(po, "parsed_op missing for arg%d\n", arg);
3684           if (tmp_op->argnum != 0) {
3685             fprintf(fout, "%ss_a%d", cast, tmp_op->argnum);
3686           }
3687           else {
3688             fprintf(fout, "%s",
3689               out_src_opr(buf1, sizeof(buf1),
3690                 tmp_op, &tmp_op->operand[0], cast, 0));
3691           }
3692         }
3693         fprintf(fout, ");");
3694
3695         if (strstr(pp->ret_type.name, "int64")) {
3696           fprintf(fout, "\n");
3697           fprintf(fout, "  edx = mul_tmp >> 32;\n");
3698           fprintf(fout, "  eax = mul_tmp;");
3699         }
3700
3701         if (po->flags & OPF_TAIL) {
3702           strcpy(g_comment, "tailcall");
3703           ret = 0;
3704           if (i == opcnt - 1)
3705             ret = 0;
3706           else if (IS(pp->ret_type.name, "void"))
3707             ret = 1;
3708           else if (IS(g_func_pp->ret_type.name, "void"))
3709             ret = 1;
3710           // else already handled as 'return f()'
3711
3712           if (ret) {
3713             if (!IS(g_func_pp->ret_type.name, "void"))
3714               ferr(po, "int func -> void func tailcall?\n");
3715             fprintf(fout, "\n  return;");
3716             strcpy(g_comment, "^ tailcall");
3717           }
3718         }
3719         delayed_flag_op = NULL;
3720         last_arith_dst = NULL;
3721         break;
3722
3723       case OP_RET:
3724         if (g_func_pp->is_vararg)
3725           fprintf(fout, "  va_end(ap);\n");
3726
3727         if (IS(g_func_pp->ret_type.name, "void")) {
3728           if (i != opcnt - 1 || label_pending)
3729             fprintf(fout, "  return;");
3730         }
3731         else if (g_func_pp->ret_type.is_ptr) {
3732           fprintf(fout, "  return (%s)eax;",
3733             g_func_pp->ret_type.name);
3734         }
3735         else
3736           fprintf(fout, "  return eax;");
3737
3738         last_arith_dst = NULL;
3739         delayed_flag_op = NULL;
3740         break;
3741
3742       case OP_PUSH:
3743         if (po->argnum != 0) {
3744           // special case - saved func arg
3745           out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]);
3746           fprintf(fout, "  s_a%d = %s;", po->argnum, buf1);
3747           break;
3748         }
3749         else if (po->flags & OPF_RSAVE) {
3750           out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]);
3751           fprintf(fout, "  s_%s = %s;", buf1, buf1);
3752           break;
3753         }
3754         if (!(g_ida_func_attr & IDAFA_NORETURN))
3755           ferr(po, "stray push encountered\n");
3756         no_output = 1;
3757         break;
3758
3759       case OP_POP:
3760         if (po->flags & OPF_RSAVE) {
3761           out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
3762           fprintf(fout, "  %s = s_%s;", buf1, buf1);
3763           break;
3764         }
3765         ferr(po, "stray pop encountered\n");
3766         break;
3767
3768       case OP_NOP:
3769         no_output = 1;
3770         break;
3771
3772       default:
3773         no_output = 1;
3774         ferr(po, "unhandled op type %d, flags %x\n",
3775           po->op, po->flags);
3776         break;
3777     }
3778
3779     if (g_comment[0] != 0) {
3780       fprintf(fout, "  // %s", g_comment);
3781       g_comment[0] = 0;
3782       no_output = 0;
3783     }
3784     if (!no_output)
3785       fprintf(fout, "\n");
3786
3787     // some sanity checking
3788     if ((po->flags & OPF_REP) && po->op != OP_STOS
3789         && po->op != OP_MOVS && po->op != OP_CMPS)
3790       ferr(po, "unexpected rep\n");
3791     if ((po->flags & (OPF_REPZ|OPF_REPNZ)) && po->op != OP_CMPS)
3792       ferr(po, "unexpected repz/repnz\n");
3793
3794     if (pfomask != 0)
3795       ferr(po, "missed flag calc, pfomask=%x\n", pfomask);
3796
3797     // see is delayed flag stuff is still valid
3798     if (delayed_flag_op != NULL && delayed_flag_op != po) {
3799       if (is_any_opr_modified(delayed_flag_op, po))
3800         delayed_flag_op = NULL;
3801     }
3802
3803     if (last_arith_dst != NULL && last_arith_dst != &po->operand[0]) {
3804       if (is_opr_modified(last_arith_dst, po))
3805         last_arith_dst = NULL;
3806     }
3807
3808     label_pending = 0;
3809   }
3810
3811   if (g_stack_fsz && !g_stack_frame_used)
3812     fprintf(fout, "  (void)sf;\n");
3813
3814   fprintf(fout, "}\n\n");
3815
3816   // cleanup
3817   for (i = 0; i < opcnt; i++) {
3818     struct label_ref *lr, *lr_del;
3819
3820     lr = g_label_refs[i].next;
3821     while (lr != NULL) {
3822       lr_del = lr;
3823       lr = lr->next;
3824       free(lr_del);
3825     }
3826     g_label_refs[i].i = -1;
3827     g_label_refs[i].next = NULL;
3828
3829     if (ops[i].op == OP_CALL) {
3830       pp = ops[i].datap;
3831       if (pp)
3832         proto_release(pp);
3833     }
3834   }
3835   g_func_pp = NULL;
3836 }
3837
3838 static void set_label(int i, const char *name)
3839 {
3840   const char *p;
3841   int len;
3842
3843   len = strlen(name);
3844   p = strchr(name, ':');
3845   if (p != NULL)
3846     len = p - name;
3847
3848   if (len > sizeof(g_labels[0]) - 1)
3849     aerr("label '%s' too long: %d\n", name, len);
3850   if (g_labels[i][0] != 0 && !IS_START(g_labels[i], "algn_"))
3851     aerr("dupe label '%s' vs '%s'?\n", name, g_labels[i]);
3852   memcpy(g_labels[i], name, len);
3853   g_labels[i][len] = 0;
3854 }
3855
3856 // '=' needs special treatment..
3857 static char *next_word_s(char *w, size_t wsize, char *s)
3858 {
3859         size_t i;
3860
3861         s = sskip(s);
3862
3863         for (i = 0; i < wsize - 1; i++) {
3864                 if (s[i] == 0 || my_isblank(s[i]) || (s[i] == '=' && i > 0))
3865                         break;
3866                 w[i] = s[i];
3867         }
3868         w[i] = 0;
3869
3870         if (s[i] != 0 && !my_isblank(s[i]) && s[i] != '=')
3871                 printf("warning: '%s' truncated\n", w);
3872
3873         return s + i;
3874 }
3875
3876 struct chunk_item {
3877   char *name;
3878   long fptr;
3879   int asmln;
3880 };
3881
3882 static struct chunk_item *func_chunks;
3883 static int func_chunk_cnt;
3884 static int func_chunk_alloc;
3885
3886 static void add_func_chunk(FILE *fasm, const char *name, int line)
3887 {
3888   if (func_chunk_cnt >= func_chunk_alloc) {
3889     func_chunk_alloc *= 2;
3890     func_chunks = realloc(func_chunks,
3891       func_chunk_alloc * sizeof(func_chunks[0]));
3892     my_assert_not(func_chunks, NULL);
3893   }
3894   func_chunks[func_chunk_cnt].fptr = ftell(fasm);
3895   func_chunks[func_chunk_cnt].name = strdup(name);
3896   func_chunks[func_chunk_cnt].asmln = line;
3897   func_chunk_cnt++;
3898 }
3899
3900 static int cmp_chunks(const void *p1, const void *p2)
3901 {
3902   const struct chunk_item *c1 = p1, *c2 = p2;
3903   return strcmp(c1->name, c2->name);
3904 }
3905
3906 static int cmpstringp(const void *p1, const void *p2)
3907 {
3908   return strcmp(*(char * const *)p1, *(char * const *)p2);
3909 }
3910
3911 static void scan_ahead(FILE *fasm)
3912 {
3913   char words[2][256];
3914   char line[256];
3915   long oldpos;
3916   int oldasmln;
3917   int wordc;
3918   char *p;
3919   int i;
3920
3921   oldpos = ftell(fasm);
3922   oldasmln = asmln;
3923
3924   while (fgets(line, sizeof(line), fasm))
3925   {
3926     wordc = 0;
3927     asmln++;
3928
3929     p = sskip(line);
3930     if (*p == 0)
3931       continue;
3932
3933     if (*p == ';')
3934     {
3935       // get rid of random tabs
3936       for (i = 0; line[i] != 0; i++)
3937         if (line[i] == '\t')
3938           line[i] = ' ';
3939
3940       if (p[2] == 'S' && IS_START(p, "; START OF FUNCTION CHUNK FOR "))
3941       {
3942         p += 30;
3943         next_word(words[0], sizeof(words[0]), p);
3944         if (words[0][0] == 0)
3945           aerr("missing name for func chunk?\n");
3946
3947         add_func_chunk(fasm, words[0], asmln);
3948       }
3949       continue;
3950     } // *p == ';'
3951
3952     for (wordc = 0; wordc < ARRAY_SIZE(words); wordc++) {
3953       words[wordc][0] = 0;
3954       p = sskip(next_word_s(words[wordc], sizeof(words[0]), p));
3955       if (*p == 0 || *p == ';') {
3956         wordc++;
3957         break;
3958       }
3959     }
3960
3961     if (wordc == 2 && IS(words[1], "ends"))
3962       break;
3963   }
3964
3965   fseek(fasm, oldpos, SEEK_SET);
3966   asmln = oldasmln;
3967 }
3968
3969 int main(int argc, char *argv[])
3970 {
3971   FILE *fout, *fasm, *frlist;
3972   struct parsed_data *pd = NULL;
3973   int pd_alloc = 0;
3974   char **rlist = NULL;
3975   int rlist_len = 0;
3976   int rlist_alloc = 0;
3977   int func_chunks_used = 0;
3978   int func_chunks_sorted = 0;
3979   int func_chunk_i = -1;
3980   long func_chunk_ret = 0;
3981   int func_chunk_ret_ln = 0;
3982   int scanned_ahead = 0;
3983   char line[256];
3984   char words[20][256];
3985   enum opr_lenmod lmod;
3986   int in_func = 0;
3987   int pending_endp = 0;
3988   int skip_func = 0;
3989   int skip_warned = 0;
3990   int eq_alloc;
3991   int verbose = 0;
3992   int arg_out;
3993   int arg = 1;
3994   int pi = 0;
3995   int i, j;
3996   int ret, len;
3997   char *p;
3998   int wordc;
3999
4000   if (argv[1] && IS(argv[1], "-v")) {
4001     verbose = 1;
4002     arg++;
4003   }
4004
4005   if (argc < arg + 3) {
4006     printf("usage:\n%s [-v] <.c> <.asm> <hdrf> [rlist]*\n",
4007       argv[0]);
4008     return 1;
4009   }
4010
4011   arg_out = arg++;
4012
4013   asmfn = argv[arg++];
4014   fasm = fopen(asmfn, "r");
4015   my_assert_not(fasm, NULL);
4016
4017   hdrfn = argv[arg++];
4018   g_fhdr = fopen(hdrfn, "r");
4019   my_assert_not(g_fhdr, NULL);
4020
4021   rlist_alloc = 64;
4022   rlist = malloc(rlist_alloc * sizeof(rlist[0]));
4023   my_assert_not(rlist, NULL);
4024   // needs special handling..
4025   rlist[rlist_len++] = "__alloca_probe";
4026
4027   func_chunk_alloc = 32;
4028   func_chunks = malloc(func_chunk_alloc * sizeof(func_chunks[0]));
4029   my_assert_not(func_chunks, NULL);
4030
4031   memset(words, 0, sizeof(words));
4032
4033   for (; arg < argc; arg++) {
4034     frlist = fopen(argv[arg], "r");
4035     my_assert_not(frlist, NULL);
4036
4037     while (fgets(line, sizeof(line), frlist)) {
4038       p = sskip(line);
4039       if (*p == 0 || *p == ';')
4040         continue;
4041       if (*p == '#') {
4042         if (IS_START(p, "#if 0"))
4043           skip_func = 1;
4044         else if (IS_START(p, "#endif"))
4045           skip_func = 0;
4046         continue;
4047       }
4048       if (skip_func)
4049         continue;
4050
4051       p = next_word(words[0], sizeof(words[0]), p);
4052       if (words[0][0] == 0)
4053         continue;
4054
4055       if (rlist_len >= rlist_alloc) {
4056         rlist_alloc = rlist_alloc * 2 + 64;
4057         rlist = realloc(rlist, rlist_alloc * sizeof(rlist[0]));
4058         my_assert_not(rlist, NULL);
4059       }
4060       rlist[rlist_len++] = strdup(words[0]);
4061     }
4062     skip_func = 0;
4063
4064     fclose(frlist);
4065     frlist = NULL;
4066   }
4067
4068   if (rlist_len > 0)
4069     qsort(rlist, rlist_len, sizeof(rlist[0]), cmpstringp);
4070
4071   fout = fopen(argv[arg_out], "w");
4072   my_assert_not(fout, NULL);
4073
4074   eq_alloc = 128;
4075   g_eqs = malloc(eq_alloc * sizeof(g_eqs[0]));
4076   my_assert_not(g_eqs, NULL);
4077
4078   for (i = 0; i < ARRAY_SIZE(g_label_refs); i++) {
4079     g_label_refs[i].i = -1;
4080     g_label_refs[i].next = NULL;
4081   }
4082
4083   while (fgets(line, sizeof(line), fasm))
4084   {
4085     wordc = 0;
4086     asmln++;
4087
4088     p = sskip(line);
4089     if (*p == 0)
4090       continue;
4091
4092     // get rid of random tabs
4093     for (i = 0; line[i] != 0; i++)
4094       if (line[i] == '\t')
4095         line[i] = ' ';
4096
4097     if (*p == ';')
4098     {
4099       if (p[2] == '=' && IS_START(p, "; =============== S U B"))
4100         goto do_pending_endp; // eww..
4101
4102       if (p[2] == 'A' && IS_START(p, "; Attributes:"))
4103       {
4104         static const char *attrs[] = {
4105           "bp-based frame",
4106           "library function",
4107           "static",
4108           "noreturn",
4109           "thunk",
4110           "fpd=",
4111         };
4112
4113         // parse IDA's attribute-list comment
4114         g_ida_func_attr = 0;
4115         p = sskip(p + 13);
4116
4117         for (; *p != 0; p = sskip(p)) {
4118           for (i = 0; i < ARRAY_SIZE(attrs); i++) {
4119             if (!strncmp(p, attrs[i], strlen(attrs[i]))) {
4120               g_ida_func_attr |= 1 << i;
4121               p += strlen(attrs[i]);
4122               break;
4123             }
4124           }
4125           if (i == ARRAY_SIZE(attrs)) {
4126             anote("unparsed IDA attr: %s\n", p);
4127             break;
4128           }
4129           if (IS(attrs[i], "fpd=")) {
4130             p = next_word(words[0], sizeof(words[0]), p);
4131             // ignore for now..
4132           }
4133         }
4134       }
4135       else if (p[2] == 'S' && IS_START(p, "; START OF FUNCTION CHUNK FOR "))
4136       {
4137         p += 30;
4138         next_word(words[0], sizeof(words[0]), p);
4139         if (words[0][0] == 0)
4140           aerr("missing name for func chunk?\n");
4141
4142         if (!scanned_ahead) {
4143           add_func_chunk(fasm, words[0], asmln);
4144           func_chunks_sorted = 0;
4145         }
4146       }
4147       else if (p[2] == 'E' && IS_START(p, "; END OF FUNCTION CHUNK"))
4148       {
4149         if (func_chunk_i >= 0) {
4150           if (func_chunk_i < func_chunk_cnt
4151             && IS(func_chunks[func_chunk_i].name, g_func))
4152           {
4153             // move on to next chunk
4154             ret = fseek(fasm, func_chunks[func_chunk_i].fptr, SEEK_SET);
4155             if (ret)
4156               aerr("seek failed for '%s' chunk #%d\n",
4157                 g_func, func_chunk_i);
4158             asmln = func_chunks[func_chunk_i].asmln;
4159             func_chunk_i++;
4160           }
4161           else {
4162             if (func_chunk_ret == 0)
4163               aerr("no return from chunk?\n");
4164             fseek(fasm, func_chunk_ret, SEEK_SET);
4165             asmln = func_chunk_ret_ln;
4166             func_chunk_ret = 0;
4167             pending_endp = 1;
4168           }
4169         }
4170       }
4171       else if (p[2] == 'F' && IS_START(p, "; FUNCTION CHUNK AT ")) {
4172         func_chunks_used = 1;
4173         p += 20;
4174         if (IS_START(g_func, "sub_")) {
4175           unsigned long addr = strtoul(p, NULL, 16);
4176           unsigned long f_addr = strtoul(g_func + 4, NULL, 16);
4177           if (addr > f_addr && !scanned_ahead) {
4178             anote("scan_ahead caused by '%s', addr %lx\n",
4179               g_func, addr);
4180             scan_ahead(fasm);
4181             scanned_ahead = 1;
4182             func_chunks_sorted = 0;
4183           }
4184         }
4185       }
4186       continue;
4187     } // *p == ';'
4188
4189 parse_words:
4190     for (i = wordc; i < ARRAY_SIZE(words); i++)
4191       words[i][0] = 0;
4192     for (wordc = 0; wordc < ARRAY_SIZE(words); wordc++) {
4193       p = sskip(next_word_s(words[wordc], sizeof(words[0]), p));
4194       if (*p == 0 || *p == ';') {
4195         wordc++;
4196         break;
4197       }
4198     }
4199     if (*p != 0 && *p != ';')
4200       aerr("too many words\n");
4201
4202     // alow asm patches in comments
4203     if (*p == ';' && IS_START(p, "; sctpatch:")) {
4204       p = sskip(p + 11);
4205       if (*p == 0 || *p == ';')
4206         continue;
4207       goto parse_words; // lame
4208     }
4209
4210     if (wordc == 0) {
4211       // shouldn't happen
4212       awarn("wordc == 0?\n");
4213       continue;
4214     }
4215
4216     // don't care about this:
4217     if (words[0][0] == '.'
4218         || IS(words[0], "include")
4219         || IS(words[0], "assume") || IS(words[1], "segment")
4220         || IS(words[0], "align"))
4221     {
4222       continue;
4223     }
4224
4225 do_pending_endp:
4226     // do delayed endp processing to collect switch jumptables
4227     if (pending_endp) {
4228       if (in_func && !skip_func && wordc >= 2
4229           && ((words[0][0] == 'd' && words[0][2] == 0)
4230               || (words[1][0] == 'd' && words[1][2] == 0)))
4231       {
4232         i = 1;
4233         if (words[1][0] == 'd' && words[1][2] == 0) {
4234           // label
4235           if (g_func_pd_cnt >= pd_alloc) {
4236             pd_alloc = pd_alloc * 2 + 16;
4237             g_func_pd = realloc(g_func_pd,
4238               sizeof(g_func_pd[0]) * pd_alloc);
4239             my_assert_not(g_func_pd, NULL);
4240           }
4241           pd = &g_func_pd[g_func_pd_cnt];
4242           g_func_pd_cnt++;
4243           memset(pd, 0, sizeof(*pd));
4244           strcpy(pd->label, words[0]);
4245           pd->type = OPT_CONST;
4246           pd->lmod = lmod_from_directive(words[1]);
4247           i = 2;
4248         }
4249         else {
4250           lmod = lmod_from_directive(words[0]);
4251           if (lmod != pd->lmod)
4252             aerr("lmod change? %d->%d\n", pd->lmod, lmod);
4253         }
4254
4255         if (pd->count_alloc < pd->count + wordc) {
4256           pd->count_alloc = pd->count_alloc * 2 + 14 + wordc;
4257           pd->d = realloc(pd->d, sizeof(pd->d[0]) * pd->count_alloc);
4258           my_assert_not(pd->d, NULL);
4259         }
4260         for (; i < wordc; i++) {
4261           if (IS(words[i], "offset")) {
4262             pd->type = OPT_OFFSET;
4263             i++;
4264           }
4265           p = strchr(words[i], ',');
4266           if (p != NULL)
4267             *p = 0;
4268           if (pd->type == OPT_OFFSET)
4269             pd->d[pd->count].u.label = strdup(words[i]);
4270           else
4271             pd->d[pd->count].u.val = parse_number(words[i]);
4272           pd->d[pd->count].bt_i = -1;
4273           pd->count++;
4274         }
4275         continue;
4276       }
4277
4278       if (in_func && !skip_func)
4279         gen_func(fout, g_fhdr, g_func, pi);
4280
4281       pending_endp = 0;
4282       in_func = 0;
4283       g_ida_func_attr = 0;
4284       skip_warned = 0;
4285       skip_func = 0;
4286       g_func[0] = 0;
4287       func_chunks_used = 0;
4288       func_chunk_i = -1;
4289       if (pi != 0) {
4290         memset(&ops, 0, pi * sizeof(ops[0]));
4291         memset(g_labels, 0, pi * sizeof(g_labels[0]));
4292         pi = 0;
4293       }
4294       g_eqcnt = 0;
4295       for (i = 0; i < g_func_pd_cnt; i++) {
4296         pd = &g_func_pd[i];
4297         if (pd->type == OPT_OFFSET) {
4298           for (j = 0; j < pd->count; j++)
4299             free(pd->d[j].u.label);
4300         }
4301         free(pd->d);
4302         pd->d = NULL;
4303       }
4304       g_func_pd_cnt = 0;
4305       pd = NULL;
4306       if (wordc == 0)
4307         continue;
4308     }
4309
4310     if (IS(words[1], "proc")) {
4311       if (in_func)
4312         aerr("proc '%s' while in_func '%s'?\n",
4313           words[0], g_func);
4314       p = words[0];
4315       if ((g_ida_func_attr & IDAFA_THUNK)
4316        || bsearch(&p, rlist, rlist_len, sizeof(rlist[0]), cmpstringp))
4317         skip_func = 1;
4318       strcpy(g_func, words[0]);
4319       set_label(0, words[0]);
4320       in_func = 1;
4321       continue;
4322     }
4323
4324     if (IS(words[1], "endp"))
4325     {
4326       if (!in_func)
4327         aerr("endp '%s' while not in_func?\n", words[0]);
4328       if (!IS(g_func, words[0]))
4329         aerr("endp '%s' while in_func '%s'?\n",
4330           words[0], g_func);
4331
4332       if (!skip_func && func_chunks_used) {
4333         // start processing chunks
4334         struct chunk_item *ci, key = { g_func, 0 };
4335
4336         func_chunk_ret = ftell(fasm);
4337         func_chunk_ret_ln = asmln;
4338         if (!func_chunks_sorted) {
4339           qsort(func_chunks, func_chunk_cnt,
4340             sizeof(func_chunks[0]), cmp_chunks);
4341           func_chunks_sorted = 1;
4342         }
4343         ci = bsearch(&key, func_chunks, func_chunk_cnt,
4344                sizeof(func_chunks[0]), cmp_chunks);
4345         if (ci == NULL)
4346           aerr("'%s' needs chunks, but none found\n", g_func);
4347         func_chunk_i = ci - func_chunks;
4348         for (; func_chunk_i > 0; func_chunk_i--)
4349           if (!IS(func_chunks[func_chunk_i - 1].name, g_func))
4350             break;
4351
4352         ret = fseek(fasm, func_chunks[func_chunk_i].fptr, SEEK_SET);
4353         if (ret)
4354           aerr("seek failed for '%s' chunk #%d\n", g_func, func_chunk_i);
4355         asmln = func_chunks[func_chunk_i].asmln;
4356         func_chunk_i++;
4357         continue;
4358       }
4359       pending_endp = 1;
4360       continue;
4361     }
4362
4363     if (wordc == 2 && IS(words[1], "ends"))
4364       break;
4365
4366     p = strchr(words[0], ':');
4367     if (p != NULL) {
4368       set_label(pi, words[0]);
4369       continue;
4370     }
4371
4372     if (!in_func || skip_func) {
4373       if (!skip_warned && !skip_func && g_labels[pi][0] != 0) {
4374         if (verbose)
4375           anote("skipping from '%s'\n", g_labels[pi]);
4376         skip_warned = 1;
4377       }
4378       g_labels[pi][0] = 0;
4379       continue;
4380     }
4381
4382     if (wordc > 1 && IS(words[1], "=")) {
4383       if (wordc != 5)
4384         aerr("unhandled equ, wc=%d\n", wordc);
4385       if (g_eqcnt >= eq_alloc) {
4386         eq_alloc *= 2;
4387         g_eqs = realloc(g_eqs, eq_alloc * sizeof(g_eqs[0]));
4388         my_assert_not(g_eqs, NULL);
4389       }
4390
4391       len = strlen(words[0]);
4392       if (len > sizeof(g_eqs[0].name) - 1)
4393         aerr("equ name too long: %d\n", len);
4394       strcpy(g_eqs[g_eqcnt].name, words[0]);
4395
4396       if (!IS(words[3], "ptr"))
4397         aerr("unhandled equ\n");
4398       if (IS(words[2], "dword"))
4399         g_eqs[g_eqcnt].lmod = OPLM_DWORD;
4400       else if (IS(words[2], "word"))
4401         g_eqs[g_eqcnt].lmod = OPLM_WORD;
4402       else if (IS(words[2], "byte"))
4403         g_eqs[g_eqcnt].lmod = OPLM_BYTE;
4404       else
4405         aerr("bad lmod: '%s'\n", words[2]);
4406
4407       g_eqs[g_eqcnt].offset = parse_number(words[4]);
4408       g_eqcnt++;
4409       continue;
4410     }
4411
4412     if (pi >= ARRAY_SIZE(ops))
4413       aerr("too many ops\n");
4414
4415     parse_op(&ops[pi], words, wordc);
4416     pi++;
4417   }
4418
4419   fclose(fout);
4420   fclose(fasm);
4421   fclose(g_fhdr);
4422
4423   return 0;
4424 }
4425
4426 // vim:ts=2:shiftwidth=2:expandtab