objfiles.c 43.4 KB
Newer Older
1
/* GDB routines for manipulating objfiles.
Andrew Cagney's avatar
Andrew Cagney committed
2

3
   Copyright (C) 1992-2019 Free Software Foundation, Inc.
Andrew Cagney's avatar
Andrew Cagney committed
4

5
6
   Contributed by Cygnus Support, using pieces from other GDB modules.

7
   This file is part of GDB.
8

9
10
   This program is free software; you can redistribute it and/or modify
   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
15
16
17
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   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
26
27
28
29
30
31

#include "defs.h"
#include "bfd.h"		/* Binary File Description */
#include "symtab.h"
#include "symfile.h"
#include "objfiles.h"
#include "gdb-stabs.h"
#include "target.h"
Andrew Cagney's avatar
Andrew Cagney committed
32
#include "bcache.h"
33
34
35
#include "expression.h"
#include "parser-defs.h"

36
#include <sys/types.h>
Tom Tromey's avatar
Tom Tromey committed
37
#include <sys/stat.h>
38
#include <fcntl.h>
39
#include "gdb_obstack.h"
40
#include "hashtab.h"
41

Stan Shebs's avatar
Stan Shebs committed
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"
Tom Tromey's avatar
Tom Tromey committed
49
#include "observable.h"
50
#include "complaints.h"
Tom Tromey's avatar
gdb    
Tom Tromey committed
51
#include "psymtab.h"
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
52
#include "solist.h"
53
#include "gdb_bfd.h"
54
#include "btrace.h"
55
#include "common/pathstuff.h"
Stan Shebs's avatar
Stan Shebs committed
56

Tom Tromey's avatar
Tom Tromey committed
57
58
#include <vector>

59
60
/* Keep a registry of per-objfile data-pointers required by other GDB
   modules.  */
61

62
DEFINE_REGISTRY (objfile, REGISTRY_ACCESS_FIELD)
63

64
/* Externally visible variables that are owned by this module.
65
   See declarations in objfile.h for more info.  */
66

67
68
69
70
struct objfile_pspace_info
{
  struct obj_section **sections;
  int num_sections;
71
72
73
74
75
76
77
78
79
80

  /* Nonzero if object files have been added since the section map
     was last updated.  */
  int new_objfiles_available;

  /* Nonzero if the section map MUST be updated before use.  */
  int section_map_dirty;

  /* Nonzero if section map updates should be inhibited if possible.  */
  int inhibit_updates;
81
82
83
84
85
86
87
88
};

/* Per-program-space data key.  */
static const struct program_space_data *objfiles_pspace_data;

static void
objfiles_pspace_data_cleanup (struct program_space *pspace, void *arg)
{
Simon Marchi's avatar
Simon Marchi committed
89
  struct objfile_pspace_info *info = (struct objfile_pspace_info *) arg;
90

Yao Qi's avatar
Yao Qi committed
91
92
  xfree (info->sections);
  xfree (info);
93
94
95
96
97
98
99
100
101
102
}

/* Get the current svr4 data.  If none is found yet, add it now.  This
   function always returns a valid object.  */

static struct objfile_pspace_info *
get_objfile_pspace_data (struct program_space *pspace)
{
  struct objfile_pspace_info *info;

Simon Marchi's avatar
Simon Marchi committed
103
104
  info = ((struct objfile_pspace_info *)
	  program_space_data (pspace, objfiles_pspace_data));
105
106
  if (info == NULL)
    {
Tom Tromey's avatar
Tom Tromey committed
107
      info = XCNEW (struct objfile_pspace_info);
108
109
110
111
112
113
      set_program_space_data (pspace, objfiles_pspace_data, info);
    }

  return info;
}

114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133


/* Per-BFD data key.  */

static const struct bfd_data *objfiles_bfd_data;

/* Create the per-BFD storage object for OBJFILE.  If ABFD is not
   NULL, and it already has a per-BFD storage object, use that.
   Otherwise, allocate a new per-BFD storage object.  If ABFD is not
   NULL, the object is allocated on the BFD; otherwise it is allocated
   on OBJFILE's obstack.  Note that it is not safe to call this
   multiple times for a given OBJFILE -- it can only be called when
   allocating or re-initializing OBJFILE.  */

