]> Git Repo - binutils.git/blob - gdb/objfiles.c
gdb: remove COMPUNIT_BLOCKVECTOR macro, add getter/setter
[binutils.git] / gdb / objfiles.c
1 /* GDB routines for manipulating objfiles.
2
3    Copyright (C) 1992-2022 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 "gdbsupport/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 "observable.h"
50 #include "complaints.h"
51 #include "psymtab.h"
52 #include "solist.h"
53 #include "gdb_bfd.h"
54 #include "btrace.h"
55 #include "gdbsupport/pathstuff.h"
56
57 #include <algorithm>
58 #include <vector>
59
60 /* Keep a registry of per-objfile data-pointers required by other GDB
61    modules.  */
62
63 DEFINE_REGISTRY (objfile, REGISTRY_ACCESS_FIELD)
64
65 /* Externally visible variables that are owned by this module.
66    See declarations in objfile.h for more info.  */
67
68 struct objfile_pspace_info
69 {
70   objfile_pspace_info () = default;
71   ~objfile_pspace_info ();
72
73   struct obj_section **sections = nullptr;
74   int num_sections = 0;
75
76   /* Nonzero if object files have been added since the section map
77      was last updated.  */
78   int new_objfiles_available = 0;
79
80   /* Nonzero if the section map MUST be updated before use.  */
81   int section_map_dirty = 0;
82
83   /* Nonzero if section map updates should be inhibited if possible.  */
84   int inhibit_updates = 0;
85 };
86
87 /* Per-program-space data key.  */
88 static const struct program_space_key<objfile_pspace_info>
89   objfiles_pspace_data;
90
91 objfile_pspace_info::~objfile_pspace_info ()
92 {
93   xfree (sections);
94 }
95
96 /* Get the current svr4 data.  If none is found yet, add it now.  This
97    function always returns a valid object.  */
98
99 static struct objfile_pspace_info *
100 get_objfile_pspace_data (struct program_space *pspace)
101 {
102   struct objfile_pspace_info *info;
103
104   info = objfiles_pspace_data.get (pspace);
105   if (info == NULL)
106     info = objfiles_pspace_data.emplace (pspace);
107
108   return info;
109 }
110
111 \f
112
113 /* Per-BFD data key.  */
114
115 static const struct bfd_key<objfile_per_bfd_storage> objfiles_bfd_data;
116
117 objfile_per_bfd_storage::~objfile_per_bfd_storage ()
118 {
119 }
120
121 /* Create the per-BFD storage object for OBJFILE.  If ABFD is not
122    NULL, and it already has a per-BFD storage object, use that.
123    Otherwise, allocate a new per-BFD storage object.  */
124
125 static struct objfile_per_bfd_storage *
126 get_objfile_bfd_data (bfd *abfd)
127 {
128   struct objfile_per_bfd_storage *storage = NULL;
129
130   if (abfd != NULL)
131     storage = objfiles_bfd_data.get (abfd);
132
133   if (storage == NULL)
134     {
135       storage = new objfile_per_bfd_storage (abfd);
136       /* If the object requires gdb to do relocations, we simply fall
137          back to not sharing data across users.  These cases are rare
138          enough that this seems reasonable.  */
139       if (abfd != NULL && !gdb_bfd_requires_relocations (abfd))
140         objfiles_bfd_data.set (abfd, storage);
141
142       /* Look up the gdbarch associated with the BFD.  */
143       if (abfd != NULL)
144         storage->gdbarch = gdbarch_from_bfd (abfd);
145     }
146
147   return storage;
148 }
149
150 /* See objfiles.h.  */
151
152 void
153 set_objfile_per_bfd (struct objfile *objfile)
154 {
155   objfile->per_bfd = get_objfile_bfd_data (objfile->obfd);
156 }
157
158 /* Set the objfile's per-BFD notion of the "main" name and
159    language.  */
160
161 void
162 set_objfile_main_name (struct objfile *objfile,
163                        const char *name, enum language lang)
164 {
165   if (objfile->per_bfd->name_of_main == NULL
166       || strcmp (objfile->per_bfd->name_of_main, name) != 0)
167     objfile->per_bfd->name_of_main
168       = obstack_strdup (&objfile->per_bfd->storage_obstack, name);
169   objfile->per_bfd->language_of_main = lang;
170 }
171
172 /* Helper structure to map blocks to static link properties in hash tables.  */
173
174 struct static_link_htab_entry
175 {
176   const struct block *block;
177   const struct dynamic_prop *static_link;
178 };
179
180 /* Return a hash code for struct static_link_htab_entry *P.  */
181
182 static hashval_t
183 static_link_htab_entry_hash (const void *p)
184 {
185   const struct static_link_htab_entry *e
186     = (const struct static_link_htab_entry *) p;
187
188   return htab_hash_pointer (e->block);
189 }
190
191 /* Return whether P1 an P2 (pointers to struct static_link_htab_entry) are
192    mappings for the same block.  */
193
194 static int
195 static_link_htab_entry_eq (const void *p1, const void *p2)
196 {
197   const struct static_link_htab_entry *e1
198     = (const struct static_link_htab_entry *) p1;
199   const struct static_link_htab_entry *e2
200     = (const struct static_link_htab_entry *) p2;
201
202   return e1->block == e2->block;
203 }
204
205 /* Register STATIC_LINK as the static link for BLOCK, which is part of OBJFILE.
206    Must not be called more than once for each BLOCK.  */
207
208 void
209 objfile_register_static_link (struct objfile *objfile,
210                               const struct block *block,
211                               const struct dynamic_prop *static_link)
212 {
213   void **slot;
214   struct static_link_htab_entry lookup_entry;
215   struct static_link_htab_entry *entry;
216
217   if (objfile->static_links == NULL)
218     objfile->static_links.reset (htab_create_alloc
219       (1, &static_link_htab_entry_hash, static_link_htab_entry_eq, NULL,
220        xcalloc, xfree));
221
222   /* Create a slot for the mapping, make sure it's the first mapping for this
223      block and then create the mapping itself.  */
224   lookup_entry.block = block;
225   slot = htab_find_slot (objfile->static_links.get (), &lookup_entry, INSERT);
226   gdb_assert (*slot == NULL);
227
228   entry = XOBNEW (&objfile->objfile_obstack, static_link_htab_entry);
229   entry->block = block;
230   entry->static_link = static_link;
231   *slot = (void *) entry;
232 }
233
234 /* Look for a static link for BLOCK, which is part of OBJFILE.  Return NULL if
235    none was found.  */
236
237 const struct dynamic_prop *
238 objfile_lookup_static_link (struct objfile *objfile,
239                             const struct block *block)
240 {
241   struct static_link_htab_entry *entry;
242   struct static_link_htab_entry lookup_entry;
243
244   if (objfile->static_links == NULL)
245     return NULL;
246   lookup_entry.block = block;
247   entry = ((struct static_link_htab_entry *)
248            htab_find (objfile->static_links.get (), &lookup_entry));
249   if (entry == NULL)
250     return NULL;
251
252   gdb_assert (entry->block == block);
253   return entry->static_link;
254 }
255
256 \f
257
258 /* Build up the section table that the objfile references.  The
259    objfile contains pointers to the start of the table
260    (objfile->sections) and to the first location after the end of the
261    table (objfile->sections_end).  */
262
263 static void
264 add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
265                               struct objfile *objfile, int force)
266 {
267   struct obj_section *section;
268
269   if (!force)
270     {
271       flagword aflag;
272
273       aflag = bfd_section_flags (asect);
274       if (!(aflag & SEC_ALLOC))
275         return;
276     }
277
278   section = &objfile->sections[gdb_bfd_section_index (abfd, asect)];
279   section->objfile = objfile;
280   section->the_bfd_section = asect;
281   section->ovly_mapped = 0;
282 }
283
284 /* Builds a section table for OBJFILE.
285
286    Note that the OFFSET and OVLY_MAPPED in each table entry are
287    initialized to zero.  */
288
289 void
290 build_objfile_section_table (struct objfile *objfile)
291 {
292   int count = gdb_bfd_count_sections (objfile->obfd);
293
294   objfile->sections = OBSTACK_CALLOC (&objfile->objfile_obstack,
295                                       count,
296                                       struct obj_section);
297   objfile->sections_end = (objfile->sections + count);
298   for (asection *sect : gdb_bfd_sections (objfile->obfd))
299     add_to_objfile_sections (objfile->obfd, sect, objfile, 0);
300
301   /* See gdb_bfd_section_index.  */
302   add_to_objfile_sections (objfile->obfd, bfd_com_section_ptr, objfile, 1);
303   add_to_objfile_sections (objfile->obfd, bfd_und_section_ptr, objfile, 1);
304   add_to_objfile_sections (objfile->obfd, bfd_abs_section_ptr, objfile, 1);
305   add_to_objfile_sections (objfile->obfd, bfd_ind_section_ptr, objfile, 1);
306 }
307
308 /* Given a pointer to an initialized bfd (ABFD) and some flag bits,
309    initialize the new objfile as best we can and link it into the list
310    of all known objfiles.
311
312    NAME should contain original non-canonicalized filename or other
313    identifier as entered by user.  If there is no better source use
314    bfd_get_filename (ABFD).  NAME may be NULL only if ABFD is NULL.
315    NAME content is copied into returned objfile.
316
317    The FLAGS word contains various bits (OBJF_*) that can be taken as
318    requests for specific operations.  Other bits like OBJF_SHARED are
319    simply copied through to the new objfile flags member.  */
320
321 objfile::objfile (bfd *abfd, const char *name, objfile_flags flags_)
322   : flags (flags_),
323     pspace (current_program_space),
324     obfd (abfd)
325 {
326   const char *expanded_name;
327
328   /* We could use obstack_specify_allocation here instead, but
329      gdb_obstack.h specifies the alloc/dealloc functions.  */
330   obstack_init (&objfile_obstack);
331
332   objfile_alloc_data (this);
333
334   gdb::unique_xmalloc_ptr<char> name_holder;
335   if (name == NULL)
336     {
337       gdb_assert (abfd == NULL);
338       gdb_assert ((flags & OBJF_NOT_FILENAME) != 0);
339       expanded_name = "<<anonymous objfile>>";
340     }
341   else if ((flags & OBJF_NOT_FILENAME) != 0
342            || is_target_filename (name))
343     expanded_name = name;
344   else
345     {
346       name_holder = gdb_abspath (name);
347       expanded_name = name_holder.get ();
348     }
349   original_name = obstack_strdup (&objfile_obstack, expanded_name);
350
351   /* Update the per-objfile information that comes from the bfd, ensuring
352      that any data that is reference is saved in the per-objfile data
353      region.  */
354
355   gdb_bfd_ref (abfd);
356   if (abfd != NULL)
357     {
358       mtime = bfd_get_mtime (abfd);
359
360       /* Build section table.  */
361       build_objfile_section_table (this);
362     }
363
364   per_bfd = get_objfile_bfd_data (abfd);
365 }
366
367 /* If there is a valid and known entry point, function fills *ENTRY_P with it
368    and returns non-zero; otherwise it returns zero.  */
369
370 int
371 entry_point_address_query (CORE_ADDR *entry_p)
372 {
373   objfile *objf = current_program_space->symfile_object_file;
374   if (objf == NULL || !objf->per_bfd->ei.entry_point_p)
375     return 0;
376
377   int idx = objf->per_bfd->ei.the_bfd_section_index;
378   *entry_p = objf->per_bfd->ei.entry_point + objf->section_offsets[idx];
379
380   return 1;
381 }
382
383 /* Get current entry point address.  Call error if it is not known.  */
384
385 CORE_ADDR
386 entry_point_address (void)
387 {
388   CORE_ADDR retval;
389
390   if (!entry_point_address_query (&retval))
391     error (_("Entry point address is not known."));
392
393   return retval;
394 }
395
396 separate_debug_iterator &
397 separate_debug_iterator::operator++ ()
398 {
399   gdb_assert (m_objfile != nullptr);
400
401   struct objfile *res;
402
403   /* If any, return the first child.  */
404   res = m_objfile->separate_debug_objfile;
405   if (res != nullptr)
406     {
407       m_objfile = res;
408       return *this;
409     }
410
411   /* Common case where there is no separate debug objfile.  */
412   if (m_objfile == m_parent)
413     {
414       m_objfile = nullptr;
415       return *this;
416     }
417
418   /* Return the brother if any.  Note that we don't iterate on brothers of
419      the parents.  */
420   res = m_objfile->separate_debug_objfile_link;
421   if (res != nullptr)
422     {
423       m_objfile = res;
424       return *this;
425     }
426
427   for (res = m_objfile->separate_debug_objfile_backlink;
428        res != m_parent;
429        res = res->separate_debug_objfile_backlink)
430     {
431       gdb_assert (res != nullptr);
432       if (res->separate_debug_objfile_link != nullptr)
433         {
434           m_objfile = res->separate_debug_objfile_link;
435           return *this;
436         }
437     }
438   m_objfile = nullptr;
439   return *this;
440 }
441
442 /* Add OBJFILE as a separate debug objfile of PARENT.  */
443
444 static void
445 add_separate_debug_objfile (struct objfile *objfile, struct objfile *parent)
446 {
447   gdb_assert (objfile && parent);
448
449   /* Must not be already in a list.  */
450   gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
451   gdb_assert (objfile->separate_debug_objfile_link == NULL);
452   gdb_assert (objfile->separate_debug_objfile == NULL);
453   gdb_assert (parent->separate_debug_objfile_backlink == NULL);
454   gdb_assert (parent->separate_debug_objfile_link == NULL);
455
456   objfile->separate_debug_objfile_backlink = parent;
457   objfile->separate_debug_objfile_link = parent->separate_debug_objfile;
458   parent->separate_debug_objfile = objfile;
459 }
460
461 /* See objfiles.h.  */
462
463 objfile *
464 objfile::make (bfd *bfd_, const char *name_, objfile_flags flags_,
465                objfile *parent)
466 {
467   objfile *result = new objfile (bfd_, name_, flags_);
468   if (parent != nullptr)
469     add_separate_debug_objfile (result, parent);
470
471   /* Using std::make_shared might be a bit nicer here, but that would
472      require making the constructor public.  */
473   current_program_space->add_objfile (std::shared_ptr<objfile> (result),
474                                       parent);
475
476   /* Rebuild section map next time we need it.  */
477   get_objfile_pspace_data (current_program_space)->new_objfiles_available = 1;
478
479   return result;
480 }
481
482 /* See objfiles.h.  */
483
484 void
485 objfile::unlink ()
486 {
487   current_program_space->remove_objfile (this);
488 }
489
490 /* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
491    itself.  */
492
493 void
494 free_objfile_separate_debug (struct objfile *objfile)
495 {
496   struct objfile *child;
497
498   for (child = objfile->separate_debug_objfile; child;)
499     {
500       struct objfile *next_child = child->separate_debug_objfile_link;
501       child->unlink ();
502       child = next_child;
503     }
504 }
505
506 /* Destroy an objfile and all the symtabs and psymtabs under it.  */
507
508 objfile::~objfile ()
509 {
510   /* First notify observers that this objfile is about to be freed.  */
511   gdb::observers::free_objfile.notify (this);
512
513   /* Free all separate debug objfiles.  */
514   free_objfile_separate_debug (this);
515
516   if (separate_debug_objfile_backlink)
517     {
518       /* We freed the separate debug file, make sure the base objfile
519          doesn't reference it.  */
520       struct objfile *child;
521
522       child = separate_debug_objfile_backlink->separate_debug_objfile;
523
524       if (child == this)
525         {
526           /* THIS is the first child.  */
527           separate_debug_objfile_backlink->separate_debug_objfile =
528             separate_debug_objfile_link;
529         }
530       else
531         {
532           /* Find THIS in the list.  */
533           while (1)
534             {
535               if (child->separate_debug_objfile_link == this)
536                 {
537                   child->separate_debug_objfile_link =
538                     separate_debug_objfile_link;
539                   break;
540                 }
541               child = child->separate_debug_objfile_link;
542               gdb_assert (child);
543             }
544         }
545     }
546
547   /* Remove any references to this objfile in the global value
548      lists.  */
549   preserve_values (this);
550
551   /* It still may reference data modules have associated with the objfile and
552      the symbol file data.  */
553   forget_cached_source_info_for_objfile (this);
554
555   breakpoint_free_objfile (this);
556   btrace_free_objfile (this);
557
558   /* First do any symbol file specific actions required when we are
559      finished with a particular symbol file.  Note that if the objfile
560      is using reusable symbol information (via mmalloc) then each of
561      these routines is responsible for doing the correct thing, either
562      freeing things which are valid only during this particular gdb
563      execution, or leaving them to be reused during the next one.  */
564
565   if (sf != NULL)
566     (*sf->sym_finish) (this);
567
568   /* Discard any data modules have associated with the objfile.  The function
569      still may reference obfd.  */
570   objfile_free_data (this);
571
572   if (obfd)
573     gdb_bfd_unref (obfd);
574   else
575     delete per_bfd;
576
577   /* Before the symbol table code was redone to make it easier to
578      selectively load and remove information particular to a specific
579      linkage unit, gdb used to do these things whenever the monolithic
580      symbol table was blown away.  How much still needs to be done
581      is unknown, but we play it safe for now and keep each action until
582      it is shown to be no longer needed.  */
583
584   /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
585      for example), so we need to call this here.  */
586   clear_pc_function_cache ();
587
588   /* Check to see if the current_source_symtab belongs to this objfile,
589      and if so, call clear_current_source_symtab_and_line.  */
590
591   {
592     struct symtab_and_line cursal = get_current_source_symtab_and_line ();
593
594     if (cursal.symtab && SYMTAB_OBJFILE (cursal.symtab) == this)
595       clear_current_source_symtab_and_line ();
596   }
597
598   /* Free the obstacks for non-reusable objfiles.  */
599   obstack_free (&objfile_obstack, 0);
600
601   /* Rebuild section map next time we need it.  */
602   get_objfile_pspace_data (pspace)->section_map_dirty = 1;
603 }
604
605 \f
606 /* A helper function for objfile_relocate1 that relocates a single
607    symbol.  */
608
609 static void
610 relocate_one_symbol (struct symbol *sym, struct objfile *objfile,
611                      const section_offsets &delta)
612 {
613   fixup_symbol_section (sym, objfile);
614
615   /* The RS6000 code from which this was taken skipped
616      any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
617      But I'm leaving out that test, on the theory that
618      they can't possibly pass the tests below.  */
619   if ((SYMBOL_CLASS (sym) == LOC_LABEL
620        || SYMBOL_CLASS (sym) == LOC_STATIC)
621       && sym->section_index () >= 0)
622     {
623       SET_SYMBOL_VALUE_ADDRESS (sym,
624                                 SYMBOL_VALUE_ADDRESS (sym)
625                                 + delta[sym->section_index ()]);
626     }
627 }
628
629 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
630    entries in new_offsets.  SEPARATE_DEBUG_OBJFILE is not touched here.
631    Return non-zero iff any change happened.  */
632
633 static int
634 objfile_relocate1 (struct objfile *objfile, 
635                    const section_offsets &new_offsets)
636 {
637   section_offsets delta (objfile->section_offsets.size ());
638
639   int something_changed = 0;
640
641   for (int i = 0; i < objfile->section_offsets.size (); ++i)
642     {
643       delta[i] = new_offsets[i] - objfile->section_offsets[i];
644       if (delta[i] != 0)
645         something_changed = 1;
646     }
647   if (!something_changed)
648     return 0;
649
650   /* OK, get all the symtabs.  */
651   {
652     for (compunit_symtab *cust : objfile->compunits ())
653       {
654         for (symtab *s : cust->filetabs ())
655           {
656             struct linetable *l;
657
658             /* First the line table.  */
659             l = SYMTAB_LINETABLE (s);
660             if (l)
661               {
662                 for (int i = 0; i < l->nitems; ++i)
663                   l->item[i].pc += delta[COMPUNIT_BLOCK_LINE_SECTION (cust)];
664               }
665           }
666       }
667
668     for (compunit_symtab *cust : objfile->compunits ())
669       {
670         const struct blockvector *bv = cust->blockvector ();
671         int block_line_section = COMPUNIT_BLOCK_LINE_SECTION (cust);
672
673         if (BLOCKVECTOR_MAP (bv))
674           addrmap_relocate (BLOCKVECTOR_MAP (bv), delta[block_line_section]);
675
676         for (int i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
677           {
678             struct block *b;
679             struct symbol *sym;
680             struct mdict_iterator miter;
681
682             b = BLOCKVECTOR_BLOCK (bv, i);
683             BLOCK_START (b) += delta[block_line_section];
684             BLOCK_END (b) += delta[block_line_section];
685
686             if (BLOCK_RANGES (b) != nullptr)
687               for (int j = 0; j < BLOCK_NRANGES (b); j++)
688                 {
689                   BLOCK_RANGE_START (b, j) += delta[block_line_section];
690                   BLOCK_RANGE_END (b, j) += delta[block_line_section];
691                 }
692
693             /* We only want to iterate over the local symbols, not any
694                symbols in included symtabs.  */
695             ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (b), miter, sym)
696               {
697                 relocate_one_symbol (sym, objfile, delta);
698               }
699           }
700       }
701   }
702
703   /* Notify the quick symbol object.  */
704   for (const auto &iter : objfile->qf)
705     iter->relocated ();
706
707   /* Relocate isolated symbols.  */
708   {
709     struct symbol *iter;
710
711     for (iter = objfile->template_symbols; iter; iter = iter->hash_next)
712       relocate_one_symbol (iter, objfile, delta);
713   }
714
715   {
716     int i;
717
718     for (i = 0; i < objfile->section_offsets.size (); ++i)
719       objfile->section_offsets[i] = new_offsets[i];
720   }
721
722   /* Rebuild section map next time we need it.  */
723   get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1;
724
725   /* Update the table in exec_ops, used to read memory.  */
726   struct obj_section *s;
727   ALL_OBJFILE_OSECTIONS (objfile, s)
728     {
729       int idx = s - objfile->sections;
730
731       exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
732                                 s->addr ());
733     }
734
735   /* Data changed.  */
736   return 1;
737 }
738
739 /* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
740    entries in new_offsets.  Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.
741
742    The number and ordering of sections does differ between the two objfiles.
743    Only their names match.  Also the file offsets will differ (objfile being
744    possibly prelinked but separate_debug_objfile is probably not prelinked) but
745    the in-memory absolute address as specified by NEW_OFFSETS must match both
746    files.  */
747
748 void
749 objfile_relocate (struct objfile *objfile,
750                   const section_offsets &new_offsets)
751 {
752   int changed = 0;
753
754   changed |= objfile_relocate1 (objfile, new_offsets);
755
756   for (::objfile *debug_objfile : objfile->separate_debug_objfiles ())
757     {
758       if (debug_objfile == objfile)
759         continue;
760
761       section_addr_info objfile_addrs
762         = build_section_addr_info_from_objfile (objfile);
763
764       /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
765          relative ones must be already created according to debug_objfile.  */
766
767       addr_info_make_relative (&objfile_addrs, debug_objfile->obfd);
768
769       gdb_assert (debug_objfile->section_offsets.size ()
770                   == gdb_bfd_count_sections (debug_objfile->obfd));
771       section_offsets new_debug_offsets
772         (debug_objfile->section_offsets.size ());
773       relative_addr_info_to_section_offsets (new_debug_offsets, objfile_addrs);
774
775       changed |= objfile_relocate1 (debug_objfile, new_debug_offsets);
776     }
777
778   /* Relocate breakpoints as necessary, after things are relocated.  */
779   if (changed)
780     breakpoint_re_set ();
781 }
782
783 /* Rebase (add to the offsets) OBJFILE by SLIDE.  SEPARATE_DEBUG_OBJFILE is
784    not touched here.
785    Return non-zero iff any change happened.  */
786
787 static int
788 objfile_rebase1 (struct objfile *objfile, CORE_ADDR slide)
789 {
790   section_offsets new_offsets (objfile->section_offsets.size (), slide);
791   return objfile_relocate1 (objfile, new_offsets);
792 }
793
794 /* Rebase (add to the offsets) OBJFILE by SLIDE.  Process also OBJFILE's
795    SEPARATE_DEBUG_OBJFILEs.  */
796
797 void
798 objfile_rebase (struct objfile *objfile, CORE_ADDR slide)
799 {
800   int changed = 0;
801
802   for (::objfile *debug_objfile : objfile->separate_debug_objfiles ())
803     changed |= objfile_rebase1 (debug_objfile, slide);
804
805   /* Relocate breakpoints as necessary, after things are relocated.  */
806   if (changed)
807     breakpoint_re_set ();
808 }
809 \f
810 /* Return non-zero if OBJFILE has full symbols.  */
811
812 int
813 objfile_has_full_symbols (struct objfile *objfile)
814 {
815   return objfile->compunit_symtabs != NULL;
816 }
817
818 /* Return non-zero if OBJFILE has full or partial symbols, either directly
819    or through a separate debug file.  */
820
821 int
822 objfile_has_symbols (struct objfile *objfile)
823 {
824   for (::objfile *o : objfile->separate_debug_objfiles ())
825     if (o->has_partial_symbols () || objfile_has_full_symbols (o))
826       return 1;
827   return 0;
828 }
829
830
831 /* Many places in gdb want to test just to see if we have any partial
832    symbols available.  This function returns zero if none are currently
833    available, nonzero otherwise.  */
834
835 int
836 have_partial_symbols (void)
837 {
838   for (objfile *ofp : current_program_space->objfiles ())
839     {
840       if (ofp->has_partial_symbols ())
841         return 1;
842     }
843   return 0;
844 }
845
846 /* Many places in gdb want to test just to see if we have any full
847    symbols available.  This function returns zero if none are currently
848    available, nonzero otherwise.  */
849
850 int
851 have_full_symbols (void)
852 {
853   for (objfile *ofp : current_program_space->objfiles ())
854     {
855       if (objfile_has_full_symbols (ofp))
856         return 1;
857     }
858   return 0;
859 }
860
861
862 /* This operations deletes all objfile entries that represent solibs that
863    weren't explicitly loaded by the user, via e.g., the add-symbol-file
864    command.  */
865
866 void
867 objfile_purge_solibs (void)
868 {
869   for (objfile *objf : current_program_space->objfiles_safe ())
870     {
871       /* We assume that the solib package has been purged already, or will
872          be soon.  */
873
874       if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
875         objf->unlink ();
876     }
877 }
878
879
880 /* Many places in gdb want to test just to see if we have any minimal
881    symbols available.  This function returns zero if none are currently
882    available, nonzero otherwise.  */
883
884 int
885 have_minimal_symbols (void)
886 {
887   for (objfile *ofp : current_program_space->objfiles ())
888     {
889       if (ofp->per_bfd->minimal_symbol_count > 0)
890         {
891           return 1;
892         }
893     }
894   return 0;
895 }
896
897 /* Qsort comparison function.  */
898
899 static bool
900 sort_cmp (const struct obj_section *sect1, const obj_section *sect2)
901 {
902   const CORE_ADDR sect1_addr = sect1->addr ();
903   const CORE_ADDR sect2_addr = sect2->addr ();
904
905   if (sect1_addr < sect2_addr)
906     return true;
907   else if (sect1_addr > sect2_addr)
908     return false;
909   else
910     {
911       /* Sections are at the same address.  This could happen if
912          A) we have an objfile and a separate debuginfo.
913          B) we are confused, and have added sections without proper relocation,
914          or something like that.  */
915
916       const struct objfile *const objfile1 = sect1->objfile;
917       const struct objfile *const objfile2 = sect2->objfile;
918
919       if (objfile1->separate_debug_objfile == objfile2
920           || objfile2->separate_debug_objfile == objfile1)
921         {
922           /* Case A.  The ordering doesn't matter: separate debuginfo files
923              will be filtered out later.  */
924
925           return false;
926         }
927
928       /* Case B.  Maintain stable sort order, so bugs in GDB are easier to
929          triage.  This section could be slow (since we iterate over all
930          objfiles in each call to sort_cmp), but this shouldn't happen
931          very often (GDB is already in a confused state; one hopes this
932          doesn't happen at all).  If you discover that significant time is
933          spent in the loops below, do 'set complaints 100' and examine the
934          resulting complaints.  */
935       if (objfile1 == objfile2)
936         {
937           /* Both sections came from the same objfile.  We are really
938              confused.  Sort on sequence order of sections within the
939              objfile.  The order of checks is important here, if we find a
940              match on SECT2 first then either SECT2 is before SECT1, or,
941              SECT2 == SECT1, in both cases we should return false.  The
942              second case shouldn't occur during normal use, but std::sort
943              does check that '!(a < a)' when compiled in debug mode.  */
944
945           const struct obj_section *osect;
946
947           ALL_OBJFILE_OSECTIONS (objfile1, osect)
948             if (osect == sect2)
949               return false;
950             else if (osect == sect1)
951               return true;
952
953           /* We should have found one of the sections before getting here.  */
954           gdb_assert_not_reached ("section not found");
955         }
956       else
957         {
958           /* Sort on sequence number of the objfile in the chain.  */
959
960           for (objfile *objfile : current_program_space->objfiles ())
961             if (objfile == objfile1)
962               return true;
963             else if (objfile == objfile2)
964               return false;
965
966           /* We should have found one of the objfiles before getting here.  */
967           gdb_assert_not_reached ("objfile not found");
968         }
969     }
970
971   /* Unreachable.  */
972   gdb_assert_not_reached ("unexpected code path");
973   return false;
974 }
975
976 /* Select "better" obj_section to keep.  We prefer the one that came from
977    the real object, rather than the one from separate debuginfo.
978    Most of the time the two sections are exactly identical, but with
979    prelinking the .rel.dyn section in the real object may have different
980    size.  */
981
982 static struct obj_section *
983 preferred_obj_section (struct obj_section *a, struct obj_section *b)
984 {
985   gdb_assert (a->addr () == b->addr ());
986   gdb_assert ((a->objfile->separate_debug_objfile == b->objfile)
987               || (b->objfile->separate_debug_objfile == a->objfile));
988   gdb_assert ((a->objfile->separate_debug_objfile_backlink == b->objfile)
989               || (b->objfile->separate_debug_objfile_backlink == a->objfile));
990
991   if (a->objfile->separate_debug_objfile != NULL)
992     return a;
993   return b;
994 }
995
996 /* Return 1 if SECTION should be inserted into the section map.
997    We want to insert only non-overlay and non-TLS section.  */
998
999 static int
1000 insert_section_p (const struct bfd *abfd,
1001                   const struct bfd_section *section)
1002 {
1003   const bfd_vma lma = bfd_section_lma (section);
1004
1005   if (overlay_debugging && lma != 0 && lma != bfd_section_vma (section)
1006       && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
1007     /* This is an overlay section.  IN_MEMORY check is needed to avoid
1008        discarding sections from the "system supplied DSO" (aka vdso)
1009        on some Linux systems (e.g. Fedora 11).  */
1010     return 0;
1011   if ((bfd_section_flags (section) & SEC_THREAD_LOCAL) != 0)
1012     /* This is a TLS section.  */
1013     return 0;
1014
1015   return 1;
1016 }
1017
1018 /* Filter out overlapping sections where one section came from the real
1019    objfile, and the other from a separate debuginfo file.
1020    Return the size of table after redundant sections have been eliminated.  */
1021
1022 static int
1023 filter_debuginfo_sections (struct obj_section **map, int map_size)
1024 {
1025   int i, j;
1026
1027   for (i = 0, j = 0; i < map_size - 1; i++)
1028     {
1029       struct obj_section *const sect1 = map[i];
1030       struct obj_section *const sect2 = map[i + 1];
1031       const struct objfile *const objfile1 = sect1->objfile;
1032       const struct objfile *const objfile2 = sect2->objfile;
1033       const CORE_ADDR sect1_addr = sect1->addr ();
1034       const CORE_ADDR sect2_addr = sect2->addr ();
1035
1036       if (sect1_addr == sect2_addr
1037           && (objfile1->separate_debug_objfile == objfile2
1038               || objfile2->separate_debug_objfile == objfile1))
1039         {
1040           map[j++] = preferred_obj_section (sect1, sect2);
1041           ++i;
1042         }
1043       else
1044         map[j++] = sect1;
1045     }
1046
1047   if (i < map_size)
1048     {
1049       gdb_assert (i == map_size - 1);
1050       map[j++] = map[i];
1051     }
1052
1053   /* The map should not have shrunk to less than half the original size.  */
1054   gdb_assert (map_size / 2 <= j);
1055
1056   return j;
1057 }
1058
1059 /* Filter out overlapping sections, issuing a warning if any are found.
1060    Overlapping sections could really be overlay sections which we didn't
1061    classify as such in insert_section_p, or we could be dealing with a
1062    corrupt binary.  */
1063
1064 static int
1065 filter_overlapping_sections (struct obj_section **map, int map_size)
1066 {
1067   int i, j;
1068
1069   for (i = 0, j = 0; i < map_size - 1; )
1070     {
1071       int k;
1072
1073       map[j++] = map[i];
1074       for (k = i + 1; k < map_size; k++)
1075         {
1076           struct obj_section *const sect1 = map[i];
1077           struct obj_section *const sect2 = map[k];
1078           const CORE_ADDR sect1_addr = sect1->addr ();
1079           const CORE_ADDR sect2_addr = sect2->addr ();
1080           const CORE_ADDR sect1_endaddr = sect1->endaddr ();
1081
1082           gdb_assert (sect1_addr <= sect2_addr);
1083
1084           if (sect1_endaddr <= sect2_addr)
1085             break;
1086           else
1087             {
1088               /* We have an overlap.  Report it.  */
1089
1090               struct objfile *const objf1 = sect1->objfile;
1091               struct objfile *const objf2 = sect2->objfile;
1092
1093               const struct bfd_section *const bfds1 = sect1->the_bfd_section;
1094               const struct bfd_section *const bfds2 = sect2->the_bfd_section;
1095
1096               const CORE_ADDR sect2_endaddr = sect2->endaddr ();
1097
1098               struct gdbarch *const gdbarch = objf1->arch ();
1099
1100               complaint (_("unexpected overlap between:\n"
1101                            " (A) section `%s' from `%s' [%s, %s)\n"
1102                            " (B) section `%s' from `%s' [%s, %s).\n"
1103                            "Will ignore section B"),
1104                          bfd_section_name (bfds1), objfile_name (objf1),
1105                          paddress (gdbarch, sect1_addr),
1106                          paddress (gdbarch, sect1_endaddr),
1107                          bfd_section_name (bfds2), objfile_name (objf2),
1108                          paddress (gdbarch, sect2_addr),
1109                          paddress (gdbarch, sect2_endaddr));
1110             }
1111         }
1112       i = k;
1113     }
1114
1115   if (i < map_size)
1116     {
1117       gdb_assert (i == map_size - 1);
1118       map[j++] = map[i];
1119     }
1120
1121   return j;
1122 }
1123
1124
1125 /* Update PMAP, PMAP_SIZE with sections from all objfiles, excluding any
1126    TLS, overlay and overlapping sections.  */
1127
1128 static void
1129 update_section_map (struct program_space *pspace,
1130                     struct obj_section ***pmap, int *pmap_size)
1131 {
1132   struct objfile_pspace_info *pspace_info;
1133   int alloc_size, map_size, i;
1134   struct obj_section *s, **map;
1135
1136   pspace_info = get_objfile_pspace_data (pspace);
1137   gdb_assert (pspace_info->section_map_dirty != 0
1138               || pspace_info->new_objfiles_available != 0);
1139
1140   map = *pmap;
1141   xfree (map);
1142
1143   alloc_size = 0;
1144   for (objfile *objfile : pspace->objfiles ())
1145     ALL_OBJFILE_OSECTIONS (objfile, s)
1146       if (insert_section_p (objfile->obfd, s->the_bfd_section))
1147         alloc_size += 1;
1148
1149   /* This happens on detach/attach (e.g. in gdb.base/attach.exp).  */
1150   if (alloc_size == 0)
1151     {
1152       *pmap = NULL;
1153       *pmap_size = 0;
1154       return;
1155     }
1156
1157   map = XNEWVEC (struct obj_section *, alloc_size);
1158
1159   i = 0;
1160   for (objfile *objfile : pspace->objfiles ())
1161     ALL_OBJFILE_OSECTIONS (objfile, s)
1162       if (insert_section_p (objfile->obfd, s->the_bfd_section))
1163         map[i++] = s;
1164
1165   std::sort (map, map + alloc_size, sort_cmp);
1166   map_size = filter_debuginfo_sections(map, alloc_size);
1167   map_size = filter_overlapping_sections(map, map_size);
1168
1169   if (map_size < alloc_size)
1170     /* Some sections were eliminated.  Trim excess space.  */
1171     map = XRESIZEVEC (struct obj_section *, map, map_size);
1172   else
1173     gdb_assert (alloc_size == map_size);
1174
1175   *pmap = map;
1176   *pmap_size = map_size;
1177 }
1178
1179 /* Bsearch comparison function.  */
1180
1181 static int
1182 bsearch_cmp (const void *key, const void *elt)
1183 {
1184   const CORE_ADDR pc = *(CORE_ADDR *) key;
1185   const struct obj_section *section = *(const struct obj_section **) elt;
1186
1187   if (pc < section->addr ())
1188     return -1;
1189   if (pc < section->endaddr ())
1190     return 0;
1191   return 1;
1192 }
1193
1194 /* Returns a section whose range includes PC or NULL if none found.   */
1195
1196 struct obj_section *
1197 find_pc_section (CORE_ADDR pc)
1198 {
1199   struct objfile_pspace_info *pspace_info;
1200   struct obj_section *s, **sp;
1201
1202   /* Check for mapped overlay section first.  */
1203   s = find_pc_mapped_section (pc);
1204   if (s)
1205     return s;
1206
1207   pspace_info = get_objfile_pspace_data (current_program_space);
1208   if (pspace_info->section_map_dirty
1209       || (pspace_info->new_objfiles_available
1210           && !pspace_info->inhibit_updates))
1211     {
1212       update_section_map (current_program_space,
1213                           &pspace_info->sections,
1214                           &pspace_info->num_sections);
1215
1216       /* Don't need updates to section map until objfiles are added,
1217          removed or relocated.  */
1218       pspace_info->new_objfiles_available = 0;
1219       pspace_info->section_map_dirty = 0;
1220     }
1221
1222   /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1223      bsearch be non-NULL.  */
1224   if (pspace_info->sections == NULL)
1225     {
1226       gdb_assert (pspace_info->num_sections == 0);
1227       return NULL;
1228     }
1229
1230   sp = (struct obj_section **) bsearch (&pc,
1231                                         pspace_info->sections,
1232                                         pspace_info->num_sections,
1233                                         sizeof (*pspace_info->sections),
1234                                         bsearch_cmp);
1235   if (sp != NULL)
1236     return *sp;
1237   return NULL;
1238 }
1239
1240
1241 /* Return non-zero if PC is in a section called NAME.  */
1242
1243 int
1244 pc_in_section (CORE_ADDR pc, const char *name)
1245 {
1246   struct obj_section *s;
1247   int retval = 0;
1248
1249   s = find_pc_section (pc);
1250
1251   retval = (s != NULL
1252             && s->the_bfd_section->name != NULL
1253             && strcmp (s->the_bfd_section->name, name) == 0);
1254   return (retval);
1255 }
1256 \f
1257
1258 /* Set section_map_dirty so section map will be rebuilt next time it
1259    is used.  Called by reread_symbols.  */
1260
1261 void
1262 objfiles_changed (void)
1263 {
1264   /* Rebuild section map next time we need it.  */
1265   get_objfile_pspace_data (current_program_space)->section_map_dirty = 1;
1266 }
1267
1268 /* See comments in objfiles.h.  */
1269
1270 scoped_restore_tmpl<int>
1271 inhibit_section_map_updates (struct program_space *pspace)
1272 {
1273   return scoped_restore_tmpl<int>
1274     (&get_objfile_pspace_data (pspace)->inhibit_updates, 1);
1275 }
1276
1277 /* See objfiles.h.  */
1278
1279 bool
1280 is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile)
1281 {
1282   struct obj_section *osect;
1283
1284   if (objfile == NULL)
1285     return false;
1286
1287   ALL_OBJFILE_OSECTIONS (objfile, osect)
1288     {
1289       if (section_is_overlay (osect) && !section_is_mapped (osect))
1290         continue;
1291
1292       if (osect->addr () <= addr && addr < osect->endaddr ())
1293         return true;
1294     }
1295   return false;
1296 }
1297
1298 /* See objfiles.h.  */
1299
1300 bool
1301 shared_objfile_contains_address_p (struct program_space *pspace,
1302                                    CORE_ADDR address)
1303 {
1304   for (objfile *objfile : pspace->objfiles ())
1305     {
1306       if ((objfile->flags & OBJF_SHARED) != 0
1307           && is_addr_in_objfile (address, objfile))
1308         return true;
1309     }
1310
1311   return false;
1312 }
1313
1314 /* The default implementation for the "iterate_over_objfiles_in_search_order"
1315    gdbarch method.  It is equivalent to use the objfiles iterable,
1316    searching the objfiles in the order they are stored internally,
1317    ignoring CURRENT_OBJFILE.
1318
1319    On most platforms, it should be close enough to doing the best
1320    we can without some knowledge specific to the architecture.  */
1321
1322 void
1323 default_iterate_over_objfiles_in_search_order
1324   (struct gdbarch *gdbarch,
1325    iterate_over_objfiles_in_search_order_cb_ftype *cb,
1326    void *cb_data, struct objfile *current_objfile)
1327 {
1328   int stop = 0;
1329
1330   for (objfile *objfile : current_program_space->objfiles ())
1331     {
1332        stop = cb (objfile, cb_data);
1333        if (stop)
1334          return;
1335     }
1336 }
1337
1338 /* See objfiles.h.  */
1339
1340 const char *
1341 objfile_name (const struct objfile *objfile)
1342 {
1343   if (objfile->obfd != NULL)
1344     return bfd_get_filename (objfile->obfd);
1345
1346   return objfile->original_name;
1347 }
1348
1349 /* See objfiles.h.  */
1350
1351 const char *
1352 objfile_filename (const struct objfile *objfile)
1353 {
1354   if (objfile->obfd != NULL)
1355     return bfd_get_filename (objfile->obfd);
1356
1357   return NULL;
1358 }
1359
1360 /* See objfiles.h.  */
1361
1362 const char *
1363 objfile_debug_name (const struct objfile *objfile)
1364 {
1365   return lbasename (objfile->original_name);
1366 }
1367
1368 /* See objfiles.h.  */
1369
1370 const char *
1371 objfile_flavour_name (struct objfile *objfile)
1372 {
1373   if (objfile->obfd != NULL)
1374     return bfd_flavour_name (bfd_get_flavour (objfile->obfd));
1375   return NULL;
1376 }
1377
1378 /* See objfiles.h.  */
1379
1380 struct type *
1381 objfile_int_type (struct objfile *of, int size_in_bytes, bool unsigned_p)
1382 {
1383   struct type *int_type;
1384
1385   /* Helper macro to examine the various builtin types.  */
1386 #define TRY_TYPE(F)                                                     \
1387   int_type = (unsigned_p                                                \
1388               ? objfile_type (of)->builtin_unsigned_ ## F               \
1389               : objfile_type (of)->builtin_ ## F);                      \
1390   if (int_type != NULL && TYPE_LENGTH (int_type) == size_in_bytes)      \
1391     return int_type
1392
1393   TRY_TYPE (char);
1394   TRY_TYPE (short);
1395   TRY_TYPE (int);
1396   TRY_TYPE (long);
1397   TRY_TYPE (long_long);
1398
1399 #undef TRY_TYPE
1400
1401   gdb_assert_not_reached ("unable to find suitable integer type");
1402 }
This page took 0.101325 seconds and 4 git commands to generate.