![[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 [Research Unix] / researchv10dc / cmd / gcc|
Return to symseg.h CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 root 1: /* GDB symbol table format definitions.
2: Copyright (C) 1987, 1988 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU CC General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU CC, but only under the conditions described in the
15: GNU CC General Public License. A copy of this license is
16: supposed to have been given to you along with GNU CC so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
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: struct symbol_root
73: {
74: int format; /* Data format version */
75: int length; /* # bytes in this symbol segment */
76: int ldsymoff; /* Offset in ld symtab of this file's syms */
77: int textrel; /* Relocation for text addresses */
78: int datarel; /* Relocation for data addresses */
79: int bssrel; /* Relocation for bss addresses */
80: char *filename; /* Name of main source file compiled */
81: char *filedir; /* Name of directory it was reached from */
82: struct blockvector *blockvector; /* Vector of all symbol-naming blocks */
83: struct typevector *typevector; /* Vector of all data types */
84: enum language language; /* Code identifying the language used */
85: char *version; /* Version info. Not fully specified */
86: char *compilation; /* Compilation info. Not fully specified */
87: int databeg; /* Address within the file of data start */
88: int bssbeg; /* Address within the file of bss start */
89: struct sourcevector *sourcevector; /* Vector of line-number info */
90: };
91:
92: /* All data types of symbols in the compiled program
93: are represented by `struct type' objects.
94: All of these objects are pointed to by the typevector.
95: The type vector may have empty slots that contain zero. */
96:
97: struct typevector
98: {
99: int length; /* Number of types described */
100: struct type *type[1];
101: };
102:
103: /* Different kinds of data types are distinguished by the `code' field. */
104:
105: enum type_code
106: {
107: TYPE_CODE_UNDEF, /* Not used; catches errors */
108: TYPE_CODE_PTR, /* Pointer type */
109: TYPE_CODE_ARRAY, /* Array type, lower bound zero */
110: TYPE_CODE_STRUCT, /* C struct or Pascal record */
111: TYPE_CODE_UNION, /* C union or Pascal variant part */
112: TYPE_CODE_ENUM, /* Enumeration type */
113: TYPE_CODE_FUNC, /* Function type */
114: TYPE_CODE_INT, /* Integer type */
115: TYPE_CODE_FLT, /* Floating type */
116: TYPE_CODE_VOID, /* Void type (values zero length) */
117: TYPE_CODE_SET, /* Pascal sets */
118: TYPE_CODE_RANGE, /* Range (integers within spec'd bounds) */
119: TYPE_CODE_PASCAL_ARRAY, /* Array with explicit type of index */
120: };
121:
122: /* This appears in a type's flags word for an unsigned integer type. */
123: #define TYPE_FLAG_UNSIGNED 1
124:
125: /* Other flag bits are used with GDB. */
126:
127: struct type
128: {
129: /* Code for kind of type */
130: enum type_code code;
131: /* Name of this type, or zero if none.
132: This is used for printing only.
133: Type names specified as input are defined by symbols. */
134: char *name;
135: /* Length in bytes of storage for a value of this type */
136: int length;
137: /* For a pointer type, describes the type of object pointed to.
138: For an array type, describes the type of the elements.
139: For a function type, describes the type of the value.
140: Unused otherwise. */
141: struct type *target_type;
142: /* Type that is a pointer to this type.
143: Zero if no such pointer-to type is known yet.
144: The debugger may add the address of such a type
145: if it has to construct one later. */
146: struct type *pointer_type;
147: /* Type that is a function returning this type.
148: Zero if no such function type is known here.
149: The debugger may add the address of such a type
150: if it has to construct one later. */
151: struct type *function_type;
152: /* Flags about this type. */
153: short flags;
154: /* Number of fields described for this type */
155: short nfields;
156: /* For structure and union types, a description of each field.
157: For set and pascal array types, there is one "field",
158: whose type is the domain type of the set or array.
159: For range types, there are two "fields",
160: the minimum and maximum values (both inclusive).
161: For enum types, each possible value is described by one "field".
162: For range types, there are two "fields", that record constant values
163: (inclusive) for the minimum and maximum.
164:
165: Using a pointer to a separate array of fields
166: allows all types to have the same size, which is useful
167: because we can allocate the space for a type before
168: we know what to put in it. */
169: struct field
170: {
171: /* Position of this field, counting in bits from start of
172: containing structure. For a function type, this is the
173: position in the argument list of this argument.
174: For a range bound or enum value, this is the value itself. */
175: int bitpos;
176: /* Size of this field, in bits, or zero if not packed.
177: For an unpacked field, the field's type's length
178: says how many bytes the field occupies. */
179: int bitsize;
180: /* In a struct or enum type, type of this field.
181: In a function type, type of this argument.
182: In an array type, the domain-type of the array. */
183: struct type *type;
184: /* Name of field, value or argument.
185: Zero for range bounds and array domains. */
186: char *name;
187: } *fields;
188: };
189:
190: /* All of the name-scope contours of the program
191: are represented by `struct block' objects.
192: All of these objects are pointed to by the blockvector.
193:
194: Each block represents one name scope.
195: Each lexical context has its own block.
196:
197: The first two blocks in the blockvector are special.
198: The first one contains all the symbols defined in this compilation
199: whose scope is the entire program linked together.
200: The second one contains all the symbols whose scope is the
201: entire compilation excluding other separate compilations.
202: In C, these correspond to global symbols and static symbols.
203:
204: Each block records a range of core addresses for the code that
205: is in the scope of the block. The first two special blocks
206: give, for the range of code, the entire range of code produced
207: by the compilation that the symbol segment belongs to.
208:
209: The blocks appear in the blockvector
210: in order of increasing starting-address,
211: and, within that, in order of decreasing ending-address.
212:
213: This implies that within the body of one function
214: the blocks appear in the order of a depth-first tree walk. */
215:
216: struct blockvector
217: {
218: /* Number of blocks in the list. */
219: int nblocks;
220: /* The blocks themselves. */
221: struct block *block[1];
222: };
223:
224: struct block
225: {
226: /* Addresses in the executable code that are in this block.
227: Note: in an unrelocated symbol segment in a file,
228: these are always zero. They can be filled in from the
229: N_LBRAC and N_RBRAC symbols in the loader symbol table. */
230: int startaddr, endaddr;
231: /* The symbol that names this block,
232: if the block is the body of a function;
233: otherwise, zero.
234: Note: In an unrelocated symbol segment in an object file,
235: this field may be zero even when the block has a name.
236: That is because the block is output before the name
237: (since the name resides in a higher block).
238: Since the symbol does point to the block (as its value),
239: it is possible to find the block and set its name properly. */
240: struct symbol *function;
241: /* The `struct block' for the containing block, or 0 if none. */
242: /* Note that in an unrelocated symbol segment in an object file
243: this pointer may be zero when the correct value should be
244: the second special block (for symbols whose scope is one compilation).
245: This is because the compiler ouptuts the special blocks at the
246: very end, after the other blocks. */
247: struct block *superblock;
248: /* Number of local symbols. */
249: int nsyms;
250: /* The symbols. */
251: struct symbol *sym[1];
252: };
253:
254: /* Represent one symbol name; a variable, constant, function or typedef. */
255:
256: /* Different name spaces for symbols. Looking up a symbol specifies
257: a namespace and ignores symbol definitions in other name spaces.
258:
259: VAR_NAMESPACE is the usual namespace.
260: In C, this contains variables, function names, typedef names
261: and enum type values.
262:
263: STRUCT_NAMESPACE is used in C to hold struct, union and enum type names.
264: Thus, if `struct foo' is used in a C program,
265: it produces a symbol named `foo' in the STRUCT_NAMESPACE.
266:
267: LABEL_NAMESPACE may be used for names of labels (for gotos);
268: currently it is not used and labels are not recorded at all. */
269:
270: /* For a non-global symbol allocated statically,
271: the correct core address cannot be determined by the compiler.
272: The compiler puts an index number into the symbol's value field.
273: This index number can be matched with the "desc" field of
274: an entry in the loader symbol table. */
275:
276: enum namespace
277: {
278: UNDEF_NAMESPACE, VAR_NAMESPACE, STRUCT_NAMESPACE, LABEL_NAMESPACE,
279: };
280:
281: /* An address-class says where to find the value of the symbol in core. */
282:
283: enum address_class
284: {
285: LOC_UNDEF, /* Not used; catches errors */
286: LOC_CONST, /* Value is constant int */
287: LOC_STATIC, /* Value is at fixed address */
288: LOC_REGISTER, /* Value is in register */
289: LOC_ARG, /* Value is at spec'd position in arglist */
290: LOC_LOCAL, /* Value is at spec'd pos in stack frame */
291: LOC_TYPEDEF, /* Value not used; definition in SYMBOL_TYPE
292: Symbols in the namespace STRUCT_NAMESPACE
293: all have this class. */
294: LOC_LABEL, /* Value is address in the code */
295: LOC_BLOCK, /* Value is address of a `struct block'.
296: Function names have this class. */
297: LOC_EXTERNAL, /* Value is at address not in this compilation.
298: This is used for .comm symbols
299: and for extern symbols within functions.
300: Inside GDB, this is changed to LOC_STATIC once the
301: real address is obtained from a loader symbol. */
302: LOC_CONST_BYTES /* Value is a constant byte-sequence. */
303: };
304:
305: struct symbol
306: {
307: /* Symbol name */
308: char *name;
309: /* Name space code. */
310: enum namespace namespace;
311: /* Address class */
312: enum address_class class;
313: /* Data type of value */
314: struct type *type;
315: /* constant value, or address if static, or register number,
316: or offset in arguments, or offset in stack frame. */
317: union
318: {
319: long value;
320: struct block *block; /* for LOC_BLOCK */
321: char *bytes; /* for LOC_CONST_BYTES */
322: }
323: value;
324: };
325:
326: /* Source-file information.
327: This describes the relation between source files and line numbers
328: and addresses in the program text. */
329:
330: struct sourcevector
331: {
332: int length; /* Number of source files described */
333: struct source *source[1]; /* Descriptions of the files */
334: };
335:
336: /* Line number and address of one line. */
337:
338: struct line
339: {
340: int linenum;
341: int address;
342: };
343:
344: /* All the information on one source file. */
345:
346: struct source
347: {
348: char *name; /* Name of file */
349: int nlines; /* Number of lines that follow */
350: struct line lines[1]; /* Information on each line */
351: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.