1 /* Read and manage MIPS symbol tables from object modules.
2 Copyright (C) 1991, 1994, 1995, 1997, 1998, 1999, 2000, 2001, 2003
3 Free Software Foundation, Inc.
4 Contributed by hartzell@boulder.colorado.edu,
5 Rewritten by meissner@osf.org.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 2, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to the Free
21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
26 #include "coretypes.h"
35 #include "mips/a.out.h"
36 #endif /* CROSS_COMPILE */
38 /* Include getopt.h for the sake of getopt_long. */
42 /* Macros for mips-tfile.c to encapsulate stabs in ECOFF, and for
43 and mips-tdump.c to print them out. This is used on the Alpha,
44 which does not include mips.h.
46 These must match the corresponding definitions in gdb/mipsread.c.
47 Unfortunately, gcc and gdb do not currently share any directories. */
49 #define CODE_MASK 0x8F300
50 #define MIPS_IS_STAB(sym) (((sym)->index & 0xFFF00) == CODE_MASK)
51 #define MIPS_MARK_STAB(code) ((code)+CODE_MASK)
52 #define MIPS_UNMARK_STAB(code) ((code)-CODE_MASK)
55 #define uchar unsigned char
56 #define ushort unsigned short
57 #define uint unsigned int
58 #define ulong unsigned long
61 /* Redefinition of storage classes as an enumeration for better
65 #define stStaParam 16 /* Fortran static parameters */
69 #define btVoid 26 /* void basic type */
73 sc_Nil = scNil, /* no storage class */
74 sc_Text = scText, /* text symbol */
75 sc_Data = scData, /* initialized data symbol */
76 sc_Bss = scBss, /* un-initialized data symbol */
77 sc_Register = scRegister, /* value of symbol is register number */
78 sc_Abs = scAbs, /* value of symbol is absolute */
79 sc_Undefined = scUndefined, /* who knows? */
80 sc_CdbLocal = scCdbLocal, /* variable's value is IN se->va.?? */
81 sc_Bits = scBits, /* this is a bit field */
82 sc_CdbSystem = scCdbSystem, /* var's value is IN CDB's address space */
83 sc_RegImage = scRegImage, /* register value saved on stack */
84 sc_Info = scInfo, /* symbol contains debugger information */
85 sc_UserStruct = scUserStruct, /* addr in struct user for current process */
86 sc_SData = scSData, /* load time only small data */
87 sc_SBss = scSBss, /* load time only small common */
88 sc_RData = scRData, /* load time only read only data */
89 sc_Var = scVar, /* Var parameter (fortran,pascal) */
90 sc_Common = scCommon, /* common variable */
91 sc_SCommon = scSCommon, /* small common */
92 sc_VarRegister = scVarRegister, /* Var parameter in a register */
93 sc_Variant = scVariant, /* Variant record */
94 sc_SUndefined = scSUndefined, /* small undefined(external) data */
95 sc_Init = scInit, /* .init section symbol */
96 sc_Max = scMax /* Max storage class+1 */
99 /* Redefinition of symbol type. */
102 st_Nil = stNil, /* Nuthin' special */
103 st_Global = stGlobal, /* external symbol */
104 st_Static = stStatic, /* static */
105 st_Param = stParam, /* procedure argument */
106 st_Local = stLocal, /* local variable */
107 st_Label = stLabel, /* label */
108 st_Proc = stProc, /* " " Procedure */
109 st_Block = stBlock, /* beginning of block */
110 st_End = stEnd, /* end (of anything) */
111 st_Member = stMember, /* member (of anything - struct/union/enum */
112 st_Typedef = stTypedef, /* type definition */
113 st_File = stFile, /* file name */
114 st_RegReloc = stRegReloc, /* register relocation */
115 st_Forward = stForward, /* forwarding address */
116 st_StaticProc = stStaticProc, /* load time only static procs */
117 st_StaParam = stStaParam, /* Fortran static parameters */
118 st_Constant = stConstant, /* const */
120 st_Struct = stStruct, /* struct */
121 st_Union = stUnion, /* union */
122 st_Enum = stEnum, /* enum */
124 st_Str = stStr, /* string */
125 st_Number = stNumber, /* pure number (ie. 4 NOR 2+2) */
126 st_Expr = stExpr, /* 2+2 vs. 4 */
127 st_Type = stType, /* post-coercion SER */
128 st_Max = stMax /* max type+1 */
131 /* Redefinition of type qualifiers. */
134 tq_Nil = tqNil, /* bt is what you see */
135 tq_Ptr = tqPtr, /* pointer */
136 tq_Proc = tqProc, /* procedure */
137 tq_Array = tqArray, /* duh */
138 tq_Far = tqFar, /* longer addressing - 8086/8 land */
139 tq_Vol = tqVol, /* volatile */
140 tq_Max = tqMax /* Max type qualifier+1 */
143 /* Redefinition of basic types. */
146 bt_Nil = btNil, /* undefined */
147 bt_Adr = btAdr, /* address - integer same size as pointer */
148 bt_Char = btChar, /* character */
149 bt_UChar = btUChar, /* unsigned character */
150 bt_Short = btShort, /* short */
151 bt_UShort = btUShort, /* unsigned short */
152 bt_Int = btInt, /* int */
153 bt_UInt = btUInt, /* unsigned int */
154 bt_Long = btLong, /* long */
155 bt_ULong = btULong, /* unsigned long */
156 bt_Float = btFloat, /* float (real) */
157 bt_Double = btDouble, /* Double (real) */
158 bt_Struct = btStruct, /* Structure (Record) */
159 bt_Union = btUnion, /* Union (variant) */
160 bt_Enum = btEnum, /* Enumerated */
161 bt_Typedef = btTypedef, /* defined via a typedef, isymRef points */
162 bt_Range = btRange, /* subrange of int */
163 bt_Set = btSet, /* pascal sets */
164 bt_Complex = btComplex, /* fortran complex */
165 bt_DComplex = btDComplex, /* fortran double complex */
166 bt_Indirect = btIndirect, /* forward or unnamed typedef */
167 bt_FixedDec = btFixedDec, /* Fixed Decimal */
168 bt_FloatDec = btFloatDec, /* Float Decimal */
169 bt_String = btString, /* Varying Length Character String */
170 bt_Bit = btBit, /* Aligned Bit String */
171 bt_Picture = btPicture, /* Picture */
172 bt_Void = btVoid, /* void */
173 bt_Max = btMax /* Max basic type+1 */
176 /* Redefinition of the language codes. */
180 lang_Pascal = langPascal,
181 lang_Fortran = langFortran,
182 lang_Assembler = langAssembler,
183 lang_Machine = langMachine,
187 lang_Cobol = langCobol
190 /* Redefinition of the debug level codes. */
192 typedef enum glevel {
200 /* Keep track of the active scopes. */
201 typedef struct scope {
202 struct scope *prev; /* previous scope */
203 ulong open_sym; /* symbol opening scope */
204 sc_t sc; /* storage class */
205 st_t st; /* symbol type */
208 struct filehdr global_hdr; /* a.out header */
210 int errors = 0; /* # of errors */
211 int want_aux = 0; /* print aux table */
212 int want_line = 0; /* print line numbers */
213 int want_rfd = 0; /* print relative file desc's */
214 int want_scope = 0; /* print scopes for every symbol */
215 int tfile = 0; /* no global header file */
216 int version = 0; /* print version # */
218 int tfile_fd; /* file descriptor of .T file */
219 off_t tfile_offset; /* current offset in .T file */
220 scope_t *cur_scope = 0; /* list of active scopes */
221 scope_t *free_scope = 0; /* list of freed scopes */
222 HDRR sym_hdr; /* symbolic header */
223 char *l_strings; /* local strings */
224 char *e_strings; /* external strings */
225 SYMR *l_symbols; /* local symbols */
226 EXTR *e_symbols; /* external symbols */
227 LINER *lines; /* line numbers */
228 DNR *dense_nums; /* dense numbers */
229 OPTR *opt_symbols; /* optimization symbols */
230 AUXU *aux_symbols; /* Auxiliary symbols */
231 char *aux_used; /* map of which aux syms are used */
232 FDR *file_desc; /* file tables */
233 ulong *rfile_desc; /* relative file tables */
234 PDR *proc_desc; /* procedure tables */
236 /* Forward reference for functions. */
237 static void *read_seek PARAMS ((void *, size_t, off_t, const char *));
238 static void read_tfile PARAMS ((void));
239 static void print_global_hdr PARAMS ((struct filehdr *));
240 static void print_sym_hdr PARAMS ((HDRR *));
241 static void print_file_desc PARAMS ((FDR *, int));
242 static void print_symbol PARAMS ((SYMR *, int, const char *, AUXU *, int, FDR *));
243 static void print_aux PARAMS ((AUXU, int, int));
244 static void emit_aggregate PARAMS ((char *, AUXU, AUXU, const char *, FDR *));
245 static const char *st_to_string PARAMS ((st_t));
246 static const char *sc_to_string PARAMS ((sc_t));
247 static const char *glevel_to_string PARAMS ((glevel_t));
248 static const char *lang_to_string PARAMS ((lang_t));
249 static const char *type_to_string PARAMS ((AUXU *, int, FDR *));
255 /* Create a table of debugging stab-codes and corresponding names. */
257 #define __define_stab(NAME, CODE, STRING) {(int)CODE, STRING},
258 const struct {const short code; const char string[10];} stab_names[] = {
263 /* Command line options for getopt_long. */
265 static const struct option options[] =
267 { "version", 0, 0, 'V' },
268 { "verbose", 0, 0, 'v' },
272 /* Read some bytes at a specified location, and return a pointer. */
275 read_seek (ptr, size, offset, context)
276 void *ptr; /* pointer to buffer or NULL */
277 size_t size; /* # bytes to read */
278 off_t offset; /* offset to read at */
279 const char *context; /* context for error message */
283 if (size == 0) /* nothing to read */
287 ptr = xmalloc (size);
289 if ((tfile_offset != offset && lseek (tfile_fd, offset, 0) == -1)
290 || (read_size = read (tfile_fd, ptr, size)) < 0)
296 if (read_size != (long) size)
298 fprintf (stderr, "%s: read %ld bytes, expected %ld bytes\n",
299 context, read_size, (long) size);
303 tfile_offset = offset + size;
308 /* Convert language code to string format. */
311 lang_to_string (lang)
316 case langC: return "C";
317 case langPascal: return "Pascal";
318 case langFortran: return "Fortran";
319 case langAssembler: return "Assembler";
320 case langMachine: return "Machine";
321 case langNil: return "Nil";
322 case langAda: return "Ada";
323 case langPl1: return "Pl1";
324 case langCobol: return "Cobol";
327 return "Unknown language";
331 /* Convert storage class to string. */
334 sc_to_string(storage_class)
337 switch(storage_class)
339 case sc_Nil: return "Nil";
340 case sc_Text: return "Text";
341 case sc_Data: return "Data";
342 case sc_Bss: return "Bss";
343 case sc_Register: return "Register";
344 case sc_Abs: return "Abs";
345 case sc_Undefined: return "Undefined";
346 case sc_CdbLocal: return "CdbLocal";
347 case sc_Bits: return "Bits";
348 case sc_CdbSystem: return "CdbSystem";
349 case sc_RegImage: return "RegImage";
350 case sc_Info: return "Info";
351 case sc_UserStruct: return "UserStruct";
352 case sc_SData: return "SData";
353 case sc_SBss: return "SBss";
354 case sc_RData: return "RData";
355 case sc_Var: return "Var";
356 case sc_Common: return "Common";
357 case sc_SCommon: return "SCommon";
358 case sc_VarRegister: return "VarRegister";
359 case sc_Variant: return "Variant";
360 case sc_SUndefined: return "SUndefined";
361 case sc_Init: return "Init";
362 case sc_Max: return "Max";
369 /* Convert symbol type to string. */
372 st_to_string(symbol_type)
377 case st_Nil: return "Nil";
378 case st_Global: return "Global";
379 case st_Static: return "Static";
380 case st_Param: return "Param";
381 case st_Local: return "Local";
382 case st_Label: return "Label";
383 case st_Proc: return "Proc";
384 case st_Block: return "Block";
385 case st_End: return "End";
386 case st_Member: return "Member";
387 case st_Typedef: return "Typedef";
388 case st_File: return "File";
389 case st_RegReloc: return "RegReloc";
390 case st_Forward: return "Forward";
391 case st_StaticProc: return "StaticProc";
392 case st_Constant: return "Constant";
393 case st_StaParam: return "StaticParam";
395 case st_Struct: return "Struct";
396 case st_Union: return "Union";
397 case st_Enum: return "Enum";
399 case st_Str: return "String";
400 case st_Number: return "Number";
401 case st_Expr: return "Expr";
402 case st_Type: return "Type";
403 case st_Max: return "Max";
410 /* Convert debug level to string. */
413 glevel_to_string (g_level)
418 case GLEVEL_0: return "G0";
419 case GLEVEL_1: return "G1";
420 case GLEVEL_2: return "G2";
421 case GLEVEL_3: return "G3";
428 /* Convert the type information to string format. */
431 type_to_string (aux_ptr, index, fdp)
446 static char buffer1[1024];
447 static char buffer2[1024];
450 char *used_ptr = aux_used + (aux_ptr - aux_symbols);
452 for (i = 0; i < 7; i++)
454 qualifiers[i].low_bound = 0;
455 qualifiers[i].high_bound = 0;
456 qualifiers[i].stride = 0;
460 u = aux_ptr[index++];
462 return "-1 (no type)";
464 basic_type = (bt_t) u.ti.bt;
465 qualifiers[0].type = (tq_t) u.ti.tq0;
466 qualifiers[1].type = (tq_t) u.ti.tq1;
467 qualifiers[2].type = (tq_t) u.ti.tq2;
468 qualifiers[3].type = (tq_t) u.ti.tq3;
469 qualifiers[4].type = (tq_t) u.ti.tq4;
470 qualifiers[5].type = (tq_t) u.ti.tq5;
471 qualifiers[6].type = tq_Nil;
474 * Go get the basic type.
478 case bt_Nil: /* undefined */
482 case bt_Adr: /* address - integer same size as pointer */
483 strcpy (p1, "address");
486 case bt_Char: /* character */
490 case bt_UChar: /* unsigned character */
491 strcpy (p1, "unsigned char");
494 case bt_Short: /* short */
495 strcpy (p1, "short");
498 case bt_UShort: /* unsigned short */
499 strcpy (p1, "unsigned short");
502 case bt_Int: /* int */
506 case bt_UInt: /* unsigned int */
507 strcpy (p1, "unsigned int");
510 case bt_Long: /* long */
514 case bt_ULong: /* unsigned long */
515 strcpy (p1, "unsigned long");
518 case bt_Float: /* float (real) */
519 strcpy (p1, "float");
522 case bt_Double: /* Double (real) */
523 strcpy (p1, "double");
526 /* Structures add 1-2 aux words:
527 1st word is [ST_RFDESCAPE, offset] pointer to struct def;
528 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
530 case bt_Struct: /* Structure (Record) */
531 emit_aggregate (p1, aux_ptr[index], aux_ptr[index+1], "struct", fdp);
533 if (aux_ptr[index].rndx.rfd == ST_RFDESCAPE)
534 used_ptr[++index] = 1;
536 index++; /* skip aux words */
539 /* Unions add 1-2 aux words:
540 1st word is [ST_RFDESCAPE, offset] pointer to union def;
541 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
543 case bt_Union: /* Union */
544 emit_aggregate (p1, aux_ptr[index], aux_ptr[index+1], "union", fdp);
546 if (aux_ptr[index].rndx.rfd == ST_RFDESCAPE)
547 used_ptr[++index] = 1;
549 index++; /* skip aux words */
552 /* Enumerations add 1-2 aux words:
553 1st word is [ST_RFDESCAPE, offset] pointer to enum def;
554 2nd word is file index if 1st word rfd is ST_RFDESCAPE. */
556 case bt_Enum: /* Enumeration */
557 emit_aggregate (p1, aux_ptr[index], aux_ptr[index+1], "enum", fdp);
559 if (aux_ptr[index].rndx.rfd == ST_RFDESCAPE)
560 used_ptr[++index] = 1;
562 index++; /* skip aux words */
565 case bt_Typedef: /* defined via a typedef, isymRef points */
566 strcpy (p1, "typedef");
569 case bt_Range: /* subrange of int */
570 strcpy (p1, "subrange");
573 case bt_Set: /* pascal sets */
577 case bt_Complex: /* fortran complex */
578 strcpy (p1, "complex");
581 case bt_DComplex: /* fortran double complex */
582 strcpy (p1, "double complex");
585 case bt_Indirect: /* forward or unnamed typedef */
586 strcpy (p1, "forward/unnamed typedef");
589 case bt_FixedDec: /* Fixed Decimal */
590 strcpy (p1, "fixed decimal");
593 case bt_FloatDec: /* Float Decimal */
594 strcpy (p1, "float decimal");
597 case bt_String: /* Varying Length Character String */
598 strcpy (p1, "string");
601 case bt_Bit: /* Aligned Bit String */
605 case bt_Picture: /* Picture */
606 strcpy (p1, "picture");
609 case bt_Void: /* Void */
614 sprintf (p1, "Unknown basic type %d", (int) basic_type);
618 p1 += strlen (buffer1);
621 * If this is a bitfield, get the bitsize.
628 bitsize = aux_ptr[index++].width;
629 sprintf (p1, " : %d", bitsize);
630 p1 += strlen (buffer1);
635 * Deal with any qualifiers.
637 if (qualifiers[0].type != tq_Nil)
640 * Snarf up any array bounds in the correct order. Arrays
641 * store 5 successive words in the aux. table:
642 * word 0 RNDXR to type of the bounds (ie, int)
643 * word 1 Current file descriptor index
645 * word 3 high bound (or -1 if [])
646 * word 4 stride size in bits
648 for (i = 0; i < 7; i++)
650 if (qualifiers[i].type == tq_Array)
652 qualifiers[i].low_bound = aux_ptr[index+2].dnLow;
653 qualifiers[i].high_bound = aux_ptr[index+3].dnHigh;
654 qualifiers[i].stride = aux_ptr[index+4].width;
656 used_ptr[index+1] = 1;
657 used_ptr[index+2] = 1;
658 used_ptr[index+3] = 1;
659 used_ptr[index+4] = 1;
665 * Now print out the qualifiers.
667 for (i = 0; i < 6; i++)
669 switch (qualifiers[i].type)
676 strcpy (p2, "ptr to ");
677 p2 += sizeof ("ptr to ")-1;
681 strcpy (p2, "volatile ");
682 p2 += sizeof ("volatile ")-1;
687 p2 += sizeof ("far ")-1;
691 strcpy (p2, "func. ret. ");
692 p2 += sizeof ("func. ret. ");
700 /* Print array bounds reversed (ie, in the order the C
701 programmer writes them). C is such a fun language.... */
703 while (i < 5 && qualifiers[i+1].type == tq_Array)
706 for (j = i; j >= first_array; j--)
708 strcpy (p2, "array [");
709 p2 += sizeof ("array [")-1;
710 if (qualifiers[j].low_bound != 0)
712 "%ld:%ld {%ld bits}",
713 (long) qualifiers[j].low_bound,
714 (long) qualifiers[j].high_bound,
715 (long) qualifiers[j].stride);
717 else if (qualifiers[j].high_bound != -1)
720 (long) (qualifiers[j].high_bound + 1),
721 (long) (qualifiers[j].stride));
724 sprintf (p2, " {%ld bits}", (long) (qualifiers[j].stride));
727 strcpy (p2, "] of ");
728 p2 += sizeof ("] of ")-1;
736 strcpy (p2, buffer1);
741 /* Print out the global file header for object files. */
744 print_global_hdr (ptr)
747 char *time = ctime ((time_t *)&ptr->f_timdat);
748 ushort flags = ptr->f_flags;
750 printf("Global file header:\n");
751 printf(" %-*s 0x%x\n", 24, "magic number", (ushort) ptr->f_magic);
752 printf(" %-*s %d\n", 24, "# sections", (int) ptr->f_nscns);
753 printf(" %-*s %ld, %s", 24, "timestamp", (long) ptr->f_timdat, time);
754 printf(" %-*s %ld\n", 24, "symbolic header offset", (long) ptr->f_symptr);
755 printf(" %-*s %ld\n", 24, "symbolic header size", (long) ptr->f_nsyms);
756 printf(" %-*s %ld\n", 24, "optional header", (long) ptr->f_opthdr);
757 printf(" %-*s 0x%x", 24, "flags", (ushort) flags);
759 if ((flags & F_RELFLG) != 0)
760 printf (", F_RELFLG");
762 if ((flags & F_EXEC) != 0)
765 if ((flags & F_LNNO) != 0)
768 if ((flags & F_LSYMS) != 0)
769 printf (", F_LSYMS");
771 if ((flags & F_MINMAL) != 0)
772 printf (", F_MINMAL");
774 if ((flags & F_UPDATE) != 0)
775 printf (", F_UPDATE");
777 if ((flags & F_SWABD) != 0)
778 printf (", F_SWABD");
780 if ((flags & F_AR16WR) != 0)
781 printf (", F_AR16WR");
783 if ((flags & F_AR32WR) != 0)
784 printf (", F_AR32WR");
786 if ((flags & F_AR32W) != 0)
787 printf (", F_AR32W");
789 if ((flags & F_PATCH) != 0)
790 printf (", F_PATCH/F_NODF");
796 /* Print out the symbolic header. */
799 print_sym_hdr (sym_ptr)
804 printf("Symbolic header, magic number = 0x%04x, vstamp = %d.%d:\n\n",
805 sym_ptr->magic & 0xffff,
806 (sym_ptr->vstamp & 0xffff) >> 8,
807 sym_ptr->vstamp & 0xff);
809 printf(" %-*s %11s %11s %11s\n", width, "Info", "Offset", "Number", "Bytes");
810 printf(" %-*s %11s %11s %11s\n", width, "====", "======", "======", "=====\n");
812 printf(" %-*s %11ld %11ld %11ld [%d]\n", width, "Line numbers",
813 (long) sym_ptr->cbLineOffset,
814 (long) sym_ptr->cbLine,
815 (long) sym_ptr->cbLine,
816 (int) sym_ptr->ilineMax);
818 printf(" %-*s %11ld %11ld %11ld\n", width, "Dense numbers",
819 (long) sym_ptr->cbDnOffset,
820 (long) sym_ptr->idnMax,
821 (long) (sym_ptr->idnMax * sizeof (DNR)));
823 printf(" %-*s %11ld %11ld %11ld\n", width, "Procedures Tables",
824 (long) sym_ptr->cbPdOffset,
825 (long) sym_ptr->ipdMax,
826 (long) (sym_ptr->ipdMax * sizeof (PDR)));
828 printf(" %-*s %11ld %11ld %11ld\n", width, "Local Symbols",
829 (long) sym_ptr->cbSymOffset,
830 (long) sym_ptr->isymMax,
831 (long) (sym_ptr->isymMax * sizeof (SYMR)));
833 printf(" %-*s %11ld %11ld %11ld\n", width, "Optimization Symbols",
834 (long) sym_ptr->cbOptOffset,
835 (long) sym_ptr->ioptMax,
836 (long) (sym_ptr->ioptMax * sizeof (OPTR)));
838 printf(" %-*s %11ld %11ld %11ld\n", width, "Auxiliary Symbols",
839 (long) sym_ptr->cbAuxOffset,
840 (long) sym_ptr->iauxMax,
841 (long) (sym_ptr->iauxMax * sizeof (AUXU)));
843 printf(" %-*s %11ld %11ld %11ld\n", width, "Local Strings",
844 (long) sym_ptr->cbSsOffset,
845 (long) sym_ptr->issMax,
846 (long) sym_ptr->issMax);
848 printf(" %-*s %11ld %11ld %11ld\n", width, "External Strings",
849 (long) sym_ptr->cbSsExtOffset,
850 (long) sym_ptr->issExtMax,
851 (long) sym_ptr->issExtMax);
853 printf(" %-*s %11ld %11ld %11ld\n", width, "File Tables",
854 (long) sym_ptr->cbFdOffset,
855 (long) sym_ptr->ifdMax,
856 (long) (sym_ptr->ifdMax * sizeof (FDR)));
858 printf(" %-*s %11ld %11ld %11ld\n", width, "Relative Files",
859 (long) sym_ptr->cbRfdOffset,
860 (long) sym_ptr->crfd,
861 (long) (sym_ptr->crfd * sizeof (ulong)));
863 printf(" %-*s %11ld %11ld %11ld\n", width, "External Symbols",
864 (long) sym_ptr->cbExtOffset,
865 (long) sym_ptr->iextMax,
866 (long) (sym_ptr->iextMax * sizeof (EXTR)));
870 /* Print out a symbol. */
873 print_symbol (sym_ptr, number, strbase, aux_base, ifd, fdp)
881 sc_t storage_class = (sc_t) sym_ptr->sc;
882 st_t symbol_type = (st_t) sym_ptr->st;
883 ulong index = sym_ptr->index;
884 char *used_ptr = aux_used + (aux_base - aux_symbols);
887 printf ("\n Symbol# %d: \"%s\"\n", number, sym_ptr->iss + strbase);
889 if (aux_base != (AUXU *) 0 && index != indexNil)
898 printf (" End+1 symbol: %ld\n", index);
901 if (free_scope == (scope_t *) 0)
902 scope_ptr = (scope_t *) xmalloc (sizeof (scope_t));
905 scope_ptr = free_scope;
906 free_scope = scope_ptr->prev;
908 scope_ptr->open_sym = number;
909 scope_ptr->st = symbol_type;
910 scope_ptr->sc = storage_class;
911 scope_ptr->prev = cur_scope;
912 cur_scope = scope_ptr;
917 if (storage_class == sc_Text || storage_class == sc_Info)
918 printf (" First symbol: %ld\n", index);
922 printf (" First symbol: %ld\n", (long) aux_base[index].isym);
927 if (cur_scope == (scope_t *) 0)
928 printf (" Can't pop end scope\n");
931 scope_ptr = cur_scope;
932 cur_scope = scope_ptr->prev;
933 scope_ptr->prev = free_scope;
934 free_scope = scope_ptr;
941 if (MIPS_IS_STAB(sym_ptr))
943 else if (ifd == -1) /* local symbol */
945 used_ptr[index] = used_ptr[index+1] = 1;
946 printf (" End+1 symbol: %-7ld Type: %s\n",
947 (long) aux_base[index].isym,
948 type_to_string (aux_base, index+1, fdp));
950 else /* global symbol */
951 printf (" Local symbol: %ld\n", index);
955 if (free_scope == (scope_t *) 0)
956 scope_ptr = (scope_t *) xmalloc (sizeof (scope_t));
959 scope_ptr = free_scope;
960 free_scope = scope_ptr->prev;
962 scope_ptr->open_sym = number;
963 scope_ptr->st = symbol_type;
964 scope_ptr->sc = storage_class;
965 scope_ptr->prev = cur_scope;
966 cur_scope = scope_ptr;
974 printf (" End+1 symbol: %lu\n", index);
979 if (!MIPS_IS_STAB (sym_ptr))
982 printf (" Type: %s\n",
983 type_to_string (aux_base, index, fdp));
990 printf (" Scopes: ");
991 if (cur_scope == (scope_t *) 0)
995 for (scope_ptr = cur_scope;
996 scope_ptr != (scope_t *) 0;
997 scope_ptr = scope_ptr->prev)
1000 if (scope_ptr->st == st_Proc || scope_ptr->st == st_StaticProc)
1002 else if (scope_ptr->st == st_File)
1004 else if (scope_ptr->st == st_Block && scope_ptr->sc == sc_Text)
1006 else if (scope_ptr->st == st_Block && scope_ptr->sc == sc_Info)
1011 printf (" %ld [%s]", scope_ptr->open_sym, class);
1017 printf (" Value: %-13ld ",
1018 (long)sym_ptr->value);
1020 printf ("String index: %ld\n", (long)sym_ptr->iss);
1022 printf ("String index: %-11ld Ifd: %d\n",
1023 (long)sym_ptr->iss, ifd);
1025 printf (" Symbol type: %-11sStorage class: %-11s",
1026 st_to_string (symbol_type), sc_to_string (storage_class));
1028 if (MIPS_IS_STAB(sym_ptr))
1030 int i = ARRAY_SIZE (stab_names);
1031 const char *stab_name = "stab";
1032 short code = MIPS_UNMARK_STAB(sym_ptr->index);
1035 if (stab_names[i].code == code)
1037 stab_name = stab_names[i].string;
1040 printf ("Index: 0x%lx (%s)\n", (long)sym_ptr->index, stab_name);
1042 else if (sym_ptr->st == stLabel && sym_ptr->index != indexNil)
1043 printf ("Index: %ld (line#)\n", (long)sym_ptr->index);
1045 printf ("Index: %ld\n", (long)sym_ptr->index);
1050 /* Print out a word from the aux. table in various formats. */
1053 print_aux (u, auxi, used)
1058 printf ("\t%s#%-5d %11ld, [%4ld/%7ld], [%2d %1d:%1d %1x:%1x:%1x:%1x:%1x:%1x]\n",
1059 (used) ? " " : "* ",
1063 (long) u.rndx.index,
1076 /* Write aggregate information to a string. */
1079 emit_aggregate (string, u, u2, which, fdp)
1086 unsigned int ifd = u.rndx.rfd;
1087 unsigned int index = u.rndx.index;
1090 if (ifd == ST_RFDESCAPE)
1093 /* An ifd of -1 is an opaque type. An escaped index of 0 is a
1094 struct return type of a procedure compiled without -g. */
1095 if (ifd == 0xffffffff
1096 || (u.rndx.rfd == ST_RFDESCAPE && index == 0))
1097 name = "<undefined>";
1098 else if (index == indexNil)
1102 if (fdp == 0 || sym_hdr.crfd == 0)
1103 fdp = &file_desc[ifd];
1105 fdp = &file_desc[rfile_desc[fdp->rfdBase + ifd]];
1106 name = &l_strings[fdp->issBase + l_symbols[index + fdp->isymBase].iss];
1110 "%s %s { ifd = %u, index = %u }",
1111 which, name, ifd, index);
1115 /* Print out information about a file descriptor, and the symbols,
1116 procedures, and line numbers within it. */
1119 print_file_desc (fdp, number)
1129 str_base = l_strings + fdp->issBase;
1130 aux_base = aux_symbols + fdp->iauxBase;
1131 used_base = aux_used + (aux_base - aux_symbols);
1133 printf ("\nFile #%d, \"%s\"\n\n",
1135 fdp->rss != issNil ? str_base + fdp->rss : "<unknown>");
1137 printf (" Name index = %-10ld Readin = %s\n",
1138 (long) fdp->rss, (fdp->fReadin) ? "Yes" : "No");
1140 printf (" Merge = %-10s Endian = %s\n",
1141 (fdp->fMerge) ? "Yes" : "No",
1142 (fdp->fBigendian) ? "BIG" : "LITTLE");
1144 printf (" Debug level = %-10s Language = %s\n",
1145 glevel_to_string (fdp->glevel),
1146 lang_to_string((lang_t) fdp->lang));
1148 printf (" Adr = 0x%08lx\n\n", (long) fdp->adr);
1150 printf(" %-*s %11s %11s %11s %11s\n", width, "Info", "Start", "Number", "Size", "Offset");
1151 printf(" %-*s %11s %11s %11s %11s\n", width, "====", "=====", "======", "====", "======");
1153 printf(" %-*s %11lu %11lu %11lu %11lu\n",
1154 width, "Local strings",
1155 (ulong) fdp->issBase,
1158 (ulong) (fdp->issBase + sym_hdr.cbSsOffset));
1160 printf(" %-*s %11lu %11lu %11lu %11lu\n",
1161 width, "Local symbols",
1162 (ulong) fdp->isymBase,
1164 (ulong) (fdp->csym * sizeof (SYMR)),
1165 (ulong) (fdp->isymBase * sizeof (SYMR) + sym_hdr.cbSymOffset));
1167 printf(" %-*s %11lu %11lu %11lu %11lu\n",
1168 width, "Line numbers",
1169 (ulong) fdp->cbLineOffset,
1171 (ulong) fdp->cbLine,
1172 (ulong) (fdp->cbLineOffset + sym_hdr.cbLineOffset));
1174 printf(" %-*s %11lu %11lu %11lu %11lu\n",
1175 width, "Optimization symbols",
1176 (ulong) fdp->ioptBase,
1178 (ulong) (fdp->copt * sizeof (OPTR)),
1179 (ulong) (fdp->ioptBase * sizeof (OPTR) + sym_hdr.cbOptOffset));
1181 printf(" %-*s %11lu %11lu %11lu %11lu\n",
1182 width, "Procedures",
1183 (ulong) fdp->ipdFirst,
1185 (ulong) (fdp->cpd * sizeof (PDR)),
1186 (ulong) (fdp->ipdFirst * sizeof (PDR) + sym_hdr.cbPdOffset));
1188 printf(" %-*s %11lu %11lu %11lu %11lu\n",
1189 width, "Auxiliary symbols",
1190 (ulong) fdp->iauxBase,
1192 (ulong) (fdp->caux * sizeof (AUXU)),
1193 (ulong) (fdp->iauxBase * sizeof(AUXU) + sym_hdr.cbAuxOffset));
1195 printf(" %-*s %11lu %11lu %11lu %11lu\n",
1196 width, "Relative Files",
1197 (ulong) fdp->rfdBase,
1199 (ulong) (fdp->crfd * sizeof (ulong)),
1200 (ulong) (fdp->rfdBase * sizeof(ulong) + sym_hdr.cbRfdOffset));
1203 if (want_scope && cur_scope != (scope_t *) 0)
1204 printf ("\n Warning scope does not start at 0!\n");
1207 * print the info about the symbol table.
1209 printf ("\n There are %lu local symbols, starting at %lu\n",
1211 (ulong) (fdp->isymBase + sym_hdr.cbSymOffset));
1213 for(symi = fdp->isymBase; symi < (fdp->csym + fdp->isymBase); symi++)
1214 print_symbol (&l_symbols[symi],
1215 symi - fdp->isymBase,
1221 if (want_scope && cur_scope != (scope_t *) 0)
1222 printf ("\n Warning scope does not end at 0!\n");
1225 * print the aux. table if desired.
1228 if (want_aux && fdp->caux != 0)
1232 printf ("\n There are %lu auxiliary table entries, starting at %lu.\n\n",
1234 (ulong) (fdp->iauxBase + sym_hdr.cbAuxOffset));
1236 for (auxi = fdp->iauxBase; auxi < (fdp->caux + fdp->iauxBase); auxi++)
1237 print_aux (aux_base[auxi], auxi, used_base[auxi]);
1241 * print the relative file descriptors.
1243 if (want_rfd && fdp->crfd != 0)
1247 printf ("\n There are %lu relative file descriptors, starting at %lu.\n",
1249 (ulong) fdp->rfdBase);
1251 rfd_ptr = rfile_desc + fdp->rfdBase;
1252 for (i = 0; i < (ulong) fdp->crfd; i++)
1254 printf ("\t#%-5ld %11ld, 0x%08lx\n", i, *rfd_ptr, *rfd_ptr);
1260 * do the procedure descriptors.
1262 printf ("\n There are %lu procedure descriptor entries, ", (ulong) fdp->cpd);
1263 printf ("starting at %lu.\n", (ulong) fdp->ipdFirst);
1265 for (pdi = fdp->ipdFirst; pdi < (fdp->cpd + fdp->ipdFirst); pdi++)
1267 PDR *proc_ptr = &proc_desc[pdi];
1268 printf ("\n\tProcedure descriptor %d:\n", (pdi - fdp->ipdFirst));
1271 printf ("\t Name index = %-11ld Name = \"%s\"\n",
1272 (long) l_symbols[proc_ptr->isym + fdp->isymBase].iss,
1273 l_symbols[proc_ptr->isym + fdp->isymBase].iss + str_base);
1275 printf ("\t .mask 0x%08lx,%-9ld .fmask 0x%08lx,%ld\n",
1276 (long) proc_ptr->regmask,
1277 (long) proc_ptr->regoffset,
1278 (long) proc_ptr->fregmask,
1279 (long) proc_ptr->fregoffset);
1281 printf ("\t .frame $%d,%ld,$%d\n",
1282 (int) proc_ptr->framereg,
1283 (long) proc_ptr->frameoffset,
1284 (int) proc_ptr->pcreg);
1286 printf ("\t Opt. start = %-11ld Symbols start = %ld\n",
1287 (long) proc_ptr->iopt,
1288 (long) proc_ptr->isym);
1290 printf ("\t First line # = %-11ld Last line # = %ld\n",
1291 (long) proc_ptr->lnLow,
1292 (long) proc_ptr->lnHigh);
1294 printf ("\t Line Offset = %-11ld Address = 0x%08lx\n",
1295 (long) proc_ptr->cbLineOffset,
1296 (long) proc_ptr->adr);
1299 * print the line number entries.
1302 if (want_line && fdp->cline != 0)
1305 long cur_line = proc_ptr->lnLow;
1306 uchar *line_ptr = (((uchar *)lines) + proc_ptr->cbLineOffset
1307 + fdp->cbLineOffset);
1310 if (pdi == fdp->cpd + fdp->ipdFirst - 1) /* last procedure */
1311 line_end = ((uchar *)lines) + fdp->cbLine + fdp->cbLineOffset;
1312 else /* not last proc. */
1313 line_end = (((uchar *)lines) + proc_desc[pdi+1].cbLineOffset
1314 + fdp->cbLineOffset);
1316 printf ("\n\tThere are %lu bytes holding line numbers, starting at %lu.\n",
1317 (ulong) (line_end - line_ptr),
1318 (ulong) (fdp->ilineBase + sym_hdr.cbLineOffset));
1320 while (line_ptr < line_end)
1321 { /* sign extend nibble */
1322 delta = ((*line_ptr >> 4) ^ 0x8) - 0x8;
1323 count = (*line_ptr & 0xf) + 1;
1328 delta = (((line_ptr[1]) & 0xff) << 8) + ((line_ptr[2]) & 0xff);
1329 delta = (delta ^ 0x8000) - 0x8000;
1334 printf ("\t Line %11ld, delta %5d, count %2d\n",
1344 /* Read in the portions of the .T file that we will print out. */
1350 off_t sym_hdr_offset = 0;
1352 (void) read_seek (&magic, sizeof (magic), (off_t) 0, "Magic number");
1355 /* Print out the global header, since this is not a T-file. */
1357 (void) read_seek (&global_hdr, sizeof (global_hdr), (off_t) 0,
1358 "Global file header");
1360 print_global_hdr (&global_hdr);
1362 if (global_hdr.f_symptr == 0)
1364 printf ("No symbolic header, Goodbye!\n");
1368 sym_hdr_offset = global_hdr.f_symptr;
1371 (void) read_seek (&sym_hdr,
1376 print_sym_hdr (&sym_hdr);
1378 lines = (LINER *) read_seek (NULL,
1380 sym_hdr.cbLineOffset,
1383 dense_nums = (DNR *) read_seek (NULL,
1384 sym_hdr.idnMax * sizeof (DNR),
1388 proc_desc = (PDR *) read_seek (NULL,
1389 sym_hdr.ipdMax * sizeof (PDR),
1391 "Procedure tables");
1393 l_symbols = (SYMR *) read_seek (NULL,
1394 sym_hdr.isymMax * sizeof (SYMR),
1395 sym_hdr.cbSymOffset,
1398 opt_symbols = (OPTR *) read_seek (NULL,
1399 sym_hdr.ioptMax * sizeof (OPTR),
1400 sym_hdr.cbOptOffset,
1401 "Optimization symbols");
1403 aux_symbols = (AUXU *) read_seek (NULL,
1404 sym_hdr.iauxMax * sizeof (AUXU),
1405 sym_hdr.cbAuxOffset,
1406 "Auxiliary symbols");
1408 if (sym_hdr.iauxMax > 0)
1409 aux_used = xcalloc (sym_hdr.iauxMax, 1);
1411 l_strings = (char *) read_seek (NULL,
1414 "Local string table");
1416 e_strings = (char *) read_seek (NULL,
1418 sym_hdr.cbSsExtOffset,
1419 "External string table");
1421 file_desc = (FDR *) read_seek (NULL,
1422 sym_hdr.ifdMax * sizeof (FDR),
1426 rfile_desc = (ulong *) read_seek (NULL,
1427 sym_hdr.crfd * sizeof (ulong),
1428 sym_hdr.cbRfdOffset,
1429 "Relative file tables");
1431 e_symbols = (EXTR *) read_seek (NULL,
1432 sym_hdr.iextMax * sizeof (EXTR),
1433 sym_hdr.cbExtOffset,
1434 "External symbols");
1439 extern int main PARAMS ((int, char **));
1451 while ((opt = getopt_long (argc, argv, "alrsvt", options, NULL)) != -1)
1454 default: errors++; break;
1455 case 'a': want_aux++; break; /* print aux table */
1456 case 'l': want_line++; break; /* print line numbers */
1457 case 'r': want_rfd++; break; /* print relative fd's */
1458 case 's': want_scope++; break; /* print scope info */
1459 case 'v': verbose++; break; /* print version # */
1460 case 'V': version++; break; /* print version # */
1461 case 't': tfile++; break; /* this is a tfile (without header),
1467 printf ("mips-tdump (GCC) %s\n", version_string);
1468 fputs ("Copyright (C) 2003 Free Software Foundation, Inc.\n", stdout);
1469 fputs ("This is free software; see the source for copying conditions. There is NO\n\
1470 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n",
1475 if (optind != argc - 1)
1478 if (verbose || errors)
1480 fprintf (stderr, "mips-tdump (GCC) %s", version_string);
1481 #ifdef TARGET_VERSION
1484 fputc ('\n', stderr);
1489 fprintf (stderr, "Calling Sequence:\n");
1490 fprintf (stderr, "\t%s [-alrst] <object-or-T-file>\n", argv[0]);
1491 fprintf (stderr, "\n");
1492 fprintf (stderr, "switches:\n");
1493 fprintf (stderr, "\t-a Print out auxiliary table.\n");
1494 fprintf (stderr, "\t-l Print out line numbers.\n");
1495 fprintf (stderr, "\t-r Print out relative file descriptors.\n");
1496 fprintf (stderr, "\t-s Print out the current scopes for an item.\n");
1497 fprintf (stderr, "\t-t Assume there is no global header (ie, a T-file).\n");
1498 fprintf (stderr, "\t-v Print program version.\n");
1503 * Open and process the input file.
1505 tfile_fd = open (argv[optind], O_RDONLY);
1508 perror (argv[optind]);
1515 * Print any global aux words if any.
1519 long last_aux_in_use;
1521 if (sym_hdr.ifdMax != 0 && file_desc[0].iauxBase != 0)
1523 printf ("\nGlobal auxiliary entries before first file:\n");
1524 for (i = 0; i < file_desc[0].iauxBase; i++)
1525 print_aux (aux_symbols[i], 0, aux_used[i]);
1528 if (sym_hdr.ifdMax == 0)
1529 last_aux_in_use = 0;
1532 = (file_desc[sym_hdr.ifdMax-1].iauxBase
1533 + file_desc[sym_hdr.ifdMax-1].caux - 1);
1535 if (last_aux_in_use < sym_hdr.iauxMax-1)
1537 printf ("\nGlobal auxiliary entries after last file:\n");
1538 for (i = last_aux_in_use; i < sym_hdr.iauxMax; i++)
1539 print_aux (aux_symbols[i], i - last_aux_in_use, aux_used[i]);
1544 * Print the information for each file.
1546 for (i = 0; i < sym_hdr.ifdMax; i++)
1547 print_file_desc (&file_desc[i], i);
1550 * Print the external symbols.
1552 want_scope = 0; /* scope info is meaning for extern symbols */
1553 printf ("\nThere are %lu external symbols, starting at %lu\n",
1554 (ulong) sym_hdr.iextMax,
1555 (ulong) sym_hdr.cbExtOffset);
1557 for(i = 0; i < sym_hdr.iextMax; i++)
1558 print_symbol (&e_symbols[i].asym, i, e_strings,
1559 aux_symbols + file_desc[e_symbols[i].ifd].iauxBase,
1561 &file_desc[e_symbols[i].ifd]);
1564 * Print unused aux symbols now.
1571 for (i = 0; i < sym_hdr.iauxMax; i++)
1577 printf ("\nThe following auxiliary table entries were unused:\n\n");
1581 printf (" #%-5d %11ld 0x%08lx %s\n",
1583 (long) aux_symbols[i].isym,
1584 (long) aux_symbols[i].isym,
1585 type_to_string (aux_symbols, i, (FDR *) 0));