static struct objfile_per_bfd_storage *
get_objfile_bfd_data (struct objfile *objfile, struct bfd *abfd)
{
  struct objfile_per_bfd_storage *storage = NULL;

  if (abfd != NULL)
Simon Marchi's avatar
Simon Marchi committed
134
135
    storage = ((struct objfile_per_bfd_storage *)
	       bfd_data (abfd, objfiles_bfd_data));
136
137
138

  if (storage == NULL)
    {
139
140
141
142
      /* If the object requires gdb to do relocations, we simply fall
	 back to not sharing data across users.  These cases are rare
	 enough that this seems reasonable.  */
      if (abfd != NULL && !gdb_bfd_requires_relocations (abfd))
143
	{
144
145
	  storage
	    = ((struct objfile_per_bfd_storage *)
Pedro Alves's avatar
Pedro Alves committed
146
	       bfd_alloc (abfd, sizeof (struct objfile_per_bfd_storage)));
147
148
149
	  /* objfile_per_bfd_storage is not trivially constructible, must
	     call the ctor manually.  */
	  storage = new (storage) objfile_per_bfd_storage ();
150
151
152
	  set_bfd_data (abfd, objfiles_bfd_data, storage);
	}
      else
153
154
	storage
	  = obstack_new<objfile_per_bfd_storage> (&objfile->objfile_obstack);
155

156
157
158
159
      /* Look up the gdbarch associated with the BFD.  */
      if (abfd != NULL)
	storage->gdbarch = gdbarch_from_bfd (abfd);

160
      storage->filename_cache = bcache_xmalloc (NULL, NULL);
161
      storage->macro_cache = bcache_xmalloc (NULL, NULL);
162
      storage->language_of_main = language_unknown;
163
164
165
166
167
168
169
170
171
172
173
    }

  return storage;
}

/* Free STORAGE.  */

static void
free_objfile_per_bfd_storage (struct objfile_per_bfd_storage *storage)
{
  bcache_xfree (storage->filename_cache);
174
  bcache_xfree (storage->macro_cache);
175
176
  if (storage->demangled_names_hash)
    htab_delete (storage->demangled_names_hash);
Pedro Alves's avatar
Pedro Alves committed
177
  storage->~objfile_per_bfd_storage ();
178
179
180
181
182
183
184
185
}

/* A wrapper for free_objfile_per_bfd_storage that can be passed as a
   cleanup function to the BFD registry.  */

static void
objfile_bfd_data_free (struct bfd *unused, void *d)
{
Simon Marchi's avatar
Simon Marchi committed
186
  free_objfile_per_bfd_storage ((struct objfile_per_bfd_storage *) d);
187
188
189
190
191
192
193
194
195
196
}

/* See objfiles.h.  */

void
set_objfile_per_bfd (struct objfile *objfile)
{
  objfile->per_bfd = get_objfile_bfd_data (objfile, objfile->obfd);
}

197
198
199
200
201
202
203
204
205
206
/* Set the objfile's per-BFD notion of the "main" name and
   language.  */

void
set_objfile_main_name (struct objfile *objfile,
		       const char *name, enum language lang)
{
  if (objfile->per_bfd->name_of_main == NULL
      || strcmp (objfile->per_bfd->name_of_main, name) != 0)
    objfile->per_bfd->name_of_main
207
208
      = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack, name,
				      strlen (name));
209
210
211
  objfile->per_bfd->language_of_main = lang;
}

212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
/* Helper structure to map blocks to static link properties in hash tables.  */

struct static_link_htab_entry
{
  const struct block *block;
  const struct dynamic_prop *static_link;
};

/* Return a hash code for struct static_link_htab_entry *P.  */

static hashval_t
static_link_htab_entry_hash (const void *p)
{
  const struct static_link_htab_entry *e
    = (const struct static_link_htab_entry *) p;

  return htab_hash_pointer (e->block);
}

/* Return whether P1 an P2 (pointers to struct static_link_htab_entry) are
   mappings for the same block.  */

static int
static_link_htab_entry_eq (const void *p1, const void *p2)
{
  const struct static_link_htab_entry *e1
    = (const struct static_link_htab_entry *) p1;
  const struct static_link_htab_entry *e2
    = (const struct static_link_htab_entry *) p2;

  return e1->block == e2->block;
}

/* Register STATIC_LINK as the static link for BLOCK, which is part of OBJFILE.
   Must not be called more than once for each BLOCK.  */

void
objfile_register_static_link (struct objfile *objfile,
			      const struct block *block,
			      const struct dynamic_prop *static_link)
{
  void **slot;
  struct static_link_htab_entry lookup_entry;
  struct static_link_htab_entry *entry;

  if (objfile->static_links == NULL)
    objfile->static_links = htab_create_alloc
      (1, &static_link_htab_entry_hash, static_link_htab_entry_eq, NULL,
       xcalloc, xfree);

  /* Create a slot for the mapping, make sure it's the first mapping for this
     block and then create the mapping itself.  */
  lookup_entry.block = block;
  slot = htab_find_slot (objfile->static_links, &lookup_entry, INSERT);
  gdb_assert (*slot == NULL);

268
  entry = XOBNEW (&objfile->objfile_obstack, static_link_htab_entry);
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
  entry->block = block;
  entry->static_link = static_link;
  *slot = (void *) entry;
}

