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
);
262 else if (bfd_get_file_flags (objfile
->obfd
) & DYNAMIC
263 && bfd_get_start_address (objfile
->obfd
) != 0)
264 /* Some shared libraries may have entry points set and be
265 runnable. There's no clear way to indicate this, so just check
266 for values other than zero. */
267 objfile
->ei
.entry_point
= bfd_get_start_address (objfile
->obfd
);
270 /* Examination of non-executable.o files. Short-circuit this stuff. */
271 objfile
->ei
.entry_point
= INVALID_ENTRY_POINT
;
275 /* Get current entry point address. */
278 entry_point_address (void)
280 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
283 /* Create the terminating entry of OBJFILE's minimal symbol table.
284 If OBJFILE->msymbols is zero, allocate a single entry from
285 OBJFILE->objfile_obstack; otherwise, just initialize
286 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */
288 terminate_minimal_symbol_table (struct objfile
*objfile
)
290 if (! objfile
->msymbols
)
291 objfile
->msymbols
= ((struct minimal_symbol
*)
292 obstack_alloc (&objfile
->objfile_obstack
,
293 sizeof (objfile
->msymbols
[0])));
296 struct minimal_symbol
*m
297 = &objfile
->msymbols
[objfile
->minimal_symbol_count
];
299 memset (m
, 0, sizeof (*m
));
300 /* Don't rely on these enumeration values being 0's. */
301 MSYMBOL_TYPE (m
) = mst_unknown
;
302 SYMBOL_INIT_LANGUAGE_SPECIFIC (m
, language_unknown
);
307 /* Put one object file before a specified on in the global list.
308 This can be used to make sure an object file is destroyed before
309 another when using ALL_OBJFILES_SAFE to free all objfiles. */
311 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
313 struct objfile
**objp
;
315 unlink_objfile (objfile
);
317 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
319 if (*objp
== before_this
)
321 objfile
->next
= *objp
;
327 internal_error (__FILE__
, __LINE__
,
328 _("put_objfile_before: before objfile not in list"));
331 /* Put OBJFILE at the front of the list. */
334 objfile_to_front (struct objfile
*objfile
)
336 struct objfile
**objp
;
337 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
339 if (*objp
== objfile
)
341 /* Unhook it from where it is. */
342 *objp
= objfile
->next
;
343 /* Put it in the front. */
344 objfile
->next
= object_files
;
345 object_files
= objfile
;
351 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
354 It is not a bug, or error, to call this function if OBJFILE is not known
355 to be in the current list. This is done in the case of mapped objfiles,
356 for example, just to ensure that the mapped objfile doesn't appear twice
357 in the list. Since the list is threaded, linking in a mapped objfile
358 twice would create a circular list.
360 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
361 unlinking it, just to ensure that we have completely severed any linkages
362 between the OBJFILE and the list. */
365 unlink_objfile (struct objfile
*objfile
)
367 struct objfile
**objpp
;
369 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
371 if (*objpp
== objfile
)
373 *objpp
= (*objpp
)->next
;
374 objfile
->next
= NULL
;
379 internal_error (__FILE__
, __LINE__
,
380 _("unlink_objfile: objfile already unlinked"));
384 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
385 that as much as possible is allocated on the objfile_obstack
386 so that the memory can be efficiently freed.
388 Things which we do NOT free because they are not in malloc'd memory
389 or not in memory specific to the objfile include:
393 FIXME: If the objfile is using reusable symbol information (via mmalloc),
394 then we need to take into account the fact that more than one process
395 may be using the symbol information at the same time (when mmalloc is
396 extended to support cooperative locking). When more than one process
397 is using the mapped symbol info, we need to be more careful about when
398 we free objects in the reusable area. */
401 free_objfile (struct objfile
*objfile
)
403 if (objfile
->separate_debug_objfile
)
405 free_objfile (objfile
->separate_debug_objfile
);
408 if (objfile
->separate_debug_objfile_backlink
)
410 /* We freed the separate debug file, make sure the base objfile
411 doesn't reference it. */
412 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
= NULL
;
415 /* Remove any references to this objfile in the global value
417 preserve_values (objfile
);
419 /* First do any symbol file specific actions required when we are
420 finished with a particular symbol file. Note that if the objfile
421 is using reusable symbol information (via mmalloc) then each of
422 these routines is responsible for doing the correct thing, either
423 freeing things which are valid only during this particular gdb
424 execution, or leaving them to be reused during the next one. */
426 if (objfile
->sf
!= NULL
)
428 (*objfile
->sf
->sym_finish
) (objfile
);
431 /* We always close the bfd. */
433 if (objfile
->obfd
!= NULL
)
435 char *name
= bfd_get_filename (objfile
->obfd
);
436 if (!bfd_close (objfile
->obfd
))
437 warning (_("cannot close \"%s\": %s"),
438 name
, bfd_errmsg (bfd_get_error ()));
442 /* Remove it from the chain of all objfiles. */
444 unlink_objfile (objfile
);
446 /* If we are going to free the runtime common objfile, mark it
449 if (objfile
== rt_common_objfile
)
450 rt_common_objfile
= NULL
;
452 /* Before the symbol table code was redone to make it easier to
453 selectively load and remove information particular to a specific
454 linkage unit, gdb used to do these things whenever the monolithic
455 symbol table was blown away. How much still needs to be done
456 is unknown, but we play it safe for now and keep each action until
457 it is shown to be no longer needed. */
459 /* Not all our callers call clear_symtab_users (objfile_purge_solibs,
460 for example), so we need to call this here. */
461 clear_pc_function_cache ();
463 /* Clear globals which might have pointed into a removed objfile.
464 FIXME: It's not clear which of these are supposed to persist
465 between expressions and which ought to be reset each time. */
466 expression_context_block
= NULL
;
467 innermost_block
= NULL
;
469 /* Check to see if the current_source_symtab belongs to this objfile,
470 and if so, call clear_current_source_symtab_and_line. */
473 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
476 ALL_OBJFILE_SYMTABS (objfile
, s
)
478 if (s
== cursal
.symtab
)
479 clear_current_source_symtab_and_line ();
483 /* The last thing we do is free the objfile struct itself. */
485 objfile_free_data (objfile
);
486 if (objfile
->name
!= NULL
)
488 xfree (objfile
->name
);
490 if (objfile
->global_psymbols
.list
)
491 xfree (objfile
->global_psymbols
.list
);
492 if (objfile
->static_psymbols
.list
)
493 xfree (objfile
->static_psymbols
.list
);
494 /* Free the obstacks for non-reusable objfiles */
495 bcache_xfree (objfile
->psymbol_cache
);
496 bcache_xfree (objfile
->macro_cache
);
497 if (objfile
->demangled_names_hash
)
498 htab_delete (objfile
->demangled_names_hash
);
499 obstack_free (&objfile
->objfile_obstack
, 0);
505 do_free_objfile_cleanup (void *obj
)
511 make_cleanup_free_objfile (struct objfile
*obj
)
513 return make_cleanup (do_free_objfile_cleanup
, obj
);
516 /* Free all the object files at once and clean up their users. */
519 free_all_objfiles (void)
521 struct objfile
*objfile
, *temp
;
523 ALL_OBJFILES_SAFE (objfile
, temp
)
525 free_objfile (objfile
);
527 clear_symtab_users ();
530 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
531 entries in new_offsets. */
533 objfile_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
)
535 struct section_offsets
*delta
=
536 ((struct section_offsets
*)
537 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
541 int something_changed
= 0;
542 for (i
= 0; i
< objfile
->num_sections
; ++i
)
545 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
546 if (ANOFFSET (delta
, i
) != 0)
547 something_changed
= 1;
549 if (!something_changed
)
553 /* OK, get all the symtabs. */
557 ALL_OBJFILE_SYMTABS (objfile
, s
)
560 struct blockvector
*bv
;
563 /* First the line table. */
567 for (i
= 0; i
< l
->nitems
; ++i
)
568 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
571 /* Don't relocate a shared blockvector more than once. */
575 bv
= BLOCKVECTOR (s
);
576 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
580 struct dict_iterator iter
;
582 b
= BLOCKVECTOR_BLOCK (bv
, i
);
583 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
584 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
585 if (BLOCKVECTOR_MAP (bv
))
586 addrmap_relocate (BLOCKVECTOR_MAP (bv
),
587 ANOFFSET (delta
, s
->block_line_section
));
589 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
591 fixup_symbol_section (sym
, objfile
);
593 /* The RS6000 code from which this was taken skipped
594 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
595 But I'm leaving out that test, on the theory that
596 they can't possibly pass the tests below. */
597 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
598 || SYMBOL_CLASS (sym
) == LOC_STATIC
599 || SYMBOL_CLASS (sym
) == LOC_INDIRECT
)
600 && SYMBOL_SECTION (sym
) >= 0)
602 SYMBOL_VALUE_ADDRESS (sym
) +=
603 ANOFFSET (delta
, SYMBOL_SECTION (sym
));
611 struct partial_symtab
*p
;
613 ALL_OBJFILE_PSYMTABS (objfile
, p
)
615 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
616 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
621 struct partial_symbol
**psym
;
623 for (psym
= objfile
->global_psymbols
.list
;
624 psym
< objfile
->global_psymbols
.next
;
627 fixup_psymbol_section (*psym
, objfile
);
628 if (SYMBOL_SECTION (*psym
) >= 0)
629 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
630 SYMBOL_SECTION (*psym
));
632 for (psym
= objfile
->static_psymbols
.list
;
633 psym
< objfile
->static_psymbols
.next
;
636 fixup_psymbol_section (*psym
, objfile
);
637 if (SYMBOL_SECTION (*psym
) >= 0)
638 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
639 SYMBOL_SECTION (*psym
));
644 struct minimal_symbol
*msym
;
645 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
646 if (SYMBOL_SECTION (msym
) >= 0)
647 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
649 /* Relocating different sections by different amounts may cause the symbols
650 to be out of order. */
651 msymbols_sort (objfile
);
655 for (i
= 0; i
< objfile
->num_sections
; ++i
)
656 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
659 if (objfile
->ei
.entry_point
!= ~(CORE_ADDR
) 0)
661 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
662 only as a fallback. */
663 struct obj_section
*s
;
664 s
= find_pc_section (objfile
->ei
.entry_point
);
666 objfile
->ei
.entry_point
+= ANOFFSET (delta
, s
->the_bfd_section
->index
);
668 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
672 struct obj_section
*s
;
675 abfd
= objfile
->obfd
;
677 ALL_OBJFILE_OSECTIONS (objfile
, s
)
679 int idx
= s
->the_bfd_section
->index
;
681 s
->addr
+= ANOFFSET (delta
, idx
);
682 s
->endaddr
+= ANOFFSET (delta
, idx
);
686 /* Relocate breakpoints as necessary, after things are relocated. */
687 breakpoint_re_set ();
690 /* Many places in gdb want to test just to see if we have any partial
691 symbols available. This function returns zero if none are currently
692 available, nonzero otherwise. */
695 have_partial_symbols (void)
701 if (ofp
->psymtabs
!= NULL
)
709 /* Many places in gdb want to test just to see if we have any full
710 symbols available. This function returns zero if none are currently
711 available, nonzero otherwise. */
714 have_full_symbols (void)
720 if (ofp
->symtabs
!= NULL
)
729 /* This operations deletes all objfile entries that represent solibs that
730 weren't explicitly loaded by the user, via e.g., the add-symbol-file
734 objfile_purge_solibs (void)
736 struct objfile
*objf
;
737 struct objfile
*temp
;
739 ALL_OBJFILES_SAFE (objf
, temp
)
741 /* We assume that the solib package has been purged already, or will
744 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
750 /* Many places in gdb want to test just to see if we have any minimal
751 symbols available. This function returns zero if none are currently
752 available, nonzero otherwise. */
755 have_minimal_symbols (void)
761 if (ofp
->minimal_symbol_count
> 0)
769 /* Returns a section whose range includes PC and SECTION, or NULL if
770 none found. Note the distinction between the return type, struct
771 obj_section (which is defined in gdb), and the input type "struct
772 bfd_section" (which is a bfd-defined data type). The obj_section
773 contains a pointer to the "struct bfd_section". */
776 find_pc_sect_section (CORE_ADDR pc
, struct bfd_section
*section
)
778 struct obj_section
*s
;
779 struct objfile
*objfile
;
781 ALL_OBJSECTIONS (objfile
, s
)
782 if ((section
== 0 || section
== s
->the_bfd_section
) &&
783 s
->addr
<= pc
&& pc
< s
->endaddr
)
789 /* Returns a section whose range includes PC or NULL if none found.
790 Backward compatibility, no section. */
793 find_pc_section (CORE_ADDR pc
)
795 return find_pc_sect_section (pc
, find_pc_mapped_section (pc
));
799 /* In SVR4, we recognize a trampoline by it's section name.
800 That is, if the pc is in a section named ".plt" then we are in
804 in_plt_section (CORE_ADDR pc
, char *name
)
806 struct obj_section
*s
;
809 s
= find_pc_section (pc
);
812 && s
->the_bfd_section
->name
!= NULL
813 && strcmp (s
->the_bfd_section
->name
, ".plt") == 0);
818 /* Keep a registry of per-objfile data-pointers required by other GDB
826 struct objfile_data_registration
828 struct objfile_data
*data
;
829 struct objfile_data_registration
*next
;
832 struct objfile_data_registry
834 struct objfile_data_registration
*registrations
;
835 unsigned num_registrations
;
838 static struct objfile_data_registry objfile_data_registry
= { NULL
, 0 };
840 const struct objfile_data
*
841 register_objfile_data (void)
843 struct objfile_data_registration
**curr
;
845 /* Append new registration. */
846 for (curr
= &objfile_data_registry
.registrations
;
847 *curr
!= NULL
; curr
= &(*curr
)->next
);
849 *curr
= XMALLOC (struct objfile_data_registration
);
850 (*curr
)->next
= NULL
;
851 (*curr
)->data
= XMALLOC (struct objfile_data
);
852 (*curr
)->data
->index
= objfile_data_registry
.num_registrations
++;
854 return (*curr
)->data
;
858 objfile_alloc_data (struct objfile
*objfile
)
860 gdb_assert (objfile
->data
== NULL
);
861 objfile
->num_data
= objfile_data_registry
.num_registrations
;
862 objfile
->data
= XCALLOC (objfile
->num_data
, void *);
866 objfile_free_data (struct objfile
*objfile
)
868 gdb_assert (objfile
->data
!= NULL
);
869 xfree (objfile
->data
);
870 objfile
->data
= NULL
;
874 clear_objfile_data (struct objfile
*objfile
)
876 gdb_assert (objfile
->data
!= NULL
);
877 memset (objfile
->data
, 0, objfile
->num_data
* sizeof (void *));
881 set_objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
,
884 gdb_assert (data
->index
< objfile
->num_data
);
885 objfile
->data
[data
->index
] = value
;
889 objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
)
891 gdb_assert (data
->index
< objfile
->num_data
);
892 return objfile
->data
[data
->index
];