![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mips-tdump.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to mips-tdump.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Read and manage MIPS symbol tables from object modules.
2: Source originally from [email protected]
3: Rewritten by: [email protected]
4: Copyright (C) 1991 Free Software Foundation, Inc.
5:
6: This file is part of GNU CC.
7:
8: GNU CC is free software; you can redistribute it and/or modify
9: it under the terms of the GNU General Public License as published by
10: the Free Software Foundation; either version 2, or (at your option)
11: any later version.
12:
13: GNU CC is distributed in the hope that it will be useful,
14: but WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16: GNU General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with GNU CC; see the file COPYING. If not, write to
20: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21:
22: #include <stdio.h>
23: #include <sys/types.h>
24: #include <sys/file.h>
25: #include <fcntl.h>
26: #include <errno.h>
27: #include "config.h"
28:
29: #ifdef index
30: #undef index
31: #undef rindex
32: #endif
33: #ifndef CROSS_COMPILE
34: #include <a.out.h>
35: #else
36: #include "mips/a.out.h"
37: #endif /* CROSS_COMPILE */
38:
39: #ifndef MIPS_IS_STAB
40: /* Macros for mips-tfile.c to encapsulate stabs in ECOFF, and for
41: and mips-tdump.c to print them out. This is used on the Alpha,
42: which does not include mips.h.
43:
44: These must match the corresponding definitions in gdb/mipsread.c.
45: Unfortunately, gcc and gdb do not currently share any directories. */
46:
47: #define CODE_MASK 0x8F300
48: #define MIPS_IS_STAB(sym) (((sym)->index & 0xFFF00) == CODE_MASK)
49: #define MIPS_MARK_STAB(code) ((code)+CODE_MASK)
50: #define MIPS_UNMARK_STAB(code) ((code)-CODE_MASK)
51: #endif
52:
53: #ifdef __STDC__
54: typedef void *PTR_T;
55: typedef const void *CPTR_T;
56: #define __proto(x) x
57: #else
58:
59: #if defined(_STDIO_H_) || defined(__STDIO_H__) /* Ultrix 4.0, SGI */
60: typedef void *PTR_T;
61: typedef void *CPTR_T;
62:
63: #else
64: typedef char *PTR_T; /* Ultrix 3.1 */
65: typedef char *CPTR_T;
66: #endif
67:
68: #define __proto(x) ()
69: #define const
70: #endif
71:
72: #define uchar unsigned char
73: #define ushort unsigned short
74: #define uint unsigned int
75: #define ulong unsigned long
76:
77:
78: /* Do to size_t being defined in sys/types.h and different
79: in stddef.h, we have to do this by hand..... Note, these
80: types are correct for MIPS based systems, and may not be
81: correct for other systems. */
82:
83: #define size_t uint
84: #define ptrdiff_t int
85:
86:
87: /* Redefinition of of storage classes as an enumeration for better
88: debugging. */
89:
90: #ifndef stStaParam
91: #define stStaParam 16 /* Fortran static parameters */
92: #endif
93:
94: #ifndef btVoid
95: #define btVoid 26 /* void basic type */
96: #endif
97:
98: typedef enum sc {
99: sc_Nil = scNil, /* no storage class */
100: sc_Text = scText, /* text symbol */
101: sc_Data = scData, /* initialized data symbol */
102: sc_Bss = scBss, /* un-initialized data symbol */
103: sc_Register = scRegister, /* value of symbol is register number */
104: sc_Abs = scAbs, /* value of symbol is absolute */
105: sc_Undefined = scUndefined, /* who knows? */
106: sc_CdbLocal = scCdbLocal, /* variable's value is IN se->va.?? */
107: sc_Bits = scBits, /* this is a bit field */
108: sc_CdbSystem = scCdbSystem, /* var's value is IN CDB's address space */
109: sc_RegImage = scRegImage, /* register value saved on stack */
110: sc_Info = scInfo, /* symbol contains debugger information */
111: sc_UserStruct = scUserStruct, /* addr in struct user for current process */
112: sc_SData = scSData, /* load time only small data */
113: sc_SBss = scSBss, /* load time only small common */
114: sc_RData = scRData, /* load time only read only data */
115: sc_Var = scVar, /* Var parameter (fortran,pascal) */
116: sc_Common = scCommon, /* common variable */
117: sc_SCommon = scSCommon, /* small common */
118: sc_VarRegister = scVarRegister, /* Var parameter in a register */
119: sc_Variant = scVariant, /* Variant record */
120: sc_SUndefined = scSUndefined, /* small undefined(external) data */
121: sc_Init = scInit, /* .init section symbol */
122: sc_Max = scMax /* Max storage class+1 */
123: } sc_t;
124:
125: /* Redefinition of symbol type. */
126:
127: typedef enum st {
128: st_Nil = stNil, /* Nuthin' special */
129: st_Global = stGlobal, /* external symbol */
130: st_Static = stStatic, /* static */
131: st_Param = stParam, /* procedure argument */
132: st_Local = stLocal, /* local variable */
133: st_Label = stLabel, /* label */
134: st_Proc = stProc, /* " " Procedure */
135: st_Block = stBlock, /* beginning of block */
136: st_End = stEnd, /* end (of anything) */
137: st_Member = stMember, /* member (of anything - struct/union/enum */
138: st_Typedef = stTypedef, /* type definition */
139: st_File = stFile, /* file name */
140: st_RegReloc = stRegReloc, /* register relocation */
141: st_Forward = stForward, /* forwarding address */
142: st_StaticProc = stStaticProc, /* load time only static procs */
143: st_StaParam = stStaParam, /* Fortran static parameters */
144: st_Constant = stConstant, /* const */
145: st_Str = stStr, /* string */
146: st_Number = stNumber, /* pure number (ie. 4 NOR 2+2) */
147: st_Expr = stExpr, /* 2+2 vs. 4 */
148: st_Type = stType, /* post-coercion SER */
149: st_Max = stMax /* max type+1 */
150: } st_t;
151:
152: /* Redefinition of type qualifiers. */
153:
154: typedef enum tq {
155: tq_Nil = tqNil, /* bt is what you see */
156: tq_Ptr = tqPtr, /* pointer */
157: tq_Proc = tqProc, /* procedure */
158: tq_Array = tqArray, /* duh */
159: tq_Far = tqFar, /* longer addressing - 8086/8 land */
160: tq_Vol = tqVol, /* volatile */
161: tq_Max = tqMax /* Max type qualifier+1 */
162: } tq_t;
163:
164: /* Redefinition of basic types. */
165:
166: typedef enum bt {
167: bt_Nil = btNil, /* undefined */
168: bt_Adr = btAdr, /* address - integer same size as pointer */
169: bt_Char = btChar, /* character */
170: bt_UChar = btUChar, /* unsigned character */
171: bt_Short = btShort, /* short */
172: bt_UShort = btUShort, /* unsigned short */
173: bt_Int = btInt, /* int */
174: bt_UInt = btUInt, /* unsigned int */
175: bt_Long = btLong, /* long */
176: bt_ULong = btULong, /* unsigned long */
177: bt_Float = btFloat, /* float (real) */
178: bt_Double = btDouble, /* Double (real) */
179: bt_Struct = btStruct, /* Structure (Record) */
180: bt_Union = btUnion, /* Union (variant) */
181: bt_Enum = btEnum, /* Enumerated */
182: bt_Typedef = btTypedef, /* defined via a typedef, isymRef points */
183: bt_Range = btRange, /* subrange of int */
184: bt_Set = btSet, /* pascal sets */
185: bt_Complex = btComplex, /* fortran complex */
186: bt_DComplex = btDComplex, /* fortran double complex */
187: bt_Indirect = btIndirect, /* forward or unnamed typedef */
188: bt_FixedDec = btFixedDec, /* Fixed Decimal */
189: bt_FloatDec = btFloatDec, /* Float Decimal */
190: bt_String = btString, /* Varying Length Character String */
191: bt_Bit = btBit, /* Aligned Bit String */
192: bt_Picture = btPicture, /* Picture */
193: bt_Void = btVoid, /* void */
194: bt_Max = btMax /* Max basic type+1 */
195: } bt_t;
196:
197: /* Redefinition of the language codes. */
198:
199: typedef enum lang {
200: lang_C = langC,
201: lang_Pascal = langPascal,
202: lang_Fortran = langFortran,
203: lang_Assembler = langAssembler,
204: lang_Machine = langMachine,
205: lang_Nil = langNil,
206: lang_Ada = langAda,
207: lang_Pl1 = langPl1,
208: lang_Cobol = langCobol
209: } lang_t;
210:
211: /* Redefinition of the debug level codes. */
212:
213: typedef enum glevel {
214: glevel_0 = GLEVEL_0,
215: glevel_1 = GLEVEL_1,
216: glevel_2 = GLEVEL_2,
217: glevel_3 = GLEVEL_3
218: } glevel_t;
219:
220:
221: /* Keep track of the active scopes. */
222: typedef struct scope {
223: struct scope *prev; /* previous scope */
224: ulong open_sym; /* symbol opening scope */
225: sc_t sc; /* storage class */
226: st_t st; /* symbol type */
227: } scope_t;
228:
229: struct filehdr global_hdr; /* a.out header */
230:
231: int errors = 0; /* # of errors */
232: int want_aux = 0; /* print aux table */
233: int want_line = 0; /* print line numbers */
234: int want_rfd = 0; /* print relative file desc's */
235: int want_scope = 0; /* print scopes for every symbol */
236: int tfile = 0; /* no global header file */
237: int tfile_fd; /* file descriptor of .T file */
238: off_t tfile_offset; /* current offset in .T file */
239: scope_t *cur_scope = 0; /* list of active scopes */
240: scope_t *free_scope = 0; /* list of freed scopes */
241: HDRR sym_hdr; /* symbolic header */
242: char *l_strings; /* local strings */
243: char *e_strings; /* external strings */
244: SYMR *l_symbols; /* local symbols */
245: EXTR *e_symbols; /* external symbols */
246: LINER *lines; /* line numbers */
247: DNR *dense_nums; /* dense numbers */
248: OPTR *opt_symbols; /* optimization symbols */
249: AUXU *aux_symbols; /* Auxiliary symbols */
250: char *aux_used; /* map of which aux syms are used */
251: FDR *file_desc; /* file tables */
252: ulong *rfile_desc; /* relative file tables */
253: PDR *proc_desc; /* procedure tables */
254:
255: /* Forward reference for functions. */
256: PTR_T read_seek __proto((PTR_T, size_t, off_t, const char *));
257: void read_tfile __proto((void));
258: void print_global_hdr __proto((struct filehdr *));
259: void print_sym_hdr __proto((HDRR *));
260: void print_file_desc __proto((FDR *, int));
261: void print_symbol __proto((SYMR *, int, char *, AUXU *, int));
262: void print_aux __proto((AUXU, int, int));
263: void emit_aggregate __proto((char *, AUXU, AUXU, const char *));
264: char *st_to_string __proto((st_t));
265: char *sc_to_string __proto((sc_t));
266: char *glevel_to_string __proto((glevel_t));
267: char *lang_to_string __proto((lang_t));
268: char *type_to_string __proto((AUXU *, int));
269:
270: #ifndef __alpha
271: extern PTR_T malloc __proto((size_t));
272: extern PTR_T calloc __proto((size_t, size_t));
273: extern PTR_T realloc __proto((PTR_T, size_t));
274: extern void free __proto((PTR_T));
275: #endif
276: extern char *ctime __proto((time_t *));
277:
278: extern char *optarg;
279: extern int optind;
280: extern int opterr;
281:
282: /* Create a table of debugging stab-codes and corresponding names. */
283:
284: #define __define_stab(NAME, CODE, STRING) {(int)CODE, STRING},
285: struct {short code; char string[10];} stab_names[] = {
286: #include "stab.def"
287: #undef __define_stab
288: };
289:
290:
291: /* Read some bytes at a specified location, and return a pointer. */
292:
293: PTR_T
294: read_seek (ptr, size, offset, context)
295: PTR_T ptr; /* pointer to buffer or NULL */
296: size_t size; /* # bytes to read */
297: off_t offset; /* offset to read at */
298: const char *context; /* context for error message */
299: {
300: long read_size = 0;
301:
302: if (size == 0) /* nothing to read */
303: return ptr;
304:
305: if ((ptr == (PTR_T)0 && (ptr = malloc (size)) == (PTR_T)0)
306: || (tfile_offset != offset && lseek (tfile_fd, offset, 0) == -1)
307: || (read_size = read (tfile_fd, ptr, size)) < 0)
308: {
309: perror (context);
310: exit (1);
311: }
312:
313: if (read_size != size)
314: {
315: fprintf (stderr, "%s: read %ld bytes, expected %ld bytes\n",
316: context, read_size, (long) size);
317: exit (1);
318: }
319:
320: tfile_offset = offset + size;
321: return ptr;
322: }
323:
324:
325: /* Convert language code to string format. */
326:
327: char *
328: lang_to_string (lang)
329: lang_t lang;
330: {
331: switch (lang)
332: {
333: case langC: return "C";
334: case langPascal: return "Pascal";
335: case langFortran: return "Fortran";
336: case langAssembler: return "Assembler";
337: case langMachine: return "Machine";
338: case langNil: return "Nil";
339: case langAda: return "Ada";
340: case langPl1: return "Pl1";
341: case langCobol: return "Cobol";
342: }
343:
344: return "Unknown language";
345: }
346:
347:
348: /* Convert storage class to string. */
349:
350: char *
351: sc_to_string(storage_class)
352: sc_t storage_class;
353: {
354: switch(storage_class)
355: {
356: case sc_Nil: return "Nil";
357: case sc_Text: return "Text";
358: case sc_Data: return "Data";
359: case sc_Bss: return "Bss";
360: case sc_Register: return "Register";
361: case sc_Abs: return "Abs";
362: case sc_Undefined: return "Undefined";
363: case sc_CdbLocal: return "CdbLocal";
364: case sc_Bits: return "Bits";
365: case sc_CdbSystem: return "CdbSystem";
366: case sc_RegImage: return "RegImage";
367: case sc_Info: return "Info";
368: case sc_UserStruct: return "UserStruct";
369: case sc_SData: return "SData";
370: case sc_SBss: return "SBss";
371: case sc_RData: return "RData";
372: case sc_Var: return "Var";
373: case sc_Common: return "Common";
374: case sc_SCommon: return "SCommon";
375: case sc_VarRegister: return "VarRegister";
376: case sc_Variant: return "Variant";
377: case sc_SUndefined: return "SUndefined";
378: case sc_Init: return "Init";
379: case sc_Max: return "Max";
380: }
381:
382: return "???";
383: }
384:
385:
386: /* Convert symbol type to string. */
387:
388: char *
389: st_to_string(symbol_type)
390: st_t symbol_type;
391: {
392: switch(symbol_type)
393: {
394: case st_Nil: return "Nil";
395: case st_Global: return "Global";
396: case st_Static: return "Static";
397: case st_Param: return "Param";
398: case st_Local: return "Local";
399: case st_Label: return "Label";
400: case st_Proc: return "Proc";
401: case st_Block: return "Block";
402: case st_End: return "End";
403: case st_Member: return "Member";
404: case st_Typedef: return "Typedef";
405: case st_File: return "File";
406: case st_RegReloc: return "RegReloc";
407: case st_Forward: return "Forward";
408: case st_StaticProc: return "StaticProc";
409: case st_Constant: return "Constant";
410: case st_StaParam: return "StaticParam";
411: case st_Str: return "String";
412: case st_Number: return "Number";
413: case st_Expr: return "Expr";
414: case st_Type: return "Type";
415: case st_Max: return "Max";
416: }
417:
418: return "???";
419: }
420:
421:
422: /* Convert debug level to string. */
423:
424: char *
425: glevel_to_string (g_level)
426: glevel_t g_level;
427: {
428: switch(g_level)
429: {
430: case GLEVEL_0: return "G0";
431: case GLEVEL_1: return "G1";
432: case GLEVEL_2: return "G2";
433: case GLEVEL_3: return "G3";
434: }
435:
436: return "??";
437: }
438:
439:
440: /* Convert the type information to string format. */
441:
442: char *
443: type_to_string (aux_ptr, index)
444: AUXU *aux_ptr;
445: int index;
446: {
447: AUXU u;
448: struct qual {
449: tq_t type;
450: int low_bound;
451: int high_bound;
452: int stride;
453: } qualifiers[7];
454:
455: bt_t basic_type;
456: int i;
457: static char buffer1[1024];
458: static char buffer2[1024];
459: char *p1 = buffer1;
460: char *p2 = buffer2;
461: char *used_ptr = aux_used + (aux_ptr - aux_symbols);
462:
463: for (i = 0; i < 7; i++)
464: {
465: qualifiers[i].low_bound = 0;
466: qualifiers[i].high_bound = 0;
467: qualifiers[i].stride = 0;
468: }
469:
470: used_ptr[index] = 1;
471: u = aux_ptr[index++];
472: if (u.isym == -1)
473: return "-1 (no type)";
474:
475: basic_type = (bt_t) u.ti.bt;
476: qualifiers[0].type = (tq_t) u.ti.tq0;
477: qualifiers[1].type = (tq_t) u.ti.tq1;
478: qualifiers[2].type = (tq_t) u.ti.tq2;
479: qualifiers[3].type = (tq_t) u.ti.tq3;
480: qualifiers[4].type = (tq_t) u.ti.tq4;
481: qualifiers[5].type = (tq_t) u.ti.tq5;
482: qualifiers[6].type = tq_Nil;
483:
484: /*
485: * Go get the basic type.
486: */
487: switch (basic_type)
488: {
489: case bt_Nil: /* undefined */
490: strcpy (p1, "nil");
491: break;
492:
493: case bt_Adr: /* address - integer same size as pointer */
494: strcpy (p1, "address");
495: break;
496:
497: case bt_Char: /* character */
498: strcpy (p1, "char");
499: break;
500:
501: case bt_UChar: /* unsigned character */
502: strcpy (p1, "unsigned char");
503: break;
504:
505: case bt_Short: /* short */
506: strcpy (p1, "short");
507: break;
508:
509: case bt_UShort: /* unsigned short */
510: strcpy (p1, "unsigned short");
511: break;
512:
513: case bt_Int: /* int */
514: strcpy (p1, "int");
515: break;
516:
517: case bt_UInt: /* unsigned int */
518: strcpy (p1, "unsigned int");
519: break;
520:
521: case bt_Long: /* long */
522: strcpy (p1, "long");
523: break;
524:
525: case bt_ULong: /* unsigned long */
526: strcpy (p1, "unsigned long");
527: break;
528:
529: case bt_Float: /* float (real) */
530: strcpy (p1, "float");
531: break;
532:
533: case bt_Double: /* Double (real) */
534: strcpy (p1, "double");
535: break;
536:
537: /* Structures add 1-2 aux words:
538: 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
539: 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
540:
541: case bt_Struct: /* Structure (Record) */
542: emit_aggregate (p1, aux_ptr[index], aux_ptr[index+1], "struct");
543: used_ptr[index] = 1;
544: if (aux_ptr[index].rndx.rfd == ST_RFDESCAPE)
545: used_ptr[++index] = 1;
546:
547: index++; /* skip aux words */
548: break;
549:
550: /* Unions add 1-2 aux words:
551: 1st word is [ST_RFDESCAPE, offset] pointer to union def;
552: 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
553:
554: case bt_Union: /* Union */
555: emit_aggregate (p1, aux_ptr[index], aux_ptr[index+1], "union");
556: used_ptr[index] = 1;
557: if (aux_ptr[index].rndx.rfd == ST_RFDESCAPE)
558: used_ptr[++index] = 1;
559:
560: index++; /* skip aux words */
561: break;
562:
563: /* Enumerations add 1-2 aux words:
564: 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
565: 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
566:
567: case bt_Enum: /* Enumeration */
568: emit_aggregate (p1, aux_ptr[index], aux_ptr[index+1], "enum");
569: used_ptr[index] = 1;
570: if (aux_ptr[index].rndx.rfd == ST_RFDESCAPE)
571: used_ptr[++index] = 1;
572:
573: index++; /* skip aux words */
574: break;
575:
576: case bt_Typedef: /* defined via a typedef, isymRef points */
577: strcpy (p1, "typedef");
578: break;
579:
580: case bt_Range: /* subrange of int */
581: strcpy (p1, "subrange");
582: break;
583:
584: case bt_Set: /* pascal sets */
585: strcpy (p1, "set");
586: break;
587:
588: case bt_Complex: /* fortran complex */
589: strcpy (p1, "complex");
590: break;
591:
592: case bt_DComplex: /* fortran double complex */
593: strcpy (p1, "double complex");
594: break;
595:
596: case bt_Indirect: /* forward or unnamed typedef */
597: strcpy (p1, "forward/unamed typedef");
598: break;
599:
600: case bt_FixedDec: /* Fixed Decimal */
601: strcpy (p1, "fixed decimal");
602: break;
603:
604: case bt_FloatDec: /* Float Decimal */
605: strcpy (p1, "float decimal");
606: break;
607:
608: case bt_String: /* Varying Length Character String */
609: strcpy (p1, "string");
610: break;
611:
612: case bt_Bit: /* Aligned Bit String */
613: strcpy (p1, "bit");
614: break;
615:
616: case bt_Picture: /* Picture */
617: strcpy (p1, "picture");
618: break;
619:
620: case bt_Void: /* Void */
621: strcpy (p1, "void");
622: break;
623:
624: default:
625: sprintf (p1, "Unknown basic type %d", (int) basic_type);
626: break;
627: }
628:
629: p1 += strlen (buffer1);
630:
631: /*
632: * If this is a bitfield, get the bitsize.
633: */
634: if (u.ti.fBitfield)
635: {
636: int bitsize;
637:
638: used_ptr[index] = 1;
639: bitsize = aux_ptr[index++].width;
640: sprintf (p1, " : %d", bitsize);
641: p1 += strlen (buffer1);
642: }
643:
644:
645: /*
646: * Deal with any qualifiers.
647: */
648: if (qualifiers[0].type != tq_Nil)
649: {
650: /*
651: * Snarf up any array bounds in the correct order. Arrays
652: * store 5 successive words in the aux. table:
653: * word 0 RNDXR to type of the bounds (ie, int)
654: * word 1 Current file descriptor index
655: * word 2 low bound
656: * word 3 high bound (or -1 if [])
657: * word 4 stride size in bits
658: */
659: for (i = 0; i < 7; i++)
660: {
661: if (qualifiers[i].type == tq_Array)
662: {
663: qualifiers[i].low_bound = aux_ptr[index+2].dnLow;
664: qualifiers[i].high_bound = aux_ptr[index+3].dnHigh;
665: qualifiers[i].stride = aux_ptr[index+4].width;
666: used_ptr[index] = 1;
667: used_ptr[index+1] = 1;
668: used_ptr[index+2] = 1;
669: used_ptr[index+3] = 1;
670: used_ptr[index+4] = 1;
671: index += 5;
672: }
673: }
674:
675: /*
676: * Now print out the qualifiers.
677: */
678: for (i = 0; i < 6; i++)
679: {
680: switch (qualifiers[i].type)
681: {
682: case tq_Nil:
683: case tq_Max:
684: break;
685:
686: case tq_Ptr:
687: strcpy (p2, "ptr to ");
688: p2 += sizeof ("ptr to ")-1;
689: break;
690:
691: case tq_Vol:
692: strcpy (p2, "volatile ");
693: p2 += sizeof ("volatile ")-1;
694: break;
695:
696: case tq_Far:
697: strcpy (p2, "far ");
698: p2 += sizeof ("far ")-1;
699: break;
700:
701: case tq_Proc:
702: strcpy (p2, "func. ret. ");
703: p2 += sizeof ("func. ret. ");
704: break;
705:
706: case tq_Array:
707: {
708: int first_array = i;
709: int j;
710:
711: /* Print array bounds reversed (ie, in the order the C
712: programmer writes them). C is such a fun language.... */
713:
714: while (i < 5 && qualifiers[i+1].type == tq_Array)
715: i++;
716:
717: for (j = i; j >= first_array; j--)
718: {
719: strcpy (p2, "array [");
720: p2 += sizeof ("array [")-1;
721: if (qualifiers[j].low_bound != 0)
722: sprintf (p2,
723: "%ld:%ld {%ld bits}",
724: (long) qualifiers[j].low_bound,
725: (long) qualifiers[j].high_bound,
726: (long) qualifiers[j].stride);
727:
728: else if (qualifiers[j].high_bound != -1)
729: sprintf (p2,
730: "%ld {%ld bits}",
731: (long) (qualifiers[j].high_bound + 1),
732: (long) (qualifiers[j].stride));
733:
734: else
735: sprintf (p2, " {%ld bits}", (long) (qualifiers[j].stride));
736:
737: p2 += strlen (p2);
738: strcpy (p2, "] of ");
739: p2 += sizeof ("] of ")-1;
740: }
741: }
742: break;
743: }
744: }
745: }
746:
747: strcpy (p2, buffer1);
748: return buffer2;
749: }
750:
751:
752: /* Print out the global file header for object files. */
753:
754: void
755: print_global_hdr (ptr)
756: struct filehdr *ptr;
757: {
758: char *time = ctime ((time_t *)&ptr->f_timdat);
759: ushort flags = ptr->f_flags;
760:
761: printf("Global file header:\n");
762: printf(" %-*s 0x%x\n", 24, "magic number", (ushort) ptr->f_magic);
763: printf(" %-*s %d\n", 24, "# sections", (int) ptr->f_nscns);
764: printf(" %-*s %ld, %s", 24, "timestamp", (long) ptr->f_timdat, time);
765: printf(" %-*s %ld\n", 24, "symbolic header offset", (long) ptr->f_symptr);
766: printf(" %-*s %ld\n", 24, "symbolic header size", (long) ptr->f_nsyms);
767: printf(" %-*s %ld\n", 24, "optional header", (long) ptr->f_opthdr);
768: printf(" %-*s 0x%lx", 24, "flags", (ushort) flags);
769:
770: if ((flags & F_RELFLG) != 0)
771: printf (", F_RELFLG");
772:
773: if ((flags & F_EXEC) != 0)
774: printf (", F_EXEC");
775:
776: if ((flags & F_LNNO) != 0)
777: printf (", F_LNNO");
778:
779: if ((flags & F_LSYMS) != 0)
780: printf (", F_LSYMS");
781:
782: if ((flags & F_MINMAL) != 0)
783: printf (", F_MINMAL");
784:
785: if ((flags & F_UPDATE) != 0)
786: printf (", F_UPDATE");
787:
788: if ((flags & F_SWABD) != 0)
789: printf (", F_SWABD");
790:
791: if ((flags & F_AR16WR) != 0)
792: printf (", F_AR16WR");
793:
794: if ((flags & F_AR32WR) != 0)
795: printf (", F_AR32WR");
796:
797: if ((flags & F_AR32W) != 0)
798: printf (", F_AR32W");
799:
800: if ((flags & F_PATCH) != 0)
801: printf (", F_PATCH/F_NODF");
802:
803: printf ("\n\n");
804: }
805:
806:
807: /* Print out the symbolic header. */
808:
809: void
810: print_sym_hdr (sym_ptr)
811: HDRR *sym_ptr;
812: {
813: int width = 20;
814:
815: printf("Symbolic header, magic number = 0x%04x, vstamp = %d.%d:\n\n",
816: sym_ptr->magic & 0xffff,
817: (sym_ptr->vstamp & 0xffff) >> 8,
818: sym_ptr->vstamp & 0xff);
819:
820: printf(" %-*s %11s %11s %11s\n", width, "Info", "Offset", "Number", "Bytes");
821: printf(" %-*s %11s %11s %11s\n", width, "====", "======", "======", "=====\n");
822:
823: printf(" %-*s %11ld %11d %11d [%d]\n", width, "Line numbers",
824: (long)sym_ptr->cbLineOffset,
825: (long)sym_ptr->cbLine,
826: (long)sym_ptr->cbLine,
827: (int)sym_ptr->ilineMax);
828:
829: printf(" %-*s %11ld %11d %11d\n", width, "Dense numbers",
830: (long)sym_ptr->cbDnOffset,
831: (long)sym_ptr->idnMax,
832: (long)(sym_ptr->idnMax * sizeof (DNR)));
833:
834: printf(" %-*s %11ld %11d %11d\n", width, "Procedures Tables",
835: (long)sym_ptr->cbPdOffset,
836: (long)sym_ptr->ipdMax,
837: (long)(sym_ptr->ipdMax * sizeof (PDR)));
838:
839: printf(" %-*s %11ld %11d %11d\n", width, "Local Symbols",
840: (long)sym_ptr->cbSymOffset,
841: (long)sym_ptr->isymMax,
842: (long)(sym_ptr->isymMax * sizeof (SYMR)));
843:
844: printf(" %-*s %11ld %11d %11d\n", width, "Optimization Symbols",
845: (long)sym_ptr->cbOptOffset,
846: (long)sym_ptr->ioptMax,
847: (long)(sym_ptr->ioptMax * sizeof (OPTR)));
848:
849: printf(" %-*s %11ld %11d %11d\n", width, "Auxiliary Symbols",
850: (long)sym_ptr->cbAuxOffset,
851: (long)sym_ptr->iauxMax,
852: (long)(sym_ptr->iauxMax * sizeof (AUXU)));
853:
854: printf(" %-*s %11ld %11d %11d\n", width, "Local Strings",
855: (long)sym_ptr->cbSsOffset,
856: (long)sym_ptr->issMax,
857: (long)sym_ptr->issMax);
858:
859: printf(" %-*s %11ld %11d %11d\n", width, "External Strings",
860: (long)sym_ptr->cbSsExtOffset,
861: (long)sym_ptr->issExtMax,
862: (long)sym_ptr->issExtMax);
863:
864: printf(" %-*s %11ld %11d %11d\n", width, "File Tables",
865: (long)sym_ptr->cbFdOffset,
866: (long)sym_ptr->ifdMax,
867: (long)(sym_ptr->ifdMax * sizeof (FDR)));
868:
869: printf(" %-*s %11ld %11d %11d\n", width, "Relative Files",
870: (long)sym_ptr->cbRfdOffset,
871: (long)sym_ptr->crfd,
872: (long)(sym_ptr->crfd * sizeof (ulong)));
873:
874: printf(" %-*s %11ld %11d %11d\n", width, "External Symbols",
875: (long)sym_ptr->cbExtOffset,
876: (long)sym_ptr->iextMax,
877: (long)(sym_ptr->iextMax * sizeof (EXTR)));
878: }
879:
880:
881: /* Print out a symbol. */
882:
883: void
884: print_symbol (sym_ptr, number, strbase, aux_base, ifd)
885: SYMR *sym_ptr;
886: int number;
887: char *strbase;
888: AUXU *aux_base;
889: int ifd;
890: {
891: sc_t storage_class = (sc_t) sym_ptr->sc;
892: st_t symbol_type = (st_t) sym_ptr->st;
893: ulong index = sym_ptr->index;
894: char *used_ptr = aux_used + (aux_base - aux_symbols);
895: scope_t *scope_ptr;
896:
897: printf ("\n Symbol# %d: \"%s\"\n", number, sym_ptr->iss + strbase);
898:
899: if (aux_base != (AUXU *)0 && index != indexNil)
900: switch (symbol_type)
901: {
902: case st_Nil:
903: case st_Label:
904: break;
905:
906: case st_File:
907: case st_Block:
908: printf (" End+1 symbol: %ld\n", index);
909: if (want_scope)
910: {
911: if (free_scope == (scope_t *)0)
912: scope_ptr = (scope_t *) malloc (sizeof (scope_t));
913: else
914: {
915: scope_ptr = free_scope;
916: free_scope = scope_ptr->prev;
917: }
918: scope_ptr->open_sym = number;
919: scope_ptr->st = symbol_type;
920: scope_ptr->sc = storage_class;
921: scope_ptr->prev = cur_scope;
922: cur_scope = scope_ptr;
923: }
924: break;
925:
926: case st_End:
927: if (storage_class == sc_Text || storage_class == sc_Info)
928: printf (" First symbol: %ld\n", index);
929: else
930: {
931: used_ptr[index] = 1;
932: printf (" First symbol: %ld\n", aux_base[index].isym);
933: }
934:
935: if (want_scope)
936: {
937: if (cur_scope == (scope_t *)0)
938: printf (" Can't pop end scope\n");
939: else
940: {
941: scope_ptr = cur_scope;
942: cur_scope = scope_ptr->prev;
943: scope_ptr->prev = free_scope;
944: free_scope = scope_ptr;
945: }
946: }
947: break;
948:
949: case st_Proc:
950: case st_StaticProc:
951: if (MIPS_IS_STAB(sym_ptr))
952: ;
953: else if (ifd == -1) /* local symbol */
954: {
955: used_ptr[index] = used_ptr[index+1] = 1;
956: printf (" End+1 symbol: %-7ld Type: %s\n",
957: aux_base[index].isym, type_to_string (aux_base, index+1));
958: }
959: else /* global symbol */
960: {
961: used_ptr[index] = 1;
962: printf (" Type: %s\n",
963: type_to_string (aux_base, index));
964: }
965:
966: if (want_scope)
967: {
968: if (free_scope == (scope_t *)0)
969: scope_ptr = (scope_t *) malloc (sizeof (scope_t));
970: else
971: {
972: scope_ptr = free_scope;
973: free_scope = scope_ptr->prev;
974: }
975: scope_ptr->open_sym = number;
976: scope_ptr->st = symbol_type;
977: scope_ptr->sc = storage_class;
978: scope_ptr->prev = cur_scope;
979: cur_scope = scope_ptr;
980: }
981: break;
982:
983: default:
984: if (!MIPS_IS_STAB (sym_ptr))
985: {
986: used_ptr[index] = 1;
987: printf (" Type: %s\n",
988: type_to_string (aux_base, index));
989: }
990: break;
991: }
992:
993: if (want_scope)
994: {
995: printf (" Scopes: ");
996: if (cur_scope == (scope_t *)0)
997: printf (" none\n");
998: else
999: {
1000: for (scope_ptr = cur_scope;
1001: scope_ptr != (scope_t *)0;
1002: scope_ptr = scope_ptr->prev)
1003: {
1004: char *class;
1005: if (scope_ptr->st == st_Proc || scope_ptr->st == st_StaticProc)
1006: class = "func.";
1007: else if (scope_ptr->st == st_File)
1008: class = "file";
1009: else if (scope_ptr->st == st_Block && scope_ptr->sc == sc_Text)
1010: class = "block";
1011: else if (scope_ptr->st == st_Block && scope_ptr->sc == sc_Info)
1012: class = "type";
1013: else
1014: class = "???";
1015:
1016: printf (" %d [%s]", scope_ptr->open_sym, class);
1017: }
1018: printf ("\n");
1019: }
1020: }
1021:
1022: printf (" Value: %-13ld ",
1023: (long)sym_ptr->value);
1024: if (ifd == -1)
1025: printf ("String index: %ld\n", (long)sym_ptr->iss);
1026: else
1027: printf ("String index: %-11ld Ifd: %d\n",
1028: (long)sym_ptr->iss, ifd);
1029:
1030: printf (" Symbol type: %-11sStorage class: %-11s",
1031: st_to_string (symbol_type), sc_to_string (storage_class));
1032:
1033: if (MIPS_IS_STAB(sym_ptr))
1034: {
1035: register int i = sizeof(stab_names) / sizeof(stab_names[0]);
1036: char *stab_name = "stab";
1037: short code = MIPS_UNMARK_STAB(sym_ptr->index);
1038: while (--i >= 0)
1039: if (stab_names[i].code == code)
1040: {
1041: stab_name = stab_names[i].string;
1042: break;
1043: }
1044: printf ("Index: 0x%lx (%s)\n", (long)sym_ptr->index, stab_name);
1045: }
1046: else if (sym_ptr->st == stLabel && sym_ptr->index != indexNil)
1047: printf ("Index: %ld (line#)\n", (long)sym_ptr->index);
1048: else
1049: printf ("Index: %ld\n", (long)sym_ptr->index);
1050:
1051: }
1052:
1053:
1054: /* Print out a word from the aux. table in various formats. */
1055:
1056: void
1057: print_aux (u, auxi, used)
1058: AUXU u;
1059: int auxi;
1060: int used;
1061: {
1062: printf ("\t%s#%-5d %11ld, [%4ld/%7ld], [%2d %1d:%1d %1x:%1x:%1x:%1x:%1x:%1x]\n",
1063: (used) ? " " : "* ",
1064: auxi,
1065: (long) u.isym,
1066: (long) u.rndx.rfd,
1067: (long) u.rndx.index,
1068: u.ti.bt,
1069: u.ti.fBitfield,
1070: u.ti.continued,
1071: u.ti.tq0,
1072: u.ti.tq1,
1073: u.ti.tq2,
1074: u.ti.tq3,
1075: u.ti.tq4,
1076: u.ti.tq5);
1077: }
1078:
1079:
1080: /* Write aggregate information to a string. */
1081:
1082: void
1083: emit_aggregate (string, u, u2, which)
1084: char *string;
1085: AUXU u;
1086: AUXU u2;
1087: const char *which;
1088: {
1089: int ifd = u.rndx.rfd;
1090: int index = u.rndx.index;
1091: int sym_base, ss_base;
1092: int name;
1093:
1094: if (ifd == ST_RFDESCAPE)
1095: ifd = u2.isym;
1096:
1097: sym_base = file_desc[ifd].isymBase;
1098: ss_base = file_desc[ifd].issBase;
1099:
1100: name = (index == indexNil) ? 0 : l_symbols[index + sym_base].iss;
1101: sprintf (string,
1102: "%s %s { ifd = %d, index = %d }",
1103: which,
1104: (name == 0) ? "/* no name */" : &l_strings[ ss_base + name ],
1105: ifd,
1106: index);
1107: }
1108:
1109:
1110: /* Print out information about a file descriptor, and the symbols,
1111: procedures, and line numbers within it. */
1112:
1113: void
1114: print_file_desc (fdp, number)
1115: FDR *fdp;
1116: int number;
1117: {
1118: char *str_base;
1119: AUXU *aux_base;
1120: int symi, pdi;
1121: int width = 20;
1122: char *used_base;
1123:
1124: str_base = l_strings + fdp->issBase;
1125: aux_base = aux_symbols + fdp->iauxBase;
1126: used_base = aux_used + (aux_base - aux_symbols);
1127:
1128: printf ("\nFile #%d, \"%s\"\n\n", number, str_base + fdp->rss);
1129:
1130: printf (" Name index = %-10d Readin = %s\n",
1131: (long) fdp->rss, (fdp->fReadin) ? "Yes" : "No");
1132:
1133: printf (" Merge = %-10s Endian = %s\n",
1134: (fdp->fMerge) ? "Yes" : "No",
1135: (fdp->fBigendian) ? "BIG" : "LITTLE");
1136:
1137: printf (" Debug level = %-10s Language = %s\n",
1138: glevel_to_string (fdp->glevel),
1139: lang_to_string((lang_t) fdp->lang));
1140:
1141: printf (" Adr = 0x%08lx\n\n", (long) fdp->adr);
1142:
1143: printf(" %-*s %11s %11s %11s %11s\n", width, "Info", "Start", "Number", "Size", "Offset");
1144: printf(" %-*s %11s %11s %11s %11s\n", width, "====", "=====", "======", "====", "======");
1145:
1146: printf(" %-*s %11lu %11lu %11lu %11lu\n",
1147: width, "Local strings",
1148: (ulong) fdp->issBase,
1149: (ulong) fdp->cbSs,
1150: (ulong) fdp->cbSs,
1151: (ulong) (fdp->issBase + sym_hdr.cbSsOffset));
1152:
1153: printf(" %-*s %11lu %11u %11u %11lu\n",
1154: width, "Local symbols",
1155: (ulong) fdp->isymBase,
1156: (ulong) fdp->csym,
1157: (ulong) (fdp->csym * sizeof (SYMR)),
1158: (ulong) (fdp->isymBase * sizeof (SYMR) + sym_hdr.cbSymOffset));
1159:
1160: printf(" %-*s %11lu %11lu %11lu %11lu\n",
1161: width, "Line numbers",
1162: (ulong) fdp->cbLineOffset,
1163: (ulong) fdp->cline,
1164: (ulong) fdp->cline,
1165: (ulong) (fdp->cbLineOffset + sym_hdr.cbLineOffset));
1166:
1167: printf(" %-*s %11lu %11lu %11lu %11lu\n",
1168: width, "Optimization symbols",
1169: (ulong) fdp->ioptBase,
1170: (ulong) fdp->copt,
1171: (ulong) (fdp->copt * sizeof (OPTR)),
1172: (ulong) (fdp->ioptBase * sizeof (OPTR) + sym_hdr.cbOptOffset));
1173:
1174: printf(" %-*s %11llu %11lu %11lu %11lu\n",
1175: width, "Procedures",
1176: (ulong) fdp->ipdFirst,
1177: (ulong) fdp->cpd,
1178: (ulong) (fdp->cpd * sizeof (PDR)),
1179: (ulong) (fdp->ipdFirst * sizeof (PDR) + sym_hdr.cbPdOffset));
1180:
1181: printf(" %-*s %11lu %11lu %11lu %11lu\n",
1182: width, "Auxiliary symbols",
1183: (ulong) fdp->iauxBase,
1184: (ulong) fdp->caux,
1185: (ulong) (fdp->caux * sizeof (AUXU)),
1186: (ulong) (fdp->iauxBase * sizeof(AUXU) + sym_hdr.cbAuxOffset));
1187:
1188: printf(" %-*s %11lu %11lu %11lu %11lu\n",
1189: width, "Relative Files",
1190: (ulong) fdp->rfdBase,
1191: (ulong) fdp->crfd,
1192: (ulong) (fdp->crfd * sizeof (ulong)),
1193: (ulong) (fdp->rfdBase * sizeof(ulong) + sym_hdr.cbRfdOffset));
1194:
1195:
1196: if (want_scope && cur_scope != (scope_t *)0)
1197: printf ("\n Warning scope does not start at 0!\n");
1198:
1199: /*
1200: * print the info about the symbol table.
1201: */
1202: printf ("\n There are %lu local symbols, starting at %lu\n",
1203: (ulong) fdp->csym,
1204: (ulong) (fdp->isymBase + sym_hdr.cbSymOffset));
1205:
1206: for(symi = fdp->isymBase; symi < (fdp->csym + fdp->isymBase); symi++)
1207: print_symbol (&l_symbols[symi],
1208: symi - fdp->isymBase,
1209: str_base,
1210: aux_base,
1211: -1);
1212:
1213: if (want_scope && cur_scope != (scope_t *)0)
1214: printf ("\n Warning scope does not end at 0!\n");
1215:
1216: /*
1217: * print the aux. table if desired.
1218: */
1219:
1220: if (want_aux && fdp->caux != 0)
1221: {
1222: int auxi;
1223:
1224: printf ("\n There are %lu auxiliary table entries, starting at %lu.\n\n",
1225: (ulong) fdp->caux,
1226: (ulong) (fdp->iauxBase + sym_hdr.cbAuxOffset));
1227:
1228: for (auxi = fdp->iauxBase; auxi < (fdp->caux + fdp->iauxBase); auxi++)
1229: print_aux (aux_base[auxi], auxi, used_base[auxi]);
1230: }
1231:
1232: /*
1233: * print the relative file descriptors.
1234: */
1235: if (want_rfd && fdp->crfd != 0)
1236: {
1237: ulong *rfd_ptr, i;
1238:
1239: printf ("\n There are %lu relative file descriptors, starting at %lu.\n",
1240: (ulong) fdp->crfd,
1241: (ulong) fdp->rfdBase);
1242:
1243: rfd_ptr = rfile_desc + fdp->rfdBase;
1244: for (i = 0; i < fdp->crfd; i++)
1245: {
1246: printf ("\t#%-5ld %11ld, 0x%08lx\n", i, *rfd_ptr, *rfd_ptr);
1247: rfd_ptr++;
1248: }
1249: }
1250:
1251: /*
1252: * do the procedure descriptors.
1253: */
1254: printf ("\n There are %lu procedure descriptor entries, ", (ulong) fdp->cpd);
1255: printf ("starting at %lu.\n", (ulong) fdp->ipdFirst);
1256:
1257: for (pdi = fdp->ipdFirst; pdi < (fdp->cpd + fdp->ipdFirst); pdi++)
1258: {
1259: PDR *proc_ptr = &proc_desc[pdi];
1260: printf ("\n\tProcedure descriptor %d:\n", (pdi - fdp->ipdFirst));
1261:
1262: printf ("\t Name index = %-11ld Name = \"%s\"\n",
1263: (long) l_symbols[proc_ptr->isym + fdp->isymBase].iss,
1264: l_symbols[proc_ptr->isym + fdp->isymBase].iss + str_base);
1265:
1266: printf ("\t .mask 0x%08lx,%-9ld .fmask 0x%08lx,%ld\n",
1267: (long) proc_ptr->regmask,
1268: (long) proc_ptr->regoffset,
1269: (long) proc_ptr->fregmask,
1270: (long) proc_ptr->fregoffset);
1271:
1272: printf ("\t .frame $%d,%ld,$%d\n",
1273: (int) proc_ptr->framereg,
1274: (long) proc_ptr->frameoffset,
1275: (int) proc_ptr->pcreg);
1276:
1277: printf ("\t Opt. start = %-11ld Symbols start = %ld\n",
1278: (long) proc_ptr->iopt,
1279: (long) proc_ptr->isym);
1280:
1281: printf ("\t First line # = %-11ld Last line # = %ld\n",
1282: (long) proc_ptr->lnLow,
1283: (long) proc_ptr->lnHigh);
1284:
1285: printf ("\t Line Offset = %-11ld Address = 0x%08lx\n",
1286: (long) proc_ptr->cbLineOffset,
1287: (long) proc_ptr->adr);
1288:
1289: /*
1290: * print the line number entries.
1291: */
1292:
1293: if (want_line && fdp->cline != 0)
1294: {
1295: int delta, count;
1296: long cur_line = proc_ptr->lnLow;
1297: uchar *line_ptr = ((uchar *)lines) + proc_ptr->cbLineOffset;
1298: uchar *line_end;
1299:
1300: if (pdi == fdp->cpd + fdp->ipdFirst - 1) /* last procedure */
1301: line_end = ((uchar *)lines) + fdp->cbLine + fdp->ilineBase;
1302: else /* not last proc. */
1303: line_end = ((uchar *)lines) + proc_desc[pdi+1].cbLineOffset;
1304:
1305:
1306: printf ("\n\tThere are %lu bytes holding line numbers, starting at %lu.\n",
1307: (ulong) (line_end - line_ptr),
1308: (ulong) (fdp->ilineBase + sym_hdr.cbLineOffset));
1309:
1310: while (line_ptr < line_end)
1311: { /* sign extend nibble */
1312: delta = ((*line_ptr >> 4) ^ 0x8) - 0x8;
1313: count = (*line_ptr & 0xf) + 1;
1314: if (delta != -8)
1315: line_ptr++;
1316: else
1317: {
1318: delta = (((line_ptr[1]) & 0xff) << 8) + ((line_ptr[2]) & 0xff);
1319: delta = (delta ^ 0x8000) - 0x8000;
1320: line_ptr += 3;
1321: }
1322:
1323: cur_line += delta;
1324: printf ("\t Line %11ld, delta %5d, count %2d\n",
1325: cur_line,
1326: delta,
1327: count);
1328: }
1329: }
1330: }
1331: }
1332:
1333:
1334: /* Read in the portions of the .T file that we will print out. */
1335:
1336: void
1337: read_tfile __proto((void))
1338: {
1339: short magic;
1340: off_t sym_hdr_offset = 0;
1341:
1342: (void) read_seek ((PTR_T) &magic, sizeof (magic), (off_t)0, "Magic number");
1343: if (!tfile)
1344: {
1345: /* Print out the global header, since this is not a T-file. */
1346:
1347: (void) read_seek ((PTR_T) &global_hdr, sizeof (global_hdr), (off_t)0,
1348: "Global file header");
1349:
1350: print_global_hdr (&global_hdr);
1351:
1352: if (global_hdr.f_symptr == 0)
1353: {
1354: printf ("No symbolic header, Goodbye!\n");
1355: exit (1);
1356: }
1357:
1358: sym_hdr_offset = global_hdr.f_symptr;
1359: }
1360:
1361: (void) read_seek ((PTR_T) &sym_hdr,
1362: sizeof (sym_hdr),
1363: sym_hdr_offset,
1364: "Symbolic header");
1365:
1366: print_sym_hdr (&sym_hdr);
1367:
1368: lines = (LINER *) read_seek ((PTR_T)0,
1369: sym_hdr.cbLine,
1370: sym_hdr.cbLineOffset,
1371: "Line numbers");
1372:
1373: dense_nums = (DNR *) read_seek ((PTR_T)0,
1374: sym_hdr.idnMax * sizeof (DNR),
1375: sym_hdr.cbDnOffset,
1376: "Dense numbers");
1377:
1378: proc_desc = (PDR *) read_seek ((PTR_T)0,
1379: sym_hdr.ipdMax * sizeof (PDR),
1380: sym_hdr.cbPdOffset,
1381: "Procedure tables");
1382:
1383: l_symbols = (SYMR *) read_seek ((PTR_T)0,
1384: sym_hdr.isymMax * sizeof (SYMR),
1385: sym_hdr.cbSymOffset,
1386: "Local symbols");
1387:
1388: opt_symbols = (OPTR *) read_seek ((PTR_T)0,
1389: sym_hdr.ioptMax * sizeof (OPTR),
1390: sym_hdr.cbOptOffset,
1391: "Optimization symbols");
1392:
1393: aux_symbols = (AUXU *) read_seek ((PTR_T)0,
1394: sym_hdr.iauxMax * sizeof (AUXU),
1395: sym_hdr.cbAuxOffset,
1396: "Auxiliary symbols");
1397:
1398: if (sym_hdr.iauxMax > 0)
1399: {
1400: aux_used = calloc (sym_hdr.iauxMax, 1);
1401: if (aux_used == (char *)0)
1402: {
1403: perror ("calloc");
1404: exit (1);
1405: }
1406: }
1407:
1408: l_strings = (char *) read_seek ((PTR_T)0,
1409: sym_hdr.issMax,
1410: sym_hdr.cbSsOffset,
1411: "Local string table");
1412:
1413: e_strings = (char *) read_seek ((PTR_T)0,
1414: sym_hdr.issExtMax,
1415: sym_hdr.cbSsExtOffset,
1416: "External string table");
1417:
1418: file_desc = (FDR *) read_seek ((PTR_T)0,
1419: sym_hdr.ifdMax * sizeof (FDR),
1420: sym_hdr.cbFdOffset,
1421: "File tables");
1422:
1423: rfile_desc = (ulong *) read_seek ((PTR_T)0,
1424: sym_hdr.crfd * sizeof (ulong),
1425: sym_hdr.cbRfdOffset,
1426: "Relative file tables");
1427:
1428: e_symbols = (EXTR *) read_seek ((PTR_T)0,
1429: sym_hdr.iextMax * sizeof (EXTR),
1430: sym_hdr.cbExtOffset,
1431: "External symbols");
1432: }
1433:
1434:
1435:
1436: int
1437: main (argc, argv)
1438: int argc;
1439: char **argv;
1440: {
1441: int i, opt;
1442:
1443: /*
1444: * Process arguments
1445: */
1446: while ((opt = getopt (argc, argv, "alrst")) != EOF)
1447: switch (opt)
1448: {
1449: default: errors++; break;
1450: case 'a': want_aux++; break; /* print aux table */
1451: case 'l': want_line++; break; /* print line numbers */
1452: case 'r': want_rfd++; break; /* print relative fd's */
1453: case 's': want_scope++; break; /* print scope info */
1454: case 't': tfile++; break; /* this is a tfile (without header), and not a .o */
1455: }
1456:
1457: if (errors || optind != argc - 1)
1458: {
1459: fprintf (stderr, "Calling Sequence:\n");
1460: fprintf (stderr, "\t%0 [-alrst] <object-or-T-file>\n", argv[0]);
1461: fprintf (stderr, "\n");
1462: fprintf (stderr, "switches:\n");
1463: fprintf (stderr, "\t-a Print out auxiliary table.\n");
1464: fprintf (stderr, "\t-l Print out line numbers.\n");
1465: fprintf (stderr, "\t-r Print out relative file descriptors.\n");
1466: fprintf (stderr, "\t-s Print out the current scopes for an item.\n");
1467: fprintf (stderr, "\t-t Assume there is no global header (ie, a T-file).\n");
1468: return 1;
1469: }
1470:
1471: /*
1472: * Open and process the input file.
1473: */
1474: tfile_fd = open (argv[optind], O_RDONLY);
1475: if (tfile_fd < 0)
1476: {
1477: perror (argv[optind]);
1478: return 1;
1479: }
1480:
1481: read_tfile ();
1482:
1483: /*
1484: * Print any global aux words if any.
1485: */
1486: if (want_aux)
1487: {
1488: long last_aux_in_use;
1489:
1490: if (sym_hdr.ifdMax != 0 && file_desc[0].iauxBase != 0)
1491: {
1492: printf ("\nGlobal auxiliary entries before first file:\n");
1493: for (i = 0; i < file_desc[0].iauxBase; i++)
1494: print_aux (aux_symbols[i], 0, aux_used[i]);
1495: }
1496:
1497: if (sym_hdr.ifdMax == 0)
1498: last_aux_in_use = 0;
1499: else
1500: last_aux_in_use =
1501: file_desc[sym_hdr.ifdMax-1].iauxBase +
1502: file_desc[sym_hdr.ifdMax-1].caux - 1;
1503:
1504: if (last_aux_in_use < sym_hdr.iauxMax-1)
1505: {
1506: printf ("\nGlobal auxiliary entries after last file:\n");
1507: for (i = last_aux_in_use; i < sym_hdr.iauxMax; i++)
1508: print_aux (aux_symbols[i], i - last_aux_in_use, aux_used[i]);
1509: }
1510: }
1511:
1512: /*
1513: * Print the information for each file.
1514: */
1515: for (i = 0; i < sym_hdr.ifdMax; i++)
1516: print_file_desc (&file_desc[i], i);
1517:
1518: /*
1519: * Print the external symbols.
1520: */
1521: want_scope = 0; /* scope info is meaning for extern symbols */
1522: printf ("\nThere are %lu external symbols, starting at %lu\n",
1523: (ulong) sym_hdr.iextMax,
1524: (ulong) sym_hdr.cbExtOffset);
1525:
1526: for(i = 0; i < sym_hdr.iextMax; i++)
1527: print_symbol (&e_symbols[i].asym, i, e_strings,
1528: aux_symbols + file_desc[e_symbols[i].ifd].iauxBase,
1529: e_symbols[i].ifd);
1530:
1531: /*
1532: * Print unused aux symbols now.
1533: */
1534:
1535: if (want_aux)
1536: {
1537: int first_time = 1;
1538:
1539: for (i = 0; i < sym_hdr.iauxMax; i++)
1540: {
1541: if (! aux_used[i])
1542: {
1543: if (first_time)
1544: {
1545: printf ("\nThe following auxiliary table entries were unused:\n\n");
1546: first_time = 0;
1547: }
1548:
1549: printf (" #%-5d %11ld 0x%08lx %s\n",
1550: i,
1551: (long) aux_symbols[i].isym,
1552: (long) aux_symbols[i].isym,
1553: type_to_string (aux_symbols, i));
1554: }
1555: }
1556: }
1557:
1558: return 0;
1559: }
1560:
1561:
1562: void
1563: fancy_abort ()
1564: {
1565: fprintf (stderr, "mips-tdump internal error");
1566: exit (1);
1567: }
1568:
1569: void
1570: fatal(s)
1571: char *s;
1572: {
1573: fprintf(stderr, "%s\n", s);
1574: exit(1);
1575: }
1576:
1577: /* Same as `malloc' but report error if no memory available. */
1578:
1579: PTR_T
1580: xmalloc (size)
1581: unsigned size;
1582: {
1583: register PTR_T value = malloc (size);
1584: if (value == 0)
1585: fatal ("Virtual memory exhausted.");
1586: return value;
1587: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.