/* Look for a static link for BLOCK, which is part of OBJFILE.  Return NULL if
   none was found.  */

const struct dynamic_prop *
objfile_lookup_static_link (struct objfile *objfile,
			    const struct block *block)
{
  struct static_link_htab_entry *entry;
  struct static_link_htab_entry lookup_entry;

  if (objfile->static_links == NULL)
    return NULL;
  lookup_entry.block = block;
  entry
    = (struct static_link_htab_entry *) htab_find (objfile->static_links,
						   &lookup_entry);
  if (entry == NULL)
    return NULL;

  gdb_assert (entry->block == block);
  return entry->static_link;
}

297
298


Jason Molenda's avatar
Jason Molenda committed
299
300
301
/* Called via bfd_map_over_sections to build up the section table that
   the objfile references.  The objfile contains pointers to the start
   of the table (objfile->sections) and to the first location after
302
   the end of the table (objfile->sections_end).  */
Jason Molenda's avatar
Jason Molenda committed
303

304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
static void
add_to_objfile_sections_full (struct bfd *abfd, struct bfd_section *asect,
			      struct objfile *objfile, int force)
{
  struct obj_section *section;

  if (!force)
    {
      flagword aflag;

      aflag = bfd_get_section_flags (abfd, asect);
      if (!(aflag & SEC_ALLOC))
	return;
    }

  section = &objfile->sections[gdb_bfd_section_index (abfd, asect)];
  section->objfile = objfile;
  section->the_bfd_section = asect;
  section->ovly_mapped = 0;
}

325
static void
326
add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
327
			 void *objfilep)
328
{
Simon Marchi's avatar
Simon Marchi committed
329
  add_to_objfile_sections_full (abfd, asect, (struct objfile *) objfilep, 0);
330
331
332
}

/* Builds a section table for OBJFILE.
Jason Molenda's avatar
Jason Molenda committed
333

334
335
   Note that the OFFSET and OVLY_MAPPED in each table entry are
   initialized to zero.  */
336

337
void
Kevin Buettner's avatar
Kevin Buettner committed
338
build_objfile_section_table (struct objfile *objfile)
339
{
340
341
342
343
344
345
  int count = gdb_bfd_count_sections (objfile->obfd);

  objfile->sections = OBSTACK_CALLOC (&objfile->objfile_obstack,
				      count,
				      struct obj_section);
  objfile->sections_end = (objfile->sections + count);
346
347
  bfd_map_over_sections (objfile->obfd,
			 add_to_objfile_sections, (void *) objfile);
348
349
350
351
352
353

  /* See gdb_bfd_section_index.  */
  add_to_objfile_sections_full (objfile->obfd, bfd_com_section_ptr, objfile, 1);
  add_to_objfile_sections_full (objfile->obfd, bfd_und_section_ptr, objfile, 1);
  add_to_objfile_sections_full (objfile->obfd, bfd_abs_section_ptr, objfile, 1);
  add_to_objfile_sections_full (objfile->obfd, bfd_ind_section_ptr, objfile, 1);
354
355
}

Tom Tromey's avatar
Tom Tromey committed
356
357
358
/* Given a pointer to an initialized bfd (ABFD) and some flag bits,
   initialize the new objfile as best we can and link it into the list
   of all known objfiles.
359

360
361
362
363
364
   NAME should contain original non-canonicalized filename or other
   identifier as entered by user.  If there is no better source use
   bfd_get_filename (ABFD).  NAME may be NULL only if ABFD is NULL.
   NAME content is copied into returned objfile.

Jason Molenda's avatar
Jason Molenda committed
365
   The FLAGS word contains various bits (OBJF_*) that can be taken as
366
   requests for specific operations.  Other bits like OBJF_SHARED are
367
   simply copied through to the new objfile flags member.  */
368

Tom Tromey's avatar
Tom Tromey committed
369
370
371
objfile::objfile (bfd *abfd, const char *name, objfile_flags flags_)
  : flags (flags_),
    pspace (current_program_space),
372
    partial_symtabs (new psymtab_storage ()),
Tom Tromey's avatar
Tom Tromey committed
373
    obfd (abfd)
