gdb: Show type summary for anonymous structures from c_print_typedef
[deliverable/binutils-gdb.git] / gdb / objfiles.h
CommitLineData
c906108c 1/* Definitions for symbol file management in GDB.
af5f3db6 2
42a4f53d 3 Copyright (C) 1992-2019 Free Software Foundation, Inc.
c906108c 4
c5aa993b 5 This file is part of GDB.
c906108c 6
c5aa993b
JM
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
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
c5aa993b 10 (at your option) any later version.
c906108c 11
c5aa993b
JM
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.
c906108c 16
c5aa993b 17 You should have received a copy of the GNU General Public License
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
19
20#if !defined (OBJFILES_H)
21#define OBJFILES_H
22
63e43d3a 23#include "hashtab.h"
3956d554 24#include "gdb_obstack.h" /* For obstack internals. */
b15cc25c 25#include "objfile-flags.h"
af5bf4ad 26#include "symfile.h"
6c95b8df 27#include "progspace.h"
8e260fc0 28#include "registry.h"
65cf3563 29#include "gdb_bfd.h"
d320c2b5 30#include "psymtab.h"
1b7a07cb 31#include <bitset>
b5ec771e 32#include <vector>
268a13a5
TT
33#include "gdbsupport/next-iterator.h"
34#include "gdbsupport/safe-iterator.h"
b366c208 35#include "bcache.h"
0d12e84c 36#include "gdbarch.h"
3956d554 37
2de7ced7 38struct htab;
4a4b3fed 39struct objfile_data;
af5bf4ad 40struct partial_symbol;
08c0b5bc 41
c906108c
SS
42/* This structure maintains information on a per-objfile basis about the
43 "entry point" of the objfile, and the scope within which the entry point
44 exists. It is possible that gdb will see more than one objfile that is
45 executable, each with its own entry point.
46
47 For example, for dynamically linked executables in SVR4, the dynamic linker
48 code is contained within the shared C library, which is actually executable
49 and is run by the kernel first when an exec is done of a user executable
50 that is dynamically linked. The dynamic linker within the shared C library
51 then maps in the various program segments in the user executable and jumps
52 to the user executable's recorded entry point, as if the call had been made
53 directly by the kernel.
54
73c1e0a1
AC
55 The traditional gdb method of using this info was to use the
56 recorded entry point to set the entry-file's lowpc and highpc from
627b3ba2
AC
57 the debugging information, where these values are the starting
58 address (inclusive) and ending address (exclusive) of the
59 instruction space in the executable which correspond to the
0df8b418 60 "startup file", i.e. crt0.o in most cases. This file is assumed to
627b3ba2
AC
61 be a startup file and frames with pc's inside it are treated as
62 nonexistent. Setting these variables is necessary so that
63 backtraces do not fly off the bottom of the stack.
64
65 NOTE: cagney/2003-09-09: It turns out that this "traditional"
66 method doesn't work. Corinna writes: ``It turns out that the call
2f72f850 67 to test for "inside entry file" destroys a meaningful backtrace
0df8b418 68 under some conditions. E.g. the backtrace tests in the asm-source
627b3ba2
AC
69 testcase are broken for some targets. In this test the functions
70 are all implemented as part of one file and the testcase is not
71 necessarily linked with a start file (depending on the target).
72 What happens is, that the first frame is printed normaly and
73 following frames are treated as being inside the enttry file then.
74 This way, only the #0 frame is printed in the backtrace output.''
75 Ref "frame.c" "NOTE: vinschen/2003-04-01".
c906108c
SS
76
77 Gdb also supports an alternate method to avoid running off the bottom
78 of the stack.
79
80 There are two frames that are "special", the frame for the function
81 containing the process entry point, since it has no predecessor frame,
82 and the frame for the function containing the user code entry point
83 (the main() function), since all the predecessor frames are for the
84 process startup code. Since we have no guarantee that the linked
85 in startup modules have any debugging information that gdb can use,
86 we need to avoid following frame pointers back into frames that might
95cf5869 87 have been built in the startup code, as we might get hopelessly
c906108c
SS
88 confused. However, we almost always have debugging information
89 available for main().
90
618ce49f
AC
91 These variables are used to save the range of PC values which are
92 valid within the main() function and within the function containing
93 the process entry point. If we always consider the frame for
94 main() as the outermost frame when debugging user code, and the
95 frame for the process entry point function as the outermost frame
96 when debugging startup code, then all we have to do is have
97 DEPRECATED_FRAME_CHAIN_VALID return false whenever a frame's
98 current PC is within the range specified by these variables. In
99 essence, we set "ceilings" in the frame chain beyond which we will
c906108c
SS
100 not proceed when following the frame chain back up the stack.
101
102 A nice side effect is that we can still debug startup code without
103 running off the end of the frame chain, assuming that we have usable
104 debugging information in the startup modules, and if we choose to not
105 use the block at main, or can't find it for some reason, everything
106 still works as before. And if we have no startup code debugging
107 information but we do have usable information for main(), backtraces
6e4c6c91 108 from user code don't go wandering off into the startup code. */
c906108c
SS
109
110struct entry_info
95cf5869
DE
111{
112 /* The unrelocated value we should use for this objfile entry point. */
113 CORE_ADDR entry_point;
c906108c 114
95cf5869
DE
115 /* The index of the section in which the entry point appears. */
116 int the_bfd_section_index;
53eddfa6 117
95cf5869
DE
118 /* Set to 1 iff ENTRY_POINT contains a valid value. */
119 unsigned entry_point_p : 1;
6ef55de7 120
95cf5869
DE
121 /* Set to 1 iff this object was initialized. */
122 unsigned initialized : 1;
123};
c906108c 124
f1f6aadf
PA
125/* Sections in an objfile. The section offsets are stored in the
126 OBJFILE. */
c906108c 127
c5aa993b 128struct obj_section
95cf5869
DE
129{
130 /* BFD section pointer */
131 struct bfd_section *the_bfd_section;
c906108c 132
95cf5869
DE
133 /* Objfile this section is part of. */
134 struct objfile *objfile;
c906108c 135
95cf5869
DE
136 /* True if this "overlay section" is mapped into an "overlay region". */
137 int ovly_mapped;
138};
c906108c 139
f1f6aadf
PA
140/* Relocation offset applied to S. */
141#define obj_section_offset(s) \
65cf3563 142 (((s)->objfile->section_offsets)->offsets[gdb_bfd_section_index ((s)->objfile->obfd, (s)->the_bfd_section)])
f1f6aadf
PA
143
144/* The memory address of section S (vma + offset). */
145#define obj_section_addr(s) \
1706c199 146 (bfd_get_section_vma ((s)->objfile->obfd, s->the_bfd_section) \
f1f6aadf
PA
147 + obj_section_offset (s))
148
149/* The one-passed-the-end memory address of section S
150 (vma + size + offset). */
151#define obj_section_endaddr(s) \
1706c199 152 (bfd_get_section_vma ((s)->objfile->obfd, s->the_bfd_section) \
f1f6aadf
PA
153 + bfd_get_section_size ((s)->the_bfd_section) \
154 + obj_section_offset (s))
c906108c 155
c906108c
SS
156/* The "objstats" structure provides a place for gdb to record some
157 interesting information about its internal state at runtime, on a
158 per objfile basis, such as information about the number of symbols
0df8b418 159 read, size of string table (if any), etc. */
c906108c 160
c5aa993b 161struct objstats
95cf5869
DE
162{
163 /* Number of partial symbols read. */
9e86da07 164 int n_psyms = 0;
95cf5869
DE
165
166 /* Number of full symbols read. */
9e86da07 167 int n_syms = 0;
95cf5869
DE
168
169 /* Number of ".stabs" read (if applicable). */
9e86da07 170 int n_stabs = 0;
95cf5869
DE
171
172 /* Number of types. */
9e86da07 173 int n_types = 0;
95cf5869
DE
174
175 /* Size of stringtable, (if applicable). */
9e86da07 176 int sz_strtab = 0;
95cf5869 177};
c906108c
SS
178
179#define OBJSTAT(objfile, expr) (objfile -> stats.expr)
180#define OBJSTATS struct objstats stats
a14ed312
KB
181extern void print_objfile_statistics (void);
182extern void print_symbol_bcache_statistics (void);
c906108c 183
9227b5eb 184/* Number of entries in the minimal symbol hash table. */
375f3d86 185#define MINIMAL_SYMBOL_HASH_SIZE 2039
9227b5eb 186
7932255d
TT
187/* An iterator for minimal symbols. */
188
189struct minimal_symbol_iterator
190{
191 typedef minimal_symbol_iterator self_type;
192 typedef struct minimal_symbol *value_type;
193 typedef struct minimal_symbol *&reference;
194 typedef struct minimal_symbol **pointer;
195 typedef std::forward_iterator_tag iterator_category;
196 typedef int difference_type;
197
198 explicit minimal_symbol_iterator (struct minimal_symbol *msym)
199 : m_msym (msym)
200 {
201 }
202
203 value_type operator* () const
204 {
205 return m_msym;
206 }
207
208 bool operator== (const self_type &other) const
209 {
210 return m_msym == other.m_msym;
211 }
212
213 bool operator!= (const self_type &other) const
214 {
215 return m_msym != other.m_msym;
216 }
217
218 self_type &operator++ ()
219 {
220 ++m_msym;
221 return *this;
222 }
223
224private:
225 struct minimal_symbol *m_msym;
226};
227
706e3705
TT
228/* Some objfile data is hung off the BFD. This enables sharing of the
229 data across all objfiles using the BFD. The data is stored in an
230 instance of this structure, and associated with the BFD using the
231 registry system. */
232
233struct objfile_per_bfd_storage
234{
23732b1e
PA
235 objfile_per_bfd_storage ()
236 : minsyms_read (false)
237 {}
238
d6797f46
TT
239 ~objfile_per_bfd_storage ();
240
706e3705
TT
241 /* The storage has an obstack of its own. */
242
23732b1e 243 auto_obstack storage_obstack;
95cf5869 244
706e3705
TT
245 /* Byte cache for file names. */
246
25629dfd 247 struct bcache filename_cache;
6532ff36
TT
248
249 /* Byte cache for macros. */
95cf5869 250
25629dfd 251 struct bcache macro_cache;
df6d5441
TT
252
253 /* The gdbarch associated with the BFD. Note that this gdbarch is
254 determined solely from BFD information, without looking at target
255 information. The gdbarch determined from a running target may
256 differ from this e.g. with respect to register types and names. */
257
23732b1e 258 struct gdbarch *gdbarch = NULL;
84a1243b
TT
259
260 /* Hash table for mapping symbol names to demangled names. Each
261 entry in the hash table is actually two consecutive strings,
262 both null-terminated; the first one is a mangled or linkage
263 name, and the second is the demangled name or just a zero byte
264 if the name doesn't demangle. */
95cf5869 265
db92718b 266 htab_up demangled_names_hash;
6ef55de7
TT
267
268 /* The per-objfile information about the entry point, the scope (file/func)
269 containing the entry point, and the scope of the user's main() func. */
270
23732b1e 271 entry_info ei {};
3d548a53
TT
272
273 /* The name and language of any "main" found in this objfile. The
274 name can be NULL, which means that the information was not
275 recorded. */
276
23732b1e
PA
277 const char *name_of_main = NULL;
278 enum language language_of_main = language_unknown;
34643a32
TT
279
280 /* Each file contains a pointer to an array of minimal symbols for all
281 global symbols that are defined within the file. The array is
282 terminated by a "null symbol", one that has a NULL pointer for the
283 name and a zero value for the address. This makes it easy to walk
284 through the array when passed a pointer to somewhere in the middle
285 of it. There is also a count of the number of symbols, which does
042d75e4 286 not include the terminating null symbol. */
34643a32 287
042d75e4 288 gdb::unique_xmalloc_ptr<minimal_symbol> msymbols;
23732b1e 289 int minimal_symbol_count = 0;
34643a32 290
5f6cac40
TT
291 /* The number of minimal symbols read, before any minimal symbol
292 de-duplication is applied. Note in particular that this has only
293 a passing relationship with the actual size of the table above;
294 use minimal_symbol_count if you need the true size. */
95cf5869 295
23732b1e 296 int n_minsyms = 0;
5f6cac40 297
34643a32
TT
298 /* This is true if minimal symbols have already been read. Symbol
299 readers can use this to bypass minimal symbol reading. Also, the
300 minimal symbol table management code in minsyms.c uses this to
301 suppress new minimal symbols. You might think that MSYMBOLS or
302 MINIMAL_SYMBOL_COUNT could be used for this, but it is possible
303 for multiple readers to install minimal symbols into a given
304 per-BFD. */
305
23732b1e 306 bool minsyms_read : 1;
34643a32
TT
307
308 /* This is a hash table used to index the minimal symbols by name. */
309
23732b1e 310 minimal_symbol *msymbol_hash[MINIMAL_SYMBOL_HASH_SIZE] {};
34643a32
TT
311
312 /* This hash table is used to index the minimal symbols by their
313 demangled names. */
314
23732b1e 315 minimal_symbol *msymbol_demangled_hash[MINIMAL_SYMBOL_HASH_SIZE] {};
b5ec771e
PA
316
317 /* All the different languages of symbols found in the demangled
1b7a07cb
TT
318 hash table. */
319 std::bitset<nr_languages> demangled_hash_languages;
706e3705
TT
320};
321
e9ad22ee
TT
322/* An iterator that first returns a parent objfile, and then each
323 separate debug objfile. */
324
325class separate_debug_iterator
326{
327public:
328
329 explicit separate_debug_iterator (struct objfile *objfile)
330 : m_objfile (objfile),
331 m_parent (objfile)
332 {
333 }
334
335 bool operator!= (const separate_debug_iterator &other)
336 {
337 return m_objfile != other.m_objfile;
338 }
339
340 separate_debug_iterator &operator++ ();
341
342 struct objfile *operator* ()
343 {
344 return m_objfile;
345 }
346
347private:
348
349 struct objfile *m_objfile;
350 struct objfile *m_parent;
351};
352
353/* A range adapter wrapping separate_debug_iterator. */
354
355class separate_debug_range
356{
357public:
358
359 explicit separate_debug_range (struct objfile *objfile)
360 : m_objfile (objfile)
361 {
362 }
363
364 separate_debug_iterator begin ()
365 {
366 return separate_debug_iterator (m_objfile);
367 }
368
369 separate_debug_iterator end ()
370 {
371 return separate_debug_iterator (nullptr);
372 }
373
374private:
375
376 struct objfile *m_objfile;
377};
378
c906108c
SS
379/* Master structure for keeping track of each file from which
380 gdb reads symbols. There are several ways these get allocated: 1.
381 The main symbol file, symfile_objfile, set by the symbol-file command,
382 2. Additional symbol files added by the add-symbol-file command,
383 3. Shared library objfiles, added by ADD_SOLIB, 4. symbol files
384 for modules that were loaded when GDB attached to a remote system
385 (see remote-vx.c). */
386
387struct objfile
95cf5869 388{
9e86da07
TT
389 objfile (bfd *, const char *, objfile_flags);
390 ~objfile ();
391
392 DISABLE_COPY_AND_ASSIGN (objfile);
393
f252c6d5
TT
394 /* A range adapter that makes it possible to iterate over all
395 psymtabs in one objfile. */
396
397 psymtab_storage::partial_symtab_range psymtabs ()
398 {
399 return partial_symtabs->range ();
400 }
401
6d6a12bf
TT
402 /* Reset the storage for the partial symbol tables. */
403
404 void reset_psymtabs ()
405 {
406 psymbol_map.clear ();
8d7bcccb 407 partial_symtabs.reset (new psymtab_storage ());
6d6a12bf
TT
408 }
409
b669c953
TT
410 typedef next_adapter<struct compunit_symtab> compunits_range;
411
412 /* A range adapter that makes it possible to iterate over all
413 compunits in one objfile. */
414
415 compunits_range compunits ()
416 {
417 return compunits_range (compunit_symtabs);
418 }
6d6a12bf 419
7932255d
TT
420 /* A range adapter that makes it possible to iterate over all
421 minimal symbols of an objfile. */
422
423 class msymbols_range
424 {
425 public:
426
427 explicit msymbols_range (struct objfile *objfile)
428 : m_objfile (objfile)
429 {
430 }
431
432 minimal_symbol_iterator begin () const
433 {
042d75e4 434 return minimal_symbol_iterator (m_objfile->per_bfd->msymbols.get ());
7932255d
TT
435 }
436
437 minimal_symbol_iterator end () const
438 {
439 return minimal_symbol_iterator
042d75e4 440 (m_objfile->per_bfd->msymbols.get ()
7932255d
TT
441 + m_objfile->per_bfd->minimal_symbol_count);
442 }
443
444 private:
445
446 struct objfile *m_objfile;
447 };
448
449 /* Return a range adapter for iterating over all minimal
450 symbols. */
451
452 msymbols_range msymbols ()
453 {
454 return msymbols_range (this);
455 }
456
e9ad22ee
TT
457 /* Return a range adapter for iterating over all the separate debug
458 objfiles of this objfile. */
459
460 separate_debug_range separate_debug_objfiles ()
461 {
462 return separate_debug_range (this);
463 }
464
7932255d 465
95cf5869
DE
466 /* All struct objfile's are chained together by their next pointers.
467 The program space field "objfiles" (frequently referenced via
468 the macro "object_files") points to the first link in this chain. */
c906108c 469
9e86da07 470 struct objfile *next = nullptr;
c906108c 471
95cf5869
DE
472 /* The object file's original name as specified by the user,
473 made absolute, and tilde-expanded. However, it is not canonicalized
474 (i.e., it has not been passed through gdb_realpath).
475 This pointer is never NULL. This does not have to be freed; it is
476 guaranteed to have a lifetime at least as long as the objfile. */
c906108c 477
9e86da07 478 char *original_name = nullptr;
c906108c 479
9e86da07 480 CORE_ADDR addr_low = 0;
c906108c 481
b15cc25c 482 /* Some flag bits for this objfile. */
e4f6d2ec 483
b15cc25c 484 objfile_flags flags;
c906108c 485
95cf5869 486 /* The program space associated with this objfile. */
c906108c 487
95cf5869 488 struct program_space *pspace;
6c95b8df 489
95cf5869
DE
490 /* List of compunits.
491 These are used to do symbol lookups and file/line-number lookups. */
6c95b8df 492
9e86da07 493 struct compunit_symtab *compunit_symtabs = nullptr;
c906108c 494
d320c2b5 495 /* The partial symbol tables. */
c906108c 496
d320c2b5 497 std::shared_ptr<psymtab_storage> partial_symtabs;
c906108c 498
95cf5869
DE
499 /* The object file's BFD. Can be null if the objfile contains only
500 minimal symbols, e.g. the run time common symbols for SunOS4. */
c906108c 501
95cf5869 502 bfd *obfd;
c906108c 503
95cf5869
DE
504 /* The per-BFD data. Note that this is treated specially if OBFD
505 is NULL. */
c906108c 506
9e86da07 507 struct objfile_per_bfd_storage *per_bfd = nullptr;
706e3705 508
95cf5869
DE
509 /* The modification timestamp of the object file, as of the last time
510 we read its symbols. */
706e3705 511
9e86da07 512 long mtime = 0;
c906108c 513
95cf5869
DE
514 /* Obstack to hold objects that should be freed when we load a new symbol
515 table from this object file. */
c906108c 516
9e86da07 517 struct obstack objfile_obstack {};
b99607ea 518
71a3c369
TT
519 /* Map symbol addresses to the partial symtab that defines the
520 object at that address. */
521
522 std::vector<std::pair<CORE_ADDR, partial_symtab *>> psymbol_map;
523
95cf5869
DE
524 /* Structure which keeps track of functions that manipulate objfile's
525 of the same type as this objfile. I.e. the function to read partial
526 symbols for example. Note that this structure is in statically
527 allocated memory, and is shared by all objfiles that use the
528 object module reader of this type. */
c906108c 529
9e86da07 530 const struct sym_fns *sf = nullptr;
c906108c 531
95cf5869 532 /* Per objfile data-pointers required by other GDB modules. */
c906108c 533
9e86da07 534 REGISTRY_FIELDS {};
0d0e1a63 535
95cf5869
DE
536 /* Set of relocation offsets to apply to each section.
537 The table is indexed by the_bfd_section->index, thus it is generally
538 as large as the number of sections in the binary.
539 The table is stored on the objfile_obstack.
0d0e1a63 540
95cf5869
DE
541 These offsets indicate that all symbols (including partial and
542 minimal symbols) which have been read have been relocated by this
543 much. Symbols which are yet to be read need to be relocated by it. */
c906108c 544
9e86da07
TT
545 struct section_offsets *section_offsets = nullptr;
546 int num_sections = 0;
c906108c 547
95cf5869
DE
548 /* Indexes in the section_offsets array. These are initialized by the
549 *_symfile_offsets() family of functions (som_symfile_offsets,
550 xcoff_symfile_offsets, default_symfile_offsets). In theory they
551 should correspond to the section indexes used by bfd for the
552 current objfile. The exception to this for the time being is the
9e86da07
TT
553 SOM version.
554
555 These are initialized to -1 so that we can later detect if they
556 are used w/o being properly assigned to. */
c906108c 557
9e86da07
TT
558 int sect_index_text = -1;
559 int sect_index_data = -1;
560 int sect_index_bss = -1;
561 int sect_index_rodata = -1;
b8fbeb18 562
95cf5869
DE
563 /* These pointers are used to locate the section table, which
564 among other things, is used to map pc addresses into sections.
565 SECTIONS points to the first entry in the table, and
566 SECTIONS_END points to the first location past the last entry
567 in the table. The table is stored on the objfile_obstack. The
568 sections are indexed by the BFD section index; but the
569 structure data is only valid for certain sections
570 (e.g. non-empty, SEC_ALLOC). */
b8fbeb18 571
9e86da07
TT
572 struct obj_section *sections = nullptr;
573 struct obj_section *sections_end = nullptr;
c906108c 574
95cf5869
DE
575 /* GDB allows to have debug symbols in separate object files. This is
576 used by .gnu_debuglink, ELF build id note and Mach-O OSO.
577 Although this is a tree structure, GDB only support one level
578 (ie a separate debug for a separate debug is not supported). Note that
579 separate debug object are in the main chain and therefore will be
2030c079 580 visited by objfiles & co iterators. Separate debug objfile always
95cf5869 581 has a non-nul separate_debug_objfile_backlink. */
c906108c 582
95cf5869 583 /* Link to the first separate debug object, if any. */
15d123c9 584
9e86da07 585 struct objfile *separate_debug_objfile = nullptr;
5b5d99cf 586
95cf5869
DE
587 /* If this is a separate debug object, this is used as a link to the
588 actual executable objfile. */
15d123c9 589
9e86da07 590 struct objfile *separate_debug_objfile_backlink = nullptr;
15d123c9 591
95cf5869
DE
592 /* If this is a separate debug object, this is a link to the next one
593 for the same executable objfile. */
5c4e30ca 594
9e86da07 595 struct objfile *separate_debug_objfile_link = nullptr;
95cf5869
DE
596
597 /* Place to stash various statistics about this objfile. */
598
599 OBJSTATS;
600
601 /* A linked list of symbols created when reading template types or
602 function templates. These symbols are not stored in any symbol
603 table, so we have to keep them here to relocate them
604 properly. */
605
9e86da07 606 struct symbol *template_symbols = nullptr;
63e43d3a
PMR
607
608 /* Associate a static link (struct dynamic_prop *) to all blocks (struct
609 block *) that have one.
610
611 In the context of nested functions (available in Pascal, Ada and GNU C,
612 for instance), a static link (as in DWARF's DW_AT_static_link attribute)
613 for a function is a way to get the frame corresponding to the enclosing
614 function.
615
616 Very few blocks have a static link, so it's more memory efficient to
617 store these here rather than in struct block. Static links must be
618 allocated on the objfile's obstack. */
cf250e36 619 htab_up static_links;
95cf5869 620};
c906108c 621
c906108c
SS
622/* Declarations for functions defined in objfiles.c */
623
9c1877ea 624extern struct gdbarch *get_objfile_arch (const struct objfile *);
5e2b427d 625
abd0a5fa
JK
626extern int entry_point_address_query (CORE_ADDR *entry_p);
627
9ab9195f
EZ
628extern CORE_ADDR entry_point_address (void);
629
d82ea6a8 630extern void build_objfile_section_table (struct objfile *);
c906108c 631
5b5d99cf
JB
632extern void put_objfile_before (struct objfile *, struct objfile *);
633
15d123c9
TG
634extern void add_separate_debug_objfile (struct objfile *, struct objfile *);
635
a14ed312 636extern void unlink_objfile (struct objfile *);
c906108c 637
15d123c9
TG
638extern void free_objfile_separate_debug (struct objfile *);
639
a14ed312 640extern void free_all_objfiles (void);
c906108c 641
3189cb12 642extern void objfile_relocate (struct objfile *, const struct section_offsets *);
4141a416 643extern void objfile_rebase (struct objfile *, CORE_ADDR);
c906108c 644
55333a84
DE
645extern int objfile_has_partial_symbols (struct objfile *objfile);
646
647extern int objfile_has_full_symbols (struct objfile *objfile);
648
e361b228
TG
649extern int objfile_has_symbols (struct objfile *objfile);
650
a14ed312 651extern int have_partial_symbols (void);
c906108c 652
a14ed312 653extern int have_full_symbols (void);
c906108c 654
8fb8eb5c
DE
655extern void objfile_set_sym_fns (struct objfile *objfile,
656 const struct sym_fns *sf);
657
bb272892 658extern void objfiles_changed (void);
63644780
NB
659
660extern int is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile);
bb272892 661
d03de421
PA
662/* Return true if ADDRESS maps into one of the sections of a
663 OBJF_SHARED objfile of PSPACE and false otherwise. */
08351840 664
d03de421
PA
665extern int shared_objfile_contains_address_p (struct program_space *pspace,
666 CORE_ADDR address);
08351840 667
c906108c
SS
668/* This operation deletes all objfile entries that represent solibs that
669 weren't explicitly loaded by the user, via e.g., the add-symbol-file
0df8b418
MS
670 command. */
671
a14ed312 672extern void objfile_purge_solibs (void);
c906108c
SS
673
674/* Functions for dealing with the minimal symbol table, really a misc
675 address<->symbol mapping for things we don't have debug symbols for. */
676
a14ed312 677extern int have_minimal_symbols (void);
c906108c 678
a14ed312 679extern struct obj_section *find_pc_section (CORE_ADDR pc);
c906108c 680
3e5d3a5a 681/* Return non-zero if PC is in a section called NAME. */
a121b7c1 682extern int pc_in_section (CORE_ADDR, const char *);
3e5d3a5a
MR
683
684/* Return non-zero if PC is in a SVR4-style procedure linkage table
685 section. */
686
687static inline int
688in_plt_section (CORE_ADDR pc)
689{
690 return pc_in_section (pc, ".plt");
691}
c906108c 692
0d0e1a63
MK
693/* Keep a registry of per-objfile data-pointers required by other GDB
694 modules. */
8e260fc0 695DECLARE_REGISTRY(objfile);
e3c69974 696
607ece04
GB
697/* In normal use, the section map will be rebuilt by find_pc_section
698 if objfiles have been added, removed or relocated since it was last
699 called. Calling inhibit_section_map_updates will inhibit this
06424eac
TT
700 behavior until the returned scoped_restore object is destroyed. If
701 you call inhibit_section_map_updates you must ensure that every
702 call to find_pc_section in the inhibited region relates to a
703 section that is already in the section map and has not since been
704 removed or relocated. */
705extern scoped_restore_tmpl<int> inhibit_section_map_updates
706 (struct program_space *pspace);
607ece04 707
19630284
JB
708extern void default_iterate_over_objfiles_in_search_order
709 (struct gdbarch *gdbarch,
710 iterate_over_objfiles_in_search_order_cb_ftype *cb,
711 void *cb_data, struct objfile *current_objfile);
0d0e1a63
MK
712\f
713
c906108c 714#define ALL_OBJFILE_OSECTIONS(objfile, osect) \
65cf3563
TT
715 for (osect = objfile->sections; osect < objfile->sections_end; osect++) \
716 if (osect->the_bfd_section == NULL) \
717 { \
718 /* Nothing. */ \
719 } \
720 else
c906108c 721
b8fbeb18 722#define SECT_OFF_DATA(objfile) \
8e65ff28 723 ((objfile->sect_index_data == -1) \
3e43a32a
MS
724 ? (internal_error (__FILE__, __LINE__, \
725 _("sect_index_data not initialized")), -1) \
8e65ff28 726 : objfile->sect_index_data)
b8fbeb18
EZ
727
728#define SECT_OFF_RODATA(objfile) \
8e65ff28 729 ((objfile->sect_index_rodata == -1) \
3e43a32a
MS
730 ? (internal_error (__FILE__, __LINE__, \
731 _("sect_index_rodata not initialized")), -1) \
8e65ff28 732 : objfile->sect_index_rodata)
b8fbeb18
EZ
733
734#define SECT_OFF_TEXT(objfile) \
8e65ff28 735 ((objfile->sect_index_text == -1) \
3e43a32a
MS
736 ? (internal_error (__FILE__, __LINE__, \
737 _("sect_index_text not initialized")), -1) \
8e65ff28 738 : objfile->sect_index_text)
b8fbeb18 739
a4c8257b 740/* Sometimes the .bss section is missing from the objfile, so we don't
0df8b418
MS
741 want to die here. Let the users of SECT_OFF_BSS deal with an
742 uninitialized section index. */
a4c8257b 743#define SECT_OFF_BSS(objfile) (objfile)->sect_index_bss
b8fbeb18 744
c14c28ba
PP
745/* Answer whether there is more than one object file loaded. */
746
747#define MULTI_OBJFILE_P() (object_files && object_files->next)
748
706e3705
TT
749/* Reset the per-BFD storage area on OBJ. */
750
751void set_objfile_per_bfd (struct objfile *obj);
752
e02c96a7
DE
753/* Return canonical name for OBJFILE.
754 This is the real file name if the file has been opened.
755 Otherwise it is the original name supplied by the user. */
756
4262abfb
JK
757const char *objfile_name (const struct objfile *objfile);
758
e02c96a7
DE
759/* Return the (real) file name of OBJFILE if the file has been opened,
760 otherwise return NULL. */
761
762const char *objfile_filename (const struct objfile *objfile);
763
cc485e62
DE
764/* Return the name to print for OBJFILE in debugging messages. */
765
766extern const char *objfile_debug_name (const struct objfile *objfile);
767
015d2e7e
DE
768/* Return the name of the file format of OBJFILE if the file has been opened,
769 otherwise return NULL. */
770
771const char *objfile_flavour_name (struct objfile *objfile);
772
3d548a53
TT
773/* Set the objfile's notion of the "main" name and language. */
774
775extern void set_objfile_main_name (struct objfile *objfile,
776 const char *name, enum language lang);
777
63e43d3a
PMR
778extern void objfile_register_static_link
779 (struct objfile *objfile,
780 const struct block *block,
781 const struct dynamic_prop *static_link);
782
783extern const struct dynamic_prop *objfile_lookup_static_link
784 (struct objfile *objfile, const struct block *block);
785
c5aa993b 786#endif /* !defined (OBJFILES_H) */
This page took 1.730946 seconds and 4 git commands to generate.