tools/cvt_data.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
  18 static const struct parsed_proto *g_func_sym_pp;
  19 static char g_comment[256];
  20 static int g_warn_cnt;
  21
  22 // note: must be in ascending order
  23 enum dx_type {
  24   DXT_UNSPEC,
  25   DXT_BYTE,
  26   DXT_WORD,
  27   DXT_DWORD,
  28   DXT_QUAD,
  29   DXT_TEN,
  30 };
  31
  32 #define anote(fmt, ...) \
  33         printf("%s:%d: note: " fmt, asmfn, asmln, ##__VA_ARGS__)
  34 #define awarn(fmt, ...) do { \
  35         printf("%s:%d: warning: " fmt, asmfn, asmln, ##__VA_ARGS__); \
  36   if (++g_warn_cnt == 10) { \
  37     fcloseall(); \
  38           exit(1); \
  39   } \
  40 } while (0)
  41 #define aerr(fmt, ...) do { \
  42         printf("%s:%d: error: " fmt, asmfn, asmln, ##__VA_ARGS__); \
  43   fcloseall(); \
  44         exit(1); \
  45 } while (0)
  46
  47 #include "masm_tools.h"
  48
  49 static char *next_word_s(char *w, size_t wsize, char *s)
  50 {
  51   int quote = 0;
  52         size_t i;
  53
  54         s = sskip(s);
  55
  56         for (i = 0; i < wsize - 1; i++) {
  57     if (s[i] == '\'')
  58       quote ^= 1;
  59                 if (s[i] == 0 || (!quote && (my_isblank(s[i]) || s[i] == ',')))
  60                         break;
  61                 w[i] = s[i];
  62         }
  63         w[i] = 0;
  64
  65         if (s[i] != 0 && !my_isblank(s[i]) && s[i] != ',')
  66                 printf("warning: '%s' truncated\n", w);
  67
  68         return s + i;
  69 }
  70
  71 static void next_section(FILE *fasm, char *name)
  72 {
  73   char words[2][256];
  74   char line[256];
  75   int wordc;
  76   char *p;
  77
  78   name[0] = 0;
  79
  80   while (fgets(line, sizeof(line), fasm))
  81   {
  82     wordc = 0;
  83     asmln++;
  84
  85     p = sskip(line);
  86     if (*p == 0)
  87       continue;
  88
  89     if (*p == ';') {
  90       while (strlen(line) == sizeof(line) - 1) {
  91         // one of those long comment lines..
  92         if (!fgets(line, sizeof(line), fasm))
  93           break;
  94       }
  95       continue;
  96     }
  97
  98     for (wordc = 0; wordc < ARRAY_SIZE(words); wordc++) {
  99       p = sskip(next_word(words[wordc], sizeof(words[0]), p));
 100       if (*p == 0 || *p == ';') {
 101         wordc++;
 102         break;
 103       }
 104     }
 105
 106     if (wordc < 2)
 107       continue;
 108
 109     if (!IS(words[1], "segment"))
 110       continue;
 111
 112     strcpy(name, words[0]);
 113     break;
 114   }
 115 }
 116
 117 static enum dx_type parse_dx_directive(const char *name)
 118 {
 119   if (IS(name, "dd"))
 120     return DXT_DWORD;
 121   if (IS(name, "dw"))
 122     return DXT_WORD;
 123   if (IS(name, "db"))
 124     return DXT_BYTE;
 125   if (IS(name, "dq"))
 126     return DXT_QUAD;
 127   if (IS(name, "dt"))
 128     return DXT_TEN;
 129
 130   return DXT_UNSPEC;
 131 }
 132
 133 static const char *type_name(enum dx_type type)
 134 {
 135   switch (type) {
 136   case DXT_BYTE:
 137     return ".byte";
 138   case DXT_WORD:
 139     return ".word";
 140   case DXT_DWORD:
 141     return ".long";
 142   case DXT_QUAD:
 143     return ".quad";
 144   case DXT_TEN:
 145     return ".tfloat";
 146   case DXT_UNSPEC:
 147     break;
 148   }
 149   return "<bad>";
 150 }
 151
 152 static const char *type_name_float(enum dx_type type)
 153 {
 154   switch (type) {
 155   case DXT_DWORD:
 156     return ".float";
 157   case DXT_QUAD:
 158     return ".double";
 159   case DXT_TEN:
 160     return ".tfloat";
 161   default:
 162     break;
 163   }
 164   return "<bad_float>";
 165 }
 166
 167 static int type_size(enum dx_type type)
 168 {
 169   switch (type) {
 170   case DXT_BYTE:
 171     return 1;
 172   case DXT_WORD:
 173     return 2;
 174   case DXT_DWORD:
 175     return 4;
 176   case DXT_QUAD:
 177     return 8;
 178   case DXT_TEN:
 179     return 10;
 180   case DXT_UNSPEC:
 181     break;
 182   }
 183   return -1;
 184 }
 185
 186 static char *escape_string(char *s)
 187 {
 188   char buf[256];
 189   char *t = buf;
 190
 191   for (; *s != 0; s++) {
 192     if (*s == '"') {
 193       strcpy(t, "\\22");
 194       t += strlen(t);
 195       continue;
 196     }
 197     if (*s == '\\') {
 198       strcpy(t, "\\\\");
 199       t += strlen(t);
 200       continue;
 201     }
 202     *t++ = *s;
 203   }
 204   *t = *s;
 205   return strcpy(s, buf);
 206 }
 207
 208 static void sprint_pp_short(const struct parsed_proto *pp, char *buf,
 209   size_t buf_size)
 210 {
 211   char *p = buf;
 212   size_t l;
 213   int i;
 214
 215   if (pp->ret_type.is_ptr)
 216     *p++ = 'p';
 217   else if (IS(pp->ret_type.name, "void"))
 218     *p++ = 'v';
 219   else
 220     *p++ = 'i';
 221   *p++ = '(';
 222   l = 2;
 223
 224   for (i = 0; i < pp->argc; i++) {
 225     if (pp->arg[i].reg != NULL)
 226       snprintf(buf + l, buf_size - l, "%s%s",
 227         i == 0 ? "" : ",", pp->arg[i].reg);
 228     else
 229       snprintf(buf + l, buf_size - l, "%sa%d",
 230         i == 0 ? "" : ",", i + 1);
 231     l = strlen(buf);
 232   }
 233   snprintf(buf + l, buf_size - l, ")");
 234 }
 235
 236 static const struct parsed_proto *check_var(FILE *fhdr,
 237   const char *sym, const char *varname)
 238 {
 239   const struct parsed_proto *pp, *pp_sym;
 240   char fp_sym[256], fp_var[256];
 241   int i, bad = 0;
 242
 243   pp = proto_parse(fhdr, varname, 1);
 244   if (pp == NULL) {
 245     if (IS_START(varname, "sub_"))
 246       awarn("sub_ sym missing proto: '%s'\n", varname);
 247     return NULL;
 248   }
 249
 250   if (!pp->is_func && !pp->is_fptr)
 251     return NULL;
 252
 253   pp_print(fp_var, sizeof(fp_var), pp);
 254
 255   if (pp->argc_reg == 0)
 256     goto check_sym;
 257   if (pp->argc_reg == 1 && pp->argc_stack == 0
 258     && IS(pp->arg[0].reg, "ecx"))
 259   {
 260     goto check_sym;
 261   }
 262   if (pp->argc_reg != 2
 263     || !IS(pp->arg[0].reg, "ecx")
 264     || !IS(pp->arg[1].reg, "edx"))
 265   {
 266     awarn("unhandled reg call: %s\n", fp_var);
 267   }
 268
 269 check_sym:
 270   sprint_pp_short(pp, g_comment, sizeof(g_comment));
 271
 272   if (sym != NULL) {
 273     g_func_sym_pp = NULL;
 274     pp_sym = proto_parse(fhdr, sym, 1);
 275     if (pp_sym == NULL)
 276       return pp;
 277     if (!pp_sym->is_fptr)
 278       aerr("func ptr data, but label '%s' !is_fptr\n", pp_sym->name);
 279     g_func_sym_pp = pp_sym;
 280   }
 281   else {
 282     pp_sym = g_func_sym_pp;
 283     if (pp_sym == NULL)
 284       return pp;
 285   }
 286
 287   if (pp->argc != pp_sym->argc || pp->argc_reg != pp_sym->argc_reg)
 288     bad = 1;
 289   else {
 290     for (i = 0; i < pp->argc; i++) {
 291       if ((pp->arg[i].reg != NULL) != (pp_sym->arg[i].reg != NULL)) {
 292         bad = 1;
 293         break;
 294       }
 295       if ((pp->arg[i].reg != NULL)
 296         && !IS(pp->arg[i].reg, pp_sym->arg[i].reg))
 297       {
 298         bad = 1;
 299         break;
 300       }
 301     }
 302   }
 303
 304   if (bad) {
 305     pp_print(fp_sym, sizeof(fp_sym), pp_sym);
 306     anote("var: %s\n", fp_var);
 307     anote("sym: %s\n", fp_sym);
 308     awarn("^ mismatch\n");
 309   }
 310
 311   return pp;
 312 }
 313
 314 static void output_decorated_pp(FILE *fout,
 315   const struct parsed_proto *pp)
 316 {
 317   if (pp->name[0] != '_')
 318     fprintf(fout, pp->is_fastcall ? "@" : "_");
 319   fprintf(fout, "%s", pp->name);
 320   if (pp->is_stdcall && pp->argc > 0)
 321     fprintf(fout, "@%d", pp->argc * 4);
 322 }
 323
 324 static int cmpstringp(const void *p1, const void *p2)
 325 {
 326   return strcmp(*(char * const *)p1, *(char * const *)p2);
 327 }
 328
 329 int main(int argc, char *argv[])
 330 {
 331   FILE *fout, *fasm, *fhdr, *frlist;
 332   const struct parsed_proto *pp;
 333   int no_decorations = 0;
 334   char words[20][256];
 335   char word[256];
 336   char line[256];
 337   unsigned long val;
 338   unsigned long cnt;
 339   const char *sym;
 340   enum dx_type type;
 341   char **pub_syms;
 342   int pub_sym_cnt = 0;
 343   int pub_sym_alloc;
 344   char **rlist;
 345   int rlist_cnt = 0;
 346   int rlist_alloc;
 347   int is_label;
 348   int is_bss;
 349   int wordc;
 350   int first;
 351   int arg_out;
 352   int arg = 1;
 353   int len;
 354   int w, i;
 355   char *p;
 356   char *p2;
 357
 358   if (argc < 4) {
 359     // -nd: no symbol decorations
 360     printf("usage:\n%s [-nd] <.s> <.asm> <hdrf> [rlist]*\n",
 361       argv[0]);
 362     return 1;
 363   }
 364
 365   for (arg = 1; arg < argc; arg++) {
 366     if (IS(argv[arg], "-nd"))
 367       no_decorations = 1;
 368     else
 369       break;
 370   }
 371
 372   arg_out = arg++;
 373
 374   asmfn = argv[arg++];
 375   fasm = fopen(asmfn, "r");
 376   my_assert_not(fasm, NULL);
 377
 378   hdrfn = argv[arg++];
 379   fhdr = fopen(hdrfn, "r");
 380   my_assert_not(fhdr, NULL);
 381
 382   fout = fopen(argv[arg_out], "w");
 383   my_assert_not(fout, NULL);
 384
 385   pub_sym_alloc = 64;
 386   pub_syms = malloc(pub_sym_alloc * sizeof(pub_syms[0]));
 387   my_assert_not(pub_syms, NULL);
 388
 389   rlist_alloc = 64;
 390   rlist = malloc(rlist_alloc * sizeof(rlist[0]));
 391   my_assert_not(rlist, NULL);
 392
 393   for (; arg < argc; arg++) {
 394     frlist = fopen(argv[arg], "r");
 395     my_assert_not(frlist, NULL);
 396
 397     while (fgets(line, sizeof(line), frlist)) {
 398       p = sskip(line);
 399       if (*p == 0 || *p == ';')
 400         continue;
 401
 402       p = next_word(words[0], sizeof(words[0]), p);
 403       if (words[0][0] == 0)
 404         continue;
 405
 406       if (rlist_cnt >= rlist_alloc) {
 407         rlist_alloc = rlist_alloc * 2 + 64;
 408         rlist = realloc(rlist, rlist_alloc * sizeof(rlist[0]));
 409         my_assert_not(rlist, NULL);
 410       }
 411       rlist[rlist_cnt++] = strdup(words[0]);
 412     }
 413
 414     fclose(frlist);
 415     frlist = NULL;
 416   }
 417
 418   if (rlist_cnt > 0)
 419     qsort(rlist, rlist_cnt, sizeof(rlist[0]), cmpstringp);
 420
 421   while (1) {
 422     next_section(fasm, line);
 423     if (feof(fasm))
 424       break;
 425     if (IS(line + 1, "text"))
 426       continue;
 427
 428     if (IS(line + 1, "rdata"))
 429       fprintf(fout, "\n.section .rodata\n");
 430     else if (IS(line + 1, "data"))
 431       fprintf(fout, "\n.data\n");
 432     else
 433       aerr("unhandled section: '%s'\n", line);
 434
 435     fprintf(fout, ".align 4\n");
 436
 437     while (fgets(line, sizeof(line), fasm))
 438     {
 439       sym = NULL;
 440       asmln++;
 441
 442       p = sskip(line);
 443       if (*p == 0 || *p == ';')
 444         continue;
 445
 446       for (wordc = 0; wordc < ARRAY_SIZE(words); wordc++) {
 447         p = sskip(next_word_s(words[wordc], sizeof(words[0]), p));
 448         if (*p == 0 || *p == ';') {
 449           wordc++;
 450           break;
 451         }
 452         if (*p == ',') {
 453           p = sskip(p + 1);
 454         }
 455       }
 456
 457       if (*p == ';') {
 458         p = sskip(p + 1);
 459         if (IS_START(p, "sctclrtype"))
 460           g_func_sym_pp = NULL;
 461       }
 462
 463       if (wordc == 2 && IS(words[1], "ends"))
 464         break;
 465       if (wordc <= 2 && IS(words[0], "end"))
 466         break;
 467       if (wordc < 2)
 468         aerr("unhandled: '%s'\n", words[0]);
 469
 470       // don't cares
 471       if (IS(words[0], "assume"))
 472         continue;
 473
 474       if (IS(words[0], "align")) {
 475         val = parse_number(words[1]);
 476         fprintf(fout, "\t\t  .align %ld", val);
 477         goto fin;
 478       }
 479
 480       w = 1;
 481       type = parse_dx_directive(words[0]);
 482       if (type == DXT_UNSPEC) {
 483         type = parse_dx_directive(words[1]);
 484         sym = words[0];
 485         w = 2;
 486       }
 487       if (type == DXT_UNSPEC)
 488         aerr("unhandled decl: '%s %s'\n", words[0], words[1]);
 489
 490       if (sym != NULL) {
 491         // public/global name
 492         if (pub_sym_cnt >= pub_sym_alloc) {
 493           pub_sym_alloc *= 2;
 494           pub_syms = realloc(pub_syms, pub_sym_alloc * sizeof(pub_syms[0]));
 495           my_assert_not(pub_syms, NULL);
 496         }
 497         pub_syms[pub_sym_cnt++] = strdup(sym);
 498
 499         pp = proto_parse(fhdr, sym, 1);
 500         if (pp != NULL)
 501           g_func_sym_pp = NULL;
 502
 503         len = strlen(sym);
 504         fprintf(fout, "%s%s:", no_decorations ? "" : "_", sym);
 505
 506         len += 2;
 507         if (len < 8)
 508           fprintf(fout, "\t");
 509         if (len < 16)
 510           fprintf(fout, "\t");
 511         if (len <= 16)
 512           fprintf(fout, "  ");
 513         else
 514           fprintf(fout, " ");
 515       }
 516       else {
 517         fprintf(fout, "\t\t  ");
 518       }
 519
 520       if (type == DXT_BYTE
 521         && (words[w][0] == '\''
 522             || (w + 1 < wordc && words[w + 1][0] == '\'')))
 523       {
 524         // string; use asciz for most common case
 525         if (w == wordc - 2 && IS(words[w + 1], "0")) {
 526           fprintf(fout, ".asciz \"");
 527           wordc--;
 528         }
 529         else
 530           fprintf(fout, ".ascii \"");
 531
 532         for (; w < wordc; w++) {
 533           if (words[w][0] == '\'') {
 534             p = words[w] + 1;
 535             p2 = strchr(p, '\'');
 536             if (p2 == NULL)
 537               aerr("unterminated string? '%s'\n", p);
 538             memcpy(word, p, p2 - p);
 539             word[p2 - p] = 0;
 540             fprintf(fout, "%s", escape_string(word));
 541           }
 542           else {
 543             val = parse_number(words[w]);
 544             if (val & ~0xff)
 545               aerr("bad string trailing byte?\n");
 546             fprintf(fout, "\\x%02lx", val);
 547           }
 548         }
 549         fprintf(fout, "\"");
 550         goto fin;
 551       }
 552
 553       if (w == wordc - 2) {
 554         if (IS_START(words[w + 1], "dup(")) {
 555           cnt = parse_number(words[w]);
 556           p = words[w + 1] + 4;
 557           p2 = strchr(p, ')');
 558           if (p2 == NULL)
 559             aerr("bad dup?\n");
 560           memmove(word, p, p2 - p);
 561           word[p2 - p] = 0;
 562
 563           val = 0;
 564           if (!IS(word, "?"))
 565             val = parse_number(word);
 566
 567           fprintf(fout, ".fill 0x%02lx,%d,0x%02lx",
 568             cnt, type_size(type), val);
 569           goto fin;
 570         }
 571       }
 572
 573       if (type == DXT_DWORD && words[w][0] == '\''
 574         && words[w][5] == '\'' && strlen(words[w]) == 6)
 575       {
 576         if (w != wordc - 1)
 577           aerr("TODO\n");
 578
 579         p = words[w];
 580         val = (p[1] << 24) | (p[2] << 16) | (p[3] << 8) | p[4];
 581         fprintf(fout, ".long 0x%lx", val);
 582         snprintf(g_comment, sizeof(g_comment), "%s", words[w]);
 583         goto fin;
 584       }
 585
 586       if (type >= DXT_DWORD && strchr(words[w], '.'))
 587       {
 588         if (w != wordc - 1)
 589           aerr("TODO\n");
 590
 591         fprintf(fout, "%s %s", type_name_float(type), words[w]);
 592         goto fin;
 593       }
 594
 595       first = 1;
 596       fprintf(fout, "%s ", type_name(type));
 597       for (; w < wordc; w++)
 598       {
 599         if (!first)
 600           fprintf(fout, ", ");
 601
 602         is_label = is_bss = 0;
 603         if (w <= wordc - 2 && IS(words[w], "offset")) {
 604           is_label = 1;
 605           w++;
 606         }
 607         else if (IS(words[w], "?")) {
 608           is_bss = 1;
 609         }
 610         else if (type == DXT_DWORD
 611                  && !('0' <= words[w][0] && words[w][0] <= '9'))
 612         {
 613           // assume label
 614           is_label = 1;
 615         }
 616
 617         if (is_bss) {
 618           fprintf(fout, "0");
 619         }
 620         else if (is_label) {
 621           p = words[w];
 622           if (IS_START(p, "loc_") || IS_START(p, "__imp")
 623              || strchr(p, '?') || strchr(p, '@')
 624              || bsearch(&p, rlist, rlist_cnt, sizeof(rlist[0]),
 625                   cmpstringp))
 626           {
 627             fprintf(fout, "0");
 628             snprintf(g_comment, sizeof(g_comment), "%s", p);
 629           }
 630           else {
 631             pp = check_var(fhdr, sym, p);
 632             if (pp == NULL) {
 633               fprintf(fout, "%s%s",
 634                 (no_decorations || p[0] == '_') ? "" : "_", p);
 635             }
 636             else {
 637               if (no_decorations)
 638                 fprintf(fout, "%s", pp->name);
 639               else
 640                 output_decorated_pp(fout, pp);
 641             }
 642           }
 643         }
 644         else {
 645           val = parse_number(words[w]);
 646           if (val < 10)
 647             fprintf(fout, "%ld", val);
 648           else
 649             fprintf(fout, "0x%lx", val);
 650         }
 651
 652         first = 0;
 653       }
 654
 655 fin:
 656       if (g_comment[0] != 0) {
 657         fprintf(fout, "\t\t# %s", g_comment);
 658         g_comment[0] = 0;
 659       }
 660       fprintf(fout, "\n");
 661     }
 662   }
 663
 664   fprintf(fout, "\n");
 665
 666   // dump public syms
 667   for (i = 0; i < pub_sym_cnt; i++)
 668     fprintf(fout, ".global %s%s\n",
 669       no_decorations ? "" : "_", pub_syms[i]);
 670
 671   fclose(fout);
 672   fclose(fasm);
 673   fclose(fhdr);
 674
 675   return 0;
 676 }
 677
 678 // vim:ts=2:shiftwidth=2:expandtab