374
{
375
  const char *expanded_name;
376

377
378
  /* We could use obstack_specify_allocation here instead, but
     gdb_obstack.h specifies the alloc/dealloc functions.  */
Tom Tromey's avatar
Tom Tromey committed
379
  obstack_init (&objfile_obstack);
380

Tom Tromey's avatar
Tom Tromey committed
381
  objfile_alloc_data (this);
382

383
  gdb::unique_xmalloc_ptr<char> name_holder;
384
385
386
  if (name == NULL)
    {
      gdb_assert (abfd == NULL);
Jan Kratochvil's avatar
Jan Kratochvil committed
387
      gdb_assert ((flags & OBJF_NOT_FILENAME) != 0);
388
      expanded_name = "<<anonymous objfile>>";
389
    }
390
391
  else if ((flags & OBJF_NOT_FILENAME) != 0
	   || is_target_filename (name))
392
    expanded_name = name;
393
  else
394
395
396
397
    {
      name_holder = gdb_abspath (name);
      expanded_name = name_holder.get ();
    }
Tom Tromey's avatar
Tom Tromey committed
398
399
  original_name
    = (char *) obstack_copy0 (&objfile_obstack,
400
401
			      expanded_name,
			      strlen (expanded_name));
402

403
404
405
406
  /* Update the per-objfile information that comes from the bfd, ensuring
     that any data that is reference is saved in the per-objfile data
     region.  */

407
  gdb_bfd_ref (abfd);
408
409
  if (abfd != NULL)
    {
Tom Tromey's avatar
Tom Tromey committed
410
      mtime = bfd_get_mtime (abfd);
411
412

      /* Build section table.  */
Tom Tromey's avatar
Tom Tromey committed
413
      build_objfile_section_table (this);
414
415
    }

Tom Tromey's avatar
Tom Tromey committed
416
  per_bfd = get_objfile_bfd_data (this, abfd);
Tom Tromey's avatar
Tom Tromey committed
417

Tom Tromey's avatar
Tom Tromey committed
418
  terminate_minimal_symbol_table (this);
419

420
  /* Add this file onto the tail of the linked list of other such files.  */
421
422

  if (object_files == NULL)
Tom Tromey's avatar
Tom Tromey committed
423
    object_files = this;
424
425
  else
    {
426
427
      struct objfile *last_one;

428
      for (last_one = object_files;
429
430
	   last_one->next;
	   last_one = last_one->next);
Tom Tromey's avatar
Tom Tromey committed
431
      last_one->next = this;
432
433
    }

434
  /* Rebuild section map next time we need it.  */
Tom Tromey's avatar
Tom Tromey committed
435
  get_objfile_pspace_data (pspace)->new_objfiles_available = 1;
436
437
}

438
/* Retrieve the gdbarch associated with OBJFILE.  */
439

440
struct gdbarch *
441
get_objfile_arch (const struct objfile *objfile)
442
{
443
  return objfile->per_bfd->gdbarch;
444
445
}

Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
446
447
/* If there is a valid and known entry point, function fills *ENTRY_P with it
   and returns non-zero; otherwise it returns zero.  */
448

Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
449
450
int
entry_point_address_query (CORE_ADDR *entry_p)
451
{
452
  if (symfile_objfile == NULL || !symfile_objfile->per_bfd->ei.entry_point_p)
453
454
    return 0;

455
  *entry_p = (symfile_objfile->per_bfd->ei.entry_point
456
	      + ANOFFSET (symfile_objfile->section_offsets,
457
			  symfile_objfile->per_bfd->ei.the_bfd_section_index));
458

Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
459
460
461
462
463
464
465
466
467
468
469
470
471
472
  return 1;
}

/* Get current entry point address.  Call error if it is not known.  */

CORE_ADDR
entry_point_address (void)
{
  CORE_ADDR retval;

  if (!entry_point_address_query (&retval))
    error (_("Entry point address is not known."));

  return retval;
473
}
474

475
476
477
478
479
480
481
482
483
484
485
486
487
488
/* Iterator on PARENT and every separate debug objfile of PARENT.
   The usage pattern is:
     for (objfile = parent;
          objfile;
          objfile = objfile_separate_debug_iterate (parent, objfile))
       ...
*/

struct objfile *
objfile_separate_debug_iterate (const struct objfile *parent,
                                const struct objfile *objfile)
{
  struct objfile *res;

489
  /* If any, return the first child.  */
490
491
492
493
494
495
496
497
  res = objfile->separate_debug_objfile;
  if (res)
    return res;

  /* Common case where there is no separate debug objfile.  */
  if (objfile == parent)
    return NULL;

498
499
500
501
502
503
  /* Return the brother if any.  Note that we don't iterate on brothers of
     the parents.  */
  res = objfile->separate_debug_objfile_link;
  if (res)
    return res;

504
505
506
507
508
509
510
511
512
513
  for (res = objfile->separate_debug_objfile_backlink;
       res != parent;
       res = res->separate_debug_objfile_backlink)
    {
      gdb_assert (res != NULL);
      if (res->separate_debug_objfile_link)
        return res->separate_debug_objfile_link;
    }
  return NULL;
}
514

Jim Blandy's avatar
Jim Blandy committed
515
516
/* Put one object file before a specified on in the global list.
   This can be used to make sure an object file is destroyed before
517
   another when using objfiles_safe to free all objfiles.  */
