1 /* Definitions for symbol file management in GDB.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2007, 2008, 2009 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program 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 3 of the License, or
11 (at your option) any later version.
13 This program 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.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #if !defined (OBJFILES_H)
24 #include "gdb_obstack.h" /* For obstack internals. */
25 #include "symfile.h" /* For struct psymbol_allocation_list */
26 #include "progspace.h"
33 /* This structure maintains information on a per-objfile basis about the
34 "entry point" of the objfile, and the scope within which the entry point
35 exists. It is possible that gdb will see more than one objfile that is
36 executable, each with its own entry point.
38 For example, for dynamically linked executables in SVR4, the dynamic linker
39 code is contained within the shared C library, which is actually executable
40 and is run by the kernel first when an exec is done of a user executable
41 that is dynamically linked. The dynamic linker within the shared C library
42 then maps in the various program segments in the user executable and jumps
43 to the user executable's recorded entry point, as if the call had been made
44 directly by the kernel.
46 The traditional gdb method of using this info was to use the
47 recorded entry point to set the entry-file's lowpc and highpc from
48 the debugging information, where these values are the starting
49 address (inclusive) and ending address (exclusive) of the
50 instruction space in the executable which correspond to the
51 "startup file", I.E. crt0.o in most cases. This file is assumed to
52 be a startup file and frames with pc's inside it are treated as
53 nonexistent. Setting these variables is necessary so that
54 backtraces do not fly off the bottom of the stack.
56 NOTE: cagney/2003-09-09: It turns out that this "traditional"
57 method doesn't work. Corinna writes: ``It turns out that the call
58 to test for "inside entry file" destroys a meaningful backtrace
59 under some conditions. E. g. the backtrace tests in the asm-source
60 testcase are broken for some targets. In this test the functions
61 are all implemented as part of one file and the testcase is not
62 necessarily linked with a start file (depending on the target).
63 What happens is, that the first frame is printed normaly and
64 following frames are treated as being inside the enttry file then.
65 This way, only the #0 frame is printed in the backtrace output.''
66 Ref "frame.c" "NOTE: vinschen/2003-04-01".
68 Gdb also supports an alternate method to avoid running off the bottom
71 There are two frames that are "special", the frame for the function
72 containing the process entry point, since it has no predecessor frame,
73 and the frame for the function containing the user code entry point
74 (the main() function), since all the predecessor frames are for the
75 process startup code. Since we have no guarantee that the linked
76 in startup modules have any debugging information that gdb can use,
77 we need to avoid following frame pointers back into frames that might
78 have been built in the startup code, as we might get hopelessly
79 confused. However, we almost always have debugging information
82 These variables are used to save the range of PC values which are
83 valid within the main() function and within the function containing
84 the process entry point. If we always consider the frame for
85 main() as the outermost frame when debugging user code, and the
86 frame for the process entry point function as the outermost frame
87 when debugging startup code, then all we have to do is have
88 DEPRECATED_FRAME_CHAIN_VALID return false whenever a frame's
89 current PC is within the range specified by these variables. In
90 essence, we set "ceilings" in the frame chain beyond which we will
91 not proceed when following the frame chain back up the stack.
93 A nice side effect is that we can still debug startup code without
94 running off the end of the frame chain, assuming that we have usable
95 debugging information in the startup modules, and if we choose to not
96 use the block at main, or can't find it for some reason, everything
97 still works as before. And if we have no startup code debugging
98 information but we do have usable information for main(), backtraces
99 from user code don't go wandering off into the startup code. */
104 /* The value we should use for this objects entry point.
105 The illegal/unknown value needs to be something other than 0, ~0
106 for instance, which is much less likely than 0. */
108 CORE_ADDR entry_point
;
110 #define INVALID_ENTRY_POINT (~0) /* ~0 will not be in any file, we hope. */
114 /* Sections in an objfile. The section offsets are stored in the
119 struct bfd_section
*the_bfd_section
; /* BFD section pointer */
121 /* Objfile this section is part of. */
122 struct objfile
*objfile
;
124 /* True if this "overlay section" is mapped into an "overlay region". */
128 /* Relocation offset applied to S. */
129 #define obj_section_offset(s) \
130 (((s)->objfile->section_offsets)->offsets[(s)->the_bfd_section->index])
132 /* The memory address of section S (vma + offset). */
133 #define obj_section_addr(s) \
134 (bfd_get_section_vma ((s)->objfile->abfd, s->the_bfd_section) \
135 + obj_section_offset (s))
137 /* The one-passed-the-end memory address of section S
138 (vma + size + offset). */
139 #define obj_section_endaddr(s) \
140 (bfd_get_section_vma ((s)->objfile->abfd, s->the_bfd_section) \
141 + bfd_get_section_size ((s)->the_bfd_section) \
142 + obj_section_offset (s))
144 /* The "objstats" structure provides a place for gdb to record some
145 interesting information about its internal state at runtime, on a
146 per objfile basis, such as information about the number of symbols
147 read, size of string table (if any), etc. */
151 int n_minsyms
; /* Number of minimal symbols read */
152 int n_psyms
; /* Number of partial symbols read */
153 int n_syms
; /* Number of full symbols read */
154 int n_stabs
; /* Number of ".stabs" read (if applicable) */
155 int n_types
; /* Number of types */
156 int sz_strtab
; /* Size of stringtable, (if applicable) */
159 #define OBJSTAT(objfile, expr) (objfile -> stats.expr)
160 #define OBJSTATS struct objstats stats
161 extern void print_objfile_statistics (void);
162 extern void print_symbol_bcache_statistics (void);
164 /* Number of entries in the minimal symbol hash table. */
165 #define MINIMAL_SYMBOL_HASH_SIZE 2039
167 /* Master structure for keeping track of each file from which
168 gdb reads symbols. There are several ways these get allocated: 1.
169 The main symbol file, symfile_objfile, set by the symbol-file command,
170 2. Additional symbol files added by the add-symbol-file command,
171 3. Shared library objfiles, added by ADD_SOLIB, 4. symbol files
172 for modules that were loaded when GDB attached to a remote system
173 (see remote-vx.c). */
178 /* All struct objfile's are chained together by their next pointers.
179 The global variable "object_files" points to the first link in this
182 FIXME: There is a problem here if the objfile is reusable, and if
183 multiple users are to be supported. The problem is that the objfile
184 list is linked through a member of the objfile struct itself, which
185 is only valid for one gdb process. The list implementation needs to
186 be changed to something like:
188 struct list {struct list *next; struct objfile *objfile};
190 where the list structure is completely maintained separately within
193 struct objfile
*next
;
195 /* The object file's name, tilde-expanded and absolute.
196 Malloc'd; free it if you free this struct. */
200 /* Some flag bits for this objfile. */
202 unsigned short flags
;
204 /* The program space associated with this objfile. */
206 struct program_space
*pspace
;
208 /* Each objfile points to a linked list of symtabs derived from this file,
209 one symtab structure for each compilation unit (source file). Each link
210 in the symtab list contains a backpointer to this objfile. */
212 struct symtab
*symtabs
;
214 /* Each objfile points to a linked list of partial symtabs derived from
215 this file, one partial symtab structure for each compilation unit
218 struct partial_symtab
*psymtabs
;
220 /* Map addresses to the entries of PSYMTABS. It would be more efficient to
221 have a map per the whole process but ADDRMAP cannot selectively remove
222 its items during FREE_OBJFILE. This mapping is already present even for
223 PARTIAL_SYMTABs which still have no corresponding full SYMTABs read. */
225 struct addrmap
*psymtabs_addrmap
;
227 /* List of freed partial symtabs, available for re-use */
229 struct partial_symtab
*free_psymtabs
;
231 /* The object file's BFD. Can be null if the objfile contains only
232 minimal symbols, e.g. the run time common symbols for SunOS4. */
236 /* The gdbarch associated with the BFD. Note that this gdbarch is
237 determined solely from BFD information, without looking at target
238 information. The gdbarch determined from a running target may
239 differ from this e.g. with respect to register types and names. */
241 struct gdbarch
*gdbarch
;
243 /* The modification timestamp of the object file, as of the last time
244 we read its symbols. */
248 /* Obstack to hold objects that should be freed when we load a new symbol
249 table from this object file. */
251 struct obstack objfile_obstack
;
253 /* A byte cache where we can stash arbitrary "chunks" of bytes that
256 struct bcache
*psymbol_cache
; /* Byte cache for partial syms */
257 struct bcache
*macro_cache
; /* Byte cache for macros */
259 /* Hash table for mapping symbol names to demangled names. Each
260 entry in the hash table is actually two consecutive strings,
261 both null-terminated; the first one is a mangled or linkage
262 name, and the second is the demangled name or just a zero byte
263 if the name doesn't demangle. */
264 struct htab
*demangled_names_hash
;
266 /* Vectors of all partial symbols read in from file. The actual data
267 is stored in the objfile_obstack. */
269 struct psymbol_allocation_list global_psymbols
;
270 struct psymbol_allocation_list static_psymbols
;
272 /* Each file contains a pointer to an array of minimal symbols for all
273 global symbols that are defined within the file. The array is terminated
274 by a "null symbol", one that has a NULL pointer for the name and a zero
275 value for the address. This makes it easy to walk through the array
276 when passed a pointer to somewhere in the middle of it. There is also
277 a count of the number of symbols, which does not include the terminating
278 null symbol. The array itself, as well as all the data that it points
279 to, should be allocated on the objfile_obstack for this file. */
281 struct minimal_symbol
*msymbols
;
282 int minimal_symbol_count
;
284 /* This is a hash table used to index the minimal symbols by name. */
286 struct minimal_symbol
*msymbol_hash
[MINIMAL_SYMBOL_HASH_SIZE
];
288 /* This hash table is used to index the minimal symbols by their
291 struct minimal_symbol
*msymbol_demangled_hash
[MINIMAL_SYMBOL_HASH_SIZE
];
293 /* Structure which keeps track of functions that manipulate objfile's
294 of the same type as this objfile. I.E. the function to read partial
295 symbols for example. Note that this structure is in statically
296 allocated memory, and is shared by all objfiles that use the
297 object module reader of this type. */
301 /* The per-objfile information about the entry point, the scope (file/func)
302 containing the entry point, and the scope of the user's main() func. */
304 struct entry_info ei
;
306 /* Information about stabs. Will be filled in with a dbx_symfile_info
307 struct by those readers that need it. */
308 /* NOTE: cagney/2004-10-23: This has been replaced by per-objfile
309 data points implemented using "data" and "num_data" below. For
310 an example of how to use this replacement, see "objfile_data"
313 struct dbx_symfile_info
*deprecated_sym_stab_info
;
315 /* Hook for information for use by the symbol reader (currently used
316 for information shared by sym_init and sym_read). It is
317 typically a pointer to malloc'd memory. The symbol reader's finish
318 function is responsible for freeing the memory thusly allocated. */
319 /* NOTE: cagney/2004-10-23: This has been replaced by per-objfile
320 data points implemented using "data" and "num_data" below. For
321 an example of how to use this replacement, see "objfile_data"
324 void *deprecated_sym_private
;
326 /* Per objfile data-pointers required by other GDB modules. */
327 /* FIXME: kettenis/20030711: This mechanism could replace
328 deprecated_sym_stab_info and deprecated_sym_private
334 /* Set of relocation offsets to apply to each section.
335 Currently on the objfile_obstack (which makes no sense, but I'm
336 not sure it's harming anything).
338 These offsets indicate that all symbols (including partial and
339 minimal symbols) which have been read have been relocated by this
340 much. Symbols which are yet to be read need to be relocated by
343 struct section_offsets
*section_offsets
;
346 /* Indexes in the section_offsets array. These are initialized by the
347 *_symfile_offsets() family of functions (som_symfile_offsets,
348 xcoff_symfile_offsets, default_symfile_offsets). In theory they
349 should correspond to the section indexes used by bfd for the
350 current objfile. The exception to this for the time being is the
356 int sect_index_rodata
;
358 /* These pointers are used to locate the section table, which
359 among other things, is used to map pc addresses into sections.
360 SECTIONS points to the first entry in the table, and
361 SECTIONS_END points to the first location past the last entry
362 in the table. Currently the table is stored on the
363 objfile_obstack (which makes no sense, but I'm not sure it's
364 harming anything). */
367 *sections
, *sections_end
;
369 /* Link to objfile that contains the debug symbols for this one.
370 One is loaded if this file has an debug link to an existing
371 debug file with the right checksum */
372 struct objfile
*separate_debug_objfile
;
374 /* If this is a separate debug object, this is used as a link to the
375 actual executable objfile. */
376 struct objfile
*separate_debug_objfile_backlink
;
378 /* Place to stash various statistics about this objfile */
381 /* A symtab that the C++ code uses to stash special symbols
382 associated to namespaces. */
384 /* FIXME/carlton-2003-06-27: Delete this in a few years once
385 "possible namespace symbols" go away. */
386 struct symtab
*cp_namespace_symtab
;
389 /* Defines for the objfile flag word. */
391 /* When an object file has its functions reordered (currently Irix-5.2
392 shared libraries exhibit this behaviour), we will need an expensive
393 algorithm to locate a partial symtab or symtab via an address.
394 To avoid this penalty for normal object files, we use this flag,
395 whose setting is determined upon symbol table read in. */
397 #define OBJF_REORDERED (1 << 0) /* Functions are reordered */
399 /* Distinguish between an objfile for a shared library and a "vanilla"
400 objfile. (If not set, the objfile may still actually be a solib.
401 This can happen if the user created the objfile by using the
402 add-symbol-file command. GDB doesn't in that situation actually
403 check whether the file is a solib. Rather, the target's
404 implementation of the solib interface is responsible for setting
405 this flag when noticing solibs used by an inferior.) */
407 #define OBJF_SHARED (1 << 1) /* From a shared library */
409 /* User requested that this objfile be read in it's entirety. */
411 #define OBJF_READNOW (1 << 2) /* Immediate full read */
413 /* This objfile was created because the user explicitly caused it
414 (e.g., used the add-symbol-file command). This bit offers a way
415 for run_command to remove old objfile entries which are no longer
416 valid (i.e., are associated with an old inferior), but to preserve
417 ones that the user explicitly loaded via the add-symbol-file
420 #define OBJF_USERLOADED (1 << 3) /* User loaded */
422 /* The object file that contains the runtime common minimal symbols
423 for SunOS4. Note that this objfile has no associated BFD. */
425 extern struct objfile
*rt_common_objfile
;
427 /* When we need to allocate a new type, we need to know which objfile_obstack
428 to allocate the type on, since there is one for each objfile. The places
429 where types are allocated are deeply buried in function call hierarchies
430 which know nothing about objfiles, so rather than trying to pass a
431 particular objfile down to them, we just do an end run around them and
432 set current_objfile to be whatever objfile we expect to be using at the
433 time types are being allocated. For instance, when we start reading
434 symbols for a particular objfile, we set current_objfile to point to that
435 objfile, and when we are done, we set it back to NULL, to ensure that we
436 never put a type someplace other than where we are expecting to put it.
437 FIXME: Maybe we should review the entire type handling system and
438 see if there is a better way to avoid this problem. */
440 extern struct objfile
*current_objfile
;
442 /* Declarations for functions defined in objfiles.c */
444 extern struct objfile
*allocate_objfile (bfd
*, int);
446 extern struct gdbarch
*get_objfile_arch (struct objfile
*);
448 extern void init_entry_point_info (struct objfile
*);
450 extern CORE_ADDR
entry_point_address (void);
452 extern int build_objfile_section_table (struct objfile
*);
454 extern void terminate_minimal_symbol_table (struct objfile
*objfile
);
456 extern void put_objfile_before (struct objfile
*, struct objfile
*);
458 extern void objfile_to_front (struct objfile
*);
460 extern void unlink_objfile (struct objfile
*);
462 extern void free_objfile (struct objfile
*);
464 extern struct cleanup
*make_cleanup_free_objfile (struct objfile
*);
466 extern void free_all_objfiles (void);
468 extern void objfile_relocate (struct objfile
*, struct section_offsets
*);
470 extern int objfile_has_partial_symbols (struct objfile
*objfile
);
472 extern int objfile_has_full_symbols (struct objfile
*objfile
);
474 extern int objfile_has_symbols (struct objfile
*objfile
);
476 extern int have_partial_symbols (void);
478 extern int have_full_symbols (void);
480 extern void objfiles_changed (void);
482 /* This operation deletes all objfile entries that represent solibs that
483 weren't explicitly loaded by the user, via e.g., the add-symbol-file
486 extern void objfile_purge_solibs (void);
488 /* Functions for dealing with the minimal symbol table, really a misc
489 address<->symbol mapping for things we don't have debug symbols for. */
491 extern int have_minimal_symbols (void);
493 extern struct obj_section
*find_pc_section (CORE_ADDR pc
);
495 extern int in_plt_section (CORE_ADDR
, char *);
497 /* Keep a registry of per-objfile data-pointers required by other GDB
500 /* Allocate an entry in the per-objfile registry. */
501 extern const struct objfile_data
*register_objfile_data (void);
503 /* Allocate an entry in the per-objfile registry.
504 SAVE and FREE are called when clearing objfile data.
505 First all registered SAVE functions are called.
506 Then all registered FREE functions are called.
507 Either or both of SAVE, FREE may be NULL. */
508 extern const struct objfile_data
*register_objfile_data_with_cleanup
509 (void (*save
) (struct objfile
*, void *),
510 void (*free
) (struct objfile
*, void *));
512 extern void clear_objfile_data (struct objfile
*objfile
);
513 extern void set_objfile_data (struct objfile
*objfile
,
514 const struct objfile_data
*data
, void *value
);
515 extern void *objfile_data (struct objfile
*objfile
,
516 const struct objfile_data
*data
);
518 extern struct bfd
*gdb_bfd_ref (struct bfd
*abfd
);
519 extern void gdb_bfd_unref (struct bfd
*abfd
);
522 /* Traverse all object files in the current program space.
523 ALL_OBJFILES_SAFE works even if you delete the objfile during the
526 /* Traverse all object files in program space SS. */
528 #define ALL_PSPACE_OBJFILES(ss, obj) \
529 for ((obj) = ss->objfiles; (obj) != NULL; (obj) = (obj)->next) \
531 #define ALL_PSPACE_OBJFILES_SAFE(ss, obj, nxt) \
532 for ((obj) = ss->objfiles; \
533 (obj) != NULL? ((nxt)=(obj)->next,1) :0; \
536 #define ALL_OBJFILES(obj) \
537 for ((obj) = current_program_space->objfiles; \
541 #define ALL_OBJFILES_SAFE(obj,nxt) \
542 for ((obj) = current_program_space->objfiles; \
543 (obj) != NULL? ((nxt)=(obj)->next,1) :0; \
546 /* Traverse all symtabs in one objfile. */
548 #define ALL_OBJFILE_SYMTABS(objfile, s) \
549 for ((s) = (objfile) -> symtabs; (s) != NULL; (s) = (s) -> next)
551 /* Traverse all psymtabs in one objfile. */
553 #define ALL_OBJFILE_PSYMTABS(objfile, p) \
554 for ((p) = (objfile) -> psymtabs; (p) != NULL; (p) = (p) -> next)
556 /* Traverse all minimal symbols in one objfile. */
558 #define ALL_OBJFILE_MSYMBOLS(objfile, m) \
559 for ((m) = (objfile) -> msymbols; SYMBOL_LINKAGE_NAME(m) != NULL; (m)++)
561 /* Traverse all symtabs in all objfiles in the current symbol
564 #define ALL_SYMTABS(objfile, s) \
565 ALL_OBJFILES (objfile) \
566 ALL_OBJFILE_SYMTABS (objfile, s)
568 #define ALL_PSPACE_SYMTABS(ss, objfile, s) \
569 ALL_PSPACE_OBJFILES (ss, objfile) \
570 ALL_OBJFILE_SYMTABS (objfile, s)
572 /* Traverse all symtabs in all objfiles in the current program space,
573 skipping included files (which share a blockvector with their
576 #define ALL_PRIMARY_SYMTABS(objfile, s) \
577 ALL_OBJFILES (objfile) \
578 ALL_OBJFILE_SYMTABS (objfile, s) \
581 #define ALL_PSPACE_PRIMARY_SYMTABS(pspace, objfile, s) \
582 ALL_PSPACE_OBJFILES (ss, objfile) \
583 ALL_OBJFILE_SYMTABS (objfile, s) \
586 /* Traverse all psymtabs in all objfiles in the current symbol
589 #define ALL_PSYMTABS(objfile, p) \
590 ALL_OBJFILES (objfile) \
591 ALL_OBJFILE_PSYMTABS (objfile, p)
593 #define ALL_PSPACE_PSYMTABS(ss, objfile, p) \
594 ALL_PSPACE_OBJFILES (ss, objfile) \
595 ALL_OBJFILE_PSYMTABS (objfile, p)
597 /* Traverse all minimal symbols in all objfiles in the current symbol
600 #define ALL_MSYMBOLS(objfile, m) \
601 ALL_OBJFILES (objfile) \
602 ALL_OBJFILE_MSYMBOLS (objfile, m)
604 #define ALL_OBJFILE_OSECTIONS(objfile, osect) \
605 for (osect = objfile->sections; osect < objfile->sections_end; osect++)
607 #define ALL_OBJSECTIONS(objfile, osect) \
608 ALL_OBJFILES (objfile) \
609 ALL_OBJFILE_OSECTIONS (objfile, osect)
611 #define SECT_OFF_DATA(objfile) \
612 ((objfile->sect_index_data == -1) \
613 ? (internal_error (__FILE__, __LINE__, _("sect_index_data not initialized")), -1) \
614 : objfile->sect_index_data)
616 #define SECT_OFF_RODATA(objfile) \
617 ((objfile->sect_index_rodata == -1) \
618 ? (internal_error (__FILE__, __LINE__, _("sect_index_rodata not initialized")), -1) \
619 : objfile->sect_index_rodata)
621 #define SECT_OFF_TEXT(objfile) \
622 ((objfile->sect_index_text == -1) \
623 ? (internal_error (__FILE__, __LINE__, _("sect_index_text not initialized")), -1) \
624 : objfile->sect_index_text)
626 /* Sometimes the .bss section is missing from the objfile, so we don't
627 want to die here. Let the users of SECT_OFF_BSS deal with an
628 uninitialized section index. */
629 #define SECT_OFF_BSS(objfile) (objfile)->sect_index_bss
631 /* Answer whether there is more than one object file loaded. */
633 #define MULTI_OBJFILE_P() (object_files && object_files->next)
635 #endif /* !defined (OBJFILES_H) */