![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to symseg.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cctools / include / gnu|
Return to symseg.h CVS log | Up to [Apple XNU] / GNUtools / cctools / include / gnu |
1.1 ! root 1: /* GDB symbol table format definitions. ! 2: Copyright (C) 1986 Free Software Foundation, Inc. ! 3: ! 4: GDB is distributed in the hope that it will be useful, but WITHOUT ANY ! 5: WARRANTY. No author or distributor accepts responsibility to anyone ! 6: for the consequences of using it or for whether it serves any ! 7: particular purpose or works at all, unless he says so in writing. ! 8: Refer to the GDB General Public License for full details. ! 9: ! 10: Everyone is granted permission to copy, modify and redistribute GDB, ! 11: but only under the conditions described in the GDB General Public ! 12: License. A copy of this license is supposed to have been given to you ! 13: along with GDB so you can know your rights and responsibilities. It ! 14: should be in a file named COPYING. Among other things, the copyright ! 15: notice and this notice must be preserved on all copies. ! 16: ! 17: In other words, go ahead and share GDB, but don't try to stop ! 18: anyone else from sharing it farther. Help stamp out software hoarding! ! 19: */ ! 20: ! 21: /* Format of GDB symbol table data. ! 22: There is one symbol segment for each source file or ! 23: independant compilation. These segments are simply concatenated ! 24: to form the GDB symbol table. A zero word where the beginning ! 25: of a segment is expected indicates there are no more segments. ! 26: ! 27: Format of a symbol segment: ! 28: ! 29: The symbol segment begins with a word containing 1 ! 30: if it is in the format described here. Other formats may ! 31: be designed, with other code numbers. ! 32: ! 33: The segment contains many objects which point at each other. ! 34: The pointers are offsets in bytes from the beginning of the segment. ! 35: Thus, each segment can be loaded into core and its pointers relocated ! 36: to make valid in-core pointers. ! 37: ! 38: All the data objects in the segment can be found indirectly from ! 39: one of them, the root object, of type `struct symbol_root'. ! 40: It appears at the beginning of the segment. ! 41: ! 42: The total size of the segment, in bytes, appears as the `length' ! 43: field of this object. This size includes the size of the ! 44: root object. ! 45: ! 46: All the object data types are defined here to contain pointer types ! 47: appropriate for in-core use on a relocated symbol segment. ! 48: Casts to and from type int are required for working with ! 49: unrelocated symbol segments such as are found in the file. ! 50: ! 51: The ldsymaddr word is filled in by the loader to contain ! 52: the offset (in bytes) within the ld symbol table ! 53: of the first nonglobal symbol from this compilation. ! 54: This makes it possible to match those symbols ! 55: (which contain line number information) reliably with ! 56: the segment they go with. ! 57: ! 58: Core addresses within the program that appear in the symbol segment ! 59: are not relocated by the loader. They are inserted by the assembler ! 60: and apply to addresses as output by the assembler, so GDB must ! 61: relocate them when it loads the symbol segment. It gets the information ! 62: on how to relocate from the textrel, datarel, bssrel, databeg and bssbeg ! 63: words of the root object. ! 64: ! 65: The words textrel, datarel and bssrel ! 66: are filled in by ld with the amounts to relocate within-the-file ! 67: text, data and bss addresses by; databeg and bssbeg can be ! 68: used to tell which kind of relocation an address needs. */ ! 69: ! 70: enum language {language_c}; ! 71: ! 72: /* ! 73: * All symbol roots must have as their first two fields format and length ! 74: * fields. The total length of the symbol root must be a multiple of ! 75: * sizeof(long) and any padding must be zeroed. ! 76: */ ! 77: struct symbol_root_header ! 78: { ! 79: int format; /* type of symbol segment */ ! 80: int length; /* # bytes in this symbol segment, rounded to sizeof(long) */ ! 81: }; ! 82: ! 83: /* ! 84: * Constants for symbol root format fields ! 85: */ ! 86: #define SYMBOL_ROOT_FORMAT 1 ! 87: #define INDIRECT_ROOT_FORMAT 1002 ! 88: #define COMMON_ROOT_FORMAT 1003 ! 89: #define SHLIB_ROOT_FORMAT 1004 ! 90: #define ALIAS_ROOT_FORMAT 1005 ! 91: #define MACH_ROOT_FORMAT 2001 ! 92: #define MACH_INDIRECT_ROOT_FORMAT 2002 ! 93: #define MACH_SHLIB_ROOT_FORMAT 2004 ! 94: ! 95: ! 96: struct symbol_root ! 97: { ! 98: int format; /* SYMBOL_ROOT_FORMAT */ ! 99: int length; /* # bytes in this symbol segment */ ! 100: int ldsymoff; /* Offset in ld symtab of this file's syms */ ! 101: int textrel; /* Relocation for text addresses */ ! 102: int datarel; /* Relocation for data addresses */ ! 103: int bssrel; /* Relocation for bss addresses */ ! 104: char *filename; /* Name of main source file compiled */ ! 105: char *filedir; /* Name of directory it was reached from */ ! 106: struct blockvector *blockvector; /* Vector of all symbol-naming blocks */ ! 107: struct typevector *typevector; /* Vector of all data types */ ! 108: enum language language; /* Code identifying the language used */ ! 109: char *version; /* Version info. Not fully specified */ ! 110: char *compilation; /* Compilation info. Not fully specified */ ! 111: int databeg; /* Address within the file of data start */ ! 112: int bssbeg; /* Address within the file of bss start */ ! 113: struct sourcevector *sourcevector; /* Vector of line-number info */ ! 114: }; ! 115: ! 116: struct mach_root ! 117: { ! 118: int format; /* MACH_ROOT_FORMAT */ ! 119: int length; /* # bytes in this symbol segment */ ! 120: int ldsymoff; /* Offset in ld symtab of this file's syms */ ! 121: struct loadmap *loadmap; /* load map of the relocatable object */ ! 122: char *filename; /* Name of main source file compiled */ ! 123: char *filedir; /* Name of directory it was reached from */ ! 124: struct blockvector *blockvector; /* Vector of all symbol-naming blocks */ ! 125: struct typevector *typevector; /* Vector of all data types */ ! 126: enum language language; /* Code identifying the language used */ ! 127: char *version; /* Version info. Not fully specified */ ! 128: char *compilation; /* Compilation info. Not fully specified */ ! 129: struct sourcevector *sourcevector; /* Vector of line-number info */ ! 130: }; ! 131: ! 132: /* ! 133: * Indirect symbol root format. Written by ld when -g is used (the default). ! 134: * This is for lazy evaluation of the -gg symbol segments. ! 135: */ ! 136: struct indirect_root { ! 137: int format; /* INDIRECT_ROOT_FORMAT */ ! 138: int length; /* length of this struct, rounded to sizeof(long) */ ! 139: int ldsymoff; /* Offset in ld symtab of this file's syms */ ! 140: int textrel; /* Relocation for text addresses */ ! 141: int datarel; /* Relocation for data addresses */ ! 142: int bssrel; /* Relocation for bss addresses */ ! 143: int textsize; /* text size */ ! 144: int datasize; /* data size */ ! 145: int bsssize; /* bss size */ ! 146: int mtime; /* last modified time, as returned by stat(2) */ ! 147: int fileoffset; /* Offset in file that contains symbol_root */ ! 148: char filename[1]; /* variable length file name, zero padded */ ! 149: }; ! 150: ! 151: /* ! 152: * Mach indirect symbol root format. Written by ld when -g is used (the ! 153: * default). This is for lazy evaluation of the -gg symbol segments. ! 154: */ ! 155: struct mach_indirect_root { ! 156: int format; /* MACH_INDIRECT_ROOT_FORMAT */ ! 157: int length; /* length of this struct, rounded to sizeof(long) */ ! 158: int ldsymoff; /* Offset in ld symtab of this file's syms */ ! 159: struct loadmap *loadmap; /* load map of the relocatable object */ ! 160: int mtime; /* last modified time, as returned by stat(2) */ ! 161: int fileoffset; /* Offset in relocatable file that contains the ! 162: mach_root */ ! 163: char filename[1]; /* variable length file name, zero padded */ ! 164: }; ! 165: ! 166: /* ! 167: * common symbol root format. For each common symbol that the link editor ! 168: * defines the storage for that symbol name is recorded in here. ! 169: */ ! 170: struct common_root { ! 171: int format; /* COMMON_SYM_FORMAT */ ! 172: int length; /* length of this struct, rounded to sizeof(long) */ ! 173: int nsyms; /* the number of strings in the data[] field for the ! 174: common symbols names of this file */ ! 175: char data[1]; ! 176: /* Data looks like the following: ! 177: - Null terminated string for the filename. ! 178: - Null terminated stings for syms. ! 179: ... ! 180: - zero padded to round to sizeof(long) ! 181: */ ! 182: }; ! 183: ! 184: /* ! 185: * shlib_root: Written by ld for target shared library output. This has two ! 186: * fields for each of the data segment fields. The data segments of .o files ! 187: * that go into target shared libraries have all their static data first in ! 188: * the data segment followed by all the global data. When it is loaded into ! 189: * a target shared library the global data from all the .o files is placed ! 190: * first in the data segment then all of the static data. So this information ! 191: * is reflected in the {global,static}datarel and the {global,static}databeg ! 192: * fields. ! 193: * ! 194: * After one of these has been written for each object in the shared library ! 195: * then the symbol root from each object is written into the shared library. ! 196: */ ! 197: struct shlib_root { ! 198: int format; /* SHLIB_ROOT_FORMAT */ ! 199: int length; /* length of this struct, rounded to sizeof(long) */ ! 200: int ldsymoff; /* Offset in ld symtab of this file's syms */ ! 201: int textrel; /* Relocation for text addresses */ ! 202: int globaldatarel; /* Relocation for global data addresses */ ! 203: int staticdatarel; /* Relocation for static data addresses */ ! 204: int globaldatabeg; /* Address of the global data start */ ! 205: int staticdatabeg; /* Address of the static data start */ ! 206: int globaldatasize; /* global data size */ ! 207: int staticdatasize; /* static data size */ ! 208: int symreloffset; /* relitive offset, from the first SYMBOL_ROOT_FORMAT ! 209: of the symbol root for this file */ ! 210: char filename[1]; /* variable length file name, zero padded */ ! 211: }; ! 212: ! 213: struct mach_shlib_root { ! 214: int format; /* MACH_SHLIB_ROOT_FORMAT */ ! 215: int length; /* length of this struct, rounded to sizeof(long) */ ! 216: int ldsymoff; /* Offset in ld symtab of this file's syms */ ! 217: struct loadmap *loadmap; /* load map of the relocatable object */ ! 218: int symreloffset; /* relitive offset, from the first SYMBOL_ROOT_FORMAT ! 219: of the symbol root for this file */ ! 220: char filename[1]; /* variable length file name, zero padded */ ! 221: }; ! 222: ! 223: /* ! 224: * This format is used when the link-editor alias option -a original:alias ! 225: * is used when producing an output file. This option changes symbols in ! 226: * the .o file from 'original' to 'alias' in the a.out file. ! 227: */ ! 228: struct alias_root { ! 229: int format; /* ALIAS_SYM_FORMAT */ ! 230: int length; /* length of this struct, rounded to sizeof(long) */ ! 231: int naliases; /* number of pairs of aliased symbols */ ! 232: char data[1]; ! 233: /* Data looks like the following: ! 234: - Pairs of: ! 235: - Null terminated string for the original symbol ! 236: - Null terminated string for the aliased symbol ! 237: - zero padded to round to sizeof(long) ! 238: */ ! 239: }; ! 240: ! 241: /* ! 242: * The load map describes where the parts the relocatable object have been ! 243: * loaded in the executable. The enitre address space of the relocatable ! 244: * is to be covered by all the map entries. There may be multiple map entries ! 245: * for a single section or one map entry for multiple sections. This allows ! 246: * the link editor to scatter load a section based on information that improves ! 247: * performance by increasing the locality of reference. ! 248: */ ! 249: struct loadmap ! 250: { ! 251: /* Number of maps in the list. */ ! 252: int nmaps; ! 253: /* The maps themselves. */ ! 254: struct map *map[1]; ! 255: }; ! 256: struct map ! 257: { ! 258: /* The starting address in the relocatable object and size of part of the ! 259: object file. */ ! 260: int reladdr, size; ! 261: /* The address the loader loaded this part of the object file at */ ! 262: int ldaddr; ! 263: }; ! 264: ! 265: ! 266: /* All data types of symbols in the compiled program ! 267: are represented by `struct type' objects. ! 268: All of these objects are pointed to by the typevector. ! 269: The type vector may have empty slots that contain zero. */ ! 270: ! 271: struct typevector ! 272: { ! 273: int length; /* Number of types described */ ! 274: struct type *type[1]; ! 275: }; ! 276: ! 277: /* Different kinds of data types are distinguished by the `code' field. */ ! 278: ! 279: enum type_code ! 280: { ! 281: TYPE_CODE_UNDEF, /* Not used; catches errors */ ! 282: TYPE_CODE_PTR, /* Pointer type */ ! 283: TYPE_CODE_ARRAY, /* Array type, lower bound zero */ ! 284: TYPE_CODE_STRUCT, /* C struct or Pascal record */ ! 285: TYPE_CODE_UNION, /* C union or Pascal variant part */ ! 286: TYPE_CODE_ENUM, /* Enumeration type */ ! 287: TYPE_CODE_FUNC, /* Function type */ ! 288: TYPE_CODE_INT, /* Integer type */ ! 289: TYPE_CODE_FLT, /* Floating type */ ! 290: TYPE_CODE_VOID, /* Void type (values zero length) */ ! 291: TYPE_CODE_SET, /* Pascal sets */ ! 292: TYPE_CODE_RANGE, /* Range (integers within spec'd bounds) */ ! 293: TYPE_CODE_PASCAL_ARRAY, /* Array with explicit type of index */ ! 294: }; ! 295: ! 296: /* This appears in a type's flags word for an unsigned integer type. */ ! 297: #define TYPE_FLAG_UNSIGNED 1 ! 298: ! 299: /* Other flag bits are used with GDB. */ ! 300: ! 301: struct type ! 302: { ! 303: /* Code for kind of type */ ! 304: enum type_code code; ! 305: /* Name of this type, or zero if none. ! 306: This is used for printing only. ! 307: Type names specified as input are defined by symbols. */ ! 308: char *name; ! 309: /* Length in bytes of storage for a value of this type */ ! 310: int length; ! 311: /* For a pointer type, describes the type of object pointed to. ! 312: For an array type, describes the type of the elements. ! 313: For a function type, describes the type of the value. ! 314: Unused otherwise. */ ! 315: struct type *target_type; ! 316: /* Type that is a pointer to this type. ! 317: Zero if no such pointer-to type is known yet. ! 318: The debugger may add the address of such a type ! 319: if it has to construct one later. */ ! 320: struct type *pointer_type; ! 321: /* Type that is a function returning this type. ! 322: Zero if no such function type is known here. ! 323: The debugger may add the address of such a type ! 324: if it has to construct one later. */ ! 325: struct type *function_type; ! 326: /* Flags about this type. */ ! 327: short flags; ! 328: /* Number of fields described for this type */ ! 329: short nfields; ! 330: /* For structure and union types, a description of each field. ! 331: For set and pascal array types, there is one "field", ! 332: whose type is the domain type of the set or array. ! 333: For range types, there are two "fields", ! 334: the minimum and maximum values (both inclusive). ! 335: For enum types, each possible value is described by one "field". ! 336: For range types, there are two "fields", that record constant values ! 337: (inclusive) for the minimum and maximum. ! 338: ! 339: Using a pointer to a separate array of fields ! 340: allows all types to have the same size, which is useful ! 341: because we can allocate the space for a type before ! 342: we know what to put in it. */ ! 343: struct field ! 344: { ! 345: /* Position of this field, counting in bits from start of ! 346: containing structure. For a function type, this is the ! 347: position in the argument list of this argument. ! 348: For a range bound or enum value, this is the value itself. */ ! 349: int bitpos; ! 350: /* Size of this field, in bits, or zero if not packed. ! 351: For an unpacked field, the field's type's length ! 352: says how many bytes the field occupies. */ ! 353: int bitsize; ! 354: /* In a struct or enum type, type of this field. ! 355: In a function type, type of this argument. ! 356: In an array type, the domain-type of the array. */ ! 357: struct type *type; ! 358: /* Name of field, value or argument. ! 359: Zero for range bounds and array domains. */ ! 360: char *name; ! 361: } *fields; ! 362: }; ! 363: ! 364: /* All of the name-scope contours of the program ! 365: are represented by `struct block' objects. ! 366: All of these objects are pointed to by the blockvector. ! 367: ! 368: Each block represents one name scope. ! 369: Each lexical context has its own block. ! 370: ! 371: The first two blocks in the blockvector are special. ! 372: The first one contains all the symbols defined in this compilation ! 373: whose scope is the entire program linked together. ! 374: The second one contains all the symbols whose scope is the ! 375: entire compilation excluding other separate compilations. ! 376: In C, these correspond to global symbols and static symbols. ! 377: ! 378: Each block records a range of core addresses for the code that ! 379: is in the scope of the block. The first two special blocks ! 380: give, for the range of code, the entire range of code produced ! 381: by the compilation that the symbol segment belongs to. ! 382: ! 383: The blocks appear in the blockvector ! 384: in order of increasing starting-address, ! 385: and, within that, in order of decreasing ending-address. ! 386: ! 387: This implies that within the body of one function ! 388: the blocks appear in the order of a depth-first tree walk. */ ! 389: ! 390: struct blockvector ! 391: { ! 392: /* Number of blocks in the list. */ ! 393: int nblocks; ! 394: /* The blocks themselves. */ ! 395: struct block *block[1]; ! 396: }; ! 397: ! 398: struct block ! 399: { ! 400: /* Addresses in the executable code that are in this block. ! 401: Note: in an unrelocated symbol segment in a file, ! 402: these are always zero. They can be filled in from the ! 403: N_LBRAC and N_RBRAC symbols in the loader symbol table. */ ! 404: int startaddr, endaddr; ! 405: /* The symbol that names this block, ! 406: if the block is the body of a function; ! 407: otherwise, zero. ! 408: Note: In an unrelocated symbol segment in an object file, ! 409: this field may be zero even when the block has a name. ! 410: That is because the block is output before the name ! 411: (since the name resides in a higher block). ! 412: Since the symbol does point to the block (as its value), ! 413: it is possible to find the block and set its name properly. */ ! 414: struct symbol *function; ! 415: /* The `struct block' for the containing block, or 0 if none. */ ! 416: /* Note that in an unrelocated symbol segment in an object file ! 417: this pointer may be zero when the correct value should be ! 418: the second special block (for symbols whose scope is one compilation). ! 419: This is because the compiler ouptuts the special blocks at the ! 420: very end, after the other blocks. */ ! 421: struct block *superblock; ! 422: /* Number of local symbols. */ ! 423: int nsyms; ! 424: /* The symbols. */ ! 425: struct symbol *sym[1]; ! 426: }; ! 427: ! 428: /* Represent one symbol name; a variable, constant, function or typedef. */ ! 429: ! 430: /* Different name spaces for symbols. Looking up a symbol specifies ! 431: a namespace and ignores symbol definitions in other name spaces. ! 432: ! 433: VAR_NAMESPACE is the usual namespace. ! 434: In C, this contains variables, function names, typedef names ! 435: and enum type values. ! 436: ! 437: STRUCT_NAMESPACE is used in C to hold struct, union and enum type names. ! 438: Thus, if `struct foo' is used in a C program, ! 439: it produces a symbol named `foo' in the STRUCT_NAMESPACE. ! 440: ! 441: LABEL_NAMESPACE may be used for names of labels (for gotos); ! 442: currently it is not used and labels are not recorded at all. */ ! 443: ! 444: /* For a non-global symbol allocated statically, ! 445: the correct core address cannot be determined by the compiler. ! 446: The compiler puts an index number into the symbol's value field. ! 447: This index number can be matched with the "desc" field of ! 448: an entry in the loader symbol table. */ ! 449: ! 450: enum namespace ! 451: { ! 452: UNDEF_NAMESPACE, VAR_NAMESPACE, STRUCT_NAMESPACE, LABEL_NAMESPACE, ! 453: }; ! 454: ! 455: /* An address-class says where to find the value of the symbol in core. */ ! 456: ! 457: enum address_class ! 458: { ! 459: LOC_UNDEF, /* Not used; catches errors */ ! 460: LOC_CONST, /* Value is constant int */ ! 461: LOC_STATIC, /* Value is at fixed address */ ! 462: LOC_REGISTER, /* Value is in register */ ! 463: LOC_ARG, /* Value is at spec'd position in arglist */ ! 464: LOC_LOCAL, /* Value is at spec'd pos in stack frame */ ! 465: LOC_TYPEDEF, /* Value not used; definition in SYMBOL_TYPE ! 466: Symbols in the namespace STRUCT_NAMESPACE ! 467: all have this class. */ ! 468: LOC_LABEL, /* Value is address in the code */ ! 469: LOC_BLOCK, /* Value is address of a `struct block'. ! 470: Function names have this class. */ ! 471: LOC_EXTERNAL, /* Value is at address not in this compilation. ! 472: This is used for .comm symbols ! 473: and for extern symbols within functions. ! 474: Inside GDB, this is changed to LOC_STATIC once the ! 475: real address is obtained from a loader symbol. */ ! 476: LOC_CONST_BYTES /* Value is a constant byte-sequence. */ ! 477: }; ! 478: ! 479: struct symbol ! 480: { ! 481: /* Symbol name */ ! 482: char *name; ! 483: /* Name space code. */ ! 484: enum namespace namespace; ! 485: /* Address class */ ! 486: enum address_class class; ! 487: /* Data type of value */ ! 488: struct type *type; ! 489: /* constant value, or address if static, or register number, ! 490: or offset in arguments, or offset in stack frame. */ ! 491: union ! 492: { ! 493: long value; ! 494: struct block *block; /* for LOC_BLOCK */ ! 495: char *bytes; /* for LOC_CONST_BYTES */ ! 496: } ! 497: value; ! 498: }; ! 499: ! 500: /* Source-file information. ! 501: This describes the relation between source files and line numbers ! 502: and addresses in the program text. */ ! 503: ! 504: struct sourcevector ! 505: { ! 506: int length; /* Number of source files described */ ! 507: struct source *source[1]; /* Descriptions of the files */ ! 508: }; ! 509: ! 510: /* Each item is either minus a line number, or a program counter. ! 511: If it represents a line number, that is the line described by the next ! 512: program counter value. If it is positive, it is the program ! 513: counter at which the code for the next line starts. ! 514: ! 515: Consecutive lines can be recorded by program counter entries ! 516: with no line number entries between them. Line number entries ! 517: are used when there are lines to skip with no code on them. ! 518: This is to make the table shorter. */ ! 519: ! 520: struct linetable ! 521: { ! 522: int nitems; ! 523: int item[1]; ! 524: }; ! 525: ! 526: /* All the information on one source file. */ ! 527: ! 528: struct source ! 529: { ! 530: char *name; /* Name of file */ ! 531: struct linetable contents; ! 532: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.