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