Jim Blandy's avatar
Jim Blandy committed
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
void
put_objfile_before (struct objfile *objfile, struct objfile *before_this)
{
  struct objfile **objp;

  unlink_objfile (objfile);
  
  for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
    {
      if (*objp == before_this)
	{
	  objfile->next = *objp;
	  *objp = objfile;
	  return;
	}
    }
  
  internal_error (__FILE__, __LINE__,
536
		  _("put_objfile_before: before objfile not in list"));
Jim Blandy's avatar
Jim Blandy committed
537
538
}

539
540
541
542
543
544
545
546
547
548
549
/* Unlink OBJFILE from the list of known objfiles, if it is found in the
   list.

   It is not a bug, or error, to call this function if OBJFILE is not known
   to be in the current list.  This is done in the case of mapped objfiles,
   for example, just to ensure that the mapped objfile doesn't appear twice
   in the list.  Since the list is threaded, linking in a mapped objfile
   twice would create a circular list.

   If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
   unlinking it, just to ensure that we have completely severed any linkages
550
   between the OBJFILE and the list.  */
551
552

void
Kevin Buettner's avatar
Kevin Buettner committed
553
unlink_objfile (struct objfile *objfile)
554
{
555
  struct objfile **objpp;
556

557
  for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
558
    {
559
      if (*objpp == objfile)
560
	{
561
562
	  *objpp = (*objpp)->next;
	  objfile->next = NULL;
563
	  return;
564
565
	}
    }
566

567
  internal_error (__FILE__, __LINE__,
568
		  _("unlink_objfile: objfile already unlinked"));
569
570
}

571
572
573
574
575
576
577
578
579
580
/* Add OBJFILE as a separate debug objfile of PARENT.  */

void
add_separate_debug_objfile (struct objfile *objfile, struct objfile *parent)
{
  gdb_assert (objfile && parent);

  /* Must not be already in a list.  */
  gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
  gdb_assert (objfile->separate_debug_objfile_link == NULL);
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
581
582
583
  gdb_assert (objfile->separate_debug_objfile == NULL);
  gdb_assert (parent->separate_debug_objfile_backlink == NULL);
  gdb_assert (parent->separate_debug_objfile_link == NULL);
584
585
586
587
588
589

  objfile->separate_debug_objfile_backlink = parent;
  objfile->separate_debug_objfile_link = parent->separate_debug_objfile;
  parent->separate_debug_objfile = objfile;

  /* Put the separate debug object before the normal one, this is so that
590
     usage of objfiles_safe will stay safe.  */
591
592
593
594
595
596
597
598
599
600
601
602
603
604
  put_objfile_before (objfile, parent);
}

/* Free all separate debug objfile of OBJFILE, but don't free OBJFILE
   itself.  */

void
free_objfile_separate_debug (struct objfile *objfile)
{
  struct objfile *child;

  for (child = objfile->separate_debug_objfile; child;)
    {
      struct objfile *next_child = child->separate_debug_objfile_link;
Tom Tromey's avatar
Tom Tromey committed
605
      delete child;
606
607
608
      child = next_child;
    }
}
609

Tom Tromey's avatar
Tom Tromey committed
610
/* Destroy an objfile and all the symtabs and psymtabs under it.  */
611

