1 /* GDB routines for manipulating objfiles.
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2007, 2008 Free Software Foundation, Inc.
6 Contributed by Cygnus Support, using pieces from other GDB modules.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* This file contains support routines for creating, manipulating, and
24 destroying objfile structures. */
27 #include "bfd.h" /* Binary File Description */
31 #include "gdb-stabs.h"
34 #include "mdebugread.h"
35 #include "expression.h"
36 #include "parser-defs.h"
38 #include "gdb_assert.h"
39 #include <sys/types.h>
42 #include "gdb_obstack.h"
43 #include "gdb_string.h"
46 #include "breakpoint.h"
48 #include "dictionary.h"
51 #include "arch-utils.h"
53 /* Prototypes for local functions */
55 static void objfile_alloc_data (struct objfile
*objfile
);
56 static void objfile_free_data (struct objfile
*objfile
);
58 /* Externally visible variables that are owned by this module.
59 See declarations in objfile.h for more info. */
61 struct objfile
*object_files
; /* Linked list of all objfiles */
62 struct objfile
*current_objfile
; /* For symbol file being read in */
63 struct objfile
*symfile_objfile
; /* Main symbol table loaded from */
64 struct objfile
*rt_common_objfile
; /* For runtime common symbols */
66 /* Locate all mappable sections of a BFD file.
67 objfile_p_char is a char * to get it through
68 bfd_map_over_sections; we cast it back to its proper type. */
70 #ifndef TARGET_KEEP_SECTION
71 #define TARGET_KEEP_SECTION(ASECT) 0
74 /* Called via bfd_map_over_sections to build up the section table that
75 the objfile references. The objfile contains pointers to the start
76 of the table (objfile->sections) and to the first location after
77 the end of the table (objfile->sections_end). */
80 add_to_objfile_sections (struct bfd
*abfd
, struct bfd_section
*asect
,
83 struct objfile
*objfile
= (struct objfile
*) objfile_p_char
;
84 struct obj_section section
;
87 aflag
= bfd_get_section_flags (abfd
, asect
);
89 if (!(aflag
& SEC_ALLOC
) && !(TARGET_KEEP_SECTION (asect
)))
92 if (0 == bfd_section_size (abfd
, asect
))
95 section
.objfile
= objfile
;
96 section
.the_bfd_section
= asect
;
97 section
.ovly_mapped
= 0;
98 section
.addr
= bfd_section_vma (abfd
, asect
);
99 section
.endaddr
= section
.addr
+ bfd_section_size (abfd
, asect
);
100 obstack_grow (&objfile
->objfile_obstack
, (char *) §ion
, sizeof (section
));
101 objfile
->sections_end
= (struct obj_section
*) (((unsigned long) objfile
->sections_end
) + 1);
104 /* Builds a section table for OBJFILE.
105 Returns 0 if OK, 1 on error (in which case bfd_error contains the
108 Note that while we are building the table, which goes into the
109 psymbol obstack, we hijack the sections_end pointer to instead hold
110 a count of the number of sections. When bfd_map_over_sections
111 returns, this count is used to compute the pointer to the end of
112 the sections table, which then overwrites the count.
114 Also note that the OFFSET and OVLY_MAPPED in each table entry
115 are initialized to zero.
117 Also note that if anything else writes to the psymbol obstack while
118 we are building the table, we're pretty much hosed. */
121 build_objfile_section_table (struct objfile
*objfile
)
123 /* objfile->sections can be already set when reading a mapped symbol
124 file. I believe that we do need to rebuild the section table in
125 this case (we rebuild other things derived from the bfd), but we
126 can't free the old one (it's in the objfile_obstack). So we just
127 waste some memory. */
129 objfile
->sections_end
= 0;
130 bfd_map_over_sections (objfile
->obfd
, add_to_objfile_sections
, (char *) objfile
);
131 objfile
->sections
= (struct obj_section
*)
132 obstack_finish (&objfile
->objfile_obstack
);
133 objfile
->sections_end
= objfile
->sections
+ (unsigned long) objfile
->sections_end
;
137 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
138 allocate a new objfile struct, fill it in as best we can, link it
139 into the list of all known objfiles, and return a pointer to the
142 The FLAGS word contains various bits (OBJF_*) that can be taken as
143 requests for specific operations. Other bits like OBJF_SHARED are
144 simply copied through to the new objfile flags member. */
146 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
147 by jv-lang.c, to create an artificial objfile used to hold
148 information about dynamically-loaded Java classes. Unfortunately,
149 that branch of this function doesn't get tested very frequently, so
150 it's prone to breakage. (E.g. at one time the name was set to NULL
151 in that situation, which broke a loop over all names in the dynamic
152 library loader.) If you change this function, please try to leave
153 things in a consistent state even if abfd is NULL. */
156 allocate_objfile (bfd
*abfd
, int flags
)
158 struct objfile
*objfile
= NULL
;
159 struct objfile
*last_one
= NULL
;
161 /* If we don't support mapped symbol files, didn't ask for the file to be
162 mapped, or failed to open the mapped file for some reason, then revert
163 back to an unmapped objfile. */
167 objfile
= (struct objfile
*) xmalloc (sizeof (struct objfile
));
168 memset (objfile
, 0, sizeof (struct objfile
));
170 objfile
->psymbol_cache
= bcache_xmalloc ();
171 objfile
->macro_cache
= bcache_xmalloc ();
172 /* We could use obstack_specify_allocation here instead, but
173 gdb_obstack.h specifies the alloc/dealloc functions. */
174 obstack_init (&objfile
->objfile_obstack
);
175 terminate_minimal_symbol_table (objfile
);
178 objfile_alloc_data (objfile
);
180 /* Update the per-objfile information that comes from the bfd, ensuring
181 that any data that is reference is saved in the per-objfile data
184 objfile
->obfd
= abfd
;
185 if (objfile
->name
!= NULL
)
187 xfree (objfile
->name
);
191 /* Look up the gdbarch associated with the BFD. */
192 objfile
->gdbarch
= gdbarch_from_bfd (abfd
);
194 objfile
->name
= xstrdup (bfd_get_filename (abfd
));
195 objfile
->mtime
= bfd_get_mtime (abfd
);
197 /* Build section table. */
199 if (build_objfile_section_table (objfile
))
201 error (_("Can't find the file sections in `%s': %s"),
202 objfile
->name
, bfd_errmsg (bfd_get_error ()));
207 objfile
->name
= xstrdup ("<<anonymous objfile>>");
210 /* Initialize the section indexes for this objfile, so that we can
211 later detect if they are used w/o being properly assigned to. */
213 objfile
->sect_index_text
= -1;
214 objfile
->sect_index_data
= -1;
215 objfile
->sect_index_bss
= -1;
216 objfile
->sect_index_rodata
= -1;
218 /* We don't yet have a C++-specific namespace symtab. */
220 objfile
->cp_namespace_symtab
= NULL
;
222 /* Add this file onto the tail of the linked list of other such files. */
224 objfile
->next
= NULL
;
225 if (object_files
== NULL
)
226 object_files
= objfile
;
229 for (last_one
= object_files
;
231 last_one
= last_one
->next
);
232 last_one
->next
= objfile
;
235 /* Save passed in flag bits. */
236 objfile
->flags
|= flags
;
241 /* Retrieve the gdbarch associated with OBJFILE. */
243 get_objfile_arch (struct objfile
*objfile
)
245 return objfile
->gdbarch
;
248 /* Initialize entry point information for this objfile. */
251 init_entry_point_info (struct objfile
*objfile
)
253 /* Save startup file's range of PC addresses to help blockframe.c
254 decide where the bottom of the stack is. */
256 if (bfd_get_file_flags (objfile
->obfd
) & EXEC_P
)
258 /* Executable file -- record its entry point so we'll recognize
259 the startup file because it contains the entry point. */
260 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
264 /* Examination of non-executable.o files. Short-circuit this stuff. */
265 objfile
->ei
.entry_point
= INVALID_ENTRY_POINT
;
269 /* Get current entry point address. */
272 entry_point_address (void)
274 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
277 /* Create the terminating entry of OBJFILE's minimal symbol table.
278 If OBJFILE->msymbols is zero, allocate a single entry from
279 OBJFILE->objfile_obstack; otherwise, just initialize
280 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */
282 terminate_minimal_symbol_table (struct objfile
*objfile
)
284 if (! objfile
->msymbols
)
285 objfile
->msymbols
= ((struct minimal_symbol
*)
286 obstack_alloc (&objfile
->objfile_obstack
,
287 sizeof (objfile
->msymbols
[0])));
290 struct minimal_symbol
*m
291 = &objfile
->msymbols
[objfile
->minimal_symbol_count
];
293 memset (m
, 0, sizeof (*m
));
294 /* Don't rely on these enumeration values being 0's. */
295 MSYMBOL_TYPE (m
) = mst_unknown
;
296 SYMBOL_INIT_LANGUAGE_SPECIFIC (m
, language_unknown
);
301 /* Put one object file before a specified on in the global list.
302 This can be used to make sure an object file is destroyed before
303 another when using ALL_OBJFILES_SAFE to free all objfiles. */
305 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
307 struct objfile
**objp
;
309 unlink_objfile (objfile
);
311 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
313 if (*objp
== before_this
)
315 objfile
->next
= *objp
;
321 internal_error (__FILE__
, __LINE__
,
322 _("put_objfile_before: before objfile not in list"));
325 /* Put OBJFILE at the front of the list. */
328 objfile_to_front (struct objfile
*objfile
)
330 struct objfile
**objp
;
331 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
333 if (*objp
== objfile
)
335 /* Unhook it from where it is. */
336 *objp
= objfile
->next
;
337 /* Put it in the front. */
338 objfile
->next
= object_files
;
339 object_files
= objfile
;
345 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
348 It is not a bug, or error, to call this function if OBJFILE is not known
349 to be in the current list. This is done in the case of mapped objfiles,
350 for example, just to ensure that the mapped objfile doesn't appear twice
351 in the list. Since the list is threaded, linking in a mapped objfile
352 twice would create a circular list.
354 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
355 unlinking it, just to ensure that we have completely severed any linkages
356 between the OBJFILE and the list. */
359 unlink_objfile (struct objfile
*objfile
)
361 struct objfile
**objpp
;
363 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
365 if (*objpp
== objfile
)
367 *objpp
= (*objpp
)->next
;
368 objfile
->next
= NULL
;
373 internal_error (__FILE__
, __LINE__
,
374 _("unlink_objfile: objfile already unlinked"));
378 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
379 that as much as possible is allocated on the objfile_obstack
380 so that the memory can be efficiently freed.
382 Things which we do NOT free because they are not in malloc'd memory
383 or not in memory specific to the objfile include:
387 FIXME: If the objfile is using reusable symbol information (via mmalloc),
388 then we need to take into account the fact that more than one process
389 may be using the symbol information at the same time (when mmalloc is
390 extended to support cooperative locking). When more than one process
391 is using the mapped symbol info, we need to be more careful about when
392 we free objects in the reusable area. */
395 free_objfile (struct objfile
*objfile
)
397 if (objfile
->separate_debug_objfile
)
399 free_objfile (objfile
->separate_debug_objfile
);
402 if (objfile
->separate_debug_objfile_backlink
)
404 /* We freed the separate debug file, make sure the base objfile
405 doesn't reference it. */
406 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
= NULL
;
409 /* Remove any references to this objfile in the global value
411 preserve_values (objfile
);
413 /* First do any symbol file specific actions required when we are
414 finished with a particular symbol file. Note that if the objfile
415 is using reusable symbol information (via mmalloc) then each of
416 these routines is responsible for doing the correct thing, either
417 freeing things which are valid only during this particular gdb
418 execution, or leaving them to be reused during the next one. */
420 if (objfile
->sf
!= NULL
)
422 (*objfile
->sf
->sym_finish
) (objfile
);
425 /* We always close the bfd. */
427 if (objfile
->obfd
!= NULL
)
429 char *name
= bfd_get_filename (objfile
->obfd
);
430 if (!bfd_close (objfile
->obfd
))
431 warning (_("cannot close \"%s\": %s"),
432 name
, bfd_errmsg (bfd_get_error ()));
436 /* Remove it from the chain of all objfiles. */
438 unlink_objfile (objfile
);
440 /* If we are going to free the runtime common objfile, mark it
443 if (objfile
== rt_common_objfile
)
444 rt_common_objfile
= NULL
;
446 /* Before the symbol table code was redone to make it easier to
447 selectively load and remove information particular to a specific
448 linkage unit, gdb used to do these things whenever the monolithic
449 symbol table was blown away. How much still needs to be done
450 is unknown, but we play it safe for now and keep each action until
451 it is shown to be no longer needed. */
453 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
454 for example), so we need to call this here. */
455 clear_pc_function_cache ();
457 /* Clear globals which might have pointed into a removed objfile.
458 FIXME: It's not clear which of these are supposed to persist
459 between expressions and which ought to be reset each time. */
460 expression_context_block
= NULL
;
461 innermost_block
= NULL
;
463 /* Check to see if the current_source_symtab belongs to this objfile,
464 and if so, call clear_current_source_symtab_and_line. */
467 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
470 ALL_OBJFILE_SYMTABS (objfile
, s
)
472 if (s
== cursal
.symtab
)
473 clear_current_source_symtab_and_line ();
477 /* The last thing we do is free the objfile struct itself. */
479 objfile_free_data (objfile
);
480 if (objfile
->name
!= NULL
)
482 xfree (objfile
->name
);
484 if (objfile
->global_psymbols
.list
)
485 xfree (objfile
->global_psymbols
.list
);
486 if (objfile
->static_psymbols
.list
)
487 xfree (objfile
->static_psymbols
.list
);
488 /* Free the obstacks for non-reusable objfiles */
489 bcache_xfree (objfile
->psymbol_cache
);
490 bcache_xfree (objfile
->macro_cache
);
491 if (objfile
->demangled_names_hash
)
492 htab_delete (objfile
->demangled_names_hash
);
493 obstack_free (&objfile
->objfile_obstack
, 0);
499 do_free_objfile_cleanup (void *obj
)
505 make_cleanup_free_objfile (struct objfile
*obj
)
507 return make_cleanup (do_free_objfile_cleanup
, obj
);
510 /* Free all the object files at once and clean up their users. */
513 free_all_objfiles (void)
515 struct objfile
*objfile
, *temp
;
517 ALL_OBJFILES_SAFE (objfile
, temp
)
519 free_objfile (objfile
);
521 clear_symtab_users ();
524 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
525 entries in new_offsets. */
527 objfile_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
)
529 struct section_offsets
*delta
=
530 ((struct section_offsets
*)
531 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
535 int something_changed
= 0;
536 for (i
= 0; i
< objfile
->num_sections
; ++i
)
539 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
540 if (ANOFFSET (delta
, i
) != 0)
541 something_changed
= 1;
543 if (!something_changed
)
547 /* OK, get all the symtabs. */
551 ALL_OBJFILE_SYMTABS (objfile
, s
)
554 struct blockvector
*bv
;
557 /* First the line table. */
561 for (i
= 0; i
< l
->nitems
; ++i
)
562 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
565 /* Don't relocate a shared blockvector more than once. */
569 bv
= BLOCKVECTOR (s
);
570 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
574 struct dict_iterator iter
;
576 b
= BLOCKVECTOR_BLOCK (bv
, i
);
577 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
578 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
579 if (BLOCKVECTOR_MAP (bv
))
580 addrmap_relocate (BLOCKVECTOR_MAP (bv
),
581 ANOFFSET (delta
, s
->block_line_section
));
583 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
585 fixup_symbol_section (sym
, objfile
);
587 /* The RS6000 code from which this was taken skipped
588 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
589 But I'm leaving out that test, on the theory that
590 they can't possibly pass the tests below. */
591 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
592 || SYMBOL_CLASS (sym
) == LOC_STATIC
593 || SYMBOL_CLASS (sym
) == LOC_INDIRECT
)
594 && SYMBOL_SECTION (sym
) >= 0)
596 SYMBOL_VALUE_ADDRESS (sym
) +=
597 ANOFFSET (delta
, SYMBOL_SECTION (sym
));
605 struct partial_symtab
*p
;
607 ALL_OBJFILE_PSYMTABS (objfile
, p
)
609 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
610 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
615 struct partial_symbol
**psym
;
617 for (psym
= objfile
->global_psymbols
.list
;
618 psym
< objfile
->global_psymbols
.next
;
621 fixup_psymbol_section (*psym
, objfile
);
622 if (SYMBOL_SECTION (*psym
) >= 0)
623 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
624 SYMBOL_SECTION (*psym
));
626 for (psym
= objfile
->static_psymbols
.list
;
627 psym
< objfile
->static_psymbols
.next
;
630 fixup_psymbol_section (*psym
, objfile
);
631 if (SYMBOL_SECTION (*psym
) >= 0)
632 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
633 SYMBOL_SECTION (*psym
));
638 struct minimal_symbol
*msym
;
639 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
640 if (SYMBOL_SECTION (msym
) >= 0)
641 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
643 /* Relocating different sections by different amounts may cause the symbols
644 to be out of order. */
645 msymbols_sort (objfile
);
649 for (i
= 0; i
< objfile
->num_sections
; ++i
)
650 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
653 if (objfile
->ei
.entry_point
!= ~(CORE_ADDR
) 0)
655 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
656 only as a fallback. */
657 struct obj_section
*s
;
658 s
= find_pc_section (objfile
->ei
.entry_point
);
660 objfile
->ei
.entry_point
+= ANOFFSET (delta
, s
->the_bfd_section
->index
);
662 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
666 struct obj_section
*s
;
669 abfd
= objfile
->obfd
;
671 ALL_OBJFILE_OSECTIONS (objfile
, s
)
673 int idx
= s
->the_bfd_section
->index
;
675 s
->addr
+= ANOFFSET (delta
, idx
);
676 s
->endaddr
+= ANOFFSET (delta
, idx
);
680 /* Relocate breakpoints as necessary, after things are relocated. */
681 breakpoint_re_set ();
684 /* Many places in gdb want to test just to see if we have any partial
685 symbols available. This function returns zero if none are currently
686 available, nonzero otherwise. */
689 have_partial_symbols (void)
695 if (ofp
->psymtabs
!= NULL
)
703 /* Many places in gdb want to test just to see if we have any full
704 symbols available. This function returns zero if none are currently
705 available, nonzero otherwise. */
708 have_full_symbols (void)
714 if (ofp
->symtabs
!= NULL
)
723 /* This operations deletes all objfile entries that represent solibs that
724 weren't explicitly loaded by the user, via e.g., the add-symbol-file
728 objfile_purge_solibs (void)
730 struct objfile
*objf
;
731 struct objfile
*temp
;
733 ALL_OBJFILES_SAFE (objf
, temp
)
735 /* We assume that the solib package has been purged already, or will
738 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
744 /* Many places in gdb want to test just to see if we have any minimal
745 symbols available. This function returns zero if none are currently
746 available, nonzero otherwise. */
749 have_minimal_symbols (void)
755 if (ofp
->minimal_symbol_count
> 0)
763 /* Returns a section whose range includes PC and SECTION, or NULL if
764 none found. Note the distinction between the return type, struct
765 obj_section (which is defined in gdb), and the input type "struct
766 bfd_section" (which is a bfd-defined data type). The obj_section
767 contains a pointer to the "struct bfd_section". */
770 find_pc_sect_section (CORE_ADDR pc
, struct bfd_section
*section
)
772 struct obj_section
*s
;
773 struct objfile
*objfile
;
775 ALL_OBJSECTIONS (objfile
, s
)
776 if ((section
== 0 || section
== s
->the_bfd_section
) &&
777 s
->addr
<= pc
&& pc
< s
->endaddr
)
783 /* Returns a section whose range includes PC or NULL if none found.
784 Backward compatibility, no section. */
787 find_pc_section (CORE_ADDR pc
)
789 return find_pc_sect_section (pc
, find_pc_mapped_section (pc
));
793 /* In SVR4, we recognize a trampoline by it's section name.
794 That is, if the pc is in a section named ".plt" then we are in
798 in_plt_section (CORE_ADDR pc
, char *name
)
800 struct obj_section
*s
;
803 s
= find_pc_section (pc
);
806 && s
->the_bfd_section
->name
!= NULL
807 && strcmp (s
->the_bfd_section
->name
, ".plt") == 0);
812 /* Keep a registry of per-objfile data-pointers required by other GDB
820 struct objfile_data_registration
822 struct objfile_data
*data
;
823 struct objfile_data_registration
*next
;
826 struct objfile_data_registry
828 struct objfile_data_registration
*registrations
;
829 unsigned num_registrations
;
832 static struct objfile_data_registry objfile_data_registry
= { NULL
, 0 };
834 const struct objfile_data
*
835 register_objfile_data (void)
837 struct objfile_data_registration
**curr
;
839 /* Append new registration. */
840 for (curr
= &objfile_data_registry
.registrations
;
841 *curr
!= NULL
; curr
= &(*curr
)->next
);
843 *curr
= XMALLOC (struct objfile_data_registration
);
844 (*curr
)->next
= NULL
;
845 (*curr
)->data
= XMALLOC (struct objfile_data
);
846 (*curr
)->data
->index
= objfile_data_registry
.num_registrations
++;
848 return (*curr
)->data
;
852 objfile_alloc_data (struct objfile
*objfile
)
854 gdb_assert (objfile
->data
== NULL
);
855 objfile
->num_data
= objfile_data_registry
.num_registrations
;
856 objfile
->data
= XCALLOC (objfile
->num_data
, void *);
860 objfile_free_data (struct objfile
*objfile
)
862 gdb_assert (objfile
->data
!= NULL
);
863 xfree (objfile
->data
);
864 objfile
->data
= NULL
;
868 clear_objfile_data (struct objfile
*objfile
)
870 gdb_assert (objfile
->data
!= NULL
);
871 memset (objfile
->data
, 0, objfile
->num_data
* sizeof (void *));
875 set_objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
,
878 gdb_assert (data
->index
< objfile
->num_data
);
879 objfile
->data
[data
->index
] = value
;
883 objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
)
885 gdb_assert (data
->index
< objfile
->num_data
);
886 return objfile
->data
[data
->index
];