tools/asmproc.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5 #include "my_assert.h"
   6 #include "my_str.h"
   7
   8 struct sl_item {
   9         char *name;
  10         unsigned int callsites:1;
  11         unsigned int found:1;
  12 };
  13
  14 static int cmp_sym(const void *p1_, const void *p2_)
  15 {
  16         const struct sl_item *p1 = p1_, *p2 = p2_;
  17         const char *s1 = p1->name, *s2 = p2->name;
  18         int i;
  19
  20         for (i = 0; ; i++) {
  21                 if ((s1[i] | s2[i]) == 0)
  22                         break;
  23
  24                 if (s1[i] == s2[i])
  25                         continue;
  26
  27                 if (s1[i] ==  0  && s2[i] == '@')
  28                         break;
  29                 if (s1[i] == '@' && s2[i] ==  0)
  30                         break;
  31
  32                 return s1[i] - s2[i];
  33         }
  34
  35         return 0;
  36 }
  37
  38 static int cmp_sym_sort(const void *p1_, const void *p2_)
  39 {
  40         const struct sl_item *p1 = p1_, *p2 = p2_;
  41         const char *s1 = p1->name, *s2 = p2->name;
  42         int ret;
  43
  44         ret = cmp_sym(p1_, p2_);
  45         if (ret == 0) {
  46                 printf("%s: dupe sym: '%s' '%s'\n", __func__, s1, s2);
  47                 exit(1);
  48         }
  49         return ret;
  50 }
  51
  52 void read_list(struct sl_item **sl_in, int *cnt, int *alloc,
  53         FILE *f, int callsites)
  54 {
  55         struct sl_item *sl = *sl_in;
  56         int c = *cnt;
  57         char line[256];
  58         char word[256];
  59
  60         while (fgets(line, sizeof(line), f) != NULL) {
  61                 next_word(word, sizeof(word), line);
  62                 if (word[0] == 0 || word[0] == ';' || word[0] == '#')
  63                         continue;
  64
  65                 sl[c].name = strdup(word);
  66                 sl[c].callsites = callsites;
  67                 sl[c].found = 0;
  68                 c++;
  69
  70                 if (c >= *alloc) {
  71                         *alloc *= 2;
  72                         sl = realloc(sl, *alloc * sizeof(sl[0]));
  73                         my_assert_not(sl, NULL);
  74                         memset(sl + c, 0, (*alloc - c) * sizeof(sl[0]));
  75                 }
  76         }
  77
  78         *sl_in = sl;
  79         *cnt = c;
  80 }
  81
  82 const char *sym_use(const struct sl_item *sym)
  83 {
  84         static char buf[256+3];
  85         int ret;
  86
  87         ret = snprintf(buf, sizeof(buf), "rm_%s", sym->name);
  88         if (ret >= sizeof(buf)) {
  89                 printf("truncation detected: '%s'\n", buf);
  90                 exit(1);
  91         }
  92
  93         return buf;
  94 }
  95
  96 #define IS(w, y) !strcasecmp(w, y)
  97 #define IS_OR2(w, x, y) (IS(w, x) || IS(w, y))
  98 #define IS_OR3(w, x, y, z) (IS(w, x) || IS(w, y) || IS(w, z))
  99
 100 int main(int argc, char *argv[])
 101 {
 102         struct sl_item *symlist, *sym, ssym = { NULL, };
 103         int patch_callsites = 0;
 104         FILE *fout, *fin, *f;
 105         int symlist_alloc;
 106         int symlist_cnt;
 107         char line[256];
 108         char word[256];
 109         char word2[256];
 110         char word3[256];
 111         char word4[256];
 112         char word5[256];
 113         char word6[256];
 114         char func[256];
 115         char *p;
 116         int i;
 117
 118         if (argc < 4) {
 119                 // -c - patch callsites
 120                 printf("usage:\n%s <asmf_out> <asmf_in> [[-c] <listf>]*>\n",
 121                         argv[0]);
 122                 return 1;
 123         }
 124
 125         symlist_alloc = 16;
 126         symlist_cnt = 0;
 127         symlist = calloc(symlist_alloc, sizeof(symlist[0]));
 128         my_assert_not(symlist, NULL);
 129
 130         for (i = 3; i < argc; i++) {
 131                 if (strcmp(argv[i], "-c") == 0) {
 132                         patch_callsites = 1;
 133                         continue;
 134                 }
 135
 136                 f = fopen(argv[i], "r");
 137                 my_assert_not(f, NULL);
 138                 read_list(&symlist, &symlist_cnt, &symlist_alloc,
 139                         f, patch_callsites);
 140                 fclose(f);
 141
 142                 patch_callsites = 0;
 143         }
 144
 145         qsort(symlist, symlist_cnt, sizeof(symlist[0]), cmp_sym_sort);
 146
 147 #if 0
 148         printf("symlist:\n");
 149         for (i = 0; i < symlist_cnt; i++)
 150                 printf("%d '%s'\n", symlist[i].callsites, symlist[i].name);
 151 #endif
 152
 153         fin = fopen(argv[2], "r");
 154         my_assert_not(fin, NULL);
 155
 156         fout = fopen(argv[1], "w");
 157         my_assert_not(fout, NULL);
 158
 159         while (fgets(line, sizeof(line), fin))
 160         {
 161                 p = sskip(line);
 162                 if (*p == 0 || *p == ';')
 163                         goto pass;
 164
 165                 p = sskip(next_word(word, sizeof(word), p));
 166                 if (*p == 0 || *p == ';')
 167                         goto pass; // need at least 2 words
 168
 169                 p = next_word(word2, sizeof(word2), p);
 170
 171                 if (IS_OR2(word2, "proc", "endp")) {
 172                         if (IS(word2, "proc"))
 173                                 strcpy(func, word);
 174                         else
 175                                 func[0] = 0;
 176
 177                         ssym.name = word;
 178                         sym = bsearch(&ssym, symlist, symlist_cnt,
 179                                 sizeof(symlist[0]), cmp_sym);
 180                         if (sym != NULL) {
 181                                 sym->found = 1;
 182                                 fprintf(fout, "rm_%s\t%s%s", word, word2, p);
 183                                 continue;
 184                         }
 185                 }
 186
 187                 if (IS_OR3(word, "call", "jmp", "public")) {
 188                         ssym.name = word2;
 189                         sym = bsearch(&ssym, symlist, symlist_cnt,
 190                                 sizeof(symlist[0]), cmp_sym);
 191                         if (sym != NULL
 192                             && (sym->callsites || IS(word2, func)))
 193                         {
 194                                 fprintf(fout, "\t\t%s\t%s%s", word,
 195                                         sym_use(sym), p);
 196                                 continue;
 197                         }
 198                 }
 199
 200                 p = sskip(p);
 201                 if (*p == 0 || *p == ';')
 202                         goto pass; // need at least 3 words
 203
 204                 p = next_word(word3, sizeof(word3), p);
 205
 206                 // dd offset <sym>
 207                 // push offset <sym>
 208                 // jcc short <sym>
 209                 if ( (IS_OR2(word, "dd", "push") && IS(word2, "offset"))
 210                   || (word[0] == 'j' && IS(word2, "short")) ) {
 211                         ssym.name = word3;
 212                         sym = bsearch(&ssym, symlist, symlist_cnt,
 213                                 sizeof(symlist[0]), cmp_sym);
 214                         if (sym != NULL
 215                             && (sym->callsites || IS(word3, func)))
 216                         {
 217                                 fprintf(fout, "\t\t%s %s %s%s",
 218                                         word, word2, sym_use(sym), p);
 219                                 continue;
 220                         }
 221                 }
 222
 223                 p = sskip(p);
 224                 if (*p == 0 || *p == ';')
 225                         goto pass; // need at least 4 words
 226
 227                 p = next_word(word4, sizeof(word4), p);
 228
 229                 // <name> dd offset <sym>
 230                 if (IS(word2, "dd") && IS(word3, "offset")) {
 231                         ssym.name = word4;
 232                         sym = bsearch(&ssym, symlist, symlist_cnt,
 233                                 sizeof(symlist[0]), cmp_sym);
 234                         if (sym != NULL && sym->callsites) {
 235                                 fprintf(fout, "%s\tdd offset %s%s", word,
 236                                         sym_use(sym), p);
 237                                 continue;
 238                         }
 239                 }
 240
 241                 // mov <something>, offset <sym>
 242                 // jcc <some> ptr <sym>
 243                 if ( (IS(word, "mov") && IS(word3, "offset"))
 244                   || (word[0] == 'j' && IS(word3, "ptr")) ) {
 245                         ssym.name = word4;
 246                         sym = bsearch(&ssym, symlist, symlist_cnt,
 247                                 sizeof(symlist[0]), cmp_sym);
 248                         if (sym != NULL && sym->callsites) {
 249                                 fprintf(fout, "\t\t%s\t%s %s %s%s",
 250                                         word, word2, word3,
 251                                         sym_use(sym), p);
 252                                 continue;
 253                         }
 254                 }
 255
 256                 p = sskip(p);
 257                 if (*p == 0 || *p == ';')
 258                         goto pass; // need at least 5 words
 259
 260                 p = next_word(word5, sizeof(word5), p);
 261
 262                 p = sskip(p);
 263                 if (*p == 0 || *p == ';')
 264                         goto pass; // need at least 6 words
 265
 266                 p = next_word(word6, sizeof(word6), p);
 267
 268                 // <op> dword ptr <something>, offset <sym>
 269                 if ( IS(word2, "dword") && IS(word3, "ptr")
 270                   && IS(word5, "offset") ) {
 271                         ssym.name = word6;
 272                         sym = bsearch(&ssym, symlist, symlist_cnt,
 273                                 sizeof(symlist[0]), cmp_sym);
 274                         if (sym != NULL && sym->callsites) {
 275                                 fprintf(fout, "\t\t%s\tdword ptr %s offset %s%s",
 276                                         word, word4, sym_use(sym), p);
 277                                 continue;
 278                         }
 279                 }
 280
 281 pass:
 282                 fwrite(line, 1, strlen(line), fout);
 283         }
 284
 285         for (i = 0; i < symlist_cnt; i++) {
 286                 if (!symlist[i].found)
 287                         printf("warning: sym '%s' not found\n", symlist[i].name);
 288         }
 289
 290         fclose(fin);
 291         fclose(fout);
 292
 293         return 0;
 294 }