Tom Tromey's avatar
Tom Tromey committed
612
objfile::~objfile ()
613
{
614
  /* First notify observers that this objfile is about to be freed.  */
Tom Tromey's avatar
Tom Tromey committed
615
  gdb::observers::free_objfile.notify (this);
616

617
  /* Free all separate debug objfiles.  */
Tom Tromey's avatar
Tom Tromey committed
618
  free_objfile_separate_debug (this);
619

Tom Tromey's avatar
Tom Tromey committed
620
  if (separate_debug_objfile_backlink)
Jim Blandy's avatar
Jim Blandy committed
621
622
623
    {
      /* We freed the separate debug file, make sure the base objfile
	 doesn't reference it.  */
624
625
      struct objfile *child;

Tom Tromey's avatar
Tom Tromey committed
626
      child = separate_debug_objfile_backlink->separate_debug_objfile;
627

Tom Tromey's avatar
Tom Tromey committed
628
      if (child == this)
629
        {
Tom Tromey's avatar
Tom Tromey committed
630
631
632
          /* THIS is the first child.  */
          separate_debug_objfile_backlink->separate_debug_objfile =
            separate_debug_objfile_link;
633
634
635
        }
      else
        {
Tom Tromey's avatar
Tom Tromey committed
636
          /* Find THIS in the list.  */
637
638
          while (1)
            {
Tom Tromey's avatar
Tom Tromey committed
639
              if (child->separate_debug_objfile_link == this)
640
641
                {
                  child->separate_debug_objfile_link =
Tom Tromey's avatar
Tom Tromey committed
642
                    separate_debug_objfile_link;
643
644
645
646
647
648
                  break;
                }
              child = child->separate_debug_objfile_link;
              gdb_assert (child);
            }
        }
Jim Blandy's avatar
Jim Blandy committed
649
    }
Tom Tromey's avatar
Tom Tromey committed
650

Daniel Jacobowitz's avatar
gdb/    
Daniel Jacobowitz committed
651
652
  /* Remove any references to this objfile in the global value
     lists.  */
Tom Tromey's avatar
Tom Tromey committed
653
  preserve_values (this);
Daniel Jacobowitz's avatar
gdb/    
Daniel Jacobowitz committed
654

Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
655
656
  /* It still may reference data modules have associated with the objfile and
     the symbol file data.  */
Tom Tromey's avatar
Tom Tromey committed
657
  forget_cached_source_info_for_objfile (this);
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
658

Tom Tromey's avatar
Tom Tromey committed
659
660
  breakpoint_free_objfile (this);
  btrace_free_objfile (this);
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
661

662
663
664
665
666
  /* First do any symbol file specific actions required when we are
     finished with a particular symbol file.  Note that if the objfile
     is using reusable symbol information (via mmalloc) then each of
     these routines is responsible for doing the correct thing, either
     freeing things which are valid only during this particular gdb
667
     execution, or leaving them to be reused during the next one.  */
668

Tom Tromey's avatar
Tom Tromey committed
669
670
  if (sf != NULL)
    (*sf->sym_finish) (this);
671

Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
672
  /* Discard any data modules have associated with the objfile.  The function
Tom Tromey's avatar
Tom Tromey committed
673
674
     still may reference obfd.  */
  objfile_free_data (this);
675

Tom Tromey's avatar
Tom Tromey committed
676
677
  if (obfd)
    gdb_bfd_unref (obfd);
678
  else
Tom Tromey's avatar
Tom Tromey committed
679
    free_objfile_per_bfd_storage (per_bfd);
680

681
  /* Remove it from the chain of all objfiles.  */
682

Tom Tromey's avatar
Tom Tromey committed
683
  unlink_objfile (this);
684

Tom Tromey's avatar
Tom Tromey committed
685
  if (this == symfile_objfile)
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
686
    symfile_objfile = NULL;
687
688
689
690
691
692

  /* Before the symbol table code was redone to make it easier to
     selectively load and remove information particular to a specific
     linkage unit, gdb used to do these things whenever the monolithic
     symbol table was blown away.  How much still needs to be done
     is unknown, but we play it safe for now and keep each action until
693
     it is shown to be no longer needed.  */
694

695
696
  /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
     for example), so we need to call this here.  */
697
698
  clear_pc_function_cache ();

699
700
701
702
  /* Clear globals which might have pointed into a removed objfile.
     FIXME: It's not clear which of these are supposed to persist
     between expressions and which ought to be reset each time.  */
  expression_context_block = NULL;
703
  innermost_block.reset ();
704

705
  /* Check to see if the current_source_symtab belongs to this objfile,
706
     and if so, call clear_current_source_symtab_and_line.  */
707
708
709
710

  {
    struct symtab_and_line cursal = get_current_source_symtab_and_line ();

Tom Tromey's avatar
Tom Tromey committed
711
    if (cursal.symtab && SYMTAB_OBJFILE (cursal.symtab) == this)
712
      clear_current_source_symtab_and_line ();
713
714
  }

715
  /* Free the obstacks for non-reusable objfiles.  */
Tom Tromey's avatar
Tom Tromey committed
716
  obstack_free (&objfile_obstack, 0);
717
718

  /* Rebuild section map next time we need it.  */
Tom Tromey's avatar
Tom Tromey committed
719
  get_objfile_pspace_data (pspace)->section_map_dirty = 1;
720

721
722
  /* Free the map for static links.  There's no need to free static link
     themselves since they were allocated on the objstack.  */
Tom Tromey's avatar
Tom Tromey committed
723
724
  if (static_links != NULL)
    htab_delete (static_links);
725
726
727
728
729
}

/* Free all the object files at once and clean up their users.  */

void
Kevin Buettner's avatar
Kevin Buettner committed
730
free_all_objfiles (void)
731
{
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
732
733
734
735
736
  struct so_list *so;

  /* Any objfile referencewould become stale.  */
  for (so = master_so_list (); so; so = so->next)
    gdb_assert (so->objfile == NULL);
737

738
  for (objfile *objfile : current_program_space->objfiles_safe ())
Tom Tromey's avatar
Tom Tromey committed
739
    delete objfile;
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
740
  clear_symtab_users (0);
741
742
}

