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