Script.c

   1 #define _GNU_SOURCE
   2 #include "Script.h"
   3 #include "Script_internal.h"
   4 #include "endianness.h"
   5 #include <string.h>
   6 #include <stdlib.h>
   7 #include <assert.h>
   8
   9 #define COMMENT(F, FMT, ...) fprintf(F, "; " FMT, ##__VA_ARGS__)
  10
  11 static int dump_sections(AF* a, FILE *f, size_t start, size_t count) {
  12         if(count) {
  13                 AF_set_pos(a, start);
  14                 fprintf(f, ".sections\n");
  15                 char buf[300];
  16                 size_t i = 0;
  17                 for(; i < count; i++) {
  18                         if(!AF_read_string(a, buf, sizeof(buf))) return 0;
  19                         int off = AF_read_int(a);
  20                         fprintf(f, "\"%s\" = %d\n", buf, off);
  21                 }
  22                 fprintf(f, "\n");
  23         }
  24         return 1;
  25 }
  26
  27 static int dump_strings(AF* a, FILE *f, size_t start, size_t len) {
  28         if(!len) return 1;
  29         AF_set_pos(a, start);
  30         fprintf(f, ".%s\n\"", "strings");
  31         char buf[4096];
  32         while(len) {
  33                 size_t togo = len > sizeof(buf) ? sizeof(buf) : len;
  34                 if(togo != (size_t) AF_read(a, buf, togo))
  35                         return 0;
  36                 size_t i;
  37                 for(i = 0; i < togo; i++) {
  38                         len --;
  39                         if(!buf[i]) {
  40                                 fprintf(f, "\"\n");
  41                                 if(len) fprintf(f, "\"");
  42                         } else
  43                                 fprintf(f, "%c", buf[i]);
  44                 }
  45         }
  46         return 1;
  47 }
  48
  49 static void free_fixup_data(struct fixup_data *ret) {
  50         size_t i;
  51         for(i = 0; i <= FIXUP_MAX; i++) {
  52                 free(ret->codeindex_per[i]);
  53         }
  54         free(ret->codeindex);
  55         free(ret->types);
  56 }
  57
  58 /* fixup_data needs to be zeroed */
  59 static int get_fixups(AF* a, size_t start, size_t count, struct fixup_data *ret) {
  60         size_t i;
  61         if(!(ret->types = malloc(count))) goto err;
  62         if(!(ret->codeindex = malloc(count * sizeof(unsigned)))) goto err;
  63
  64         AF_set_pos(a, start);
  65
  66         if(count != (size_t) AF_read(a, ret->types, count)) goto err;
  67         for(i = 0; i < count; i++) {
  68                 assert(ret->types[i]>=0 && ret->types[i]<=FIXUP_MAX);
  69                 ret->count[ret->types[i]]++;
  70                 ret->codeindex[i] = AF_read_uint(a);
  71         }
  72         for(i = 0; i <= FIXUP_MAX; i++) {
  73                 ret->codeindex_per[i] = malloc(ret->count[i] * sizeof(unsigned));
  74                 if(!ret->codeindex_per[i]) goto err;
  75                 ret->count[i] = 0; /* reset to 0 to use as index i.t. next loop */
  76         }
  77
  78         for(i = 0; i < count; i++) {
  79                 ret->codeindex_per[ret->types[i]][ret->count[ret->types[i]]++] = ret->codeindex[i];
  80         }
  81
  82         return 1;
  83 err:
  84         free_fixup_data(ret);
  85         return 0;
  86 }
  87
  88 static int dump_fixups(FILE *f, size_t count, struct fixup_data *fxd) {
  89         static const char* typenames[] = {
  90                 [FIXUP_GLOBALDATA] = "FIXUP_GLOBALDATA",
  91                 [FIXUP_FUNCTION] = "FIXUP_FUNCTION",
  92                 [FIXUP_STRING] = "FIXUP_STRING",
  93                 [FIXUP_IMPORT] = "FIXUP_IMPORT",
  94                 [FIXUP_DATADATA] = "FIXUP_DATADATA",
  95                 [FIXUP_STACK] = "FIXUP_STACK",
  96         };
  97
  98         fprintf(f, ".%ss\n", "fixup");
  99         size_t i;
 100         for(i = 0; i < count; i++) {
 101                 fprintf(f, "%s: %.12u\n", typenames[(int)fxd->types[i]], fxd->codeindex[i]);
 102         }
 103         return 1;
 104 }
 105
 106
 107 static int dump_import_export(AF* a, FILE *f, size_t start, size_t count, int import) {
 108         static const char* secnames[2] = { "export", "import" };
 109         const char* secname = secnames[import];
 110         size_t i;
 111         char buf[256]; /* arbitrarily chosen */
 112         if(!count) return 1;
 113         AF_set_pos(a, start);
 114         fprintf(f, ".%ss\n", secname);
 115         for(i = 0; i < count; i++) {
 116                 if(!AF_read_string(a, buf, sizeof(buf))) return 0;
 117                 fprintf(f, "%.12zu\"%s\"\n", i, buf);
 118                 if(!import) {
 119                         unsigned int addr = AF_read_uint(a);
 120                         fprintf(f, "%d:%.12u\n", addr >> 24, addr & 0x00FFFFFF);
 121                 }
 122         }
 123         return 1;
 124 }
 125
 126 static struct function_export* get_exports(AF* a, size_t start, size_t count) {
 127         if(!count) return 0;
 128         struct function_export* fl = malloc(count * sizeof(struct function_export));
 129         AF_set_pos(a, start);
 130         char buf[4096]; size_t i;
 131         for(i = 0; i < count; i++) {
 132                 if(!AF_read_string(a, buf, sizeof(buf))) return 0;
 133                 fl[i].fn = strdup(buf);
 134                 unsigned int addr = AF_read_uint(a);
 135                 fl[i].type = addr >> 24;
 136                 fl[i].instr = (addr & 0x00FFFFFF);
 137         }
 138         return fl;
 139 }
 140
 141 static struct importlist get_imports(AF* a, size_t start, size_t count) {
 142         struct importlist ret = {0};
 143         if(!count) return ret;
 144         ret.names = malloc(count * sizeof(char*));
 145         if(!ret.names) return ret;
 146         AF_set_pos(a, start);
 147         char buf[4096]; size_t i;
 148         for(i = 0; i < count; i++) {
 149                 if(!AF_read_string(a, buf, sizeof(buf))) {
 150                         free(ret.names);
 151                         return (struct importlist) {0};
 152                 }
 153                 ret.names[i] = strdup(buf);
 154         }
 155         return ret;
 156 }
 157
 158 struct labels {
 159         unsigned count;
 160         unsigned *insno;
 161 };
 162
 163 static int sort_comp(const void* xp, const void *yp) {
 164         const unsigned *x = xp, *y = yp;
 165         if(*x == *y) return 0;
 166         else if(*x > *y) return 1;
 167         else return -1;
 168 }
 169
 170 #include "ags_cpu.h"
 171 static struct labels get_labels(unsigned *code, size_t count) {
 172         struct labels ret = {0, 0};
 173         if(!count) return ret;
 174         size_t capa = 0;
 175         unsigned *p = 0;
 176         size_t insno = 0;
 177         unsigned insn;
 178         while(insno < count) {
 179                 if(ret.count + 1 > capa) {
 180                         capa = capa ? capa * 2 : 16;
 181                         if(!(p = realloc(ret.insno, capa * sizeof(unsigned*)))) {
 182                                 if(ret.insno) free(ret.insno);
 183                                 ret.count = 0;
 184                                 ret.insno = 0;
 185                                 return ret;
 186                         } else ret.insno = p;
 187                 }
 188                 insn = code[insno] & 0x00ffffff;
 189                 insno++;
 190                 int isjmp = 0;
 191                 assert(insn < SCMD_MAX);
 192                 switch(insn) {
 193                         case SCMD_JZ: case SCMD_JMP: case SCMD_JNZ:
 194                                 isjmp = 1;
 195                         default:
 196                                 break;
 197                 }
 198                 size_t i = 0;
 199                 for(; i < opcodes[insn].argcount; i++) {
 200                         int val = code[insno];
 201                         insno++;
 202                         if(isjmp) {
 203                                 if((int) insno + val < 0 || insno + val >= count || code[insno + val] > SCMD_MAX) {
 204                                         dprintf(2, "error: label referenced from jump at %zu is out of bounds\n"
 205                                         "or points to non-instruction start code.\n", insno);
 206                                         assert(0);
 207                                 }
 208                                 ret.insno[ret.count] = insno + val;
 209                                 ret.count++;
 210                         }
 211                 }
 212         }
 213         qsort(ret.insno, ret.count, sizeof(unsigned), sort_comp);
 214         return ret;
 215 }
 216
 217 static struct strings get_strings(AF* a, size_t start, size_t size) {
 218         struct strings ret = {0,0,0};
 219         if(!size) return ret;
 220         if(!(ret.data = malloc(size))) return ret;
 221         AF_set_pos(a, start);
 222         if(size != (size_t) AF_read(a, ret.data, size)) {
 223                 free1:
 224                 free(ret.data);
 225                 retrn:
 226                 return ret;
 227         }
 228         size_t i, strcnt = 0;
 229         for(i = 0; i < size; i++) {
 230                 if(!ret.data[i]) strcnt++;
 231         }
 232         if(!(ret.strings = malloc(strcnt * sizeof(char*)))) goto free1;
 233         char* p = ret.data;
 234         size_t l = 0;
 235         strcnt = 0;
 236
 237         for(i = 0; i < size; i++) {
 238                 if(!ret.data[i]) {
 239                         ret.strings[strcnt] = p;
 240                         p += l + 1;
 241                         l = 0;
 242                         strcnt++;
 243                 } else
 244                         l++;
 245         }
 246         ret.count = strcnt;
 247         goto retrn;
 248 }
 249
 250 static char* get_varname(struct function_export* exp, size_t expcount, unsigned globaloffset) {
 251         size_t i = 0;
 252         for(; i < expcount; i++)
 253                 if(exp[i].type == EXPORT_DATA && exp[i].instr == globaloffset)
 254                         return exp[i].fn;
 255         return 0;
 256 }
 257
 258 unsigned *get_code(AF *a, size_t start, size_t count) {
 259         unsigned *ret = malloc(count * sizeof(unsigned));
 260         if(!ret) return 0;
 261         AF_set_pos(a, start);
 262         size_t i;
 263         for(i=0; i<count; i++)
 264                 ret[i] = AF_read_uint(a);
 265         return ret;
 266 }
 267
 268 static unsigned get_varsize_from_instr(unsigned* code, size_t codecount, size_t index) {
 269         assert(index < codecount);
 270         switch(code[index]) {
 271                 case SCMD_MEMREADB: case SCMD_MEMWRITEB:
 272                         return 1;
 273                 case SCMD_MEMREADW: case SCMD_MEMWRITEW:
 274                         return 2;
 275                 case SCMD_MEMWRITEPTR:
 276                 case SCMD_MEMREADPTR:
 277                 case SCMD_MEMZEROPTR:
 278                 case SCMD_MEMINITPTR:
 279                 case SCMD_MEMREAD: case SCMD_MEMWRITE:
 280                         return 4;
 281                 default:
 282                         return 0;
 283         }
 284 }
 285
 286 struct fixup_resolved {
 287         unsigned code;
 288         unsigned offset;
 289 };
 290
 291 static int fixup_cmp(const void *a, const void *b) {
 292         const struct fixup_resolved *u1 = a;
 293         const struct fixup_resolved *u2 = b;
 294         return (u1->code - u2->code);
 295 }
 296
 297 /* assumes list members are sorted. set iter to -1 for first call */
 298 int find_next_match(struct fixup_resolved *list, size_t nel, unsigned value, size_t *iter) {
 299         struct fixup_resolved comparer = {
 300                 .code = value
 301         };
 302         if(*iter == (size_t)-1) {
 303                 struct fixup_resolved* ret = bsearch(&comparer, list, nel, sizeof(list[0]), fixup_cmp);
 304                 if(!ret) return 0;
 305                 *iter = ret - list;
 306                 while(*iter>=1 && list[*iter-1].code == value)
 307                         --(*iter);
 308                 return 1;
 309         } else {
 310                 ++(*iter);
 311                 if(*iter < nel && list[*iter].code == value)
 312                         return 1;
 313                 return 0;
 314         }
 315 }
 316
 317 static int has_datadata_fixup(unsigned gdoffset, struct fixup_data *fxd) {
 318         size_t i;
 319         for(i = 0; i < fxd->count[FIXUP_DATADATA]; i++)
 320                 if(fxd->codeindex_per[FIXUP_DATADATA][i] == gdoffset)
 321                         return 1;
 322         return 0;
 323 }
 324
 325 struct varinfo find_fixup_for_globaldata(FILE *f, size_t offset,
 326                 struct fixup_resolved *fxlist_resolved, size_t fxlist_cnt,
 327                 unsigned* code, size_t codecount)
 328 {
 329
 330         size_t iter = (size_t)-1, x;
 331         struct varinfo ret = {0,0};
 332         while(find_next_match(fxlist_resolved, fxlist_cnt, offset, &iter)) {
 333                 x = fxlist_resolved[iter].offset;
 334                 if(1) {
 335                         assert(x + 1 < codecount);
 336                         if(1) {
 337                                 ret.numrefs++;
 338                                 unsigned oldvarsize = ret.varsize;
 339                                 ret.varsize = get_varsize_from_instr(code, codecount, x+1);
 340                                 if(!ret.varsize) switch(code[x+1]) {
 341                                 case SCMD_REGTOREG:
 342                                         // li mar, @Obj; mr ax, mar; callobj ax
 343                                         if(x+5 < codecount &&
 344                                                 code[x+2] == AR_MAR &&
 345                                                 code[x+4] == SCMD_CALLOBJ &&
 346                                                 code[x+3] == code[x+5]) {
 347                                                 ret.varsize = 4;
 348                                         }
 349                                         break;
 350                                 case SCMD_MUL:
 351                                         // li mar, @var; muli dx, 4; ptrget mar; ptrassert; dynamicbounds dx
 352                                         if(x+5 < codecount &&
 353                                                 code[x+2] != AR_MAR &&
 354                                                 code[x+4] == SCMD_MEMREADPTR &&
 355                                                 code[x+5] == AR_MAR)
 356                                                 ret.varsize = 4;
 357                                         // muli is used as an array index like:
 358                                         // muli REG, 4; add MAR, REG; PUSH/POP MAR; ...
 359                                         else if(x+11 < codecount &&
 360                                                 code[x+4] == SCMD_ADDREG &&
 361                                                 code[x+5] == AR_MAR &&
 362                                                 code[x+6] == code[x+2] &&
 363                                                 code[x+7] == SCMD_PUSHREG &&
 364                                                 code[x+8] == AR_MAR &&
 365                                                 code[x+9] == SCMD_POPREG &&
 366                                                 code[x+10] == AR_MAR) {
 367                                                         ret.varsize = get_varsize_from_instr(code, codecount, x+11);
 368                                                         if(!ret.varsize &&
 369                                                             x+14 < codecount &&
 370                                                             code[x+11] == SCMD_ADDREG &&
 371                                                             code[x+12] == AR_MAR &&
 372                                                             code[x+13] != code[x+2]
 373                                                         )
 374                                                         /* this variation adds another reg to mar before calling ptrget */
 375                                                                 ret.varsize = get_varsize_from_instr(code, codecount, x+14);
 376                                                         else if(!ret.varsize &&
 377                                                                 x+13 < codecount &&
 378                                                                 code[x+11] == SCMD_PUSHREG &&
 379                                                                 code[x+12] == AR_AX)
 380                                                         /* this variation pushes ax on the stack before doing a ptrget ax, which overwrites ax */
 381                                                                 ret.varsize = get_varsize_from_instr(code, codecount, x+13);
 382                                                 }
 383                                         /* muli dx, 4; add mar, dx; add mar, cx; ptr... */
 384                                         else if(x+10 < codecount &&
 385                                                 code[x+4] == SCMD_ADDREG &&
 386                                                 code[x+5] == AR_MAR &&
 387                                                 (code[x+6] == AR_CX || code[x+6] == AR_DX) &&
 388                                                 code[x+7] == SCMD_ADDREG &&
 389                                                 code[x+8] == AR_MAR &&
 390                                                 (code[x+9] == AR_CX || code[x+9] == AR_DX))
 391                                                         ret.varsize = get_varsize_from_instr(code, codecount, x+10);
 392                                         else if(x+7 < codecount &&
 393                                                 code[x+4] == SCMD_ADDREG &&
 394                                                 code[x+5] == AR_MAR &&
 395                                                 code[x+6] == code[x+2]) {
 396                                                 ret.varsize = get_varsize_from_instr(code, codecount, x+7);
 397                                                 if(!ret.varsize &&
 398                                                    x + 9 < codecount &&
 399                                                    code[x+7] == SCMD_PUSHREG &&
 400                                                    code[x+8] == AR_AX)
 401                                                         ret.varsize = get_varsize_from_instr(code, codecount, x+9);
 402                                         }
 403
 404                                         break;
 405                                 case SCMD_ADDREG:
 406                                         // addreg is typically used on an index register into an array
 407                                         // followed by a byteread/store of the desired size
 408                                         // the index register needs to be added to mar reg
 409                                         assert(x+2 < codecount && code[x+2] == AR_MAR);
 410                                         ret.varsize = get_varsize_from_instr(code, codecount, x+4);
 411                                         // a typical method call
 412                                         if(!ret.varsize && x+8 < codecount &&
 413                                            code[x+4] == SCMD_REGTOREG &&
 414                                            code[x+5] == AR_MAR &&
 415                                            code[x+7] == SCMD_CALLOBJ &&
 416                                            code[x+6] == code[x+8])
 417                                                 ret.varsize = 4;
 418                                         break;
 419                                 case SCMD_PUSHREG:
 420                                         // ptrget and similar ops are typically preceded by push mar, pop mar
 421                                         if(x+4 < codecount &&
 422                                            code[x+2] == AR_MAR &&
 423                                            code[x+3] == SCMD_POPREG &&
 424                                            code[x+4] == AR_MAR) {
 425                                                 ret.varsize = get_varsize_from_instr(code, codecount, x+5);
 426                                                 if(!ret.varsize && x+7 < codecount &&
 427                                                    code[x+5] == SCMD_ADDREG &&
 428                                                    code[x+6] == AR_MAR)
 429                                                         ret.varsize = get_varsize_from_instr(code, codecount, x+8);
 430                                         } else if(x+2 < codecount &&
 431                                                   code[x+2] == AR_AX)
 432                                                 /* ptrget is sometimes preceded by push ax */
 433                                                 ret.varsize = get_varsize_from_instr(code, codecount, x+3);
 434                                         break;
 435                                 }
 436                                 if(!ret.varsize) {
 437                                         if(oldvarsize) {
 438                                                 /* don't bother guessing the varsize if we already determined it */
 439                                                 ret.varsize = oldvarsize;
 440                                         }
 441                                         dprintf(2, "warning: '%s' globaldata fixup on insno %zu offset %zu\n",
 442                                                 opcodes[code[x+1]].mnemonic, x+1, offset);
 443                                         COMMENT(f, "warning: '%s' globaldata fixup on insno %zu offset %zu\n",
 444                                                 opcodes[code[x+1]].mnemonic, x+1, offset);
 445                                 }
 446                                 if(oldvarsize != 0 && oldvarsize != ret.varsize)
 447                                         assert(0);
 448                         }
 449                 }
 450         }
 451         return ret;
 452 }
 453
 454 static int is_all_zeroes(const char* buf, int len) {
 455         while(len--) {
 456                 if(*buf != 0) return 0;
 457                 buf++;
 458         }
 459         return 1;
 460 }
 461
 462 static const char* get_varsize_typename(unsigned varsize) {
 463         static const char typenames[][6] = {[0]="ERR", [1]="char", [2]="short", [4]="int"};
 464         switch(varsize) {
 465                 case 0: case 1: case 2: case 4:
 466                         return typenames[varsize];
 467                 case 200:
 468                         return "string";
 469         }
 470         return 0;
 471 }
 472
 473 static struct varinfo get_varinfo_from_code(
 474         unsigned *code, size_t codesize,
 475         size_t offset,
 476         struct fixup_data *fxd,
 477         struct fixup_resolved *gd_fixups_resolved,
 478         FILE *f)
 479 {
 480                 struct varinfo vi;
 481                 if(has_datadata_fixup(offset, fxd))
 482                         vi = (struct varinfo){0,4};
 483                 else {
 484                         vi = find_fixup_for_globaldata(f, offset, gd_fixups_resolved, fxd->count[FIXUP_GLOBALDATA], code, codesize);
 485                         if(vi.varsize == 0 && has_datadata_fixup(offset+200, fxd))
 486                                 vi.varsize = 200;
 487                 }
 488                 return vi;
 489 }
 490
 491 static int dump_globaldata(AF *a, FILE *f, size_t start, size_t size,
 492                            struct function_export* exp, size_t expcount,
 493                            struct fixup_data *fxd,
 494                            unsigned *code, size_t codesize) {
 495         if(!size) return 1;
 496
 497         size_t fxcount = fxd->count[FIXUP_GLOBALDATA];
 498         struct fixup_resolved *gd_fixups_resolved = malloc(sizeof(struct fixup_resolved) * fxcount);
 499         if(!gd_fixups_resolved) return 0;
 500         size_t i;
 501         for(i=0; i < fxcount; i++) {
 502                 unsigned x = fxd->codeindex_per[FIXUP_GLOBALDATA][i];
 503                 assert(x < codesize);
 504                 gd_fixups_resolved[i].code = code[x];
 505                 gd_fixups_resolved[i].offset = x;
 506         }
 507         qsort(gd_fixups_resolved, fxcount, sizeof(gd_fixups_resolved[0]), fixup_cmp);
 508
 509         fprintf(f, ".%s\n", "data");
 510         AF_set_pos(a, start);
 511
 512         for(i = 0; i < size; ) {
 513                 struct varinfo vi = get_varinfo_from_code(code, codesize, i, fxd, gd_fixups_resolved, f);
 514                 int x;
 515                 char *comment = "";
 516                 int is_str = 0;
 517                 sw:
 518                 switch(vi.varsize) {
 519                         case 200:
 520                                 {
 521                                         off_t savepos = AF_get_pos(a);
 522                                         if(i + 204 <= size) {
 523                                                 char buf[200];
 524                                                 assert(200 == AF_read(a, buf, 200));
 525                                                 /* read the datadata fixup content*/
 526                                                 x = AF_read_int(a);
 527                                                 if(x == i && is_all_zeroes(buf, 200)) {
 528                                                         x = 0;
 529                                                         AF_set_pos(a, savepos + 200);
 530                                                         is_str = 1;
 531                                                         break;
 532                                                 }
 533                                         }
 534                                         AF_set_pos(a, savepos);
 535                                         vi.varsize = 0;
 536                                         goto sw;
 537                                 }
 538                         case 4:
 539                                 x = AF_read_int(a);
 540                                 break;
 541                         case 2:
 542                                 x = AF_read_short(a);
 543                                 break;
 544                         case 1:
 545                                 x = ByteArray_readByte(a->b);
 546                                 break;
 547                         case 0:
 548                                 vi.varsize = 1;
 549                                 x = ByteArray_readByte(a->b);
 550                                 if(vi.numrefs) comment = " ; warning: couldn't determine varsize, default to 1";
 551                                 else {
 552                                         comment = " ; unreferenced variable, assuming char";
 553                                         if(x) break;
 554                                         struct varinfo vi2;
 555                                         size_t j = i;
 556                                         while(++j < size) {
 557                                                 vi2 = get_varinfo_from_code(code, codesize, j, fxd, gd_fixups_resolved, f);
 558                                                 if(vi2.varsize || vi.numrefs) break;
 559                                                 x = ByteArray_readByte(a->b);
 560                                                 if(x) {
 561                                                         ByteArray_set_position_rel(a->b, -1);
 562                                                         x = 0;
 563                                                         break;
 564                                                 }
 565                                                 ++vi.varsize;
 566                                         }
 567                                 }
 568                                 break;
 569                 }
 570                 char* vn = get_varname(exp, expcount, i),
 571                 *tn = get_varsize_typename(vi.varsize), buf[32];
 572                 if(!tn || (vi.varsize == 200 && !is_str)) {
 573                         snprintf(buf, sizeof buf, "char[%u]", vi.varsize);
 574                         tn = buf;
 575                 }
 576                 if(has_datadata_fixup(i, fxd)) {
 577                         if(vn) fprintf(f, "export %s %s = .data + %d%s\n", tn, vn, x, comment);
 578                         else fprintf(f, "%s var%.6zu = .data + %d%s\n", tn, i, x, comment);
 579                 } else {
 580                         if(vn) fprintf(f, "export %s %s = %d%s\n", tn, vn, x, comment);
 581                         else fprintf(f, "%s var%.6zu = %d%s\n", tn, i, x, comment);
 582                 }
 583                 i += vi.varsize;
 584         }
 585         free(gd_fixups_resolved);
 586         return 1;
 587 }
 588
 589 #include "StringEscape.h"
 590 #define DEBUG_OFFSETS 1
 591 #define DEBUG_BYTECODE 1
 592 static int disassemble_code_and_data(AF* a, ASI* s, FILE *f, int flags, struct fixup_data *fxd) {
 593         int debugmode = getenv("AGSDEBUG") != 0;
 594         size_t start = s->codestart;
 595         size_t len = s->codesize * sizeof(unsigned);
 596
 597         unsigned *code = get_code(a, s->codestart, s->codesize);
 598
 599         struct function_export* fl = get_exports(a, s->exportstart, s->exportcount);
 600
 601         dump_globaldata(a, f, s->globaldatastart, s->globaldatasize, fl, s->exportcount, fxd, code, s->codesize);
 602
 603         if(!len) return 1; /* its valid for a scriptfile to have no code at all */
 604
 605
 606         struct importlist il = get_imports(a, s->importstart, s->importcount);
 607
 608         struct labels lbl = get_labels(code, s->codesize);
 609
 610         struct strings str = get_strings(a, s->stringsstart, s->stringssize);
 611
 612         AF_set_pos(a, start);
 613         fprintf(f, ".%s\n", "text");
 614
 615         size_t currInstr = 0, currExp = 0, currFixup = 0, currLbl = 0;
 616         char *curr_func = 0;
 617         /* the data_data fixups appear to be glued separately onto the fixup logic,
 618          * they are the only entries not sorted by instrucion number */
 619         while(currFixup < s->fixupcount && fxd->types[currFixup] == FIXUP_DATADATA) currFixup++;
 620         while(currInstr < s->codesize) {
 621                 if(flags & DISAS_DEBUG_OFFSETS) COMMENT(f, "offset: %llu (insno %zu)\n", (long long) AF_get_pos(a), currInstr);
 622                 unsigned regs, args, insn = AF_read_uint(a), op = insn & 0x00ffffff;
 623                 assert(op < SCMD_MAX);
 624                 while(currExp < s->exportcount && fl[currExp].type != EXPORT_FUNCTION)
 625                         currExp++;
 626                 if(currExp < s->exportcount && fl[currExp].instr == currInstr) {
 627                         /* new function starts here */
 628                         curr_func = fl[currExp].fn;
 629                         char comment[64], *p = strrchr(fl[currExp].fn, '$');
 630                         comment[0] = 0;
 631                         if(p) {
 632                                 int n;
 633                                 if((n = atoi(p+1)) >= 100)
 634                                         sprintf(comment, " ; variadic, %d fixed args", n - 100);
 635                                 else
 636                                         sprintf(comment, " ; %d args", n);
 637                         }
 638                         fprintf(f, "\n%s:%s\n", curr_func, comment);
 639                         currExp++;
 640                 }
 641                 if(currLbl < lbl.count) {
 642                         if(lbl.insno[currLbl] == currInstr) {
 643                                 size_t numrefs = 0;
 644                                 while(currLbl < lbl.count && lbl.insno[currLbl] == currInstr) {
 645                                         currLbl++; numrefs++;
 646                                 }
 647                                 fprintf(f, "label%.12zu: ", currInstr);
 648                                 COMMENT(f, "inside %s, ", curr_func ? curr_func : "???");
 649                                 COMMENT(f, "referenced by %zu spots\n", numrefs);
 650                         }
 651                 }
 652
 653                 currInstr++;
 654
 655                 regs = opcodes[op].regcount;
 656                 args = opcodes[op].argcount;
 657
 658                 if(insn == SCMD_LINENUM && (flags & DISAS_SKIP_LINENO)) {
 659                         insn = AF_read_uint(a);
 660                         COMMENT(f, "line %u\n", insn);
 661                         currInstr++;
 662                         continue;
 663                 }
 664
 665                 if(flags & DISAS_DEBUG_BYTECODE) {
 666                         unsigned char insbuf[16];
 667                         unsigned iblen = 0, val;
 668                         val = end_htole32(insn);
 669                         memcpy(insbuf+iblen, &val, 4); iblen += 4;
 670
 671                         off_t currpos = AF_get_pos(a);
 672
 673                         for(size_t l = 0; l < args; l++) {
 674                                 assert(iblen+4 <= sizeof(insbuf));
 675                                 val = AF_read_uint(a);
 676                                 val = end_htole32(val);
 677                                 memcpy(insbuf+iblen, &val, 4); iblen += 4;
 678                         }
 679
 680                         char printbuf[sizeof(insbuf)*2 + 1], *pb = printbuf;
 681                         for(size_t l = 0; l < iblen; l++, pb+=2)
 682                                 sprintf(pb, "%02x", (int) insbuf[l]);
 683                         COMMENT(f, "%s\n", printbuf);
 684
 685                         AF_set_pos(a, currpos);
 686                 }
 687
 688                 if(debugmode)
 689                         fprintf(f, "%.12zu""\t%s ", currInstr - 1, opcodes[op].mnemonic);
 690                 else
 691                         fprintf(f, /*"%.12zu"*/"\t%s ", /*currInstr - 1, */opcodes[op].mnemonic);
 692
 693                 if(insn == SCMD_REGTOREG) {
 694                         /* the "mov" instruction differs from all others in that the source comes first
 695                            we do not want that. */
 696                         unsigned src, dst;
 697                         src = AF_read_uint(a);
 698                         currInstr++;
 699                         dst = AF_read_uint(a);
 700                         currInstr++;
 701                         fprintf(f, "%s, %s\n", regnames[dst], regnames[src]);
 702                         continue;
 703                 }
 704                 for (size_t l = 0; l < args; l++) {
 705                         char escapebuf[4096];
 706                         if(l) fprintf(f, ", ");
 707                         insn = AF_read_uint(a);
 708                         currInstr++;
 709                         if((!l && regs) || (l == 1 && regs == 2))
 710                                 fprintf(f, "%s", regnames[insn]);
 711                         else {
 712                                 while(currFixup < s->fixupcount && fxd->types[currFixup] == FIXUP_DATADATA)
 713                                         currFixup++; /* DATADATA fixups are unrelated to the code */
 714                                 if(currFixup < s->fixupcount && fxd->codeindex[currFixup] == currInstr - 1) {
 715                                         switch(fxd->types[currFixup]) {
 716                                                 case FIXUP_IMPORT:
 717                                                         if(debugmode)
 718                                                                 fprintf(f, "IMP:%s", il.names[insn]);
 719                                                         else
 720                                                                 fprintf(f, "%s", il.names[insn]);
 721                                                         break;
 722                                                 case FIXUP_FUNCTION: {
 723                                                         size_t x = 0;
 724                                                         for(; x < s->exportcount; x++) {
 725                                                                 if(fl[x].type == EXPORT_FUNCTION && fl[x].instr == insn) {
 726                                                                         fprintf(f, "%s", fl[x].fn);
 727                                                                         break;
 728                                                                 }
 729                                                         }
 730                                                         break;
 731                                                 }
 732                                                 case FIXUP_GLOBALDATA: {
 733                                                         char *vn = get_varname(fl, s->exportcount, insn);
 734                                                         if(vn) fprintf(f, "@%s", vn);
 735                                                         else fprintf(f, "@var%.6u", insn);
 736                                                         break; }
 737                                                 case FIXUP_STACK: /* it is unclear if and where those ever get generated */
 738                                                         fprintf(f, ".stack + %d", insn);
 739                                                         break;
 740                                                 case FIXUP_STRING:
 741                                                         escape(str.data + insn, escapebuf, sizeof(escapebuf));
 742                                                         fprintf(f, "\"%s\"", escapebuf);
 743                                                 default:
 744                                                         break;
 745                                         }
 746                                         currFixup++;
 747                                 } else {
 748                                         switch(op) {
 749                                                 case SCMD_JMP: case SCMD_JZ: case SCMD_JNZ:
 750                                                         fprintf(f, "label%.12zu", currInstr + (int) insn);
 751                                                         break;
 752                                                 default:
 753                                                         fprintf(f, "%d", insn);
 754                                         }
 755                                 }
 756                         }
 757                 }
 758                 fprintf(f, "\n");
 759         }
 760         free (fl);
 761         return 1;
 762 }
 763
 764 int ASI_disassemble(AF* a, ASI* s, char *fn, int flags) {
 765         FILE *f;
 766         int ret = 1;
 767         if((f = fopen(fn, "w")) == 0)
 768                 return 0;
 769         AF_set_pos(a, s->start);
 770         struct fixup_data fxd = {0};
 771         if(!get_fixups(a, s->fixupstart, s->fixupcount, &fxd)) return 0;
 772
 773         //if(!dump_globaldata(a, fd, s->globaldatastart, s->globaldatasize)) goto err_close;
 774         if(!disassemble_code_and_data(a, s, f, flags, &fxd)) goto err_close;
 775         if(!dump_strings(a, f, s->stringsstart, s->stringssize)) goto err_close;
 776         if((flags & DISAS_DEBUG_FIXUPS) && !dump_fixups(f, s->fixupcount, &fxd)) goto err_close;
 777         if(!dump_import_export(a, f, s->importstart, s->importcount, 1)) goto err_close;
 778         if(!dump_import_export(a, f, s->exportstart, s->exportcount, 0)) goto err_close;
 779         if(!dump_sections(a, f, s->sectionstart, s->sectioncount)) goto err_close;
 780         ret:
 781         free_fixup_data(&fxd);
 782         fclose(f);
 783         return ret;
 784         err_close:
 785         ret = 0;
 786         goto ret;
 787 }
 788
 789 int ASI_read_script(AF *a, ASI* s) {
 790         s->start = AF_get_pos(a);
 791         char sig[4];
 792         size_t l = 4;
 793         if(l != (size_t) AF_read(a, sig, l)) return 0;
 794         assert(memcmp("SCOM", sig, 4) == 0);
 795         s->version = AF_read_int(a);
 796         s->globaldatasize = AF_read_int(a);
 797         s->codesize = AF_read_int(a);
 798         s->stringssize = AF_read_int(a);
 799         if(s->globaldatasize) {
 800                 s->globaldatastart = AF_get_pos(a);
 801                 l = s->globaldatasize;
 802                 if(!AF_read_junk(a, l)) return 0;
 803         } else s->globaldatastart = 0;
 804         if(s->codesize) {
 805                 s->codestart = AF_get_pos(a);
 806                 l = s->codesize * sizeof(int);
 807                 if(!AF_read_junk(a, l)) return 0;
 808         } else s->codestart = 0;
 809         if(s->stringssize) {
 810                 s->stringsstart = AF_get_pos(a);
 811                 l = s->stringssize;
 812                 if(!AF_read_junk(a, l)) return 0;
 813         } else s->stringsstart = 0;
 814         s->fixupcount = AF_read_int(a);
 815         if(s->fixupcount) {
 816                 s->fixupstart = AF_get_pos(a);
 817                 l = s->fixupcount;
 818                 if(!AF_read_junk(a, l)) return 0; /* fixup types */
 819                 l *= sizeof(int);
 820                 if(!AF_read_junk(a, l)) return 0; /* fixups */
 821         } else s->fixupstart = 0;
 822         s->importcount = AF_read_int(a);
 823         if(s->importcount) {
 824                 s->importstart = AF_get_pos(a);
 825                 char buf[300];
 826                 size_t i = 0;
 827                 for(; i < s->importcount; i++)
 828                         if(!AF_read_string(a, buf, sizeof(buf))) return 0;
 829         } else s->importstart = 0;
 830         s->exportcount = AF_read_int(a);
 831         if(s->exportcount) {
 832                 s->exportstart = AF_get_pos(a);
 833                 char buf[300];
 834                 size_t i = 0;
 835                 for(; i < s->exportcount; i++) {
 836                         if(!AF_read_string(a, buf, sizeof(buf))) return 0;
 837                         AF_read_int(a); /* export_addr */
 838                 }
 839         }  else s->exportstart = 0;
 840         s->sectionstart = 0;
 841         s->sectioncount = 0;
 842         if (s->version >= 83) {
 843                 s->sectioncount = AF_read_int(a);
 844                 if(s->sectioncount) {
 845                         s->sectionstart = AF_get_pos(a);
 846                         char buf[300];
 847                         size_t i = 0;
 848                         for(; i < s->sectioncount; i++) {
 849                                 if(!AF_read_string(a, buf, sizeof(buf))) return 0;
 850                                 AF_read_int(a); /* section offset */
 851                         }
 852                 }
 853         }
 854         if(0xbeefcafe != AF_read_uint(a)) return 0;
 855         s->len = AF_get_pos(a) - s->start;
 856         return 1;
 857 }