Tom Tromey's avatar
gdb    
Tom Tromey committed
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
/* A helper function for objfile_relocate1 that relocates a single
   symbol.  */

static void
relocate_one_symbol (struct symbol *sym, struct objfile *objfile,
		     struct section_offsets *delta)
{
  fixup_symbol_section (sym, objfile);

  /* The RS6000 code from which this was taken skipped
     any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
     But I'm leaving out that test, on the theory that
     they can't possibly pass the tests below.  */
  if ((SYMBOL_CLASS (sym) == LOC_LABEL
       || SYMBOL_CLASS (sym) == LOC_STATIC)
      && SYMBOL_SECTION (sym) >= 0)
    {
      SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (delta, SYMBOL_SECTION (sym));
    }
}

764
/* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
765
766
   entries in new_offsets.  SEPARATE_DEBUG_OBJFILE is not touched here.
   Return non-zero iff any change happened.  */
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
767

Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
768
static int
769
objfile_relocate1 (struct objfile *objfile, 
770
		   const struct section_offsets *new_offsets)
771
{
Stan Shebs's avatar
Stan Shebs committed
772
  struct section_offsets *delta =
773
774
    ((struct section_offsets *) 
     alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
775

776
777
  int something_changed = 0;

Tom Tromey's avatar
Tom Tromey committed
778
  for (int i = 0; i < objfile->num_sections; ++i)
779
780
781
782
783
784
785
786
    {
      delta->offsets[i] =
	ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
      if (ANOFFSET (delta, i) != 0)
	something_changed = 1;
    }
  if (!something_changed)
    return 0;
787
788
789

  /* OK, get all the symtabs.  */
  {
Tom Tromey's avatar
Tom Tromey committed
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
    for (compunit_symtab *cust : objfile_compunits (objfile))
      {
	for (symtab *s : compunit_filetabs (cust))
	  {
	    struct linetable *l;

	    /* First the line table.  */
	    l = SYMTAB_LINETABLE (s);
	    if (l)
	      {
		for (int i = 0; i < l->nitems; ++i)
		  l->item[i].pc += ANOFFSET (delta,
					     COMPUNIT_BLOCK_LINE_SECTION
					     (cust));
	      }
	  }
      }
807

Tom Tromey's avatar
Tom Tromey committed
808
809
810
811
812
813
814
815
816
817
818
819
820
    for (compunit_symtab *cust : objfile_compunits (objfile))
      {
	const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (cust);
	int block_line_section = COMPUNIT_BLOCK_LINE_SECTION (cust);

	if (BLOCKVECTOR_MAP (bv))
	  addrmap_relocate (BLOCKVECTOR_MAP (bv),
			    ANOFFSET (delta, block_line_section));

	for (int i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
	  {
	    struct block *b;
	    struct symbol *sym;
821
	    struct mdict_iterator miter;
Tom Tromey's avatar
Tom Tromey committed
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837

	    b = BLOCKVECTOR_BLOCK (bv, i);
	    BLOCK_START (b) += ANOFFSET (delta, block_line_section);
	    BLOCK_END (b) += ANOFFSET (delta, block_line_section);

	    if (BLOCK_RANGES (b) != nullptr)
	      for (int j = 0; j < BLOCK_NRANGES (b); j++)
		{
		  BLOCK_RANGE_START (b, j)
		    += ANOFFSET (delta, block_line_section);
		  BLOCK_RANGE_END (b, j) += ANOFFSET (delta,
						      block_line_section);
		}

	    /* We only want to iterate over the local symbols, not any
	       symbols in included symtabs.  */
838
	    ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (b), miter, sym)
839
	      {
Tom Tromey's avatar
Tom Tromey committed
840
		relocate_one_symbol (sym, objfile, delta);
841
	      }
Tom Tromey's avatar
Tom Tromey committed
842
843
	  }
      }
844
845
  }

846
847
848
849
  /* This stores relocated addresses and so must be cleared.  This
     will cause it to be recreated on demand.  */
  objfile->psymbol_map.clear ();

Tom Tromey's avatar
gdb    
Tom Tromey committed
850
851
852
853
854
855
856
857
  /* Relocate isolated symbols.  */
  {
    struct symbol *iter;

    for (iter = objfile->template_symbols; iter; iter = iter->hash_next)
      relocate_one_symbol (iter, objfile, delta);
  }

858
859
  {
    int i;
860

861
862
863
864
865
    for (i = 0; i < objfile->num_sections; ++i)
      (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
  }

  /* Rebuild section map next time we need it.  */
866
  get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1;
867

868
  /* Update the table in exec_ops, used to read memory.  */
Tom Tromey's avatar
Tom Tromey committed
869
  struct obj_section *s;
870
871
  ALL_OBJFILE_OSECTIONS (objfile, s)
    {
872
      int idx = s - objfile->sections;
873
874

      exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
875
				obj_section_addr (s));
876
    }
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
877
878
879

  /* Data changed.  */
  return 1;
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
880
881
882
883
884
885
886
887
888
889
890
891
}

/* Relocate OBJFILE to NEW_OFFSETS.  There should be OBJFILE->NUM_SECTIONS
   entries in new_offsets.  Process also OBJFILE's SEPARATE_DEBUG_OBJFILEs.

   The number and ordering of sections does differ between the two objfiles.
   Only their names match.  Also the file offsets will differ (objfile being
   possibly prelinked but separate_debug_objfile is probably not prelinked) but
   the in-memory absolute address as specified by NEW_OFFSETS must match both
   files.  */

void
892
893
objfile_relocate (struct objfile *objfile,
		  const struct section_offsets *new_offsets)
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
894
895
{
  struct objfile *debug_objfile;
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
896
  int changed = 0;
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
897

Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
898
  changed |= objfile_relocate1 (objfile, new_offsets);
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
899
900
901
902
903

  for (debug_objfile = objfile->separate_debug_objfile;
       debug_objfile;
       debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
    {
904
905
      section_addr_info objfile_addrs
	= build_section_addr_info_from_objfile (objfile);
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
906
907
908
909

      /* Here OBJFILE_ADDRS contain the correct absolute addresses, the
	 relative ones must be already created according to debug_objfile.  */

910
      addr_info_make_relative (&objfile_addrs, debug_objfile->obfd);
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
911
912

      gdb_assert (debug_objfile->num_sections
913
		  == gdb_bfd_count_sections (debug_objfile->obfd));
Tom Tromey's avatar
Tom Tromey committed
914
915
916
      std::vector<struct section_offsets>
	new_debug_offsets (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections));
      relative_addr_info_to_section_offsets (new_debug_offsets.data (),
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
917
918
919
					     debug_objfile->num_sections,
					     objfile_addrs);

Tom Tromey's avatar
Tom Tromey committed
920
      changed |= objfile_relocate1 (debug_objfile, new_debug_offsets.data ());
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
921
    }
922

923
  /* Relocate breakpoints as necessary, after things are relocated.  */
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
924
925
  if (changed)
    breakpoint_re_set ();
926
}
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965

/* Rebase (add to the offsets) OBJFILE by SLIDE.  SEPARATE_DEBUG_OBJFILE is
   not touched here.
   Return non-zero iff any change happened.  */

static int
objfile_rebase1 (struct objfile *objfile, CORE_ADDR slide)
{
  struct section_offsets *new_offsets =
    ((struct section_offsets *)
     alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
  int i;

  for (i = 0; i < objfile->num_sections; ++i)
    new_offsets->offsets[i] = slide;

  return objfile_relocate1 (objfile, new_offsets);
}

/* Rebase (add to the offsets) OBJFILE by SLIDE.  Process also OBJFILE's
   SEPARATE_DEBUG_OBJFILEs.  */

void
objfile_rebase (struct objfile *objfile, CORE_ADDR slide)
{
  struct objfile *debug_objfile;
  int changed = 0;

  changed |= objfile_rebase1 (objfile, slide);

  for (debug_objfile = objfile->separate_debug_objfile;
       debug_objfile;
       debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
    changed |= objfile_rebase1 (debug_objfile, slide);

  /* Relocate breakpoints as necessary, after things are relocated.  */
  if (changed)
    breakpoint_re_set ();
}
966

967
968
969
970
971
/* Return non-zero if OBJFILE has partial symbols.  */

int
objfile_has_partial_symbols (struct objfile *objfile)
{
972
973
  if (!objfile->sf)
    return 0;
Jan Kratochvil's avatar
gdb/    
Jan Kratochvil committed
974
975
976
977
978
979
980
981
982

  /* If we have not read psymbols, but we have a function capable of reading
     them, then that is an indication that they are in fact available.  Without
     this function the symbols may have been already read in but they also may
     not be present in this objfile.  */
  if ((objfile->flags & OBJF_PSYMTABS_READ) == 0
      && objfile->sf->sym_read_psymbols != NULL)
    return 1;

983
  return objfile->sf->qf->has_symbols (objfile);
984
985
986
987
988
989
990
}

/* Return non-zero if OBJFILE has full symbols.  */

int
objfile_has_full_symbols (struct objfile *objfile)
{
991
  return objfile->compunit_symtabs != NULL;
992
993
}

994
/* Return non-zero if OBJFILE has full or partial symbols, either directly
995
   or through a separate debug file.  */
996
997
998
999

int
objfile_has_symbols (struct objfile *objfile)
{
1000
  struct objfile *o;
For faster browsing, not all history is shown. View entire blame