![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to symbols.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src / debug|
Return to symbols.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src / debug |
1.1 root 1: /*
2: * Hatari - symbols.c
3: *
1.1.1.9 root 4: * Copyright (C) 2010-2017 by Eero Tamminen
1.1 root 5: *
1.1.1.5 root 6: * This file is distributed under the GNU General Public License, version 2
7: * or at your option any later version. Read the file gpl.txt for details.
1.1 root 8: *
9: * symbols.c - Hatari debugger symbol/address handling; parsing, sorting,
10: * matching, TAB completion support etc.
11: *
1.1.1.5 root 12: * Symbol/address information is read either from:
1.1.1.9 root 13: * - A program file's DRI/GST or a.out format symbol table, or
1.1.1.5 root 14: * - ASCII file which contents are subset of "nm" output i.e. composed of
15: * a hexadecimal addresses followed by a space, letter indicating symbol
16: * type (T = text/code, D = data, B = BSS), space and the symbol name.
17: * Empty lines and lines starting with '#' are ignored. It's AHCC SYM
18: * output compatible.
1.1 root 19: */
20: const char Symbols_fileid[] = "Hatari symbols.c : " __DATE__ " " __TIME__;
21:
22: #include <ctype.h>
23: #include <stdio.h>
24: #include <string.h>
25: #include <assert.h>
26: #include <SDL_types.h>
1.1.1.5 root 27: #include <SDL_endian.h>
1.1 root 28: #include "main.h"
1.1.1.7 root 29: #include "file.h"
30: #include "options.h"
1.1 root 31: #include "symbols.h"
32: #include "debugui.h"
33: #include "debug_priv.h"
1.1.1.5 root 34: #include "debugInfo.h"
1.1 root 35: #include "evaluate.h"
1.1.1.7 root 36: #include "configuration.h"
1.1.1.9 root 37: #include "a.out.h"
1.1 root 38:
39: typedef struct {
40: char *name;
41: Uint32 address;
42: symtype_t type;
43: } symbol_t;
44:
45: typedef struct {
1.1.1.5 root 46: int symbols; /* initial symbol count */
1.1.1.9 root 47: int namecount; /* final symbol count */
48: int codecount; /* TEXT symbol address count */
49: int datacount; /* DATA/BSS symbol address count */
50: symbol_t *addresses; /* TEXT + DATA/BSS items sorted by address */
51: symbol_t *names; /* all items sorted by symbol name */
52: char *strtab;
1.1 root 53: } symbol_list_t;
54:
1.1.1.5 root 55: typedef struct {
56: Uint32 offset;
57: Uint32 end;
58: } prg_section_t;
59:
1.1 root 60:
61: /* how many characters the symbol name can have.
62: * NOTE: change also sscanf width arg if you change this!!!
63: */
64: #define MAX_SYM_SIZE 32
65:
1.1.1.9 root 66: /* Magic used to denote different symbol table formats */
67: #define SYMBOL_FORMAT_GNU 0x474E555f /* "MiNT" */
68: #define SYMBOL_FORMAT_MINT 0x4D694E54 /* "GNU_" */
69: #define SYMBOL_FORMAT_DRI 0x0
70:
1.1 root 71:
72: /* TODO: add symbol name/address file names to configuration? */
73: static symbol_list_t *CpuSymbolsList;
74: static symbol_list_t *DspSymbolsList;
75:
1.1.1.6 root 76: /* path for last loaded program (through GEMDOS HD emulation) */
77: static char *CurrentProgramPath;
1.1.1.9 root 78: /* whether current symbols were loaded from a program file */
1.1.1.6 root 79: static bool SymbolsAreForProgram;
1.1.1.9 root 80: /* prevent repeated failing on every debugger invocation */
1.1.1.6 root 81: static bool AutoLoadFailed;
82:
1.1 root 83:
84: /* ------------------ load and free functions ------------------ */
85:
86: /**
1.1.1.9 root 87: * return true if given symbol name is object/library/file name
88: */
89: static bool is_obj_file(const char *name)
90: {
91: int len = strlen(name);
92: /* object (.a or .o) / file name? */
93: if (len > 2 && ((name[len-2] == '.' && (name[len-1] == 'a' || name[len-1] == 'o')) || strchr(name, '/'))) {
94: return true;
95: }
96: return false;
97: }
98:
99: /**
100: * compare function for qsort() to sort according to
101: * symbol type & address. Text section symbols will
102: * be sorted first.
1.1 root 103: */
104: static int symbols_by_address(const void *s1, const void *s2)
105: {
1.1.1.9 root 106: const symbol_t *sym1 = (const symbol_t*)s1;
107: const symbol_t *sym2 = (const symbol_t*)s2;
1.1 root 108:
1.1.1.9 root 109: /* separate TEXT type addresses from others */
110: if (sym1->type != sym2->type) {
111: if (sym1->type == SYMTYPE_TEXT) {
112: return -1;
113: }
114: if (sym2->type == SYMTYPE_TEXT) {
115: return 1;
116: }
117: }
118: /* then sort by address */
119: if (sym1->address < sym2->address) {
1.1 root 120: return -1;
121: }
1.1.1.9 root 122: if (sym1->address > sym2->address) {
1.1 root 123: return 1;
124: }
125: return 0;
126: }
127:
128: /**
1.1.1.9 root 129: * compare function for qsort() to sort according to
130: * symbol name & address
1.1 root 131: */
132: static int symbols_by_name(const void *s1, const void *s2)
133: {
1.1.1.9 root 134: const symbol_t *sym1 = (const symbol_t*)s1;
135: const symbol_t *sym2 = (const symbol_t*)s2;
1.1 root 136: int ret;
137:
1.1.1.9 root 138: /* first by name */
139: ret = strcmp(sym1->name, sym2->name);
140: if (ret) {
141: return ret;
142: }
143: /* then by address */
144: return (sym1->address - sym2->address);
145: }
146:
147: /**
148: * Check for duplicate addresses in symbol list
149: * (called separately for TEXT & non-TEXT symbols)
150: * Return number of duplicates
151: */
152: static int symbols_check_addresses(const symbol_t *syms, int count)
153: {
154: int i, j, dups = 0;
155:
156: for (i = 0; i < (count - 1); i++)
157: {
158: /* absolute symbols have values, not addresses */
159: if (syms[i].type == SYMTYPE_ABS) {
160: continue;
161: }
162: for (j = i + 1; j < count && syms[i].address == syms[j].address; j++) {
163: if (syms[j].type == SYMTYPE_ABS) {
164: continue;
165: }
166: /* ASCII symbol files contain also object file addresses,
167: * those will often have the same address as the first symbol
168: * in given object -> no point warning about them
169: */
170: if (is_obj_file(syms[i].name) || is_obj_file(syms[j].name)) {
171: continue;
172: }
173: fprintf(stderr, "WARNING: symbols '%s' & '%s' have the same 0x%x address\n",
174: syms[i].name, syms[j].name, syms[i].address);
175: dups++;
176: i = j;
177: }
1.1 root 178: }
1.1.1.9 root 179: return dups;
1.1 root 180: }
181:
1.1.1.9 root 182: /**
183: * Check for duplicate names in symbol list
184: * Return number of duplicates
185: */
186: static int symbols_check_names(const symbol_t *syms, int count)
187: {
188: int i, j, dups = 0;
189:
190: for (i = 0; i < (count - 1); i++)
191: {
192: for (j = i + 1; j < count && strcmp(syms[i].name, syms[j].name) == 0; j++) {
193: /* this is common case for object files having different sections */
194: if (syms[i].type != syms[j].type && is_obj_file(syms[i].name)) {
195: continue;
196: }
197: fprintf(stderr, "WARNING: addresses 0x%x & 0x%x have the same '%s' name\n",
198: syms[i].address, syms[j].address, syms[i].name);
199: dups++;
200: i = j;
201: }
202: }
203: return dups;
204: }
1.1 root 205:
206: /**
1.1.1.5 root 207: * Allocate symbol list & names for given number of items.
208: * Return allocated list or NULL on failure.
209: */
210: static symbol_list_t* symbol_list_alloc(int symbols)
211: {
212: symbol_list_t *list;
213:
214: if (!symbols) {
215: return NULL;
216: }
217: list = calloc(1, sizeof(symbol_list_t));
218: if (list) {
219: list->names = malloc(symbols * sizeof(symbol_t));
220: if (!list->names) {
221: free(list);
222: list = NULL;
223: }
224: }
225: return list;
226: }
227:
228: /**
229: * Free symbol list & names.
230: */
231: static void symbol_list_free(symbol_list_t *list)
232: {
233: if (list) {
234: if (list->names) {
235: free(list->names);
236: }
237: free(list);
238: }
239: }
240:
241: /**
1.1.1.6 root 242: * Return symbol type identifier char
243: */
244: static char symbol_char(int type)
245: {
246: switch (type) {
247: case SYMTYPE_TEXT: return 'T';
248: case SYMTYPE_DATA: return 'D';
249: case SYMTYPE_BSS: return 'B';
1.1.1.9 root 250: case SYMTYPE_ABS: return 'A';
1.1.1.6 root 251: default: return '?';
252: }
253: }
254:
1.1.1.9 root 255: /**
256: * Return true if symbol name matches internal GCC symbol name,
257: * or is object / file name.
258: */
259: static bool symbol_remove_obj(const char *name)
260: {
261: static const char *gcc_sym[] = {
262: "___gnu_compiled_c",
263: "gcc2_compiled."
264: };
265: int i;
266:
267: if (is_obj_file(name)) {
268: return true;
269: }
270: /* useless symbols GCC (v2) seems to add to every object? */
271: for (i = 0; i < ARRAY_SIZE(gcc_sym); i++) {
272: if (strcmp(name, gcc_sym[i]) == 0) {
273: return true;
274: }
275: }
276: return false;
277: }
278:
1.1.1.6 root 279:
280: /**
1.1 root 281: * Load symbols of given type and the symbol address addresses from
1.1.1.5 root 282: * DRI/GST format symbol table, and add given offsets to the addresses:
283: * http://toshyp.atari.org/en/005005.html
1.1 root 284: * Return symbols list or NULL for failure.
285: */
1.1.1.5 root 286: static symbol_list_t* symbols_load_dri(FILE *fp, prg_section_t *sections, symtype_t gettype, Uint32 tablesize)
1.1 root 287: {
1.1.1.9 root 288: int i, count, symbols, invalid;
289: int notypes, dtypes, locals, ofiles;
1.1.1.5 root 290: prg_section_t *section;
1.1 root 291: symbol_list_t *list;
292: symtype_t symtype;
1.1.1.5 root 293: #define DRI_ENTRY_SIZE 14
294: char name[23];
295: Uint16 symid;
1.1 root 296: Uint32 address;
1.1.1.5 root 297:
1.1.1.6 root 298: if (tablesize % DRI_ENTRY_SIZE || !tablesize) {
1.1.1.5 root 299: fprintf(stderr, "ERROR: invalid DRI/GST symbol table size %d!\n", tablesize);
300: return NULL;
301: }
302: symbols = tablesize / DRI_ENTRY_SIZE;
303: if (!(list = symbol_list_alloc(symbols))) {
304: return NULL;
305: }
306:
1.1.1.9 root 307: invalid = dtypes = notypes = ofiles = locals = count = 0;
1.1.1.5 root 308: for (i = 1; i <= symbols; i++) {
309: /* read DRI symbol table slot */
310: if (fread(name, 8, 1, fp) != 1 ||
311: fread(&symid, sizeof(symid), 1, fp) != 1 ||
312: fread(&address, sizeof(address), 1, fp) != 1) {
313: break;
314: }
315: address = SDL_SwapBE32(address);
316: symid = SDL_SwapBE16(symid);
317:
318: /* GST extended DRI symbol format? */
319: if ((symid & 0x0048)) {
320: /* next slot is rest of name */
321: i += 1;
322: if (fread(name+8, 14, 1, fp) != 1) {
323: break;
324: }
325: name[22] = '\0';
326: } else {
327: name[8] = '\0';
328: }
329:
330: /* check section */
331: switch (symid & 0xf00) {
332: case 0x0200:
333: symtype = SYMTYPE_TEXT;
334: section = &(sections[0]);
335: break;
336: case 0x0400:
337: symtype = SYMTYPE_DATA;
338: section = &(sections[1]);
339: break;
340: case 0x0100:
341: symtype = SYMTYPE_BSS;
342: section = &(sections[2]);
343: break;
344: default:
345: if ((symid & 0xe000) == 0xe000) {
346: dtypes++;
347: continue;
348: }
1.1.1.9 root 349: if ((symid & 0x4000) == 0x4000) {
350: symtype = SYMTYPE_ABS;
351: section = NULL;
352: break;
353: }
1.1.1.5 root 354: fprintf(stderr, "WARNING: ignoring symbol '%s' in slot %d of unknown type 0x%x.\n", name, i, symid);
1.1.1.9 root 355: invalid++;
1.1.1.5 root 356: continue;
357: }
358: if (!(gettype & symtype)) {
1.1.1.9 root 359: notypes++;
1.1.1.5 root 360: continue;
361: }
362: if (name[0] == '.' && name[1] == 'L') {
363: locals++;
364: continue;
365: }
1.1.1.9 root 366: if (symbol_remove_obj(name)) {
1.1.1.5 root 367: ofiles++;
368: continue;
369: }
1.1.1.9 root 370: if (section) {
371: address += section->offset;
372: if (address > section->end) {
373: fprintf(stderr, "WARNING: ignoring symbol '%s' of type %c in slot %d with invalid offset 0x%x (>= 0x%x).\n",
374: name, symbol_char(symtype), i, address, section->end);
375: invalid++;
376: continue;
1.1.1.6 root 377: }
1.1.1.5 root 378: }
379: list->names[count].address = address;
380: list->names[count].type = symtype;
381: list->names[count].name = strdup(name);
382: assert(list->names[count].name);
383: count++;
384: }
385: if (i <= symbols) {
386: perror("ERROR: reading symbol failed");
387: symbol_list_free(list);
1.1 root 388: return NULL;
389: }
1.1.1.9 root 390: list->symbols = symbols;
391: list->namecount = count;
392:
393: /* skip verbose output when symbol loading is forced */
394: if (ConfigureParams.Debugger.bSymbolsResident) {
395: return list;
396: }
397:
398: if (invalid) {
399: fprintf(stderr, "NOTE: ignored %d invalid symbols.\n", invalid);
400: }
1.1.1.5 root 401: if (dtypes) {
1.1.1.9 root 402: fprintf(stderr, "NOTE: ignored %d debugging symbols.\n", dtypes);
403: }
404: if (notypes) {
405: fprintf(stderr, "NOTE: ignored %d other unwanted symbol types.\n", notypes);
1.1.1.5 root 406: }
407: if (locals) {
408: fprintf(stderr, "NOTE: ignored %d unnamed / local symbols (= name starts with '.L').\n", locals);
409: }
410: if (ofiles) {
411: /* object file path names most likely get truncated and
412: * as result cause unnecessary symbol name conflicts in
413: * addition to object file addresses conflicting with
414: * first symbol in the object file.
415: */
1.1.1.9 root 416: fprintf(stderr, "NOTE: ignored %d object symbols (= name has '/', ends in '.[ao]' or is GCC internal).\n", ofiles);
417: }
418: return list;
419: }
420:
421:
422: /**
423: * Load symbols of given type and the symbol address addresses from
424: * a.out format symbol table, and add given offsets to the addresses:
425: * Return symbols list or NULL for failure.
426: */
427: static symbol_list_t* symbols_load_gnu(FILE *fp, prg_section_t *sections, symtype_t gettype, Uint32 tablesize, Uint32 stroff, Uint32 strsize)
428: {
429: size_t slots = tablesize / SIZEOF_STRUCT_NLIST;
430: size_t i;
431: size_t strx;
432: unsigned char *p;
433: char *name;
434: symbol_t *sym;
435: symtype_t symtype;
436: uint32_t address;
437: uint32_t nread;
438: symbol_list_t *list;
439: unsigned char n_type;
440: unsigned char n_other;
441: unsigned short n_desc;
442: static char dummy[] = "<invalid>";
443: int dtypes, locals, ofiles, count, notypes, invalid, weak;
444: prg_section_t *section;
445:
446: if (!(list = symbol_list_alloc(slots))) {
447: return NULL;
448: }
449:
450: list->strtab = (char *)malloc(tablesize + strsize);
451:
452: if (list->strtab == NULL)
453: {
454: symbol_list_free(list);
455: return NULL;
456: }
457:
458: nread = fread(list->strtab, tablesize + strsize, 1, fp);
459: if (nread != 1)
460: {
461: perror("ERROR: reading symbols failed");
462: symbol_list_free(list);
463: return NULL;
464: }
465:
466: p = (unsigned char *)list->strtab;
467: sym = list->names;
468:
469: weak = invalid = dtypes = notypes = ofiles = locals = count = 0;
470: for (i = 0; i < slots; i++)
471: {
472: strx = SDL_SwapBE32(*(Uint32*)p);
473: p += 4;
474: n_type = *p++;
475: n_other = *p++;
476: n_desc = SDL_SwapBE16(*(Uint16*)p);
477: p += 2;
478: address = SDL_SwapBE32(*(Uint32*)p);
479: p += 4;
480: name = dummy;
481: if (!strx) {
482: invalid++;
483: continue;
484: }
485: if (strx >= strsize) {
486: fprintf(stderr, "symbol name index %x out of range\n", (unsigned int)strx);
487: invalid++;
488: continue;
489: }
490: name = list->strtab + strx + stroff;
491:
492: if (n_type & N_STAB)
493: {
494: dtypes++;
495: continue;
496: }
497: section = NULL;
498: switch (n_type & (N_TYPE|N_EXT))
499: {
500: case N_UNDF:
501: case N_UNDF|N_EXT:
502: /* shouldn't happen here */
503: weak++;
504: continue;
505: case N_ABS:
506: case N_ABS|N_EXT:
507: symtype = SYMTYPE_ABS;
508: break;
509: case N_TEXT:
510: case N_TEXT|N_EXT:
511: symtype = SYMTYPE_TEXT;
512: section = &(sections[0]);
513: break;
514: case N_DATA:
515: case N_DATA|N_EXT:
516: symtype = SYMTYPE_DATA;
517: section = &(sections[1]);
518: break;
519: case N_BSS:
520: case N_BSS|N_EXT:
521: case N_COMM:
522: case N_COMM|N_EXT:
523: symtype = SYMTYPE_BSS;
524: section = &(sections[2]);
525: break;
526: case N_FN: /* filenames, not object addresses? */
527: dtypes++;
528: continue;
529: case N_SIZE:
530: case N_WARNING:
531: case N_SETA:
532: case N_SETT:
533: case N_SETD:
534: case N_SETB:
535: case N_SETV:
536: dtypes++;
537: continue;
538: case N_WEAKU:
539: case N_WEAKT:
540: case N_WEAKD:
541: case N_WEAKB:
542: weak++;
543: continue;
544: default:
545: fprintf(stderr, "WARNING: ignoring symbol '%s' in slot %u of unknown type 0x%x.\n", name, (unsigned int)i, n_type);
546: invalid++;
547: continue;
548: }
549: /*
550: * the value of a common symbol is its size, not its address:
551: */
552: if (((n_type & N_TYPE) == N_COMM) ||
553: (((n_type & N_EXT) && (n_type & N_TYPE) == N_UNDF && address != 0)))
554: {
555: /* if we ever want to know a symbols size, get that here */
556: fprintf(stderr, "WARNING: ignoring common symbol '%s' in slot %u.\n", name, (unsigned int)i);
557: dtypes++;
558: continue;
559: }
560: if (!(gettype & symtype)) {
561: notypes++;
562: continue;
563: }
564: if (name[0] == '.' && name[1] == 'L') {
565: locals++;
566: continue;
567: }
568: if (symbol_remove_obj(name)) {
569: ofiles++;
570: continue;
571: }
572: if (section) {
573: address += sections[0].offset; /* all GNU symbol addresses are TEXT relative */
574: if (address > section->end) {
575: fprintf(stderr, "WARNING: ignoring symbol '%s' of type %c in slot %u with invalid offset 0x%x (>= 0x%x).\n",
576: name, symbol_char(symtype), (unsigned int)i, address, section->end);
577: invalid++;
578: continue;
579: }
580: }
581: sym->address = address;
582: sym->type = symtype;
583: sym->name = name;
584: sym++;
585: count++;
586: (void) n_desc;
587: (void) n_other;
588: }
589: list->symbols = slots;
590: list->namecount = count;
591:
592: /* skip verbose output when symbol loading is forced */
593: if (ConfigureParams.Debugger.bSymbolsResident) {
594: return list;
595: }
596:
597: if (invalid) {
598: fprintf(stderr, "NOTE: ignored %d invalid symbols.\n", invalid);
599: }
600: if (dtypes) {
601: fprintf(stderr, "NOTE: ignored %d debugging symbols.\n", dtypes);
602: }
603: if (weak) {
604: fprintf(stderr, "NOTE: ignored %d weak / undefined symbols.\n", weak);
605: }
606: if (notypes) {
607: fprintf(stderr, "NOTE: ignored %d other unwanted symbol types.\n", notypes);
608: }
609: if (locals) {
610: fprintf(stderr, "NOTE: ignored %d unnamed / local symbols (= name starts with '.L').\n", locals);
611: }
612: if (ofiles) {
613: /* object file path names most likely get truncated and
614: * as result cause unnecessary symbol name conflicts in
615: * addition to object file addresses conflicting with
616: * first symbol in the object file.
617: */
618: fprintf(stderr, "NOTE: ignored %d object symbols (= name has '/', ends in '.[ao]' or is GCC internal).\n", ofiles);
1.1.1.5 root 619: }
620: return list;
621: }
622:
1.1.1.7 root 623:
624: /**
625: * Print program header information.
626: * Return false for unrecognized symbol table type.
627: */
628: static bool symbols_print_prg_info(Uint32 tabletype, Uint32 prgflags, Uint16 relocflag)
629: {
630: static const struct {
631: Uint32 flag;
632: const char *name;
633: } flags[] = {
634: { 0x0001, "FASTLOAD" },
635: { 0x0002, "TTRAMLOAD" },
636: { 0x0004, "TTRAMMEM" },
637: { 0x0008, "MINIMUM" }, /* MagiC */
638: { 0x1000, "SHAREDTEXT" }
639: };
640: const char *info;
641: int i;
642:
643: switch (tabletype) {
1.1.1.9 root 644: case SYMBOL_FORMAT_MINT: /* "MiNT" */
1.1.1.7 root 645: info = "GCC/MiNT executable, GST symbol table";
646: break;
1.1.1.9 root 647: case SYMBOL_FORMAT_GNU: /* "GNU_" */
648: info = "GCC/MiNT executable, a.out symbol table";
649: break;
650: case SYMBOL_FORMAT_DRI:
1.1.1.7 root 651: info = "TOS executable, DRI / GST symbol table";
652: break;
653: default:
654: fprintf(stderr, "ERROR: unknown executable type 0x%x!\n", tabletype);
655: return false;
656: }
657: fprintf(stderr, "%s, reloc=%d, program flags:", info, relocflag);
658: /* bit flags */
1.1.1.8 root 659: for (i = 0; i < ARRAY_SIZE(flags); i++) {
1.1.1.7 root 660: if (prgflags & flags[i].flag) {
661: fprintf(stderr, " %s", flags[i].name);
662: }
663: }
664: /* memory protection flags */
665: switch((prgflags >> 4) & 3) {
666: case 0: info = "PRIVATE"; break;
667: case 1: info = "GLOBAL"; break;
668: case 2: info = "SUPER"; break;
669: case 3: info = "READONLY"; break;
670: }
671: fprintf(stderr, " %s (0x%x)\n", info, prgflags);
672: return true;
673: }
674:
1.1.1.5 root 675: /**
676: * Parse program header and use symbol table format specific loader
677: * loader function to load the symbols.
678: * Return symbols list or NULL for failure.
679: */
680: static symbol_list_t* symbols_load_binary(FILE *fp, symtype_t gettype)
681: {
1.1.1.6 root 682: Uint32 textlen, datalen, bsslen, start, tablesize, tabletype, prgflags;
1.1.1.5 root 683: prg_section_t sections[3];
684: int offset, reads = 0;
1.1.1.6 root 685: Uint16 relocflag;
686: symbol_list_t* symbols;
1.1.1.9 root 687: Uint32 symoff = 0;
688: Uint32 stroff = 0;
689: Uint32 strsize = 0;
1.1.1.5 root 690:
691: /* get TEXT, DATA & BSS section sizes */
1.1.1.6 root 692: fseek(fp, 2, SEEK_SET);
1.1.1.5 root 693: reads += fread(&textlen, sizeof(textlen), 1, fp);
694: textlen = SDL_SwapBE32(textlen);
695: reads += fread(&datalen, sizeof(datalen), 1, fp);
696: datalen = SDL_SwapBE32(datalen);
697: reads += fread(&bsslen, sizeof(bsslen), 1, fp);
698: bsslen = SDL_SwapBE32(bsslen);
699:
700: /* get symbol table size & type and check that all reads succeeded */
701: reads += fread(&tablesize, sizeof(tablesize), 1, fp);
702: tablesize = SDL_SwapBE32(tablesize);
703: reads += fread(&tabletype, sizeof(tabletype), 1, fp);
704: tabletype = SDL_SwapBE32(tabletype);
1.1.1.6 root 705:
706: /* get program header and whether there's reloc table */
707: reads += fread(&prgflags, sizeof(prgflags), 1, fp);
708: prgflags = SDL_SwapBE32(prgflags);
709: reads += fread(&relocflag, sizeof(relocflag), 1, fp);
710: relocflag = SDL_SwapBE32(relocflag);
711:
712: if (reads != 7) {
1.1.1.5 root 713: fprintf(stderr, "ERROR: program header reading failed!\n");
714: return NULL;
715: }
1.1.1.9 root 716: /*
717: * check for GNU-style symbol table in aexec header
718: */
719: if (tabletype == SYMBOL_FORMAT_MINT) { /* MiNT */
720: Uint32 magic1, magic2;
721: Uint32 dummy;
722: Uint32 a_text, a_data, a_bss, a_syms, a_entry, a_trsize, a_drsize;
723: Uint32 g_tparel_pos, g_tparel_size, g_stkpos, g_symbol_format;
724:
725: reads = fread(&magic1, sizeof(magic1), 1, fp);
726: magic1 = SDL_SwapBE32(magic1);
727: reads += fread(&magic2, sizeof(magic2), 1, fp);
728: magic2 = SDL_SwapBE32(magic2);
729: if (reads == 2 &&
730: ((magic1 == 0x283a001a && magic2 == 0x4efb48fa) || /* Original binutils: move.l 28(pc),d4; jmp 0(pc,d4.l) */
731: (magic1 == 0x203a001a && magic2 == 0x4efb08fa))) { /* binutils >= 2.18-mint-20080209: move.l 28(pc),d0; jmp 0(pc,d0.l) */
732: reads += fread(&dummy, sizeof(dummy), 1, fp); /* skip a_info */
733: reads += fread(&a_text, sizeof(a_text), 1, fp);
734: a_text = SDL_SwapBE32(a_text);
735: reads += fread(&a_data, sizeof(a_data), 1, fp);
736: a_data = SDL_SwapBE32(a_data);
737: reads += fread(&a_bss, sizeof(a_bss), 1, fp);
738: a_bss = SDL_SwapBE32(a_bss);
739: reads += fread(&a_syms, sizeof(a_syms), 1, fp);
740: a_syms = SDL_SwapBE32(a_syms);
741: reads += fread(&a_entry, sizeof(a_entry), 1, fp);
742: a_entry = SDL_SwapBE32(a_entry);
743: reads += fread(&a_trsize, sizeof(a_trsize), 1, fp);
744: a_trsize = SDL_SwapBE32(a_trsize);
745: reads += fread(&a_drsize, sizeof(a_drsize), 1, fp);
746: a_drsize = SDL_SwapBE32(a_drsize);
747: reads += fread(&g_tparel_pos, sizeof(g_tparel_pos), 1, fp);
748: g_tparel_pos = SDL_SwapBE32(g_tparel_pos);
749: reads += fread(&g_tparel_size, sizeof(g_tparel_size), 1, fp);
750: g_tparel_size = SDL_SwapBE32(g_tparel_size);
751: reads += fread(&g_stkpos, sizeof(g_stkpos), 1, fp);
752: g_stkpos = SDL_SwapBE32(g_stkpos);
753: reads += fread(&g_symbol_format, sizeof(g_symbol_format), 1, fp);
754: g_symbol_format = SDL_SwapBE32(g_symbol_format);
755: if (g_symbol_format == 0)
756: {
757: tabletype = SYMBOL_FORMAT_GNU;
758: }
759: if ((a_text + (256 - 28)) != textlen)
760: fprintf(stderr, "warning: inconsistent text segment size %08x != %08x\n", textlen, a_text + (256 - 28));
761: if (a_data != datalen)
762: fprintf(stderr, "warning: inconsistent data segment size %08x != %08x\n", datalen, a_data);
763: if (a_bss != bsslen)
764: fprintf(stderr, "warning: inconsistent bss segment size %08x != %08x\n", bsslen, a_bss);
765: /*
766: * the symbol table size in the GEMDOS header includes the string table,
767: * the symbol table size in the exec header does not.
768: */
769: if (tabletype == SYMBOL_FORMAT_GNU)
770: {
771: strsize = tablesize - a_syms;
772: tablesize = a_syms;
773: stroff = a_syms;
774: }
775:
776: textlen = a_text + (256 - 28);
777: datalen = a_data;
778: bsslen = a_bss;
779: symoff = 0x100 + /* sizeof(extended exec header) */
780: a_text +
781: a_data +
782: a_trsize +
783: a_drsize;
784: }
785: }
1.1.1.7 root 786: if (!symbols_print_prg_info(tabletype, prgflags, relocflag)) {
787: return NULL;
788: }
789: if (!tablesize) {
790: fprintf(stderr, "ERROR: symbol table missing from the program!\n");
791: return NULL;
792: }
1.1.1.5 root 793:
794: /* offsets & max sizes for running program TEXT/DATA/BSS section symbols */
795: start = DebugInfo_GetTEXT();
796: if (!start) {
797: fprintf(stderr, "ERROR: no valid program basepage!\n");
798: return NULL;
799: }
800: sections[0].offset = start;
801: sections[0].end = start + textlen;
1.1.1.9 root 802: if (DebugInfo_GetTEXTEnd() != sections[0].end) {
1.1.1.5 root 803: fprintf(stderr, "ERROR: given program TEXT section size differs from one in RAM!\n");
804: return NULL;
805: }
806:
807: start = DebugInfo_GetDATA();
1.1.1.6 root 808: sections[1].offset = start;
1.1.1.9 root 809: sections[1].end = start + datalen;
1.1.1.5 root 810:
811: start = DebugInfo_GetBSS();
1.1.1.6 root 812: sections[2].offset = start;
1.1.1.9 root 813: sections[2].end = start + bsslen;
1.1.1.5 root 814:
1.1.1.9 root 815: if (sections[0].end != sections[1].offset) {
816: fprintf(stderr, "WARNIGN: DATA start doesn't match TEXT start + size!\n");
817: }
818: if (sections[1].end != sections[2].offset) {
819: fprintf(stderr, "WARNIGN: BSS start doesn't match DATA start + size!\n");
1.1.1.6 root 820: }
821:
1.1.1.9 root 822: if (tabletype == SYMBOL_FORMAT_GNU) {
823: /* go to start of symbol table */
824: offset = symoff;
825: if (fseek(fp, offset, SEEK_SET) < 0) {
826: perror("ERROR: seeking to symbol table failed");
827: return NULL;
828: }
829: fprintf(stderr, "Trying to load symbol table at offset 0x%x...\n", offset);
830: symbols = symbols_load_gnu(fp, sections, gettype, tablesize, stroff, strsize);
831: } else {
832: /* go to start of symbol table */
833: offset = 0x1C + textlen + datalen;
834: if (fseek(fp, offset, SEEK_SET) < 0) {
835: perror("ERROR: seeking to symbol table failed");
836: return NULL;
837: }
838: fprintf(stderr, "Trying to load symbol table at offset 0x%x...\n", offset);
1.1.1.6 root 839: symbols = symbols_load_dri(fp, sections, gettype, tablesize);
840: }
841: return symbols;
1.1.1.5 root 842: }
843:
844: /**
845: * Load symbols of given type and the symbol address addresses from
846: * the given ASCII file and add given offsets to the addresses.
847: * Return symbols list or NULL for failure.
848: */
849: static symbol_list_t* symbols_load_ascii(FILE *fp, Uint32 *offsets, Uint32 maxaddr, symtype_t gettype)
850: {
851: symbol_list_t *list;
852: char symchar, buffer[128], name[MAX_SYM_SIZE+1], *buf;
853: int count, line, symbols;
854: Uint32 address, offset;
855: symtype_t symtype;
1.1 root 856:
857: /* count content lines */
1.1.1.9 root 858: line = symbols = 0;
1.1 root 859: while (fgets(buffer, sizeof(buffer), fp)) {
1.1.1.9 root 860: line++;
861:
1.1.1.3 root 862: /* skip comments (AHCC SYM file comments start with '*') */
863: if (*buffer == '#' || *buffer == '*') {
1.1 root 864: continue;
865: }
866: /* skip empty lines */
1.1.1.6 root 867: for (buf = buffer; isspace((unsigned char)*buf); buf++);
1.1 root 868: if (!*buf) {
869: continue;
870: }
1.1.1.9 root 871: if (!isxdigit(*buf)) {
872: fprintf(stderr, "ERROR: line %d doesn't start with an address.\n", line);
873: return NULL;
874: }
1.1 root 875: symbols++;
876: }
1.1.1.6 root 877: if (!symbols) {
878: fprintf(stderr, "ERROR: no symbols.\n");
1.1.1.9 root 879: return NULL;
1.1.1.6 root 880: }
881:
1.1 root 882: fseek(fp, 0, SEEK_SET);
883:
1.1.1.5 root 884: /* allocate space for symbol list & names */
885: if (!(list = symbol_list_alloc(symbols))) {
1.1 root 886: return NULL;
887: }
888:
889: /* read symbols */
890: count = 0;
891: for (line = 1; fgets(buffer, sizeof(buffer), fp); line++) {
1.1.1.3 root 892: /* skip comments (AHCC SYM file comments start with '*') */
893: if (*buffer == '#' || *buffer == '*') {
1.1 root 894: continue;
895: }
896: /* skip empty lines */
1.1.1.6 root 897: for (buf = buffer; isspace((unsigned char)*buf); buf++);
1.1 root 898: if (!*buf) {
899: continue;
900: }
901: assert(count < symbols); /* file not modified in meanwhile? */
1.1.1.5 root 902: if (sscanf(buffer, "%x %c %32[0-9A-Za-z_.-]s", &address, &symchar, name) != 3) {
903: fprintf(stderr, "WARNING: syntax error on line %d, skipping.\n", line);
1.1 root 904: continue;
905: }
1.1.1.6 root 906: switch (toupper((unsigned char)symchar)) {
1.1.1.5 root 907: case 'T':
908: symtype = SYMTYPE_TEXT;
909: offset = offsets[0];
910: break;
911: case 'O': /* AHCC type for _StkSize etc */
912: case 'D':
913: symtype = SYMTYPE_DATA;
914: offset = offsets[1];
915: break;
916: case 'B':
917: symtype = SYMTYPE_BSS;
918: offset = offsets[2];
919: break;
1.1.1.9 root 920: case 'A':
921: symtype = SYMTYPE_ABS;
922: offset = 0;
923: break;
1.1 root 924: default:
1.1.1.5 root 925: fprintf(stderr, "WARNING: unrecognized symbol type '%c' on line %d, skipping.\n", symchar, line);
1.1 root 926: continue;
927: }
928: if (!(gettype & symtype)) {
929: continue;
930: }
1.1.1.5 root 931: address += offset;
932: if (address > maxaddr) {
933: fprintf(stderr, "WARNING: invalid address 0x%x on line %d, skipping.\n", address, line);
934: continue;
935: }
1.1 root 936: list->names[count].address = address;
937: list->names[count].type = symtype;
938: list->names[count].name = strdup(name);
939: assert(list->names[count].name);
940: count++;
941: }
1.1.1.5 root 942: list->symbols = symbols;
1.1.1.9 root 943: list->namecount = count;
1.1.1.5 root 944: return list;
945: }
1.1 root 946:
1.1.1.5 root 947: /**
1.1.1.9 root 948: * Remove full duplicates from the sorted names list
949: * and trim the allocation to remaining symbols
950: */
951: static void symbols_trim_names(symbol_list_t* list)
952: {
953: symbol_t *sym = list->names;
954: int i, next, count, dups;
955:
956: count = list->namecount;
957: for (dups = i = 0; i < count - 1; i++) {
958: next = i + 1;
959: if (strcmp(sym[i].name, sym[next].name) == 0 &&
960: sym[i].address == sym[next].address &&
961: sym[i].type == sym[next].type) {
962: /* remove duplicate */
963: memmove(sym+i, sym+next, (count-next) * sizeof(symbol_t));
964: count--;
965: dups++;
966: }
967: }
968: if (dups || list->namecount < list->symbols) {
969: list->names = realloc(list->names, i * sizeof(symbol_t));
970: assert(list->names);
971: list->namecount = i;
972: }
973: if (dups) {
974: fprintf(stderr, "WARNING: removed %d complete symbol duplicates\n", dups);
975: }
976: }
977:
978: /**
979: * Separate TEXT symbols from other symbols in address list.
980: */
981: static void symbols_trim_addresses(symbol_list_t* list)
982: {
983: symbol_t *sym = list->addresses;
984: int i;
985:
986: for (i = 0; i < list->namecount; i++) {
987: if (sym[i].type != SYMTYPE_TEXT) {
988: break;
989: }
990: }
991: list->codecount = i;
992: list->datacount = list->namecount - i;
993: }
994:
995: /**
1.1.1.5 root 996: * Load symbols of given type and the symbol address addresses from
997: * the given file and add given offsets to the addresses.
998: * Return symbols list or NULL for failure.
999: */
1000: static symbol_list_t* Symbols_Load(const char *filename, Uint32 *offsets, Uint32 maxaddr)
1001: {
1002: symbol_list_t *list;
1003: FILE *fp;
1004:
1.1.1.7 root 1005: if (!File_Exists(filename)) {
1006: fprintf(stderr, "ERROR: file '%s' doesn't exist or isn't readable!\n", filename);
1.1.1.5 root 1007: return NULL;
1008: }
1.1.1.7 root 1009: if (Opt_IsAtariProgram(filename)) {
1.1.1.6 root 1010: const char *last = CurrentProgramPath;
1011: if (!last) {
1012: /* "pc=text" breakpoint used as point for loading program symbols gives false hits during bootup */
1013: fprintf(stderr, "WARNING: no program loaded yet (through GEMDOS HD emu)!\n");
1014: } else if (strcmp(last, filename) != 0) {
1015: fprintf(stderr, "WARNING: given program doesn't match last program executed by GEMDOS HD emulation:\n\t%s\n", last);
1.1.1.5 root 1016: }
1.1.1.6 root 1017: fprintf(stderr, "Reading symbols from program '%s' symbol table...\n", filename);
1.1.1.7 root 1018: fp = fopen(filename, "rb");
1.1.1.5 root 1019: list = symbols_load_binary(fp, SYMTYPE_ALL);
1.1.1.6 root 1020: SymbolsAreForProgram = true;
1.1.1.5 root 1021: } else {
1022: fprintf(stderr, "Reading 'nm' style ASCII symbols from '%s'...\n", filename);
1.1.1.7 root 1023: fp = fopen(filename, "r");
1.1.1.5 root 1024: list = symbols_load_ascii(fp, offsets, maxaddr, SYMTYPE_ALL);
1.1.1.6 root 1025: SymbolsAreForProgram = false;
1.1.1.5 root 1026: }
1027: fclose(fp);
1028:
1029: if (!list) {
1.1.1.6 root 1030: fprintf(stderr, "ERROR: reading symbols from '%s' failed!\n", filename);
1.1.1.5 root 1031: return NULL;
1032: }
1033:
1.1.1.9 root 1034: if (!list->namecount) {
1035: fprintf(stderr, "ERROR: no valid symbols in '%s', loading failed!\n", filename);
1036: symbol_list_free(list);
1037: return NULL;
1.1 root 1038: }
1039:
1.1.1.9 root 1040: /* sort and trim names list */
1041: qsort(list->names, list->namecount, sizeof(symbol_t), symbols_by_name);
1042: symbols_trim_names(list);
1043:
1.1 root 1044: /* copy name list to address list */
1.1.1.9 root 1045: list->addresses = malloc(list->namecount * sizeof(symbol_t));
1.1 root 1046: assert(list->addresses);
1.1.1.9 root 1047: memcpy(list->addresses, list->names, list->namecount * sizeof(symbol_t));
1.1 root 1048:
1.1.1.9 root 1049: /* sort address list and trim to contain just TEXT symbols */
1050: qsort(list->addresses, list->namecount, sizeof(symbol_t), symbols_by_address);
1051: symbols_trim_addresses(list);
1.1 root 1052:
1.1.1.9 root 1053: /* skip verbose output when symbol loading is forced */
1054: if (!ConfigureParams.Debugger.bSymbolsResident) {
1055: /* check for duplicate names */
1056: if (symbols_check_names(list->names, list->namecount)) {
1057: fprintf(stderr, "-> Hatari symbol expansion can match only one of the addresses for name duplicates!\n");
1058: }
1059: /* check for duplicate TEXT & other addresses */
1060: if (symbols_check_addresses(list->addresses, list->codecount)) {
1061: fprintf(stderr, "-> Hatari profile/dissassembly will show only one of the TEXT symbols for given address!\n");
1062: }
1063: if (symbols_check_addresses(list->addresses + list->codecount, list->datacount)) {
1064: fprintf(stderr, "-> Hatari dissassembly will show only one of the symbols for given address!\n");
1065: }
1066: }
1067:
1068: fprintf(stderr, "Loaded %d symbols (%d TEXT) from '%s'.\n",
1069: list->namecount, list->codecount, filename);
1.1 root 1070: return list;
1071: }
1072:
1073:
1074: /**
1075: * Free read symbols.
1076: */
1077: static void Symbols_Free(symbol_list_t* list)
1078: {
1.1.1.5 root 1079: int i;
1.1 root 1080:
1081: if (!list) {
1082: return;
1083: }
1.1.1.9 root 1084: assert(list->namecount);
1085: if (list->strtab) {
1086: free(list->strtab);
1087: list->strtab = NULL;
1088: } else {
1089: for (i = 0; i < list->namecount; i++) {
1090: free(list->names[i].name);
1091: }
1.1 root 1092: }
1093: free(list->addresses);
1094: free(list->names);
1.1.1.5 root 1095:
1096: /* catch use of freed list */
1097: list->addresses = NULL;
1.1.1.9 root 1098: list->codecount = 0;
1099: list->datacount = 0;
1.1.1.5 root 1100: list->names = NULL;
1.1.1.9 root 1101: list->namecount = 0;
1.1 root 1102: free(list);
1103: }
1104:
1105:
1106: /* ---------------- symbol name completion support ------------------ */
1107:
1108: /**
1109: * Helper for symbol name completion and finding their addresses.
1110: * STATE = 0 -> different text from previous one.
1111: * Return (copy of) next name or NULL if no matches.
1112: */
1113: static char* Symbols_MatchByName(symbol_list_t* list, symtype_t symtype, const char *text, int state)
1114: {
1.1.1.5 root 1115: static int i, len;
1.1 root 1116: const symbol_t *entry;
1117:
1118: if (!list) {
1119: return NULL;
1120: }
1121:
1122: if (!state) {
1123: /* first match */
1124: len = strlen(text);
1125: i = 0;
1126: }
1127:
1128: /* next match */
1129: entry = list->names;
1.1.1.9 root 1130: while (i < list->namecount) {
1.1 root 1131: if ((entry[i].type & symtype) &&
1132: strncmp(entry[i].name, text, len) == 0) {
1133: return strdup(entry[i++].name);
1134: } else {
1135: i++;
1136: }
1137: }
1138: return NULL;
1139: }
1140:
1141: /**
1142: * Readline match callbacks for CPU symbol name completion.
1143: * STATE = 0 -> different text from previous one.
1144: * Return next match or NULL if no matches.
1145: */
1146: char* Symbols_MatchCpuAddress(const char *text, int state)
1147: {
1148: return Symbols_MatchByName(CpuSymbolsList, SYMTYPE_ALL, text, state);
1149: }
1150: char* Symbols_MatchCpuCodeAddress(const char *text, int state)
1151: {
1.1.1.9 root 1152: if (ConfigureParams.Debugger.bMatchAllSymbols) {
1153: return Symbols_MatchByName(CpuSymbolsList, SYMTYPE_ALL, text, state);
1154: } else {
1155: return Symbols_MatchByName(CpuSymbolsList, SYMTYPE_TEXT, text, state);
1156: }
1.1 root 1157: }
1158: char* Symbols_MatchCpuDataAddress(const char *text, int state)
1159: {
1.1.1.9 root 1160: if (ConfigureParams.Debugger.bMatchAllSymbols) {
1161: return Symbols_MatchByName(CpuSymbolsList, SYMTYPE_ALL, text, state);
1162: } else {
1163: return Symbols_MatchByName(CpuSymbolsList, SYMTYPE_DATA|SYMTYPE_BSS, text, state);
1164: }
1.1 root 1165: }
1166:
1167: /**
1168: * Readline match callback for DSP symbol name completion.
1169: * STATE = 0 -> different text from previous one.
1170: * Return next match or NULL if no matches.
1171: */
1172: char* Symbols_MatchDspAddress(const char *text, int state)
1173: {
1174: return Symbols_MatchByName(DspSymbolsList, SYMTYPE_ALL, text, state);
1175: }
1176: char* Symbols_MatchDspCodeAddress(const char *text, int state)
1177: {
1178: return Symbols_MatchByName(DspSymbolsList, SYMTYPE_TEXT, text, state);
1179: }
1180: char* Symbols_MatchDspDataAddress(const char *text, int state)
1181: {
1182: return Symbols_MatchByName(DspSymbolsList, SYMTYPE_DATA|SYMTYPE_BSS, text, state);
1183: }
1184:
1185:
1186: /* ---------------- symbol name -> address search ------------------ */
1187:
1188: /**
1.1.1.9 root 1189: * Binary search symbol of given type by name.
1.1 root 1190: * Return symbol if name matches, zero otherwise.
1191: */
1.1.1.9 root 1192: static const symbol_t* Symbols_SearchByName(symbol_t* entries, int count, symtype_t symtype, const char *name)
1.1 root 1193: {
1194: /* left, right, middle */
1195: int l, r, m, dir;
1196:
1197: /* bisect */
1198: l = 0;
1.1.1.9 root 1199: r = count - 1;
1.1 root 1200: do {
1201: m = (l+r) >> 1;
1202: dir = strcmp(entries[m].name, name);
1203: if (dir == 0 && (entries[m].type & symtype)) {
1204: return &(entries[m]);
1205: }
1206: if (dir > 0) {
1207: r = m-1;
1208: } else {
1209: l = m+1;
1210: }
1211: } while (l <= r);
1212: return NULL;
1213: }
1214:
1215: /**
1.1.1.9 root 1216: * Set given symbol's address to variable and return true if one
1217: * was found from given list.
1.1 root 1218: */
1.1.1.9 root 1219: static bool Symbols_GetAddress(symbol_list_t* list, symtype_t symtype, const char *name, Uint32 *addr)
1.1 root 1220: {
1221: const symbol_t *entry;
1.1.1.9 root 1222: if (!(list && list->names)) {
1223: return false;
1224: }
1225: entry = Symbols_SearchByName(list->names, list->namecount, symtype, name);
1.1 root 1226: if (entry) {
1227: *addr = entry->address;
1228: return true;
1229: }
1230: return false;
1231: }
1.1.1.9 root 1232: bool Symbols_GetCpuAddress(symtype_t symtype, const char *name, Uint32 *addr)
1233: {
1234: return Symbols_GetAddress(CpuSymbolsList, symtype, name, addr);
1235: }
1.1 root 1236: bool Symbols_GetDspAddress(symtype_t symtype, const char *name, Uint32 *addr)
1237: {
1.1.1.9 root 1238: return Symbols_GetAddress(DspSymbolsList, symtype, name, addr);
1.1 root 1239: }
1240:
1241:
1242: /* ---------------- symbol address -> name search ------------------ */
1243:
1244: /**
1.1.1.9 root 1245: * Binary search symbol by address in given sorted list.
1.1.1.5 root 1246: * Return symbol index if address matches, -1 otherwise.
1.1 root 1247: */
1.1.1.9 root 1248: static int Symbols_SearchByAddress(symbol_t* entries, int count, Uint32 addr)
1.1 root 1249: {
1250: /* left, right, middle */
1251: int l, r, m;
1252: Uint32 curr;
1253:
1254: /* bisect */
1255: l = 0;
1.1.1.9 root 1256: r = count - 1;
1.1 root 1257: do {
1258: m = (l+r) >> 1;
1259: curr = entries[m].address;
1260: if (curr == addr) {
1.1.1.5 root 1261: return m;
1.1 root 1262: }
1263: if (curr > addr) {
1264: r = m-1;
1265: } else {
1266: l = m+1;
1267: }
1268: } while (l <= r);
1.1.1.5 root 1269: return -1;
1.1 root 1270: }
1271:
1272: /**
1.1.1.9 root 1273: * Search symbol in given list by type & address.
1274: * Return symbol name if there's a match, NULL otherwise.
1275: * TEXT symbols will be matched before other symbol types.
1.1 root 1276: * Returned name is valid only until next Symbols_* function call.
1277: */
1.1.1.9 root 1278: static const char* Symbols_GetByAddress(symbol_list_t* list, Uint32 addr, symtype_t type)
1.1 root 1279: {
1.1.1.9 root 1280: if (!(list && list->addresses)) {
1.1.1.5 root 1281: return NULL;
1282: }
1.1.1.9 root 1283: if (type & SYMTYPE_TEXT) {
1284: int i = Symbols_SearchByAddress(list->addresses, list->codecount, addr);
1285: if (i >= 0) {
1286: return list->addresses[i].name;
1287: }
1288: }
1289: if (type & ~SYMTYPE_TEXT) {
1290: int i = Symbols_SearchByAddress(list->addresses + list->codecount, list->datacount, addr);
1291: if (i >= 0) {
1292: return list->addresses[list->codecount + i].name;
1293: }
1294: }
1295: return NULL;
1.1 root 1296: }
1.1.1.9 root 1297: const char* Symbols_GetByCpuAddress(Uint32 addr, symtype_t type)
1.1 root 1298: {
1.1.1.9 root 1299: return Symbols_GetByAddress(CpuSymbolsList, addr, type);
1.1.1.5 root 1300: }
1.1.1.9 root 1301: const char* Symbols_GetByDspAddress(Uint32 addr, symtype_t type)
1.1.1.5 root 1302: {
1.1.1.9 root 1303: return Symbols_GetByAddress(DspSymbolsList, addr, type);
1.1.1.5 root 1304: }
1305:
1306: /**
1.1.1.9 root 1307: * Search given list for TEXT symbol by address.
1.1.1.5 root 1308: * Return symbol index if address matches, -1 otherwise.
1309: */
1.1.1.9 root 1310: static int Symbols_GetCodeIndex(symbol_list_t* list, Uint32 addr)
1311: {
1312: if (!list) {
1313: return -1;
1314: }
1315: return Symbols_SearchByAddress(list->addresses, list->codecount, addr);
1316: }
1317: int Symbols_GetCpuCodeIndex(Uint32 addr)
1318: {
1319: return Symbols_GetCodeIndex(CpuSymbolsList, addr);
1320: }
1321: int Symbols_GetDspCodeIndex(Uint32 addr)
1.1.1.5 root 1322: {
1.1.1.9 root 1323: return Symbols_GetCodeIndex(DspSymbolsList, addr);
1.1 root 1324: }
1325:
1.1.1.5 root 1326: /**
1.1.1.9 root 1327: * Return how many TEXT symbols are loaded/available
1.1.1.5 root 1328: */
1.1.1.9 root 1329: int Symbols_CpuCodeCount(void)
1.1.1.5 root 1330: {
1.1.1.9 root 1331: return (CpuSymbolsList ? CpuSymbolsList->codecount : 0);
1.1.1.5 root 1332: }
1.1.1.9 root 1333: int Symbols_DspCodeCount(void)
1.1.1.5 root 1334: {
1.1.1.9 root 1335: return (DspSymbolsList ? DspSymbolsList->codecount : 0);
1.1.1.5 root 1336: }
1.1 root 1337:
1.1.1.6 root 1338: /* ---------------- symbol showing ------------------ */
1.1 root 1339:
1340: /**
1341: * Show symbols from given list with paging.
1342: */
1.1.1.9 root 1343: static void Symbols_Show(symbol_list_t* list, const char *sortcmd)
1.1 root 1344: {
1345: symbol_t *entry, *entries;
1.1.1.9 root 1346: const char *symtype, *sorttype;
1347: int i, rows, count;
1.1 root 1348: char symchar;
1.1.1.9 root 1349: char line[80];
1.1 root 1350:
1351: if (!list) {
1352: fprintf(stderr, "No symbols!\n");
1353: return;
1354: }
1355:
1.1.1.9 root 1356: if (strcmp("code", sortcmd) == 0) {
1357: sorttype = "address";
1.1 root 1358: entries = list->addresses;
1.1.1.9 root 1359: count = list->codecount;
1360: symtype = " TEXT";
1361: } else if (strcmp("data", sortcmd) == 0) {
1362: sorttype = "address";
1363: entries = list->addresses + list->codecount;
1364: count = list->datacount;
1365: symtype = " DATA/BSS/ABS";
1.1 root 1366: } else {
1.1.1.9 root 1367: sorttype = "name";
1.1 root 1368: entries = list->names;
1.1.1.9 root 1369: count = list->namecount;
1370: symtype = "";
1.1 root 1371: }
1.1.1.9 root 1372: rows = DebugUI_GetPageLines(ConfigureParams.Debugger.nSymbolLines, 20);
1.1 root 1373:
1.1.1.9 root 1374: for (entry = entries, i = 0; i < count; i++, entry++) {
1.1.1.6 root 1375: symchar = symbol_char(entry->type);
1.1 root 1376: fprintf(stderr, "0x%08x %c %s\n",
1377: entry->address, symchar, entry->name);
1.1.1.9 root 1378: if ((i + 1) % rows == 0) {
1.1 root 1379: fprintf(stderr, "--- q to exit listing, just enter to continue --- ");
1.1.1.9 root 1380: if (fgets(line, sizeof(line), stdin) == NULL ||
1381: toupper(line[0]) == 'Q') {
1382: break;
1.1 root 1383: }
1384: }
1385: }
1.1.1.9 root 1386: fprintf(stderr, "%d %s%s symbols (of %d) sorted by %s.\n", i,
1387: (list == CpuSymbolsList ? "CPU" : "DSP"),
1388: symtype, count, sorttype);
1.1 root 1389: }
1390:
1.1.1.6 root 1391: /* ---------------- binary load handling ------------------ */
1392:
1393: /**
1.1.1.9 root 1394: * If symbols are set resident, load them if they aren't yet loaded,
1395: * otherwise remove them along with program path.
1396: *
1397: * Called on GEMDOS reset and when program terminates
1398: * (unless terminated with Ptermres()).
1.1.1.6 root 1399: */
1400: void Symbols_RemoveCurrentProgram(void)
1401: {
1402: if (CurrentProgramPath) {
1.1.1.9 root 1403: if (ConfigureParams.Debugger.bSymbolsResident) {
1404: Symbols_LoadCurrentProgram();
1405: }
1.1.1.6 root 1406: free(CurrentProgramPath);
1407: CurrentProgramPath = NULL;
1408:
1.1.1.9 root 1409: if (CpuSymbolsList && SymbolsAreForProgram && !ConfigureParams.Debugger.bSymbolsResident) {
1.1.1.6 root 1410: Symbols_Free(CpuSymbolsList);
1.1.1.9 root 1411: fprintf(stderr, "Program exit, removing its symbols.\n");
1.1.1.6 root 1412: CpuSymbolsList = NULL;
1413: }
1414: }
1415: AutoLoadFailed = false;
1416: }
1417:
1418: /**
1.1.1.9 root 1419: * Set last opened program path and remove symbols if they
1420: * didn't get remove beforehand.
1421: *
1422: * Called on first Fopen() after Pexec().
1.1.1.6 root 1423: */
1.1.1.7 root 1424: void Symbols_ChangeCurrentProgram(const char *path)
1.1.1.6 root 1425: {
1.1.1.7 root 1426: if (Opt_IsAtariProgram(path)) {
1.1.1.9 root 1427: if (ConfigureParams.Debugger.bSymbolsResident) {
1428: if (CpuSymbolsList && SymbolsAreForProgram) {
1429: Symbols_Free(CpuSymbolsList);
1430: fprintf(stderr, "Program launch, removing previous program symbols.\n");
1431: CpuSymbolsList = NULL;
1432: }
1433: if (CurrentProgramPath) {
1434: free(CurrentProgramPath);
1435: }
1436: } else {
1437: Symbols_RemoveCurrentProgram();
1438: }
1.1.1.6 root 1439: CurrentProgramPath = strdup(path);
1440: }
1441: }
1442:
1443: /**
1444: * Load symbols for last opened program.
1.1.1.9 root 1445: * Called when debugger is invoked.
1.1.1.6 root 1446: */
1447: void Symbols_LoadCurrentProgram(void)
1448: {
1449: /* symbols already loaded, program path missing or previous load failed? */
1450: if (CpuSymbolsList || !CurrentProgramPath || AutoLoadFailed) {
1451: return;
1452: }
1453: CpuSymbolsList = Symbols_Load(CurrentProgramPath, NULL, 0);
1454: if (!CpuSymbolsList) {
1455: AutoLoadFailed = true;
1456: } else {
1457: AutoLoadFailed = false;
1458: }
1459: }
1460:
1461: /* ---------------- command parsing ------------------ */
1462:
1463: /**
1464: * Readline match callback to list symbols subcommands.
1465: * STATE = 0 -> different text from previous one.
1466: * Return next match or NULL if no matches.
1467: */
1468: char *Symbols_MatchCommand(const char *text, int state)
1469: {
1470: static const char* subs[] = {
1.1.1.9 root 1471: "code", "data", "free", "match", "name", "prg", "resident"
1.1.1.6 root 1472: };
1.1.1.8 root 1473: return DebugUI_MatchHelper(subs, ARRAY_SIZE(subs), text, state);
1.1.1.6 root 1474: }
1475:
1.1 root 1476: const char Symbols_Description[] =
1.1.1.10! root 1477: "<code|data|name> -- list symbols\n"
1.1.1.9 root 1478: "\tsymbols <prg|free> -- load/free symbols\n"
1479: "\tsymbols <filename> [<T offset> [<D offset> <B offset>]]\n"
1480: "\tsymbols <resident|match> -- toggle symbol options\n"
1.1.1.5 root 1481: "\n"
1.1.1.9 root 1482: "\t'name' command lists the currently loaded symbols, sorted by name.\n"
1483: "\t'code' and 'data' commands list them sorted by address; 'code' lists\n"
1484: "\tonly TEXT symbols, 'data' lists DATA/BSS/ABS symbols.\n"
1.1.1.5 root 1485: "\n"
1.1.1.9 root 1486: "\tBy default, symbols are loaded from the currently executing program's\n"
1487: "\tbinary when entering the debugger, IF program is started through\n"
1488: "\tGEMDOS HD, and they're freed when that program terminates.\n"
1.1.1.5 root 1489: "\n"
1.1.1.9 root 1490: "\tThat corresponds to 'prg' command which loads (DRI/GST or a.out\n"
1491: "\tformat) symbol table from the last program executed through\n"
1492: "\tthe GEMDOS HD emulation.\n"
1493: "\n"
1494: "\t'free' command removes the loaded symbols.\n"
1495: "\n"
1496: "\tIf program lacks symbols, or it's not run through the GEMDOS HD\n"
1497: "\temulation, user can ask symbols to be loaded from a file that's\n"
1498: "\tan unstripped version of the binary. Or from an ASCII symbols file\n"
1499: "\tproduced by the 'nm' and (Hatari) 'gst2ascii' tools.\n"
1500: "\n"
1501: "\tWith ASCII symbols files, given non-zero offset(s) are added to\n"
1502: "\tthe text (T), data (D) and BSS (B) symbols. Typically one uses\n"
1503: "\tTEXT variable, sometimes also DATA & BSS, variables for this.\n"
1504: "\n"
1505: "\t'resident' command toggles whether debugger will load symbols\n"
1506: "\tbefore program terminates (if user hasn't entered debugger before\n"
1507: "\tthis), and defers symbol freeing until another program is started.\n"
1508: "\n"
1509: "\t'match' command toggles whether TAB completion matches all symbols,\n"
1510: "\tor only symbol types that should be relevant for given command.";
1511:
1.1 root 1512:
1513: /**
1514: * Handle debugger 'symbols' command and its arguments
1515: */
1516: int Symbols_Command(int nArgc, char *psArgs[])
1517: {
1.1.1.9 root 1518: enum { TYPE_CPU, TYPE_DSP } listtype;
1.1.1.5 root 1519: Uint32 offsets[3], maxaddr;
1.1 root 1520: symbol_list_t *list;
1521: const char *file;
1.1.1.5 root 1522: int i;
1.1 root 1523:
1524: if (strcmp("dspsymbols", psArgs[0]) == 0) {
1525: listtype = TYPE_DSP;
1526: maxaddr = 0xFFFF;
1.1.1.9 root 1527: } else {
1.1 root 1528: listtype = TYPE_CPU;
1.1.1.7 root 1529: if ( ConfigureParams.System.bAddressSpace24 )
1530: maxaddr = 0x00FFFFFF;
1531: else
1532: maxaddr = 0xFFFFFFFF;
1.1.1.9 root 1533: }
1534: if (nArgc < 2) {
1535: file = "name";
1.1 root 1536: } else {
1.1.1.9 root 1537: file = psArgs[1];
1.1 root 1538: }
1.1.1.9 root 1539:
1540: /* toggle whether to autoload symbols on program start,
1541: * and keep them until next program start (=resident),
1542: * OR only loading them when entering the debugger and
1543: * freeing them when program terminates.
1544: */
1545: if (strcmp(file, "resident") == 0) {
1546: ConfigureParams.Debugger.bSymbolsResident = !ConfigureParams.Debugger.bSymbolsResident;
1547: if (ConfigureParams.Debugger.bSymbolsResident) {
1548: Symbols_LoadCurrentProgram();
1549: fprintf(stderr, "Program symbols will always be loaded (with reduced warnings)\nand kept resident until next program start.\n");
1550: } else {
1551: fprintf(stderr, "Program symbols will be removed when program terminates.\n");
1552: if (!CurrentProgramPath) {
1553: /* make sure normal autoloading isn't prevented */
1554: Symbols_Free(CpuSymbolsList);
1555: CpuSymbolsList = NULL;
1556: }
1557: }
1558: return DEBUGGER_CMDDONE;
1559: }
1560: /* toggling whether all or only specific symbols types get TAB completed */
1561: if (strcmp(file, "match") == 0) {
1562: ConfigureParams.Debugger.bMatchAllSymbols = !ConfigureParams.Debugger.bMatchAllSymbols;
1563: if (ConfigureParams.Debugger.bMatchAllSymbols) {
1564: fprintf(stderr, "Matching all symbols types.\n");
1565: } else {
1566: fprintf(stderr, "Matching only symbols (most) relevant for given command.\n");
1567: }
1568: return DEBUGGER_CMDDONE;
1.1 root 1569: }
1570:
1571: /* handle special cases */
1.1.1.9 root 1572: if (strcmp(file, "name") == 0 || strcmp(file, "code") == 0 || strcmp(file, "data") == 0) {
1.1 root 1573: list = (listtype == TYPE_DSP ? DspSymbolsList : CpuSymbolsList);
1574: Symbols_Show(list, file);
1575: return DEBUGGER_CMDDONE;
1576: }
1577: if (strcmp(file, "free") == 0) {
1578: if (listtype == TYPE_DSP) {
1579: Symbols_Free(DspSymbolsList);
1580: DspSymbolsList = NULL;
1581: } else {
1582: Symbols_Free(CpuSymbolsList);
1583: CpuSymbolsList = NULL;
1584: }
1585: return DEBUGGER_CMDDONE;
1586: }
1.1.1.5 root 1587:
1588: /* get offsets */
1589: offsets[0] = 0;
1.1.1.8 root 1590: for (i = 0; i < ARRAY_SIZE(offsets); i++) {
1.1.1.5 root 1591: if (i+2 < nArgc) {
1592: int dummy;
1593: Eval_Expression(psArgs[i+2], &(offsets[i]), &dummy, listtype==TYPE_DSP);
1594: } else {
1595: /* default to first (text) offset */
1596: offsets[i] = offsets[0];
1597: }
1.1 root 1598: }
1599:
1.1.1.5 root 1600: if (strcmp(file, "prg") == 0) {
1.1.1.6 root 1601: file = CurrentProgramPath;
1.1.1.5 root 1602: if (!file) {
1603: fprintf(stderr, "ERROR: no program loaded (through GEMDOS HD emu)!\n");
1604: return DEBUGGER_CMDDONE;
1605: }
1606: }
1607: list = Symbols_Load(file, offsets, maxaddr);
1.1 root 1608: if (list) {
1609: if (listtype == TYPE_CPU) {
1610: Symbols_Free(CpuSymbolsList);
1611: CpuSymbolsList = list;
1612: } else {
1613: Symbols_Free(DspSymbolsList);
1614: DspSymbolsList = list;
1615: }
1616: } else {
1617: DebugUI_PrintCmdHelp(psArgs[0]);
1618: }
1619: return DEBUGGER_CMDDONE;
1620: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.