?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
improve agssemble performance 3x
[rofl0r-agsutils.git] / Script.c
blobe87b5193962c13716e44779ef03daf360490e13d
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 }