GDB (xrefs)

/tmp/gdb-8.1/gdb/objfiles.c
Go to the documentation of this file.
1 /* GDB routines for manipulating objfiles.
2
3 Copyright (C) 1992-2018 Free Software Foundation, Inc.
4
5 Contributed by Cygnus Support, using pieces from other GDB modules.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22 /* This file contains support routines for creating, manipulating, and
23 destroying objfile structures. */
24
25 #include "defs.h"
26 #include "bfd.h" /* Binary File Description */
27 #include "symtab.h"
28 #include "symfile.h"
29 #include "objfiles.h"
30 #include "gdb-stabs.h"
31 #include "target.h"
32 #include "bcache.h"
33 #include "expression.h"
34 #include "parser-defs.h"
35
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <fcntl.h>
39 #include "gdb_obstack.h"
40 #include "hashtab.h"
41
42 #include "breakpoint.h"
43 #include "block.h"
44 #include "dictionary.h"
45 #include "source.h"
46 #include "addrmap.h"
47 #include "arch-utils.h"
48 #include "exec.h"
49 #include "observer.h"
50 #include "complaints.h"
51 #include "psymtab.h"
52 #include "solist.h"
53 #include "gdb_bfd.h"
54 #include "btrace.h"
55
56 #include <vector>
57
58 /* Keep a registry of per-objfile data-pointers required by other GDB
59 modules. */
60
61 DEFINE_REGISTRY (objfile, REGISTRY_ACCESS_FIELD)
62
63 /* Externally visible variables that are owned by this module.
64 See declarations in objfile.h for more info. */
65
66 struct objfile_pspace_info
67 {
68 struct obj_section **sections;
69 int num_sections;
70
71 /* Nonzero if object files have been added since the section map
72 was last updated. */
73 int new_objfiles_available;
74
75 /* Nonzero if the section map MUST be updated before use. */
76 int section_map_dirty;
77
78 /* Nonzero if section map updates should be inhibited if possible. */
79 int inhibit_updates;
80 };
81
82 /* Per-program-space data key. */
83 static const struct program_space_data *objfiles_pspace_data;
84
85 static void
86 objfiles_pspace_data_cleanup (struct program_space *pspace, void *arg)
87 {
88 struct objfile_pspace_info *info = (struct objfile_pspace_info *) arg;
89
90 xfree (info->sections);
91 xfree (info);
92 }
93
94 /* Get the current svr4 data. If none is found yet, add it now. This
95 function always returns a valid object. */
96
97 static struct objfile_pspace_info *
98 get_objfile_pspace_data (struct program_space *pspace)
99 {
100 struct objfile_pspace_info *info;
101
102 info = ((struct objfile_pspace_info *)
103 program_space_data (pspace, objfiles_pspace_data));
104 if (info == NULL)
105 {
106 info = XCNEW (struct objfile_pspace_info);
107 set_program_space_data (pspace, objfiles_pspace_data, info);
108 }
109
110 return info;
111 }
112
113
114
115 /* Per-BFD data key. */
116
117 static const struct bfd_data *objfiles_bfd_data;
118
119 /* Create the per-BFD storage object for OBJFILE. If ABFD is not
120 NULL, and it already has a per-BFD storage object, use that.
121 Otherwise, allocate a new per-BFD storage object. If ABFD is not
122 NULL, the object is allocated on the BFD; otherwise it is allocated
123 on OBJFILE's obstack. Note that it is not safe to call this
124 multiple times for a given OBJFILE -- it can only be called when
125 allocating or re-initializing OBJFILE. */
126
127 static struct objfile_per_bfd_storage *
128 get_objfile_bfd_data (struct objfile *objfile, struct bfd *abfd)
129 {
130 struct objfile_per_bfd_storage *storage = NULL;
131
132 if (abfd != NULL)
133 storage = ((struct objfile_per_bfd_storage *)
134 bfd_data (abfd, objfiles_bfd_data));
135
136 if (storage == NULL)
137 {
138 /* If the object requires gdb to do relocations, we simply fall
139 back to not sharing data across users. These cases are rare
140 enough that this seems reasonable. */
141 if (abfd != NULL && !gdb_bfd_requires_relocations (abfd))
142 {
143 storage
144 = ((struct objfile_per_bfd_storage *)
145 bfd_alloc (abfd, sizeof (struct objfile_per_bfd_storage)));
146 set_bfd_data (abfd, objfiles_bfd_data, storage);
147 }
148 else
149 {
150 storage = (objfile_per_bfd_storage *)
151 obstack_alloc (&objfile->objfile_obstack,
152 sizeof (objfile_per_bfd_storage));
153 }
154
155 /* objfile_per_bfd_storage is not trivially constructible, must
156 call the ctor manually. */
157 storage = new (storage) objfile_per_bfd_storage ();
158
159 /* Look up the gdbarch associated with the BFD. */
160 if (abfd != NULL)
161 storage->gdbarch = gdbarch_from_bfd (abfd);
162
163 storage->filename_cache = bcache_xmalloc (NULL, NULL);
164 storage->macro_cache = bcache_xmalloc (NULL, NULL);
165 storage->language_of_main = language_unknown;
166 }
167
168 return storage;
169 }
170
171 /* Free STORAGE. */
172
173 static void
174 free_objfile_per_bfd_storage (struct objfile_per_bfd_storage *storage)
175 {
176 bcache_xfree (storage->filename_cache);
177 bcache_xfree (storage->macro_cache);
178 if (storage->demangled_names_hash)
179 htab_delete (storage->demangled_names_hash);
180 storage->~objfile_per_bfd_storage ();
181 }
182
183 /* A wrapper for free_objfile_per_bfd_storage that can be passed as a
184 cleanup function to the BFD registry. */
185
186 static void
187 objfile_bfd_data_free (struct bfd *unused, void *d)
188 {
189 free_objfile_per_bfd_storage ((struct objfile_per_bfd_storage *) d);
190 }
191
192 /* See objfiles.h. */
193
194 void
195 set_objfile_per_bfd (struct objfile *objfile)
196 {
197 objfile->per_bfd = get_objfile_bfd_data (objfile, objfile->obfd);
198 }
199
200 /* Set the objfile's per-BFD notion of the "main" name and
201 language. */
202
203 void
204 set_objfile_main_name (struct objfile *objfile,
205 const char *name, enum language lang)
206 {
207 if (objfile->per_bfd->name_of_main == NULL
208 || strcmp (objfile->per_bfd->name_of_main, name) != 0)
209 objfile->per_bfd->name_of_main
210 = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack, name,
211 strlen (name));
212 objfile->per_bfd->language_of_main = lang;
213 }
214
215 /* Helper structure to map blocks to static link properties in hash tables. */
216
217 struct static_link_htab_entry
218 {
219 const struct block *block;
220 const struct dynamic_prop *static_link;
221 };
222
223 /* Return a hash code for struct static_link_htab_entry *P. */
224
225 static hashval_t
226 static_link_htab_entry_hash (const void *p)
227 {
228 const struct static_link_htab_entry *e
229 = (const struct static_link_htab_entry *) p;
230
231 return htab_hash_pointer (e->block);
232 }
233
234 /* Return whether P1 an P2 (pointers to struct static_link_htab_entry) are
235 mappings for the same block. */
236
237 static int
238 static_link_htab_entry_eq (const void *p1, const void *p2)
239 {
240 const struct static_link_htab_entry *e1
241 = (const struct static_link_htab_entry *) p1;
242 const struct static_link_htab_entry *e2
243 = (const struct static_link_htab_entry *) p2;
244
245 return e1->block == e2->block;
246 }
247
248 /* Register STATIC_LINK as the static link for BLOCK, which is part of OBJFILE.
249 Must not be called more than once for each BLOCK. */
250
251 void
252 objfile_register_static_link (struct objfile *objfile,
253 const struct block *block,
254 const struct dynamic_prop *static_link)
255 {
256 void **slot;
257 struct static_link_htab_entry lookup_entry;
258 struct static_link_htab_entry *entry;
259
260 if (objfile->static_links == NULL)
261 objfile->static_links = htab_create_alloc
262 (1, &static_link_htab_entry_hash, static_link_htab_entry_eq, NULL,
263 xcalloc, xfree);
264
265 /* Create a slot for the mapping, make sure it's the first mapping for this
266 block and then create the mapping itself. */
267 lookup_entry.block = block;
268 slot = htab_find_slot (objfile->static_links, &lookup_entry, INSERT);
269 gdb_assert (*slot == NULL);
270
271 entry = (struct static_link_htab_entry *) obstack_alloc
272 (&objfile->objfile_obstack, sizeof (*entry));
273 entry->block = block;
274 entry->static_link = static_link;
275 *slot = (void *) entry;
276 }
277
278 /* Look for a static link for BLOCK, which is part of OBJFILE. Return NULL if
279 none was found. */
280
281 const struct dynamic_prop *
282 objfile_lookup_static_link (struct objfile *objfile,
283 const struct block *block)
284 {
285 struct static_link_htab_entry *entry;
286 struct static_link_htab_entry lookup_entry;
287
288 if (objfile->static_links == NULL)
289 return NULL;
290 lookup_entry.block = block;
291 entry
292 = (struct static_link_htab_entry *) htab_find (objfile->static_links,
293 &lookup_entry);
294 if (entry == NULL)
295 return NULL;
296
297 gdb_assert (entry->block == block);
298 return entry->static_link;
299 }
300
301
302
303 /* Called via bfd_map_over_sections to build up the section table that
304 the objfile references. The objfile contains pointers to the start
305 of the table (objfile->sections) and to the first location after
306 the end of the table (objfile->sections_end). */
307
308 static void
309 add_to_objfile_sections_full (struct bfd *abfd, struct bfd_section *asect,
310 struct objfile *objfile, int force)
311 {
312 struct obj_section *section;
313
314 if (!force)
315 {
316 flagword aflag;
317
318 aflag = bfd_get_section_flags (abfd, asect);
319 if (!(aflag & SEC_ALLOC))
320 return;
321 }
322
323 section = &objfile->sections[gdb_bfd_section_index (abfd, asect)];
324 section->objfile = objfile;
325 section->the_bfd_section = asect;
326 section->ovly_mapped = 0;
327 }
328
329 static void
330 add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
331 void *objfilep)
332 {
333 add_to_objfile_sections_full (abfd, asect, (struct objfile *) objfilep, 0);
334 }
335
336 /* Builds a section table for OBJFILE.
337
338 Note that the OFFSET and OVLY_MAPPED in each table entry are
339 initialized to zero. */
340
341 void
342 build_objfile_section_table (struct objfile *objfile)
343 {
344 int count = gdb_bfd_count_sections (objfile->obfd);
345
346 objfile->sections = OBSTACK_CALLOC (&objfile->objfile_obstack,
347 count,
348 struct obj_section);
349 objfile->sections_end = (objfile->sections + count);
350 bfd_map_over_sections (objfile->obfd,
351 add_to_objfile_sections, (void *) objfile);
352
353 /* See gdb_bfd_section_index. */
354 add_to_objfile_sections_full (objfile->obfd, bfd_com_section_ptr, objfile, 1);
355 add_to_objfile_sections_full (objfile->obfd, bfd_und_section_ptr, objfile, 1);
356 add_to_objfile_sections_full (objfile->obfd, bfd_abs_section_ptr, objfile, 1);
357 add_to_objfile_sections_full (objfile->obfd, bfd_ind_section_ptr, objfile, 1);
358 }
359
360 /* Given a pointer to an initialized bfd (ABFD) and some flag bits,
361 initialize the new objfile as best we can and link it into the list
362 of all known objfiles.
363
364 NAME should contain original non-canonicalized filename or other
365 identifier as entered by user. If there is no better source use
366 bfd_get_filename (ABFD). NAME may be NULL only if ABFD is NULL.
367 NAME content is copied into returned objfile.
368
369 The FLAGS word contains various bits (OBJF_*) that can be taken as
370 requests for specific operations. Other bits like OBJF_SHARED are
371 simply copied through to the new objfile flags member. */
372
373 objfile::objfile (bfd *abfd, const char *name, objfile_flags flags_)
374 : flags (flags_),
375 pspace (current_program_space),
376 obfd (abfd),
377 psymbol_cache (psymbol_bcache_init ())
378 {
379 const char *expanded_name;
380
381 /* We could use obstack_specify_allocation here instead, but
382 gdb_obstack.h specifies the alloc/dealloc functions. */
383 obstack_init (&objfile_obstack);
384
385 objfile_alloc_data (this);
386
387 gdb::unique_xmalloc_ptr<char> name_holder;
388 if (name == NULL)
389 {
390 gdb_assert (abfd == NULL);
391 gdb_assert ((flags & OBJF_NOT_FILENAME) != 0);
392 expanded_name = "<<anonymous objfile>>";
393 }
394 else if ((flags & OBJF_NOT_FILENAME) != 0
395 || is_target_filename (name))
396 expanded_name = name;
397 else
398 {
399 name_holder = gdb_abspath (name);
400 expanded_name = name_holder.get ();
401 }
402 original_name
403 = (char *) obstack_copy0 (&objfile_obstack,
404 expanded_name,
405 strlen (expanded_name));
406
407 /* Update the per-objfile information that comes from the bfd, ensuring
408 that any data that is reference is saved in the per-objfile data
409 region. */
410
411 gdb_bfd_ref (abfd);
412 if (abfd != NULL)
413 {
414 mtime = bfd_get_mtime (abfd);
415
416 /* Build section table. */
417 build_objfile_section_table (this);
418 }
419
420 per_bfd = get_objfile_bfd_data (this, abfd);
421
422 terminate_minimal_symbol_table (this);
423
424 /* Add this file onto the tail of the linked list of other such files. */
425
426 if (object_files == NULL)
427 object_files = this;
428 else
429 {
430 struct objfile *last_one;
431
432 for (last_one = object_files;
433 last_one->next;
434 last_one = last_one->next);
435 last_one->next = this;
436 }
437
438 /* Rebuild section map next time we need it. */
439 get_objfile_pspace_data (pspace)->new_objfiles_available = 1;
440 }
441
442 /* Retrieve the gdbarch associated with OBJFILE. */
443
444 struct gdbarch *
445 get_objfile_arch (const struct objfile *objfile)
446 {
447 return objfile->per_bfd->gdbarch;
448 }
449
450 /* If there is a valid and known entry point, function fills *ENTRY_P with it
451 and returns non-zero; otherwise it returns zero. */
452
453 int
454 entry_point_address_query (CORE_ADDR *entry_p)
455 {
456 if (symfile_objfile == NULL || !symfile_objfile->per_bfd->ei.entry_point_p)
457 return 0;
458
459 *entry_p = (symfile_objfile->per_bfd->ei.entry_point
460 + ANOFFSET (symfile_objfile->section_offsets,
461 symfile_objfile->per_bfd->ei.the_bfd_section_index));
462
463 return 1;
464 }
465
466 /* Get current entry point address. Call error if it is not known. */
467
468 CORE_ADDR
469 entry_point_address (void)
470 {
471 CORE_ADDR retval;
472
473 if (!entry_point_address_query (&retval))
474 error (_("Entry point address is not known."));
475
476 return retval;
477 }
478
479 /* Iterator on PARENT and every separate debug objfile of PARENT.
480 The usage pattern is:
481 for (objfile = parent;
482 objfile;
483 objfile = objfile_separate_debug_iterate (parent, objfile))
484 ...
485 */
486
487 struct objfile *
488 objfile_separate_debug_iterate (const struct objfile *parent,
489 const struct objfile *objfile)
490 {
491 struct objfile *res;
492
493 /* If any, return the first child. */
494 res = objfile->separate_debug_objfile;
495 if (res)
496 return res;
497
498 /* Common case where there is no separate debug objfile. */
499 if (objfile == parent)
500 return NULL;
501
502 /* Return the brother if any. Note that we don't iterate on brothers of
503 the parents. */
504 res = objfile->separate_debug_objfile_link;
505 if (res)
506 return res;
507
508 for (res = objfile->separate_debug_objfile_backlink;
509 res != parent;
510 res = res->separate_debug_objfile_backlink)
511 {
512 gdb_assert (res != NULL);
513 if (res->separate_debug_objfile_link)
514 return res->separate_debug_objfile_link;
515 }
516 return NULL;
517 }
518
519 /* Put one object file before a specified on in the global list.
520 This can be used to make sure an object file is destroyed before
521 another when using ALL_OBJFILES_SAFE to free all objfiles. */
522 void
523 put_objfile_before (struct objfile *objfile, struct objfile *before_this)
524 {
525 struct objfile **objp;
526
527 unlink_objfile (objfile);
528
529 for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
530 {
531 if (*objp == before_this)
532 {
533 objfile->next = *objp;
534 *objp = objfile;
535 return;
536 }
537 }
538
539 internal_error (__FILE__, __LINE__,
540 _("put_objfile_before: before objfile not in list"));
541 }
542
543 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
544 list.
545
546 It is not a bug, or error, to call this function if OBJFILE is not known
547 to be in the current list. This is done in the case of mapped objfiles,
548 for example, just to ensure that the mapped objfile doesn't appear twice
549 in the list. Since the list is threaded, linking in a mapped objfile
550 twice would create a circular list.
551
552 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
553 unlinking it, just to ensure that we have completely severed any linkages
554 between the OBJFILE and the list. */
555
556 void
557 unlink_objfile (struct objfile *objfile)
558 {
559 struct objfile **objpp;
560
561 for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
562 {
563 if (*objpp == objfile)
564 {
565 *objpp = (*objpp)->next;
566 objfile->next = NULL;
567 return;
568 }
569 }
570
571 internal_error (__FILE__, __LINE__,
572 _("unlink_objfile: objfile already unlinked"));
573 }
574
575 /* Add OBJFILE as a separate debug objfile of PARENT. */
576
577 void
578 add_separate_debug_objfile (struct objfile *objfile, struct objfile *parent)
579 {
580 gdb_assert (objfile && parent);
581
582 /* Must not be already in a list. */
583 gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
584 gdb_assert (objfile->separate_debug_objfile_link == NULL);
585 gdb_assert (objfile->separate_debug_objfile == NULL);
586 gdb_assert (parent->separate_debug_objfile_backlink == NULL);
587 gdb_assert (parent->separate_debug_objfile_link == NULL);
588
589 objfile->separate_debug_objfile_backlink = parent;
590 objfile->separate_debug_objfile_link = parent->separate_debug_objfile;
591 parent->separate_debug_objfile = objfile;
592
593 /* Put the separate debug object before the normal one, this is so that
594 usage of the ALL_OBJFILES_SAFE macro will stay safe. */
595 put_objfile_before (objfile, parent);
596 }
597
598 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
599 itself. */
600
601 void
602 free_objfile_separate_debug (struct objfile *objfile)
603 {
604 struct objfile *child;
605
606 for (child = objfile->separate_debug_objfile; child;)
607 {
608 struct objfile *next_child = child->separate_debug_objfile_link;
609 delete child;
610 child = next_child;
611 }
612 }
613
614 /* Destroy an objfile and all the symtabs and psymtabs under it. */
615
616 objfile::~objfile ()
617 {
618 /* First notify observers that this objfile is about to be freed. */
619 observer_notify_free_objfile (this);
620
621 /* Free all separate debug objfiles. */
622 free_objfile_separate_debug (this);
623
624 if (separate_debug_objfile_backlink)
625 {
626 /* We freed the separate debug file, make sure the base objfile
627 doesn't reference it. */
628 struct objfile *child;
629
630 child = separate_debug_objfile_backlink->separate_debug_objfile;
631
632 if (child == this)
633 {
634 /* THIS is the first child. */
635 separate_debug_objfile_backlink->separate_debug_objfile =
636 separate_debug_objfile_link;
637 }
638 else
639 {
640 /* Find THIS in the list. */
641 while (1)
642 {
643 if (child->separate_debug_objfile_link == this)
644 {
645 child->separate_debug_objfile_link =
646 separate_debug_objfile_link;
647 break;
648 }
649 child = child->separate_debug_objfile_link;
650 gdb_assert (child);
651 }
652 }
653 }
654
655 /* Remove any references to this objfile in the global value
656 lists. */
657 preserve_values (this);
658
659 /* It still may reference data modules have associated with the objfile and
660 the symbol file data. */
661 forget_cached_source_info_for_objfile (this);
662
663 breakpoint_free_objfile (this);
664 btrace_free_objfile (this);
665
666 /* First do any symbol file specific actions required when we are
667 finished with a particular symbol file. Note that if the objfile
668 is using reusable symbol information (via mmalloc) then each of
669 these routines is responsible for doing the correct thing, either
670 freeing things which are valid only during this particular gdb
671 execution, or leaving them to be reused during the next one. */
672
673 if (sf != NULL)
674 (*sf->sym_finish) (this);
675
676 /* Discard any data modules have associated with the objfile. The function
677 still may reference obfd. */
678 objfile_free_data (this);
679
680 if (obfd)
681 gdb_bfd_unref (obfd);
682 else
683 free_objfile_per_bfd_storage (per_bfd);
684
685 /* Remove it from the chain of all objfiles. */
686
687 unlink_objfile (this);
688
689 if (this == symfile_objfile)
690 symfile_objfile = NULL;
691
692 /* Before the symbol table code was redone to make it easier to
693 selectively load and remove information particular to a specific
694 linkage unit, gdb used to do these things whenever the monolithic
695 symbol table was blown away. How much still needs to be done
696 is unknown, but we play it safe for now and keep each action until
697 it is shown to be no longer needed. */
698
699 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
700 for example), so we need to call this here. */
701 clear_pc_function_cache ();
702
703 /* Clear globals which might have pointed into a removed objfile.
704 FIXME: It's not clear which of these are supposed to persist
705 between expressions and which ought to be reset each time. */
706 expression_context_block = NULL;
707 innermost_block = NULL;
708
709 /* Check to see if the current_source_symtab belongs to this objfile,
710 and if so, call clear_current_source_symtab_and_line. */
711
712 {
713 struct symtab_and_line cursal = get_current_source_symtab_and_line ();
714
715 if (cursal.symtab && SYMTAB_OBJFILE (cursal.symtab) == this)
716 clear_current_source_symtab_and_line ();
717 }
718
719 /* Free the obstacks for non-reusable objfiles. */
720 psymbol_bcache_free (psymbol_cache);
721 obstack_free (&objfile_obstack, 0);
722
723 /* Rebuild section map next time we need it. */
724 get_objfile_pspace_data (pspace)->section_map_dirty = 1;
725
726 /* Free the map for static links. There's no need to free static link
727 themselves since they were allocated on the objstack. */
728 if (static_links != NULL)
729 htab_delete (static_links);
730 }
731
732 /* Free all the object files at once and clean up their users. */
733
734 void
735 free_all_objfiles (void)
736 {
737 struct objfile *objfile, *temp;
738 struct so_list *so;
739
740 /* Any objfile referencewould become stale. */
741 for (so = master_so_list (); so; so = so->next)
742 gdb_assert (so->objfile == NULL);
743
744 ALL_OBJFILES_SAFE (objfile, temp)
745 {
746 delete objfile;
747 }
748 clear_symtab_users (0);
749 }
750
751 /* A helper function for objfile_relocate1 that relocates a single
752 symbol. */
753
754 static void
755 relocate_one_symbol (struct symbol *sym, struct objfile *objfile,
756 struct section_offsets *delta)
757 {
758 fixup_symbol_section (sym, objfile);
759
760 /* The RS6000 code from which this was taken skipped
761 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
762 But I'm leaving out that test, on the theory that
763 they can't possibly pass the tests below. */
764 if ((SYMBOL_CLASS (sym) == LOC_LABEL
765 || SYMBOL_CLASS (sym) == LOC_STATIC)
766 && SYMBOL_SECTION (sym) >= 0)
767 {
768 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (delta, SYMBOL_SECTION (sym));
769 }
770 }
771
772 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
773 entries in new_offsets. SEPARATE_DEBUG_OBJFILE is not touched here.
774 Return non-zero iff any change happened. */
775
776 static int
777 objfile_relocate1 (struct objfile *objfile,
778 const struct section_offsets *new_offsets)
779 {
780 struct obj_section *s;
781 struct section_offsets *delta =
782 ((struct section_offsets *)
783 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
784
785 int i;
786 int something_changed = 0;
787
788 for (i = 0; i < objfile->num_sections; ++i)
789 {
790 delta->offsets[i] =
791 ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
792 if (ANOFFSET (delta, i) != 0)
793 something_changed = 1;
794 }
795 if (!something_changed)
796 return 0;
797
798 /* OK, get all the symtabs. */
799 {
800 struct compunit_symtab *cust;
801 struct symtab *s;
802
803 ALL_OBJFILE_FILETABS (objfile, cust, s)
804 {
805 struct linetable *l;
806 int i;
807
808 /* First the line table. */
809 l = SYMTAB_LINETABLE (s);
810 if (l)
811 {
812 for (i = 0; i < l->nitems; ++i)
813 l->item[i].pc += ANOFFSET (delta,
814 COMPUNIT_BLOCK_LINE_SECTION
815 (cust));
816 }
817 }
818
819 ALL_OBJFILE_COMPUNITS (objfile, cust)
820 {
821 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (cust);
822 int block_line_section = COMPUNIT_BLOCK_LINE_SECTION (cust);
823
824 if (BLOCKVECTOR_MAP (bv))
825 addrmap_relocate (BLOCKVECTOR_MAP (bv),
826 ANOFFSET (delta, block_line_section));
827
828 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
829 {
830 struct block *b;
831 struct symbol *sym;
832 struct dict_iterator iter;
833
834 b = BLOCKVECTOR_BLOCK (bv, i);
835 BLOCK_START (b) += ANOFFSET (delta, block_line_section);
836 BLOCK_END (b) += ANOFFSET (delta, block_line_section);
837
838 /* We only want to iterate over the local symbols, not any
839 symbols in included symtabs. */
840 ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
841 {
842 relocate_one_symbol (sym, objfile, delta);
843 }
844 }
845 }
846 }
847
848 /* Relocate isolated symbols. */
849 {
850 struct symbol *iter;
851
852 for (iter = objfile->template_symbols; iter; iter = iter->hash_next)
853 relocate_one_symbol (iter, objfile, delta);
854 }
855
856 if (objfile->psymtabs_addrmap)
857 addrmap_relocate (objfile->psymtabs_addrmap,
858 ANOFFSET (delta, SECT_OFF_TEXT (objfile)));
859
860 if (objfile->sf)
861 objfile->sf->qf->relocate (objfile, new_offsets, delta);
862
863 {
864 int i;
865
866 for (i = 0; i < objfile->num_sections; ++i)
867 (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
868 }
869
870 /* Rebuild section map next time we need it. */
871 get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1;
872
873 /* Update the table in exec_ops, used to read memory. */
874 ALL_OBJFILE_OSECTIONS (objfile, s)
875 {
876 int idx = s - objfile->sections;
877
878 exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
879 obj_section_addr (s));
880 }
881
882 /* Data changed. */
883 return 1;
884 }
885
886 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
887 entries in new_offsets. Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
888
889 The number and ordering of sections does differ between the two objfiles.
890 Only their names match. Also the file offsets will differ (objfile being
891 possibly prelinked but separate_debug_objfile is probably not prelinked) but
892 the in-memory absolute address as specified by NEW_OFFSETS must match both
893 files. */
894
895 void
896 objfile_relocate (struct objfile *objfile,
897 const struct section_offsets *new_offsets)
898 {
899 struct objfile *debug_objfile;
900 int changed = 0;
901
902 changed |= objfile_relocate1 (objfile, new_offsets);
903
904 for (debug_objfile = objfile->separate_debug_objfile;
905 debug_objfile;
906 debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
907 {
908 struct section_addr_info *objfile_addrs;
909 struct cleanup *my_cleanups;
910
911 objfile_addrs = build_section_addr_info_from_objfile (objfile);
912 my_cleanups = make_cleanup (xfree, objfile_addrs);
913
914 /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
915 relative ones must be already created according to debug_objfile. */
916
917 addr_info_make_relative (objfile_addrs, debug_objfile->obfd);
918
919 gdb_assert (debug_objfile->num_sections
920 == gdb_bfd_count_sections (debug_objfile->obfd));
921 std::vector<struct section_offsets>
922 new_debug_offsets (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections));
923 relative_addr_info_to_section_offsets (new_debug_offsets.data (),
924 debug_objfile->num_sections,
925 objfile_addrs);
926
927 changed |= objfile_relocate1 (debug_objfile, new_debug_offsets.data ());
928
929 do_cleanups (my_cleanups);
930 }
931
932 /* Relocate breakpoints as necessary, after things are relocated. */
933 if (changed)
934 breakpoint_re_set ();
935 }
936
937 /* Rebase (add to the offsets) OBJFILE by SLIDE. SEPARATE_DEBUG_OBJFILE is
938 not touched here.
939 Return non-zero iff any change happened. */
940
941 static int
942 objfile_rebase1 (struct objfile *objfile, CORE_ADDR slide)
943 {
944 struct section_offsets *new_offsets =
945 ((struct section_offsets *)
946 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
947 int i;
948
949 for (i = 0; i < objfile->num_sections; ++i)
950 new_offsets->offsets[i] = slide;
951
952 return objfile_relocate1 (objfile, new_offsets);
953 }
954
955 /* Rebase (add to the offsets) OBJFILE by SLIDE. Process also OBJFILE's
956 SEPARATE_DEBUG_OBJFILEs. */
957
958 void
959 objfile_rebase (struct objfile *objfile, CORE_ADDR slide)
960 {
961 struct objfile *debug_objfile;
962 int changed = 0;
963
964 changed |= objfile_rebase1 (objfile, slide);
965
966 for (debug_objfile = objfile->separate_debug_objfile;
967 debug_objfile;
968 debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
969 changed |= objfile_rebase1 (debug_objfile, slide);
970
971 /* Relocate breakpoints as necessary, after things are relocated. */
972 if (changed)
973 breakpoint_re_set ();
974 }
975
976 /* Return non-zero if OBJFILE has partial symbols. */
977
978 int
979 objfile_has_partial_symbols (struct objfile *objfile)
980 {
981 if (!objfile->sf)
982 return 0;
983
984 /* If we have not read psymbols, but we have a function capable of reading
985 them, then that is an indication that they are in fact available. Without
986 this function the symbols may have been already read in but they also may
987 not be present in this objfile. */
988 if ((objfile->flags & OBJF_PSYMTABS_READ) == 0
989 && objfile->sf->sym_read_psymbols != NULL)
990 return 1;
991
992 return objfile->sf->qf->has_symbols (objfile);
993 }
994
995 /* Return non-zero if OBJFILE has full symbols. */
996
997 int
998 objfile_has_full_symbols (struct objfile *objfile)
999 {
1000 return objfile->compunit_symtabs != NULL;
1001 }
1002
1003 /* Return non-zero if OBJFILE has full or partial symbols, either directly
1004 or through a separate debug file. */
1005
1006 int
1007 objfile_has_symbols (struct objfile *objfile)
1008 {
1009 struct objfile *o;
1010
1011 for (o = objfile; o; o = objfile_separate_debug_iterate (objfile, o))
1012 if (objfile_has_partial_symbols (o) || objfile_has_full_symbols (o))
1013 return 1;
1014 return 0;
1015 }
1016
1017
1018 /* Many places in gdb want to test just to see if we have any partial
1019 symbols available. This function returns zero if none are currently
1020 available, nonzero otherwise. */
1021
1022 int
1023 have_partial_symbols (void)
1024 {
1025 struct objfile *ofp;
1026
1027 ALL_OBJFILES (ofp)
1028 {
1029 if (objfile_has_partial_symbols (ofp))
1030 return 1;
1031 }
1032 return 0;
1033 }
1034
1035 /* Many places in gdb want to test just to see if we have any full
1036 symbols available. This function returns zero if none are currently
1037 available, nonzero otherwise. */
1038
1039 int
1040 have_full_symbols (void)
1041 {
1042 struct objfile *ofp;
1043
1044 ALL_OBJFILES (ofp)
1045 {
1046 if (objfile_has_full_symbols (ofp))
1047 return 1;
1048 }
1049 return 0;
1050 }
1051
1052
1053 /* This operations deletes all objfile entries that represent solibs that
1054 weren't explicitly loaded by the user, via e.g., the add-symbol-file
1055 command. */
1056
1057 void
1058 objfile_purge_solibs (void)
1059 {
1060 struct objfile *objf;
1061 struct objfile *temp;
1062
1063 ALL_OBJFILES_SAFE (objf, temp)
1064 {
1065 /* We assume that the solib package has been purged already, or will
1066 be soon. */
1067
1068 if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
1069 delete objf;
1070 }
1071 }
1072
1073
1074 /* Many places in gdb want to test just to see if we have any minimal
1075 symbols available. This function returns zero if none are currently
1076 available, nonzero otherwise. */
1077
1078 int
1079 have_minimal_symbols (void)
1080 {
1081 struct objfile *ofp;
1082
1083 ALL_OBJFILES (ofp)
1084 {
1085 if (ofp->per_bfd->minimal_symbol_count > 0)
1086 {
1087 return 1;
1088 }
1089 }
1090 return 0;
1091 }
1092
1093 /* Qsort comparison function. */
1094
1095 static int
1096 qsort_cmp (const void *a, const void *b)
1097 {
1098 const struct obj_section *sect1 = *(const struct obj_section **) a;
1099 const struct obj_section *sect2 = *(const struct obj_section **) b;
1100 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1101 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1102
1103 if (sect1_addr < sect2_addr)
1104 return -1;
1105 else if (sect1_addr > sect2_addr)
1106 return 1;
1107 else
1108 {
1109 /* Sections are at the same address. This could happen if
1110 A) we have an objfile and a separate debuginfo.
1111 B) we are confused, and have added sections without proper relocation,
1112 or something like that. */
1113
1114 const struct objfile *const objfile1 = sect1->objfile;
1115 const struct objfile *const objfile2 = sect2->objfile;
1116
1117 if (objfile1->separate_debug_objfile == objfile2
1118 || objfile2->separate_debug_objfile == objfile1)
1119 {
1120 /* Case A. The ordering doesn't matter: separate debuginfo files
1121 will be filtered out later. */
1122
1123 return 0;
1124 }
1125
1126 /* Case B. Maintain stable sort order, so bugs in GDB are easier to
1127 triage. This section could be slow (since we iterate over all
1128 objfiles in each call to qsort_cmp), but this shouldn't happen
1129 very often (GDB is already in a confused state; one hopes this
1130 doesn't happen at all). If you discover that significant time is
1131 spent in the loops below, do 'set complaints 100' and examine the
1132 resulting complaints. */
1133
1134 if (objfile1 == objfile2)
1135 {
1136 /* Both sections came from the same objfile. We are really confused.
1137 Sort on sequence order of sections within the objfile. */
1138
1139 const struct obj_section *osect;
1140
1141 ALL_OBJFILE_OSECTIONS (objfile1, osect)
1142 if (osect == sect1)
1143 return -1;
1144 else if (osect == sect2)
1145 return 1;
1146
1147 /* We should have found one of the sections before getting here. */
1148 gdb_assert_not_reached ("section not found");
1149 }
1150 else
1151 {
1152 /* Sort on sequence number of the objfile in the chain. */
1153
1154 const struct objfile *objfile;
1155
1156 ALL_OBJFILES (objfile)
1157 if (objfile == objfile1)
1158 return -1;
1159 else if (objfile == objfile2)
1160 return 1;
1161
1162 /* We should have found one of the objfiles before getting here. */
1163 gdb_assert_not_reached ("objfile not found");
1164 }
1165 }
1166
1167 /* Unreachable. */
1168 gdb_assert_not_reached ("unexpected code path");
1169 return 0;
1170 }
1171
1172 /* Select "better" obj_section to keep. We prefer the one that came from
1173 the real object, rather than the one from separate debuginfo.
1174 Most of the time the two sections are exactly identical, but with
1175 prelinking the .rel.dyn section in the real object may have different
1176 size. */
1177
1178 static struct obj_section *
1179 preferred_obj_section (struct obj_section *a, struct obj_section *b)
1180 {
1181 gdb_assert (obj_section_addr (a) == obj_section_addr (b));
1182 gdb_assert ((a->objfile->separate_debug_objfile == b->objfile)
1183 || (b->objfile->separate_debug_objfile == a->objfile));
1184 gdb_assert ((a->objfile->separate_debug_objfile_backlink == b->objfile)
1185 || (b->objfile->separate_debug_objfile_backlink == a->objfile));
1186
1187 if (a->objfile->separate_debug_objfile != NULL)
1188 return a;
1189 return b;
1190 }
1191
1192 /* Return 1 if SECTION should be inserted into the section map.
1193 We want to insert only non-overlay and non-TLS section. */
1194
1195 static int
1196 insert_section_p (const struct bfd *abfd,
1197 const struct bfd_section *section)
1198 {
1199 const bfd_vma lma = bfd_section_lma (abfd, section);
1200
1201 if (overlay_debugging && lma != 0 && lma != bfd_section_vma (abfd, section)
1202 && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
1203 /* This is an overlay section. IN_MEMORY check is needed to avoid
1204 discarding sections from the "system supplied DSO" (aka vdso)
1205 on some Linux systems (e.g. Fedora 11). */
1206 return 0;
1207 if ((bfd_get_section_flags (abfd, section) & SEC_THREAD_LOCAL) != 0)
1208 /* This is a TLS section. */
1209 return 0;
1210
1211 return 1;
1212 }
1213
1214 /* Filter out overlapping sections where one section came from the real
1215 objfile, and the other from a separate debuginfo file.
1216 Return the size of table after redundant sections have been eliminated. */
1217
1218 static int
1219 filter_debuginfo_sections (struct obj_section **map, int map_size)
1220 {
1221 int i, j;
1222
1223 for (i = 0, j = 0; i < map_size - 1; i++)
1224 {
1225 struct obj_section *const sect1 = map[i];
1226 struct obj_section *const sect2 = map[i + 1];
1227 const struct objfile *const objfile1 = sect1->objfile;
1228 const struct objfile *const objfile2 = sect2->objfile;
1229 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1230 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1231
1232 if (sect1_addr == sect2_addr
1233 && (objfile1->separate_debug_objfile == objfile2
1234 || objfile2->separate_debug_objfile == objfile1))
1235 {
1236 map[j++] = preferred_obj_section (sect1, sect2);
1237 ++i;
1238 }
1239 else
1240 map[j++] = sect1;
1241 }
1242
1243 if (i < map_size)
1244 {
1245 gdb_assert (i == map_size - 1);
1246 map[j++] = map[i];
1247 }
1248
1249 /* The map should not have shrunk to less than half the original size. */
1250 gdb_assert (map_size / 2 <= j);
1251
1252 return j;
1253 }
1254
1255 /* Filter out overlapping sections, issuing a warning if any are found.
1256 Overlapping sections could really be overlay sections which we didn't
1257 classify as such in insert_section_p, or we could be dealing with a
1258 corrupt binary. */
1259
1260 static int
1261 filter_overlapping_sections (struct obj_section **map, int map_size)
1262 {
1263 int i, j;
1264
1265 for (i = 0, j = 0; i < map_size - 1; )
1266 {
1267 int k;
1268
1269 map[j++] = map[i];
1270 for (k = i + 1; k < map_size; k++)
1271 {
1272 struct obj_section *const sect1 = map[i];
1273 struct obj_section *const sect2 = map[k];
1274 const CORE_ADDR sect1_addr = obj_section_addr (sect1);
1275 const CORE_ADDR sect2_addr = obj_section_addr (sect2);
1276 const CORE_ADDR sect1_endaddr = obj_section_endaddr (sect1);
1277
1278 gdb_assert (sect1_addr <= sect2_addr);
1279
1280 if (sect1_endaddr <= sect2_addr)
1281 break;
1282 else
1283 {
1284 /* We have an overlap. Report it. */
1285
1286 struct objfile *const objf1 = sect1->objfile;
1287 struct objfile *const objf2 = sect2->objfile;
1288
1289 const struct bfd_section *const bfds1 = sect1->the_bfd_section;
1290 const struct bfd_section *const bfds2 = sect2->the_bfd_section;
1291
1292 const CORE_ADDR sect2_endaddr = obj_section_endaddr (sect2);
1293
1294 struct gdbarch *const gdbarch = get_objfile_arch (objf1);
1295
1296 complaint (&symfile_complaints,
1297 _("unexpected overlap between:\n"
1298 " (A) section `%s' from `%s' [%s, %s)\n"
1299 " (B) section `%s' from `%s' [%s, %s).\n"
1300 "Will ignore section B"),
1301 bfd_section_name (abfd1, bfds1), objfile_name (objf1),
1302 paddress (gdbarch, sect1_addr),
1303 paddress (gdbarch, sect1_endaddr),
1304 bfd_section_name (abfd2, bfds2), objfile_name (objf2),
1305 paddress (gdbarch, sect2_addr),
1306 paddress (gdbarch, sect2_endaddr));
1307 }
1308 }
1309 i = k;
1310 }
1311
1312 if (i < map_size)
1313 {
1314 gdb_assert (i == map_size - 1);
1315 map[j++] = map[i];
1316 }
1317
1318 return j;
1319 }
1320
1321
1322 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1323 TLS, overlay and overlapping sections. */
1324
1325 static void
1326 update_section_map (struct program_space *pspace,
1327 struct obj_section ***pmap, int *pmap_size)
1328 {
1329 struct objfile_pspace_info *pspace_info;
1330 int alloc_size, map_size, i;
1331 struct obj_section *s, **map;
1332 struct objfile *objfile;
1333
1334 pspace_info = get_objfile_pspace_data (pspace);
1335 gdb_assert (pspace_info->section_map_dirty != 0
1336 || pspace_info->new_objfiles_available != 0);
1337
1338 map = *pmap;
1339 xfree (map);
1340
1341 alloc_size = 0;
1342 ALL_PSPACE_OBJFILES (pspace, objfile)
1343 ALL_OBJFILE_OSECTIONS (objfile, s)
1344 if (insert_section_p (objfile->obfd, s->the_bfd_section))
1345 alloc_size += 1;
1346
1347 /* This happens on detach/attach (e.g. in gdb.base/attach.exp). */
1348 if (alloc_size == 0)
1349 {
1350 *pmap = NULL;
1351 *pmap_size = 0;
1352 return;
1353 }
1354
1355 map = XNEWVEC (struct obj_section *, alloc_size);
1356
1357 i = 0;
1358 ALL_PSPACE_OBJFILES (pspace, objfile)
1359 ALL_OBJFILE_OSECTIONS (objfile, s)
1360 if (insert_section_p (objfile->obfd, s->the_bfd_section))
1361 map[i++] = s;
1362
1363 qsort (map, alloc_size, sizeof (*map), qsort_cmp);
1364 map_size = filter_debuginfo_sections(map, alloc_size);
1365 map_size = filter_overlapping_sections(map, map_size);
1366
1367 if (map_size < alloc_size)
1368 /* Some sections were eliminated. Trim excess space. */
1369 map = XRESIZEVEC (struct obj_section *, map, map_size);
1370 else
1371 gdb_assert (alloc_size == map_size);
1372
1373 *pmap = map;
1374 *pmap_size = map_size;
1375 }
1376
1377 /* Bsearch comparison function. */
1378
1379 static int
1380 bsearch_cmp (const void *key, const void *elt)
1381 {
1382 const CORE_ADDR pc = *(CORE_ADDR *) key;
1383 const struct obj_section *section = *(const struct obj_section **) elt;
1384
1385 if (pc < obj_section_addr (section))
1386 return -1;
1387 if (pc < obj_section_endaddr (section))
1388 return 0;
1389 return 1;
1390 }
1391
1392 /* Returns a section whose range includes PC or NULL if none found. */
1393
1394 struct obj_section *
1395 find_pc_section (CORE_ADDR pc)
1396 {
1397 struct objfile_pspace_info *pspace_info;
1398 struct obj_section *s, **sp;
1399
1400 /* Check for mapped overlay section first. */
1401 s = find_pc_mapped_section (pc);
1402 if (s)
1403 return s;
1404
1405 pspace_info = get_objfile_pspace_data (current_program_space);
1406 if (pspace_info->section_map_dirty
1407 || (pspace_info->new_objfiles_available
1408 && !pspace_info->inhibit_updates))
1409 {
1410 update_section_map (current_program_space,
1411 &pspace_info->sections,
1412 &pspace_info->num_sections);
1413
1414 /* Don't need updates to section map until objfiles are added,
1415 removed or relocated. */
1416 pspace_info->new_objfiles_available = 0;
1417 pspace_info->section_map_dirty = 0;
1418 }
1419
1420 /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1421 bsearch be non-NULL. */
1422 if (pspace_info->sections == NULL)
1423 {
1424 gdb_assert (pspace_info->num_sections == 0);
1425 return NULL;
1426 }
1427
1428 sp = (struct obj_section **) bsearch (&pc,
1429 pspace_info->sections,
1430 pspace_info->num_sections,
1431 sizeof (*pspace_info->sections),
1432 bsearch_cmp);
1433 if (sp != NULL)
1434 return *sp;
1435 return NULL;
1436 }
1437
1438
1439 /* Return non-zero if PC is in a section called NAME. */
1440
1441 int
1442 pc_in_section (CORE_ADDR pc, const char *name)
1443 {
1444 struct obj_section *s;
1445 int retval = 0;
1446
1447 s = find_pc_section (pc);
1448
1449 retval = (s != NULL
1450 && s->the_bfd_section->name != NULL
1451 && strcmp (s->the_bfd_section->name, name) == 0);
1452 return (retval);
1453 }
1454
1455
1456 /* Set section_map_dirty so section map will be rebuilt next time it
1457 is used. Called by reread_symbols. */
1458
1459 void
1460 objfiles_changed (void)
1461 {
1462 /* Rebuild section map next time we need it. */
1463 get_objfile_pspace_data (current_program_space)->section_map_dirty = 1;
1464 }
1465
1466 /* See comments in objfiles.h. */
1467
1468 void
1469 inhibit_section_map_updates (struct program_space *pspace)
1470 {
1471 get_objfile_pspace_data (pspace)->inhibit_updates = 1;
1472 }
1473
1474 /* See comments in objfiles.h. */
1475
1476 void
1477 resume_section_map_updates (struct program_space *pspace)
1478 {
1479 get_objfile_pspace_data (pspace)->inhibit_updates = 0;
1480 }
1481
1482 /* See comments in objfiles.h. */
1483
1484 void
1485 resume_section_map_updates_cleanup (void *arg)
1486 {
1487 resume_section_map_updates ((struct program_space *) arg);
1488 }
1489
1490 /* Return 1 if ADDR maps into one of the sections of OBJFILE and 0
1491 otherwise. */
1492
1493 int
1494 is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile)
1495 {
1496 struct obj_section *osect;
1497
1498 if (objfile == NULL)
1499 return 0;
1500
1501 ALL_OBJFILE_OSECTIONS (objfile, osect)
1502 {
1503 if (section_is_overlay (osect) && !section_is_mapped (osect))
1504 continue;
1505
1506 if (obj_section_addr (osect) <= addr
1507 && addr < obj_section_endaddr (osect))
1508 return 1;
1509 }
1510 return 0;
1511 }
1512
1513 int
1514 shared_objfile_contains_address_p (struct program_space *pspace,
1515 CORE_ADDR address)
1516 {
1517 struct objfile *objfile;
1518
1519 ALL_PSPACE_OBJFILES (pspace, objfile)
1520 {
1521 if ((objfile->flags & OBJF_SHARED) != 0
1522 && is_addr_in_objfile (address, objfile))
1523 return 1;
1524 }
1525
1526 return 0;
1527 }
1528
1529 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1530 gdbarch method. It is equivalent to use the ALL_OBJFILES macro,
1531 searching the objfiles in the order they are stored internally,
1532 ignoring CURRENT_OBJFILE.
1533
1534 On most platorms, it should be close enough to doing the best
1535 we can without some knowledge specific to the architecture. */
1536
1537 void
1538 default_iterate_over_objfiles_in_search_order
1539 (struct gdbarch *gdbarch,
1540 iterate_over_objfiles_in_search_order_cb_ftype *cb,
1541 void *cb_data, struct objfile *current_objfile)
1542 {
1543 int stop = 0;
1544 struct objfile *objfile;
1545
1546 ALL_OBJFILES (objfile)
1547 {
1548 stop = cb (objfile, cb_data);
1549 if (stop)
1550 return;
1551 }
1552 }
1553
1554 /* See objfiles.h. */
1555
1556 const char *
1557 objfile_name (const struct objfile *objfile)
1558 {
1559 if (objfile->obfd != NULL)
1560 return bfd_get_filename (objfile->obfd);
1561
1562 return objfile->original_name;
1563 }
1564
1565 /* See objfiles.h. */
1566
1567 const char *
1568 objfile_filename (const struct objfile *objfile)
1569 {
1570 if (objfile->obfd != NULL)
1571 return bfd_get_filename (objfile->obfd);
1572
1573 return NULL;
1574 }
1575
1576 /* See objfiles.h. */
1577
1578 const char *
1579 objfile_debug_name (const struct objfile *objfile)
1580 {
1581 return lbasename (objfile->original_name);
1582 }
1583
1584 /* See objfiles.h. */
1585
1586 const char *
1587 objfile_flavour_name (struct objfile *objfile)
1588 {
1589 if (objfile->obfd != NULL)
1590 return bfd_flavour_name (bfd_get_flavour (objfile->obfd));
1591 return NULL;
1592 }
1593
1594 void
1595 _initialize_objfiles (void)
1596 {
1597 objfiles_pspace_data
1598 = register_program_space_data_with_cleanup (NULL,
1599 objfiles_pspace_data_cleanup);
1600
1601 objfiles_bfd_data = register_bfd_data_with_cleanup (NULL,
1602 objfile_bfd_data_free);
1603 }
objfiles_changed
void objfiles_changed(void)
Definition: objfiles.c:1460
gdbarch
Definition: gdbarch.c:127
objfile::flags
objfile_flags flags
Definition: objfiles.h:311
resume_section_map_updates
void resume_section_map_updates(struct program_space *pspace)
Definition: objfiles.c:1477
addr_info_make_relative
void addr_info_make_relative(struct section_addr_info *addrs, bfd *abfd)
Definition: symfile.c:547
static_link_htab_entry
Definition: objfiles.c:217
object_files
#define object_files
Definition: progspace.h:231
gdb-stabs.h
gdb_obstack.h
section_offsets::offsets
CORE_ADDR offsets[1]
Definition: symtab.h:1273
OBSTACK_CALLOC
#define OBSTACK_CALLOC(OBSTACK, NUMBER, TYPE)
Definition: gdb_obstack.h:30
SECT_OFF_TEXT
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:686
objfile::obfd
bfd * obfd
Definition: objfiles.h:342
ALL_OBJFILE_FILETABS
#define ALL_OBJFILE_FILETABS(objfile, cu, s)
Definition: objfiles.h:594
pc_in_section
int pc_in_section(CORE_ADDR pc, const char *name)
Definition: objfiles.c:1442
psymbol_bcache_init
struct psymbol_bcache * psymbol_bcache_init(void)
Definition: psymtab.c:1663
DEFINE_REGISTRY
#define DEFINE_REGISTRY(TAG, ACCESS)
Definition: registry.h:154
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
linetable::item
struct linetable_entry item[1]
Definition: symtab.h:1258
psymbol_bcache_free
void psymbol_bcache_free(struct psymbol_bcache *bcache)
Definition: psymtab.c:1674
gdb_bfd_section_index
int gdb_bfd_section_index(bfd *abfd, asection *section)
Definition: gdb_bfd.c:888
xfree
void xfree(void *)
free_all_objfiles
void free_all_objfiles(void)
Definition: objfiles.c:735
objfile::separate_debug_objfile_backlink
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:441
so_list::next
struct so_list * next
Definition: solist.h:44
solist.h
section_is_overlay
int section_is_overlay(struct obj_section *section)
Definition: symfile.c:2978
symbol::hash_next
struct symbol * hash_next
Definition: symtab.h:1127
obj_section::the_bfd_section
struct bfd_section * the_bfd_section
Definition: objfiles.h:126
relative_addr_info_to_section_offsets
void relative_addr_info_to_section_offsets(struct section_offsets *section_offsets, int num_sections, const struct section_addr_info *addrs)
Definition: symfile.c:464
objfile_has_symbols
int objfile_has_symbols(struct objfile *objfile)
Definition: objfiles.c:1007
objfile::pspace
struct program_space * pspace
Definition: objfiles.h:315
gdb_bfd_requires_relocations
int gdb_bfd_requires_relocations(bfd *abfd)
Definition: gdb_bfd.c:914
static_link_htab_entry::static_link
const struct dynamic_prop * static_link
Definition: objfiles.c:220
get_current_source_symtab_and_line
struct symtab_and_line get_current_source_symtab_and_line(void)
Definition: source.c:171
SYMBOL_CLASS
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:1155
objfile_per_bfd_storage
Definition: objfiles.h:187
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
obj_section_endaddr
#define obj_section_endaddr(s)
Definition: objfiles.h:146
OBJF_NOT_FILENAME
Definition: objfile-flags.h:66
objfile::mtime
long mtime
Definition: objfiles.h:352
objfile_filename
const char * objfile_filename(const struct objfile *objfile)
Definition: objfiles.c:1568
REGISTRY_ACCESS_FIELD
#define REGISTRY_ACCESS_FIELD(CONTAINER)
Definition: registry.h:85
objfile_relocate
void objfile_relocate(struct objfile *objfile, const struct section_offsets *new_offsets)
Definition: objfiles.c:896
build_section_addr_info_from_objfile
struct section_addr_info * build_section_addr_info_from_objfile(const struct objfile *objfile)
Definition: symfile.c:296
ALL_DICT_SYMBOLS
#define ALL_DICT_SYMBOLS(dict, iter, sym)
Definition: dictionary.h:162
psymtab.h
btrace.h
set_objfile_main_name
void set_objfile_main_name(struct objfile *objfile, const char *name, enum language lang)
Definition: objfiles.c:204
innermost_block
const struct block * innermost_block
Definition: parse.c:71
have_partial_symbols
int have_partial_symbols(void)
Definition: objfiles.c:1023
so_list
Definition: solist.h:38
compunit_symtab
Definition: symtab.h:1380
ALL_OBJFILE_OSECTIONS
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition: objfiles.h:630
BLOCKVECTOR_BLOCK
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:125
OBJF_SHARED
Definition: objfile-flags.h:42
dynamic_prop
Definition: gdbtypes.h:398
objfile_pspace_info::inhibit_updates
int inhibit_updates
Definition: objfiles.c:79
cleanup
Definition: cleanups.c:38
_
#define _(String)
Definition: gdb_locale.h:35
gdb_bfd.h
inhibit_section_map_updates
void inhibit_section_map_updates(struct program_space *pspace)
Definition: objfiles.c:1469
defs.h
objfile::original_name
char * original_name
Definition: objfiles.h:305
BLOCK_START
#define BLOCK_START(bl)
Definition: block.h:105
objfile::per_bfd
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:347
objfile::template_symbols
struct symbol * template_symbols
Definition: objfiles.h:457
is_addr_in_objfile
int is_addr_in_objfile(CORE_ADDR addr, const struct objfile *objfile)
Definition: objfiles.c:1494
objfile_rebase1
static int objfile_rebase1(struct objfile *objfile, CORE_ADDR slide)
Definition: objfiles.c:942
set_objfile_per_bfd
void set_objfile_per_bfd(struct objfile *objfile)
Definition: objfiles.c:195
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
objfiles.h
arch-utils.h
observer.h
breakpoint_free_objfile
void breakpoint_free_objfile(struct objfile *objfile)
Definition: breakpoint.c:15404
gdb_bfd_ref
void gdb_bfd_ref(struct bfd *abfd)
Definition: gdb_bfd.c:523
observer_notify_free_objfile
void observer_notify_free_objfile(struct objfile *objfile)
parser-defs.h
flags
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1891
symtab.h
default_iterate_over_objfiles_in_search_order
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:1539
SIZEOF_N_SECTION_OFFSETS
#define SIZEOF_N_SECTION_OFFSETS(n)
Definition: symtab.h:1283
master_so_list
struct so_list * master_so_list(void)
Definition: solib.c:666
objfile_has_partial_symbols
int objfile_has_partial_symbols(struct objfile *objfile)
Definition: objfiles.c:979
name
const char *const name
Definition: aarch64-tdep.c:76
shared_objfile_contains_address_p
int shared_objfile_contains_address_p(struct program_space *pspace, CORE_ADDR address)
Definition: objfiles.c:1514
section_offsets
Definition: symtab.h:1271
update_section_map
static void update_section_map(struct program_space *pspace, struct obj_section ***pmap, int *pmap_size)
Definition: objfiles.c:1326
breakpoint_re_set
void breakpoint_re_set(void)
Definition: breakpoint.c:13952
SYMBOL_VALUE_ADDRESS
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:464
free_objfile_separate_debug
void free_objfile_separate_debug(struct objfile *objfile)
Definition: objfiles.c:602
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
clear_current_source_symtab_and_line
void clear_current_source_symtab_and_line(void)
Definition: source.c:232
gdb_bfd_unref
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:561
linetable_entry::pc
CORE_ADDR pc
Definition: symtab.h:1231
objfile::objfile
objfile(bfd *, const char *, objfile_flags)
Definition: objfiles.c:373
objfile_has_full_symbols
int objfile_has_full_symbols(struct objfile *objfile)
Definition: objfiles.c:998
SYMTAB_OBJFILE
#define SYMTAB_OBJFILE(symtab)
Definition: symtab.h:1336
objfile::static_links
htab_t static_links
Definition: objfiles.h:470
objfiles_pspace_data
static const struct program_space_data * objfiles_pspace_data
Definition: objfiles.c:83
objfiles_pspace_data_cleanup
static void objfiles_pspace_data_cleanup(struct program_space *pspace, void *arg)
Definition: objfiles.c:86
objfile_per_bfd_storage::minimal_symbol_count
int minimal_symbol_count
Definition: objfiles.h:243
OBJF_PSYMTABS_READ
Definition: objfile-flags.h:57
objfile_pspace_info::sections
struct obj_section ** sections
Definition: objfiles.c:68
linetable
Definition: symtab.h:1251
preserve_values
void preserve_values(struct objfile *objfile)
Definition: value.c:2629
add_separate_debug_objfile
void add_separate_debug_objfile(struct objfile *objfile, struct objfile *parent)
Definition: objfiles.c:578
expression.h
gdb_assert_not_reached
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:55
objfile::sf
const struct sym_fns * sf
Definition: objfiles.h:381
build_objfile_section_table
void build_objfile_section_table(struct objfile *objfile)
Definition: objfiles.c:342
static_link_htab_entry_hash
static hashval_t static_link_htab_entry_hash(const void *p)
Definition: objfiles.c:226
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
ANOFFSET
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:1276
get_objfile_arch
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:445
objfile::sections
struct obj_section * sections
Definition: objfiles.h:423
filter_overlapping_sections
static int filter_overlapping_sections(struct obj_section **map, int map_size)
Definition: objfiles.c:1261
bcache_xmalloc
struct bcache * bcache_xmalloc(unsigned long(*hash_function)(const void *, int length), int(*compare_function)(const void *, const void *, int length))
Definition: bcache.c:306
objfile_pspace_info::num_sections
int num_sections
Definition: objfiles.c:69
forget_cached_source_info_for_objfile
void forget_cached_source_info_for_objfile(struct objfile *objfile)
Definition: source.c:360
objfile_per_bfd_storage::demangled_names_hash
htab * demangled_names_hash
Definition: objfiles.h:218
objfile::separate_debug_objfile
struct objfile * separate_debug_objfile
Definition: objfiles.h:436
_initialize_objfiles
void _initialize_objfiles(void)
Definition: objfiles.c:1595
objfile_relocate1
static int objfile_relocate1(struct objfile *objfile, const struct section_offsets *new_offsets)
Definition: objfiles.c:777
complaint
#define complaint(COMPLAINTS, FMT,...)
Definition: complaints.h:40
objfile::compunit_symtabs
struct compunit_symtab * compunit_symtabs
Definition: objfiles.h:320
symfile_objfile
#define symfile_objfile
Definition: progspace.h:227
BLOCK_END
#define BLOCK_END(bl)
Definition: block.h:106
LOC_STATIC
Definition: symtab.h:805
qsort_cmp
static int qsort_cmp(const void *a, const void *b)
Definition: objfiles.c:1096
add_to_objfile_sections
static void add_to_objfile_sections(struct bfd *abfd, struct bfd_section *asect, void *objfilep)
Definition: objfiles.c:330
BLOCK_DICT
#define BLOCK_DICT(bl)
Definition: block.h:109
breakpoint.h
section_is_mapped
int section_is_mapped(struct obj_section *osect)
Definition: symfile.c:3017
relocate_one_symbol
static void relocate_one_symbol(struct symbol *sym, struct objfile *objfile, struct section_offsets *delta)
Definition: objfiles.c:755
sym_fns::sym_finish
void(* sym_finish)(struct objfile *)
Definition: symfile.h:334
objfile_per_bfd_storage::macro_cache
bcache * macro_cache
Definition: objfiles.h:203
symtab
Definition: symtab.h:1291
find_pc_section
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition: objfiles.c:1395
OBJF_USERLOADED
Definition: objfile-flags.h:53
objfile_name
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1557
XRESIZEVEC
#define XRESIZEVEC(T, P, N)
Definition: poison.h:169
quick_symbol_functions::relocate
void(* relocate)(struct objfile *objfile, const struct section_offsets *new_offsets, const struct section_offsets *delta)
Definition: symfile.h:191
symtab_and_line::symtab
struct symtab * symtab
Definition: symtab.h:1751
sym_fns::sym_read_psymbols
void(* sym_read_psymbols)(struct objfile *)
Definition: symfile.h:328
complaints.h
section_addr_info
Definition: symfile.h:64
objfile_pspace_info::section_map_dirty
int section_map_dirty
Definition: objfiles.c:76
objfile_lookup_static_link
const struct dynamic_prop * objfile_lookup_static_link(struct objfile *objfile, const struct block *block)
Definition: objfiles.c:282
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
ALL_OBJFILE_COMPUNITS
#define ALL_OBJFILE_COMPUNITS(objfile, cu)
Definition: objfiles.h:600
dict_iterator
Definition: dictionary.h:106
objfile::~objfile
~objfile()
Definition: objfiles.c:616
objfile::separate_debug_objfile_link
struct objfile * separate_debug_objfile_link
Definition: objfiles.h:446
blockvector
Definition: block.h:112
addrmap.h
exec_set_section_address
void exec_set_section_address(const char *filename, int index, CORE_ADDR address)
Definition: exec.c:1002
clear_pc_function_cache
void clear_pc_function_cache(void)
Definition: blockframe.c:167
iterate_over_objfiles_in_search_order_cb_ftype
int() iterate_over_objfiles_in_search_order_cb_ftype(struct objfile *objfile, void *cb_data)
Definition: gdbarch.h:90
have_minimal_symbols
int have_minimal_symbols(void)
Definition: objfiles.c:1079
objfile
Definition: objfiles.h:286
symtab_and_line
Definition: symtab.h:1746
objfile_purge_solibs
void objfile_purge_solibs(void)
Definition: objfiles.c:1058
COMPUNIT_BLOCKVECTOR
#define COMPUNIT_BLOCKVECTOR(cust)
Definition: symtab.h:1465
fixup_symbol_section
struct symbol * fixup_symbol_section(struct symbol *sym, struct objfile *objfile)
Definition: symtab.c:1718
entry_point_address_query
int entry_point_address_query(CORE_ADDR *entry_p)
Definition: objfiles.c:454
obj_section
Definition: objfiles.h:123
static_link_htab_entry_eq
static int static_link_htab_entry_eq(const void *p1, const void *p2)
Definition: objfiles.c:238
unlink_objfile
void unlink_objfile(struct objfile *objfile)
Definition: objfiles.c:557
gdbarch_from_bfd
struct gdbarch * gdbarch_from_bfd(bfd *abfd)
Definition: arch-utils.c:577
XNEWVEC
#define XNEWVEC(T, N)
Definition: poison.h:145
bcache.h
objfile_flavour_name
const char * objfile_flavour_name(struct objfile *objfile)
Definition: objfiles.c:1587
entry_point_address
CORE_ADDR entry_point_address(void)
Definition: objfiles.c:469
find_pc_mapped_section
struct obj_section * find_pc_mapped_section(CORE_ADDR pc)
Definition: symfile.c:3202
source.h
gdb_abspath
gdb::unique_xmalloc_ptr< char > gdb_abspath(const char *path)
Definition: utils.c:2978
objfile_per_bfd_storage::filename_cache
bcache * filename_cache
Definition: objfiles.h:199
objfile_per_bfd_storage::name_of_main
const char * name_of_main
Definition: objfiles.h:229
XCNEW
#define XCNEW(T)
Definition: poison.h:121
objfile::num_sections
int num_sections
Definition: objfiles.h:397
btrace_free_objfile
void btrace_free_objfile(struct objfile *objfile)
Definition: btrace.c:1988
get_objfile_pspace_data
static struct objfile_pspace_info * get_objfile_pspace_data(struct program_space *pspace)
Definition: objfiles.c:98
exec.h
symfile_complaints
struct complaints * symfile_complaints
Definition: complaints.c:96
gdb_bfd_count_sections
int gdb_bfd_count_sections(bfd *abfd)
Definition: gdb_bfd.c:906
COMPUNIT_BLOCK_LINE_SECTION
#define COMPUNIT_BLOCK_LINE_SECTION(cust)
Definition: symtab.h:1466
objfile_per_bfd_storage::gdbarch
struct gdbarch * gdbarch
Definition: objfiles.h:210
obj_section_addr
#define obj_section_addr(s)
Definition: objfiles.h:140
objfile_separate_debug_iterate
struct objfile * objfile_separate_debug_iterate(const struct objfile *parent, const struct objfile *objfile)
Definition: objfiles.c:488
objfile_debug_name
const char * objfile_debug_name(const struct objfile *objfile)
Definition: objfiles.c:1579
objfile::next
struct objfile * next
Definition: objfiles.h:297
obj_section::objfile
struct objfile * objfile
Definition: objfiles.h:129
objfile_per_bfd_storage::language_of_main
enum language language_of_main
Definition: objfiles.h:230
qsort
#define qsort
Definition: ada-exp.c:2694
bsearch_cmp
static int bsearch_cmp(const void *key, const void *elt)
Definition: objfiles.c:1380
LOC_LABEL
Definition: symtab.h:848
ALL_OBJFILES_SAFE
#define ALL_OBJFILES_SAFE(obj, nxt)
Definition: objfiles.h:587
target.h
BLOCKVECTOR_NBLOCKS
#define BLOCKVECTOR_NBLOCKS(blocklist)
Definition: block.h:124
have_full_symbols
int have_full_symbols(void)
Definition: objfiles.c:1040
free_objfile_per_bfd_storage
static void free_objfile_per_bfd_storage(struct objfile_per_bfd_storage *storage)
Definition: objfiles.c:174
bcache_xfree
void bcache_xfree(struct bcache *bcache)
Definition: bcache.c:328
static_link_htab_entry::block
const struct block * block
Definition: objfiles.c:219
addrmap_relocate
void addrmap_relocate(struct addrmap *map, CORE_ADDR offset)
Definition: addrmap.c:75
objfiles_bfd_data
static const struct bfd_data * objfiles_bfd_data
Definition: objfiles.c:117
expression_context_block
const struct block * expression_context_block
Definition: parse.c:69
overlay_debugging
enum overlay_debugging_state overlay_debugging
Definition: symfile.c:2970
current_program_space
struct program_space * current_program_space
Definition: progspace.c:35
objfile_register_static_link
void objfile_register_static_link(struct objfile *objfile, const struct block *block, const struct dynamic_prop *static_link)
Definition: objfiles.c:252
objfile::psymtabs_addrmap
struct addrmap * psymtabs_addrmap
Definition: objfiles.h:333
language
language
Definition: defs.h:203
linetable::nitems
int nitems
Definition: symtab.h:1253
symbol
Definition: symtab.h:1049
preferred_obj_section
static struct obj_section * preferred_obj_section(struct obj_section *a, struct obj_section *b)
Definition: objfiles.c:1179
BLOCKVECTOR_MAP
#define BLOCKVECTOR_MAP(blocklist)
Definition: block.h:126
objfile_per_bfd_storage::storage_obstack
auto_obstack storage_obstack
Definition: objfiles.h:195
SYMBOL_SECTION
#define SYMBOL_SECTION(symbol)
Definition: symtab.h:470
objfile_pspace_info::new_objfiles_available
int new_objfiles_available
Definition: objfiles.c:73
objfile_pspace_info
Definition: objfiles.c:66
objfile::section_offsets
struct section_offsets * section_offsets
Definition: objfiles.h:396
terminate_minimal_symbol_table
void terminate_minimal_symbol_table(struct objfile *objfile)
Definition: minsyms.c:1441
objfile::objfile_obstack
Definition: objfiles.h:357
language_unknown
Definition: defs.h:205
ALL_OBJFILES
#define ALL_OBJFILES(obj)
Definition: objfiles.h:582
obj_section::ovly_mapped
int ovly_mapped
Definition: objfiles.h:132
insert_section_p
static int insert_section_p(const struct bfd *abfd, const struct bfd_section *section)
Definition: objfiles.c:1196
sym_fns::qf
const struct quick_symbol_functions * qf
Definition: symfile.h:369
so_list::objfile
struct objfile * objfile
Definition: solist.h:77
put_objfile_before
void put_objfile_before(struct objfile *objfile, struct objfile *before_this)
Definition: objfiles.c:523
filter_debuginfo_sections
static int filter_debuginfo_sections(struct obj_section **map, int map_size)
Definition: objfiles.c:1219
add_to_objfile_sections_full
static void add_to_objfile_sections_full(struct bfd *abfd, struct bfd_section *asect, struct objfile *objfile, int force)
Definition: objfiles.c:309
xcalloc
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:72
quick_symbol_functions::has_symbols
int(* has_symbols)(struct objfile *objfile)
Definition: symfile.h:141
ALL_PSPACE_OBJFILES
#define ALL_PSPACE_OBJFILES(ss, obj)
Definition: objfiles.h:579
is_target_filename
int is_target_filename(const char *name)
Definition: gdb_bfd.c:208
resume_section_map_updates_cleanup
void resume_section_map_updates_cleanup(void *arg)
Definition: objfiles.c:1485
SYMTAB_LINETABLE
#define SYMTAB_LINETABLE(symtab)
Definition: symtab.h:1332
objfile::psymbol_cache
struct psymbol_bcache * psymbol_cache
Definition: objfiles.h:362
get_objfile_bfd_data
static struct objfile_per_bfd_storage * get_objfile_bfd_data(struct objfile *objfile, struct bfd *abfd)
Definition: objfiles.c:128
clear_symtab_users
void clear_symtab_users(symfile_add_flags add_flags)
Definition: symfile.c:2885
error
void error(const char *fmt,...)
Definition: errors.c:38
objfile_rebase
void objfile_rebase(struct objfile *objfile, CORE_ADDR slide)
Definition: objfiles.c:959
dictionary.h
block.h
do_cleanups
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:174
objfile_bfd_data_free
static void objfile_bfd_data_free(struct bfd *unused, void *d)
Definition: objfiles.c:187
program_space
Definition: progspace.h:137
symfile.h
objfile::sections_end
struct obj_section * sections_end
Definition: objfiles.h:424