GDB (xrefs)
/tmp/gdb-7.10/gdb/objfiles.h
Go to the documentation of this file.
1 /* Definitions for symbol file management in GDB.
2 
3  Copyright (C) 1992-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #if !defined (OBJFILES_H)
21 #define OBJFILES_H
22 
23 #include "gdb_obstack.h" /* For obstack internals. */
24 #include "symfile.h" /* For struct psymbol_allocation_list. */
25 #include "progspace.h"
26 #include "registry.h"
27 #include "gdb_bfd.h"
28 
29 struct bcache;
30 struct htab;
31 struct objfile_data;
32 
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.
37 
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.
45 
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.
55 
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".
67 
68  Gdb also supports an alternate method to avoid running off the bottom
69  of the stack.
70 
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
80  available for main().
81 
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.
92 
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. */
100 
102  {
103  /* The unrelocated value we should use for this objfile entry point. */
105 
106  /* The index of the section in which the entry point appears. */
108 
109  /* Set to 1 iff ENTRY_POINT contains a valid value. */
110  unsigned entry_point_p : 1;
111 
112  /* Set to 1 iff this object was initialized. */
113  unsigned initialized : 1;
114  };
115 
116 /* Sections in an objfile. The section offsets are stored in the
117  OBJFILE. */
118 
120  {
121  struct bfd_section *the_bfd_section; /* BFD section pointer */
122 
123  /* Objfile this section is part of. */
124  struct objfile *objfile;
125 
126  /* True if this "overlay section" is mapped into an "overlay region". */
128  };
129 
130 /* Relocation offset applied to S. */
131 #define obj_section_offset(s) \
132  (((s)->objfile->section_offsets)->offsets[gdb_bfd_section_index ((s)->objfile->obfd, (s)->the_bfd_section)])
133 
134 /* The memory address of section S (vma + offset). */
135 #define obj_section_addr(s) \
136  (bfd_get_section_vma ((s)->objfile->obfd, s->the_bfd_section) \
137  + obj_section_offset (s))
138 
139 /* The one-passed-the-end memory address of section S
140  (vma + size + offset). */
141 #define obj_section_endaddr(s) \
142  (bfd_get_section_vma ((s)->objfile->obfd, s->the_bfd_section) \
143  + bfd_get_section_size ((s)->the_bfd_section) \
144  + obj_section_offset (s))
145 
146 /* The "objstats" structure provides a place for gdb to record some
147  interesting information about its internal state at runtime, on a
148  per objfile basis, such as information about the number of symbols
149  read, size of string table (if any), etc. */
150 
151 struct objstats
152  {
153  int n_psyms; /* Number of partial symbols read */
154  int n_syms; /* Number of full symbols read */
155  int n_stabs; /* Number of ".stabs" read (if applicable) */
156  int n_types; /* Number of types */
157  int sz_strtab; /* Size of stringtable, (if applicable) */
158  };
159 
160 #define OBJSTAT(objfile, expr) (objfile -> stats.expr)
161 #define OBJSTATS struct objstats stats
162 extern void print_objfile_statistics (void);
163 extern void print_symbol_bcache_statistics (void);
164 
165 /* Number of entries in the minimal symbol hash table. */
166 #define MINIMAL_SYMBOL_HASH_SIZE 2039
167 
168 /* Some objfile data is hung off the BFD. This enables sharing of the
169  data across all objfiles using the BFD. The data is stored in an
170  instance of this structure, and associated with the BFD using the
171  registry system. */
172 
174 {
175  /* The storage has an obstack of its own. */
176 
177  struct obstack storage_obstack;
178 
179  /* Byte cache for file names. */
180 
182 
183  /* Byte cache for macros. */
185 
186  /* The gdbarch associated with the BFD. Note that this gdbarch is
187  determined solely from BFD information, without looking at target
188  information. The gdbarch determined from a running target may
189  differ from this e.g. with respect to register types and names. */
190 
191  struct gdbarch *gdbarch;
192 
193  /* Hash table for mapping symbol names to demangled names. Each
194  entry in the hash table is actually two consecutive strings,
195  both null-terminated; the first one is a mangled or linkage
196  name, and the second is the demangled name or just a zero byte
197  if the name doesn't demangle. */
198  struct htab *demangled_names_hash;
199 
200  /* The per-objfile information about the entry point, the scope (file/func)
201  containing the entry point, and the scope of the user's main() func. */
202 
203  struct entry_info ei;
204 
205  /* The name and language of any "main" found in this objfile. The
206  name can be NULL, which means that the information was not
207  recorded. */
208 
209  const char *name_of_main;
211 
212  /* Each file contains a pointer to an array of minimal symbols for all
213  global symbols that are defined within the file. The array is
214  terminated by a "null symbol", one that has a NULL pointer for the
215  name and a zero value for the address. This makes it easy to walk
216  through the array when passed a pointer to somewhere in the middle
217  of it. There is also a count of the number of symbols, which does
218  not include the terminating null symbol. The array itself, as well
219  as all the data that it points to, should be allocated on the
220  objfile_obstack for this file. */
221 
224 
225  /* The number of minimal symbols read, before any minimal symbol
226  de-duplication is applied. Note in particular that this has only
227  a passing relationship with the actual size of the table above;
228  use minimal_symbol_count if you need the true size. */
230 
231  /* This is true if minimal symbols have already been read. Symbol
232  readers can use this to bypass minimal symbol reading. Also, the
233  minimal symbol table management code in minsyms.c uses this to
234  suppress new minimal symbols. You might think that MSYMBOLS or
235  MINIMAL_SYMBOL_COUNT could be used for this, but it is possible
236  for multiple readers to install minimal symbols into a given
237  per-BFD. */
238 
239  unsigned int minsyms_read : 1;
240 
241  /* This is a hash table used to index the minimal symbols by name. */
242 
244 
245  /* This hash table is used to index the minimal symbols by their
246  demangled names. */
247 
249 };
250 
251 /* Master structure for keeping track of each file from which
252  gdb reads symbols. There are several ways these get allocated: 1.
253  The main symbol file, symfile_objfile, set by the symbol-file command,
254  2. Additional symbol files added by the add-symbol-file command,
255  3. Shared library objfiles, added by ADD_SOLIB, 4. symbol files
256  for modules that were loaded when GDB attached to a remote system
257  (see remote-vx.c). */
258 
259 struct objfile
260  {
261 
262  /* All struct objfile's are chained together by their next pointers.
263  The program space field "objfiles" (frequently referenced via
264  the macro "object_files") points to the first link in this
265  chain. */
266 
267  struct objfile *next;
268 
269  /* The object file's original name as specified by the user,
270  made absolute, and tilde-expanded. However, it is not canonicalized
271  (i.e., it has not been passed through gdb_realpath).
272  This pointer is never NULL. This does not have to be freed; it is
273  guaranteed to have a lifetime at least as long as the objfile. */
274 
276 
278 
279  /* Some flag bits for this objfile.
280  The values are defined by OBJF_*. */
281 
282  unsigned short flags;
283 
284  /* The program space associated with this objfile. */
285 
287 
288  /* List of compunits.
289  These are used to do symbol lookups and file/line-number lookups. */
290 
292 
293  /* Each objfile points to a linked list of partial symtabs derived from
294  this file, one partial symtab structure for each compilation unit
295  (source file). */
296 
298 
299  /* Map addresses to the entries of PSYMTABS. It would be more efficient to
300  have a map per the whole process but ADDRMAP cannot selectively remove
301  its items during FREE_OBJFILE. This mapping is already present even for
302  PARTIAL_SYMTABs which still have no corresponding full SYMTABs read. */
303 
305 
306  /* List of freed partial symtabs, available for re-use. */
307 
309 
310  /* The object file's BFD. Can be null if the objfile contains only
311  minimal symbols, e.g. the run time common symbols for SunOS4. */
312 
313  bfd *obfd;
314 
315  /* The per-BFD data. Note that this is treated specially if OBFD
316  is NULL. */
317 
319 
320  /* The modification timestamp of the object file, as of the last time
321  we read its symbols. */
322 
323  long mtime;
324 
325  /* Obstack to hold objects that should be freed when we load a new symbol
326  table from this object file. */
327 
328  struct obstack objfile_obstack;
329 
330  /* A byte cache where we can stash arbitrary "chunks" of bytes that
331  will not change. */
332 
333  struct psymbol_bcache *psymbol_cache; /* Byte cache for partial syms. */
334 
335  /* Vectors of all partial symbols read in from file. The actual data
336  is stored in the objfile_obstack. */
337 
340 
341  /* Structure which keeps track of functions that manipulate objfile's
342  of the same type as this objfile. I.e. the function to read partial
343  symbols for example. Note that this structure is in statically
344  allocated memory, and is shared by all objfiles that use the
345  object module reader of this type. */
346 
347  const struct sym_fns *sf;
348 
349  /* Per objfile data-pointers required by other GDB modules. */
350 
352 
353  /* Set of relocation offsets to apply to each section.
354  The table is indexed by the_bfd_section->index, thus it is generally
355  as large as the number of sections in the binary.
356  The table is stored on the objfile_obstack.
357 
358  These offsets indicate that all symbols (including partial and
359  minimal symbols) which have been read have been relocated by this
360  much. Symbols which are yet to be read need to be relocated by it. */
361 
364 
365  /* Indexes in the section_offsets array. These are initialized by the
366  *_symfile_offsets() family of functions (som_symfile_offsets,
367  xcoff_symfile_offsets, default_symfile_offsets). In theory they
368  should correspond to the section indexes used by bfd for the
369  current objfile. The exception to this for the time being is the
370  SOM version. */
371 
376 
377  /* These pointers are used to locate the section table, which
378  among other things, is used to map pc addresses into sections.
379  SECTIONS points to the first entry in the table, and
380  SECTIONS_END points to the first location past the last entry
381  in the table. The table is stored on the objfile_obstack. The
382  sections are indexed by the BFD section index; but the
383  structure data is only valid for certain sections
384  (e.g. non-empty, SEC_ALLOC). */
385 
387 
388  /* GDB allows to have debug symbols in separate object files. This is
389  used by .gnu_debuglink, ELF build id note and Mach-O OSO.
390  Although this is a tree structure, GDB only support one level
391  (ie a separate debug for a separate debug is not supported). Note that
392  separate debug object are in the main chain and therefore will be
393  visited by ALL_OBJFILES & co iterators. Separate debug objfile always
394  has a non-nul separate_debug_objfile_backlink. */
395 
396  /* Link to the first separate debug object, if any. */
398 
399  /* If this is a separate debug object, this is used as a link to the
400  actual executable objfile. */
402 
403  /* If this is a separate debug object, this is a link to the next one
404  for the same executable objfile. */
406 
407  /* Place to stash various statistics about this objfile. */
409 
410  /* A linked list of symbols created when reading template types or
411  function templates. These symbols are not stored in any symbol
412  table, so we have to keep them here to relocate them
413  properly. */
415  };
416 
417 /* Defines for the objfile flag word. */
418 
419 /* When an object file has its functions reordered (currently Irix-5.2
420  shared libraries exhibit this behaviour), we will need an expensive
421  algorithm to locate a partial symtab or symtab via an address.
422  To avoid this penalty for normal object files, we use this flag,
423  whose setting is determined upon symbol table read in. */
424 
425 #define OBJF_REORDERED (1 << 0) /* Functions are reordered */
426 
427 /* Distinguish between an objfile for a shared library and a "vanilla"
428  objfile. This may come from a target's implementation of the solib
429  interface, from add-symbol-file, or any other mechanism that loads
430  dynamic objects. */
431 
432 #define OBJF_SHARED (1 << 1) /* From a shared library */
433 
434 /* User requested that this objfile be read in it's entirety. */
435 
436 #define OBJF_READNOW (1 << 2) /* Immediate full read */
437 
438 /* This objfile was created because the user explicitly caused it
439  (e.g., used the add-symbol-file command). This bit offers a way
440  for run_command to remove old objfile entries which are no longer
441  valid (i.e., are associated with an old inferior), but to preserve
442  ones that the user explicitly loaded via the add-symbol-file
443  command. */
444 
445 #define OBJF_USERLOADED (1 << 3) /* User loaded */
446 
447 /* Set if we have tried to read partial symtabs for this objfile.
448  This is used to allow lazy reading of partial symtabs. */
449 
450 #define OBJF_PSYMTABS_READ (1 << 4)
451 
452 /* Set if this is the main symbol file
453  (as opposed to symbol file for dynamically loaded code). */
454 
455 #define OBJF_MAINLINE (1 << 5)
456 
457 /* ORIGINAL_NAME and OBFD->FILENAME correspond to text description unrelated to
458  filesystem names. It can be for example "<image in memory>". */
459 
460 #define OBJF_NOT_FILENAME (1 << 6)
461 
462 /* Declarations for functions defined in objfiles.c */
463 
464 extern struct objfile *allocate_objfile (bfd *, const char *name, int);
465 
466 extern struct gdbarch *get_objfile_arch (const struct objfile *);
467 
468 extern int entry_point_address_query (CORE_ADDR *entry_p);
469 
470 extern CORE_ADDR entry_point_address (void);
471 
472 extern void build_objfile_section_table (struct objfile *);
473 
474 extern void terminate_minimal_symbol_table (struct objfile *objfile);
475 
476 extern struct objfile *objfile_separate_debug_iterate (const struct objfile *,
477  const struct objfile *);
478 
479 extern void put_objfile_before (struct objfile *, struct objfile *);
480 
481 extern void add_separate_debug_objfile (struct objfile *, struct objfile *);
482 
483 extern void unlink_objfile (struct objfile *);
484 
485 extern void free_objfile (struct objfile *);
486 
487 extern void free_objfile_separate_debug (struct objfile *);
488 
489 extern struct cleanup *make_cleanup_free_objfile (struct objfile *);
490 
491 extern void free_all_objfiles (void);
492 
493 extern void objfile_relocate (struct objfile *, const struct section_offsets *);
494 extern void objfile_rebase (struct objfile *, CORE_ADDR);
495 
496 extern int objfile_has_partial_symbols (struct objfile *objfile);
497 
498 extern int objfile_has_full_symbols (struct objfile *objfile);
499 
500 extern int objfile_has_symbols (struct objfile *objfile);
501 
502 extern int have_partial_symbols (void);
503 
504 extern int have_full_symbols (void);
505 
506 extern void objfile_set_sym_fns (struct objfile *objfile,
507  const struct sym_fns *sf);
508 
509 extern void objfiles_changed (void);
510 
511 extern int is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile);
512 
513 /* Return true if ADDRESS maps into one of the sections of a
514  OBJF_SHARED objfile of PSPACE and false otherwise. */
515 
516 extern int shared_objfile_contains_address_p (struct program_space *pspace,
517  CORE_ADDR address);
518 
519 /* This operation deletes all objfile entries that represent solibs that
520  weren't explicitly loaded by the user, via e.g., the add-symbol-file
521  command. */
522 
523 extern void objfile_purge_solibs (void);
524 
525 /* Functions for dealing with the minimal symbol table, really a misc
526  address<->symbol mapping for things we don't have debug symbols for. */
527 
528 extern int have_minimal_symbols (void);
529 
530 extern struct obj_section *find_pc_section (CORE_ADDR pc);
531 
532 /* Return non-zero if PC is in a section called NAME. */
533 extern int pc_in_section (CORE_ADDR, char *);
534 
535 /* Return non-zero if PC is in a SVR4-style procedure linkage table
536  section. */
537 
538 static inline int
540 {
541  return pc_in_section (pc, ".plt");
542 }
543 
544 /* Keep a registry of per-objfile data-pointers required by other GDB
545  modules. */
547 
548 /* In normal use, the section map will be rebuilt by find_pc_section
549  if objfiles have been added, removed or relocated since it was last
550  called. Calling inhibit_section_map_updates will inhibit this
551  behavior until resume_section_map_updates is called. If you call
552  inhibit_section_map_updates you must ensure that every call to
553  find_pc_section in the inhibited region relates to a section that
554  is already in the section map and has not since been removed or
555  relocated. */
556 extern void inhibit_section_map_updates (struct program_space *pspace);
557 
558 /* Resume automatically rebuilding the section map as required. */
559 extern void resume_section_map_updates (struct program_space *pspace);
560 
561 /* Version of the above suitable for use as a cleanup. */
562 extern void resume_section_map_updates_cleanup (void *arg);
563 
565  (struct gdbarch *gdbarch,
567  void *cb_data, struct objfile *current_objfile);
568 
569 
570 /* Traverse all object files in the current program space.
571  ALL_OBJFILES_SAFE works even if you delete the objfile during the
572  traversal. */
573 
574 /* Traverse all object files in program space SS. */
575 
576 #define ALL_PSPACE_OBJFILES(ss, obj) \
577  for ((obj) = ss->objfiles; (obj) != NULL; (obj) = (obj)->next)
578 
579 #define ALL_OBJFILES(obj) \
580  for ((obj) = current_program_space->objfiles; \
581  (obj) != NULL; \
582  (obj) = (obj)->next)
583 
584 #define ALL_OBJFILES_SAFE(obj,nxt) \
585  for ((obj) = current_program_space->objfiles; \
586  (obj) != NULL? ((nxt)=(obj)->next,1) :0; \
587  (obj) = (nxt))
588 
589 /* Traverse all symtabs in one objfile. */
590 
591 #define ALL_OBJFILE_FILETABS(objfile, cu, s) \
592  ALL_OBJFILE_COMPUNITS (objfile, cu) \
593  ALL_COMPUNIT_FILETABS (cu, s)
594 
595 /* Traverse all compunits in one objfile. */
596 
597 #define ALL_OBJFILE_COMPUNITS(objfile, cu) \
598  for ((cu) = (objfile) -> compunit_symtabs; (cu) != NULL; (cu) = (cu) -> next)
599 
600 /* Traverse all minimal symbols in one objfile. */
601 
602 #define ALL_OBJFILE_MSYMBOLS(objfile, m) \
603  for ((m) = (objfile)->per_bfd->msymbols; \
604  MSYMBOL_LINKAGE_NAME (m) != NULL; \
605  (m)++)
606 
607 /* Traverse all symtabs in all objfiles in the current symbol
608  space. */
609 
610 #define ALL_FILETABS(objfile, ps, s) \
611  ALL_OBJFILES (objfile) \
612  ALL_OBJFILE_FILETABS (objfile, ps, s)
613 
614 /* Traverse all compunits in all objfiles in the current program space. */
615 
616 #define ALL_COMPUNITS(objfile, cu) \
617  ALL_OBJFILES (objfile) \
618  ALL_OBJFILE_COMPUNITS (objfile, cu)
619 
620 /* Traverse all minimal symbols in all objfiles in the current symbol
621  space. */
622 
623 #define ALL_MSYMBOLS(objfile, m) \
624  ALL_OBJFILES (objfile) \
625  ALL_OBJFILE_MSYMBOLS (objfile, m)
626 
627 #define ALL_OBJFILE_OSECTIONS(objfile, osect) \
628  for (osect = objfile->sections; osect < objfile->sections_end; osect++) \
629  if (osect->the_bfd_section == NULL) \
630  { \
631  /* Nothing. */ \
632  } \
633  else
634 
635 /* Traverse all obj_sections in all objfiles in the current program
636  space.
637 
638  Note that this detects a "break" in the inner loop, and exits
639  immediately from the outer loop as well, thus, client code doesn't
640  need to know that this is implemented with a double for. The extra
641  hair is to make sure that a "break;" stops the outer loop iterating
642  as well, and both OBJFILE and OSECT are left unmodified:
643 
644  - The outer loop learns about the inner loop's end condition, and
645  stops iterating if it detects the inner loop didn't reach its
646  end. In other words, the outer loop keeps going only if the
647  inner loop reached its end cleanly [(osect) ==
648  (objfile)->sections_end].
649 
650  - OSECT is initialized in the outer loop initialization
651  expressions, such as if the inner loop has reached its end, so
652  the check mentioned above succeeds the first time.
653 
654  - The trick to not clearing OBJFILE on a "break;" is, in the outer
655  loop's loop expression, advance OBJFILE, but iff the inner loop
656  reached its end. If not, there was a "break;", so leave OBJFILE
657  as is; the outer loop's conditional will break immediately as
658  well (as OSECT will be different from OBJFILE->sections_end). */
659 
660 #define ALL_OBJSECTIONS(objfile, osect) \
661  for ((objfile) = current_program_space->objfiles, \
662  (objfile) != NULL ? ((osect) = (objfile)->sections_end) : 0; \
663  (objfile) != NULL \
664  && (osect) == (objfile)->sections_end; \
665  ((osect) == (objfile)->sections_end \
666  ? ((objfile) = (objfile)->next, \
667  (objfile) != NULL ? (osect) = (objfile)->sections_end : 0) \
668  : 0)) \
669  ALL_OBJFILE_OSECTIONS (objfile, osect)
670 
671 #define SECT_OFF_DATA(objfile) \
672  ((objfile->sect_index_data == -1) \
673  ? (internal_error (__FILE__, __LINE__, \
674  _("sect_index_data not initialized")), -1) \
675  : objfile->sect_index_data)
676 
677 #define SECT_OFF_RODATA(objfile) \
678  ((objfile->sect_index_rodata == -1) \
679  ? (internal_error (__FILE__, __LINE__, \
680  _("sect_index_rodata not initialized")), -1) \
681  : objfile->sect_index_rodata)
682 
683 #define SECT_OFF_TEXT(objfile) \
684  ((objfile->sect_index_text == -1) \
685  ? (internal_error (__FILE__, __LINE__, \
686  _("sect_index_text not initialized")), -1) \
687  : objfile->sect_index_text)
688 
689 /* Sometimes the .bss section is missing from the objfile, so we don't
690  want to die here. Let the users of SECT_OFF_BSS deal with an
691  uninitialized section index. */
692 #define SECT_OFF_BSS(objfile) (objfile)->sect_index_bss
693 
694 /* Answer whether there is more than one object file loaded. */
695 
696 #define MULTI_OBJFILE_P() (object_files && object_files->next)
697 
698 /* Reset the per-BFD storage area on OBJ. */
699 
700 void set_objfile_per_bfd (struct objfile *obj);
701 
702 /* Return canonical name for OBJFILE.
703  This is the real file name if the file has been opened.
704  Otherwise it is the original name supplied by the user. */
705 
706 const char *objfile_name (const struct objfile *objfile);
707 
708 /* Return the (real) file name of OBJFILE if the file has been opened,
709  otherwise return NULL. */
710 
711 const char *objfile_filename (const struct objfile *objfile);
712 
713 /* Return the name to print for OBJFILE in debugging messages. */
714 
715 extern const char *objfile_debug_name (const struct objfile *objfile);
716 
717 /* Set the objfile's notion of the "main" name and language. */
718 
719 extern void set_objfile_main_name (struct objfile *objfile,
720  const char *name, enum language lang);
721 
722 #endif /* !defined (OBJFILES_H) */
int sect_index_text
Definition: objfiles.h:372
struct psymbol_allocation_list static_psymbols
Definition: objfiles.h:339
struct entry_info ei
Definition: objfiles.h:203
struct minimal_symbol * msymbols
Definition: objfiles.h:222
void build_objfile_section_table(struct objfile *)
Definition: objfiles.c:243
struct htab * demangled_names_hash
Definition: objfiles.h:198
void objfile_set_sym_fns(struct objfile *objfile, const struct sym_fns *sf)
bfd * obfd
Definition: objfiles.h:313
void objfile_purge_solibs(void)
Definition: objfiles.c:1000
struct obstack storage_obstack
Definition: objfiles.h:177
struct objfile * allocate_objfile(bfd *, const char *name, int)
Definition: objfiles.c:285
bfd_vma CORE_ADDR
Definition: common-types.h:41
int have_partial_symbols(void)
Definition: objfiles.c:965
void free_objfile_separate_debug(struct objfile *)
Definition: objfiles.c:525
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:401
struct bfd_section * the_bfd_section
Definition: objfiles.h:121
void unlink_objfile(struct objfile *)
Definition: objfiles.c:480
struct psymbol_allocation_list global_psymbols
Definition: objfiles.h:338
struct program_space * pspace
Definition: objfiles.h:286
CORE_ADDR addr_low
Definition: objfiles.h:277
long mtime
Definition: objfiles.h:323
REGISTRY_FIELDS
Definition: objfiles.h:351
void default_iterate_over_objfiles_in_search_order(struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile)
Definition: objfiles.c:1481
void objfiles_changed(void)
Definition: objfiles.c:1402
int have_minimal_symbols(void)
Definition: objfiles.c:1021
#define MINIMAL_SYMBOL_HASH_SIZE
Definition: objfiles.h:166
char * original_name
Definition: objfiles.h:275
int objfile_has_symbols(struct objfile *objfile)
Definition: objfiles.c:949
int objfile_has_full_symbols(struct objfile *objfile)
Definition: objfiles.c:940
int sz_strtab
Definition: objfiles.h:157
int n_types
Definition: objfiles.h:156
void free_objfile(struct objfile *)
Definition: objfiles.c:540
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:318
struct symbol * template_symbols
Definition: objfiles.h:414
int objfile_has_partial_symbols(struct objfile *objfile)
Definition: objfiles.c:921
struct objfile * objfile_separate_debug_iterate(const struct objfile *, const struct objfile *)
Definition: objfiles.c:411
struct obstack objfile_obstack
Definition: objfiles.h:328
int n_stabs
Definition: objfiles.h:155
int is_addr_in_objfile(CORE_ADDR addr, const struct objfile *objfile)
Definition: objfiles.c:1436
int( iterate_over_objfiles_in_search_order_cb_ftype)(struct objfile *objfile, void *cb_data)
Definition: gdbarch.h:89
void objfile_rebase(struct objfile *, CORE_ADDR)
Definition: objfiles.c:901
const char *const name
Definition: aarch64-tdep.c:68
int n_syms
Definition: objfiles.h:154
void set_objfile_main_name(struct objfile *objfile, const char *name, enum language lang)
Definition: objfiles.c:192
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
struct cleanup * make_cleanup_free_objfile(struct objfile *)
Definition: objfiles.c:667
const struct sym_fns * sf
Definition: objfiles.h:347
int sect_index_rodata
Definition: objfiles.h:375
struct obj_section * sections
Definition: objfiles.h:386
void inhibit_section_map_updates(struct program_space *pspace)
Definition: objfiles.c:1411
int shared_objfile_contains_address_p(struct program_space *pspace, CORE_ADDR address)
Definition: objfiles.c:1456
void free_all_objfiles(void)
Definition: objfiles.c:675
struct objfile * separate_debug_objfile
Definition: objfiles.h:397
struct compunit_symtab * compunit_symtabs
Definition: objfiles.h:291
int have_full_symbols(void)
Definition: objfiles.c:982
CORE_ADDR entry_point
Definition: objfiles.h:104
const char * objfile_filename(const struct objfile *objfile)
Definition: objfiles.c:1510
int entry_point_address_query(CORE_ADDR *entry_p)
Definition: objfiles.c:377
struct bcache * macro_cache
Definition: objfiles.h:184
struct objfile * separate_debug_objfile_link
Definition: objfiles.h:405
void add_separate_debug_objfile(struct objfile *, struct objfile *)
Definition: objfiles.c:501
struct bcache * filename_cache
Definition: objfiles.h:181
unsigned int minsyms_read
Definition: objfiles.h:239
struct gdbarch * get_objfile_arch(const struct objfile *)
Definition: objfiles.c:368
unsigned initialized
Definition: objfiles.h:113
const char * name_of_main
Definition: objfiles.h:209
const char * objfile_debug_name(const struct objfile *objfile)
Definition: objfiles.c:1521
int num_sections
Definition: objfiles.h:363
DECLARE_REGISTRY(objfile)
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition: objfiles.c:1337
struct obj_section * sections_end
Definition: objfiles.h:386
static int in_plt_section(CORE_ADDR pc)
Definition: objfiles.h:539
void print_objfile_statistics(void)
Definition: symmisc.c:96
struct gdbarch * gdbarch
Definition: objfiles.h:191
int pc_in_section(CORE_ADDR, char *)
Definition: objfiles.c:1384
Definition: bcache.c:57
struct objfile * next
Definition: objfiles.h:267
struct objfile * objfile
Definition: objfiles.h:124
enum language language_of_main
Definition: objfiles.h:210
struct partial_symtab * free_psymtabs
Definition: objfiles.h:308
int the_bfd_section_index
Definition: objfiles.h:107
void resume_section_map_updates_cleanup(void *arg)
Definition: objfiles.c:1427
struct addrmap * psymtabs_addrmap
Definition: objfiles.h:304
language
Definition: defs.h:167
Definition: symtab.h:703
unsigned short flags
Definition: objfiles.h:282
void terminate_minimal_symbol_table(struct objfile *objfile)
Definition: minsyms.c:1343
struct minimal_symbol * msymbol_hash[MINIMAL_SYMBOL_HASH_SIZE]
Definition: objfiles.h:243
int sect_index_bss
Definition: objfiles.h:374
void resume_section_map_updates(struct program_space *pspace)
Definition: objfiles.c:1419
struct section_offsets * section_offsets
Definition: objfiles.h:362
int ovly_mapped
Definition: objfiles.h:127
unsigned entry_point_p
Definition: objfiles.h:110
struct minimal_symbol * msymbol_demangled_hash[MINIMAL_SYMBOL_HASH_SIZE]
Definition: objfiles.h:248
CORE_ADDR entry_point_address(void)
Definition: objfiles.c:392
int sect_index_data
Definition: objfiles.h:373
void put_objfile_before(struct objfile *, struct objfile *)
Definition: objfiles.c:446
struct psymbol_bcache * psymbol_cache
Definition: objfiles.h:333
void set_objfile_per_bfd(struct objfile *obj)
Definition: objfiles.c:183
void objfile_relocate(struct objfile *, const struct section_offsets *)
Definition: objfiles.c:836
struct partial_symtab * psymtabs
Definition: objfiles.h:297
void print_symbol_bcache_statistics(void)
Definition: symmisc.c:75
int n_psyms
Definition: objfiles.h:153