1 /* GDB routines for manipulating objfiles.
3 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 2001, 2002, 2003, 2004 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 2 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, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* This file contains support routines for creating, manipulating, and
26 destroying objfile structures. */
29 #include "bfd.h" /* Binary File Description */
33 #include "gdb-stabs.h"
37 #include "gdb_assert.h"
38 #include <sys/types.h>
41 #include "gdb_obstack.h"
42 #include "gdb_string.h"
45 #include "breakpoint.h"
47 #include "dictionary.h"
49 /* Prototypes for local functions */
51 static void objfile_alloc_data (struct objfile
*objfile
);
52 static void objfile_free_data (struct objfile
*objfile
);
54 /* Externally visible variables that are owned by this module.
55 See declarations in objfile.h for more info. */
57 struct objfile
*object_files
; /* Linked list of all objfiles */
58 struct objfile
*current_objfile
; /* For symbol file being read in */
59 struct objfile
*symfile_objfile
; /* Main symbol table loaded from */
60 struct objfile
*rt_common_objfile
; /* For runtime common symbols */
62 /* Locate all mappable sections of a BFD file.
63 objfile_p_char is a char * to get it through
64 bfd_map_over_sections; we cast it back to its proper type. */
66 #ifndef TARGET_KEEP_SECTION
67 #define TARGET_KEEP_SECTION(ASECT) 0
70 /* Called via bfd_map_over_sections to build up the section table that
71 the objfile references. The objfile contains pointers to the start
72 of the table (objfile->sections) and to the first location after
73 the end of the table (objfile->sections_end). */
76 add_to_objfile_sections (struct bfd
*abfd
, struct bfd_section
*asect
,
79 struct objfile
*objfile
= (struct objfile
*) objfile_p_char
;
80 struct obj_section section
;
83 aflag
= bfd_get_section_flags (abfd
, asect
);
85 if (!(aflag
& SEC_ALLOC
) && !(TARGET_KEEP_SECTION (asect
)))
88 if (0 == bfd_section_size (abfd
, asect
))
91 section
.objfile
= objfile
;
92 section
.the_bfd_section
= asect
;
93 section
.ovly_mapped
= 0;
94 section
.addr
= bfd_section_vma (abfd
, asect
);
95 section
.endaddr
= section
.addr
+ bfd_section_size (abfd
, asect
);
96 obstack_grow (&objfile
->objfile_obstack
, (char *) §ion
, sizeof (section
));
97 objfile
->sections_end
= (struct obj_section
*) (((unsigned long) objfile
->sections_end
) + 1);
100 /* Builds a section table for OBJFILE.
101 Returns 0 if OK, 1 on error (in which case bfd_error contains the
104 Note that while we are building the table, which goes into the
105 psymbol obstack, we hijack the sections_end pointer to instead hold
106 a count of the number of sections. When bfd_map_over_sections
107 returns, this count is used to compute the pointer to the end of
108 the sections table, which then overwrites the count.
110 Also note that the OFFSET and OVLY_MAPPED in each table entry
111 are initialized to zero.
113 Also note that if anything else writes to the psymbol obstack while
114 we are building the table, we're pretty much hosed. */
117 build_objfile_section_table (struct objfile
*objfile
)
119 /* objfile->sections can be already set when reading a mapped symbol
120 file. I believe that we do need to rebuild the section table in
121 this case (we rebuild other things derived from the bfd), but we
122 can't free the old one (it's in the objfile_obstack). So we just
123 waste some memory. */
125 objfile
->sections_end
= 0;
126 bfd_map_over_sections (objfile
->obfd
, add_to_objfile_sections
, (char *) objfile
);
127 objfile
->sections
= (struct obj_section
*)
128 obstack_finish (&objfile
->objfile_obstack
);
129 objfile
->sections_end
= objfile
->sections
+ (unsigned long) objfile
->sections_end
;
133 /* Given a pointer to an initialized bfd (ABFD) and some flag bits
134 allocate a new objfile struct, fill it in as best we can, link it
135 into the list of all known objfiles, and return a pointer to the
138 The FLAGS word contains various bits (OBJF_*) that can be taken as
139 requests for specific operations. Other bits like OBJF_SHARED are
140 simply copied through to the new objfile flags member. */
142 /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
143 by jv-lang.c, to create an artificial objfile used to hold
144 information about dynamically-loaded Java classes. Unfortunately,
145 that branch of this function doesn't get tested very frequently, so
146 it's prone to breakage. (E.g. at one time the name was set to NULL
147 in that situation, which broke a loop over all names in the dynamic
148 library loader.) If you change this function, please try to leave
149 things in a consistent state even if abfd is NULL. */
152 allocate_objfile (bfd
*abfd
, int flags
)
154 struct objfile
*objfile
= NULL
;
155 struct objfile
*last_one
= NULL
;
157 /* If we don't support mapped symbol files, didn't ask for the file to be
158 mapped, or failed to open the mapped file for some reason, then revert
159 back to an unmapped objfile. */
163 objfile
= (struct objfile
*) xmalloc (sizeof (struct objfile
));
164 memset (objfile
, 0, sizeof (struct objfile
));
166 objfile
->psymbol_cache
= bcache_xmalloc ();
167 objfile
->macro_cache
= bcache_xmalloc ();
168 obstack_specify_allocation (&objfile
->objfile_obstack
, 0, 0, xmalloc
,
170 terminate_minimal_symbol_table (objfile
);
173 objfile_alloc_data (objfile
);
175 /* Update the per-objfile information that comes from the bfd, ensuring
176 that any data that is reference is saved in the per-objfile data
179 objfile
->obfd
= abfd
;
180 if (objfile
->name
!= NULL
)
182 xmfree (objfile
->md
, objfile
->name
);
186 objfile
->name
= mstrsave (objfile
->md
, bfd_get_filename (abfd
));
187 objfile
->mtime
= bfd_get_mtime (abfd
);
189 /* Build section table. */
191 if (build_objfile_section_table (objfile
))
193 error ("Can't find the file sections in `%s': %s",
194 objfile
->name
, bfd_errmsg (bfd_get_error ()));
199 objfile
->name
= mstrsave (objfile
->md
, "<<anonymous objfile>>");
202 /* Initialize the section indexes for this objfile, so that we can
203 later detect if they are used w/o being properly assigned to. */
205 objfile
->sect_index_text
= -1;
206 objfile
->sect_index_data
= -1;
207 objfile
->sect_index_bss
= -1;
208 objfile
->sect_index_rodata
= -1;
210 /* We don't yet have a C++-specific namespace symtab. */
212 objfile
->cp_namespace_symtab
= NULL
;
214 /* Add this file onto the tail of the linked list of other such files. */
216 objfile
->next
= NULL
;
217 if (object_files
== NULL
)
218 object_files
= objfile
;
221 for (last_one
= object_files
;
223 last_one
= last_one
->next
);
224 last_one
->next
= objfile
;
227 /* Save passed in flag bits. */
228 objfile
->flags
|= flags
;
234 /* Create the terminating entry of OBJFILE's minimal symbol table.
235 If OBJFILE->msymbols is zero, allocate a single entry from
236 OBJFILE->objfile_obstack; otherwise, just initialize
237 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */
239 terminate_minimal_symbol_table (struct objfile
*objfile
)
241 if (! objfile
->msymbols
)
242 objfile
->msymbols
= ((struct minimal_symbol
*)
243 obstack_alloc (&objfile
->objfile_obstack
,
244 sizeof (objfile
->msymbols
[0])));
247 struct minimal_symbol
*m
248 = &objfile
->msymbols
[objfile
->minimal_symbol_count
];
250 memset (m
, 0, sizeof (*m
));
251 DEPRECATED_SYMBOL_NAME (m
) = NULL
;
252 SYMBOL_VALUE_ADDRESS (m
) = 0;
253 MSYMBOL_INFO (m
) = NULL
;
254 MSYMBOL_SIZE (m
) = 0;
255 MSYMBOL_TYPE (m
) = mst_unknown
;
256 SYMBOL_INIT_LANGUAGE_SPECIFIC (m
, language_unknown
);
261 /* Put one object file before a specified on in the global list.
262 This can be used to make sure an object file is destroyed before
263 another when using ALL_OBJFILES_SAFE to free all objfiles. */
265 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
267 struct objfile
**objp
;
269 unlink_objfile (objfile
);
271 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
273 if (*objp
== before_this
)
275 objfile
->next
= *objp
;
281 internal_error (__FILE__
, __LINE__
,
282 "put_objfile_before: before objfile not in list");
285 /* Put OBJFILE at the front of the list. */
288 objfile_to_front (struct objfile
*objfile
)
290 struct objfile
**objp
;
291 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
293 if (*objp
== objfile
)
295 /* Unhook it from where it is. */
296 *objp
= objfile
->next
;
297 /* Put it in the front. */
298 objfile
->next
= object_files
;
299 object_files
= objfile
;
305 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
308 It is not a bug, or error, to call this function if OBJFILE is not known
309 to be in the current list. This is done in the case of mapped objfiles,
310 for example, just to ensure that the mapped objfile doesn't appear twice
311 in the list. Since the list is threaded, linking in a mapped objfile
312 twice would create a circular list.
314 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
315 unlinking it, just to ensure that we have completely severed any linkages
316 between the OBJFILE and the list. */
319 unlink_objfile (struct objfile
*objfile
)
321 struct objfile
**objpp
;
323 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
325 if (*objpp
== objfile
)
327 *objpp
= (*objpp
)->next
;
328 objfile
->next
= NULL
;
333 internal_error (__FILE__
, __LINE__
,
334 "unlink_objfile: objfile already unlinked");
338 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
339 that as much as possible is allocated on the objfile_obstack
340 so that the memory can be efficiently freed.
342 Things which we do NOT free because they are not in malloc'd memory
343 or not in memory specific to the objfile include:
347 FIXME: If the objfile is using reusable symbol information (via mmalloc),
348 then we need to take into account the fact that more than one process
349 may be using the symbol information at the same time (when mmalloc is
350 extended to support cooperative locking). When more than one process
351 is using the mapped symbol info, we need to be more careful about when
352 we free objects in the reusable area. */
355 free_objfile (struct objfile
*objfile
)
357 if (objfile
->separate_debug_objfile
)
359 free_objfile (objfile
->separate_debug_objfile
);
362 if (objfile
->separate_debug_objfile_backlink
)
364 /* We freed the separate debug file, make sure the base objfile
365 doesn't reference it. */
366 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
= NULL
;
369 /* First do any symbol file specific actions required when we are
370 finished with a particular symbol file. Note that if the objfile
371 is using reusable symbol information (via mmalloc) then each of
372 these routines is responsible for doing the correct thing, either
373 freeing things which are valid only during this particular gdb
374 execution, or leaving them to be reused during the next one. */
376 if (objfile
->sf
!= NULL
)
378 (*objfile
->sf
->sym_finish
) (objfile
);
381 /* We always close the bfd. */
383 if (objfile
->obfd
!= NULL
)
385 char *name
= bfd_get_filename (objfile
->obfd
);
386 if (!bfd_close (objfile
->obfd
))
387 warning ("cannot close \"%s\": %s",
388 name
, bfd_errmsg (bfd_get_error ()));
392 /* Remove it from the chain of all objfiles. */
394 unlink_objfile (objfile
);
396 /* If we are going to free the runtime common objfile, mark it
399 if (objfile
== rt_common_objfile
)
400 rt_common_objfile
= NULL
;
402 /* Before the symbol table code was redone to make it easier to
403 selectively load and remove information particular to a specific
404 linkage unit, gdb used to do these things whenever the monolithic
405 symbol table was blown away. How much still needs to be done
406 is unknown, but we play it safe for now and keep each action until
407 it is shown to be no longer needed. */
409 /* I *think* all our callers call clear_symtab_users. If so, no need
410 to call this here. */
411 clear_pc_function_cache ();
413 /* The last thing we do is free the objfile struct itself. */
415 objfile_free_data (objfile
);
416 if (objfile
->name
!= NULL
)
418 xmfree (objfile
->md
, objfile
->name
);
420 if (objfile
->global_psymbols
.list
)
421 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
422 if (objfile
->static_psymbols
.list
)
423 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
424 /* Free the obstacks for non-reusable objfiles */
425 bcache_xfree (objfile
->psymbol_cache
);
426 bcache_xfree (objfile
->macro_cache
);
427 if (objfile
->demangled_names_hash
)
428 htab_delete (objfile
->demangled_names_hash
);
429 obstack_free (&objfile
->objfile_obstack
, 0);
430 xmfree (objfile
->md
, objfile
);
435 do_free_objfile_cleanup (void *obj
)
441 make_cleanup_free_objfile (struct objfile
*obj
)
443 return make_cleanup (do_free_objfile_cleanup
, obj
);
446 /* Free all the object files at once and clean up their users. */
449 free_all_objfiles (void)
451 struct objfile
*objfile
, *temp
;
453 ALL_OBJFILES_SAFE (objfile
, temp
)
455 free_objfile (objfile
);
457 clear_symtab_users ();
460 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
461 entries in new_offsets. */
463 objfile_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
)
465 struct section_offsets
*delta
=
466 ((struct section_offsets
*)
467 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
471 int something_changed
= 0;
472 for (i
= 0; i
< objfile
->num_sections
; ++i
)
475 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
476 if (ANOFFSET (delta
, i
) != 0)
477 something_changed
= 1;
479 if (!something_changed
)
483 /* OK, get all the symtabs. */
487 ALL_OBJFILE_SYMTABS (objfile
, s
)
490 struct blockvector
*bv
;
493 /* First the line table. */
497 for (i
= 0; i
< l
->nitems
; ++i
)
498 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
501 /* Don't relocate a shared blockvector more than once. */
505 bv
= BLOCKVECTOR (s
);
506 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
510 struct dict_iterator iter
;
512 b
= BLOCKVECTOR_BLOCK (bv
, i
);
513 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
514 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
516 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
518 fixup_symbol_section (sym
, objfile
);
520 /* The RS6000 code from which this was taken skipped
521 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
522 But I'm leaving out that test, on the theory that
523 they can't possibly pass the tests below. */
524 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
525 || SYMBOL_CLASS (sym
) == LOC_STATIC
526 || SYMBOL_CLASS (sym
) == LOC_INDIRECT
)
527 && SYMBOL_SECTION (sym
) >= 0)
529 SYMBOL_VALUE_ADDRESS (sym
) +=
530 ANOFFSET (delta
, SYMBOL_SECTION (sym
));
532 #ifdef MIPS_EFI_SYMBOL_NAME
533 /* Relocate Extra Function Info for ecoff. */
535 else if (SYMBOL_CLASS (sym
) == LOC_CONST
536 && SYMBOL_DOMAIN (sym
) == LABEL_DOMAIN
537 && strcmp (DEPRECATED_SYMBOL_NAME (sym
), MIPS_EFI_SYMBOL_NAME
) == 0)
538 ecoff_relocate_efi (sym
, ANOFFSET (delta
,
539 s
->block_line_section
));
547 struct partial_symtab
*p
;
549 ALL_OBJFILE_PSYMTABS (objfile
, p
)
551 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
552 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
557 struct partial_symbol
**psym
;
559 for (psym
= objfile
->global_psymbols
.list
;
560 psym
< objfile
->global_psymbols
.next
;
563 fixup_psymbol_section (*psym
, objfile
);
564 if (SYMBOL_SECTION (*psym
) >= 0)
565 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
566 SYMBOL_SECTION (*psym
));
568 for (psym
= objfile
->static_psymbols
.list
;
569 psym
< objfile
->static_psymbols
.next
;
572 fixup_psymbol_section (*psym
, objfile
);
573 if (SYMBOL_SECTION (*psym
) >= 0)
574 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
575 SYMBOL_SECTION (*psym
));
580 struct minimal_symbol
*msym
;
581 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
582 if (SYMBOL_SECTION (msym
) >= 0)
583 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
585 /* Relocating different sections by different amounts may cause the symbols
586 to be out of order. */
587 msymbols_sort (objfile
);
591 for (i
= 0; i
< objfile
->num_sections
; ++i
)
592 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
595 if (objfile
->ei
.entry_point
!= ~(CORE_ADDR
) 0)
597 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
598 only as a fallback. */
599 struct obj_section
*s
;
600 s
= find_pc_section (objfile
->ei
.entry_point
);
602 objfile
->ei
.entry_point
+= ANOFFSET (delta
, s
->the_bfd_section
->index
);
604 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
608 struct obj_section
*s
;
611 abfd
= objfile
->obfd
;
613 ALL_OBJFILE_OSECTIONS (objfile
, s
)
615 int idx
= s
->the_bfd_section
->index
;
617 s
->addr
+= ANOFFSET (delta
, idx
);
618 s
->endaddr
+= ANOFFSET (delta
, idx
);
622 if (objfile
->ei
.entry_func_lowpc
!= INVALID_ENTRY_LOWPC
)
624 objfile
->ei
.entry_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
625 objfile
->ei
.entry_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
628 if (objfile
->ei
.deprecated_entry_file_lowpc
!= INVALID_ENTRY_LOWPC
)
630 objfile
->ei
.deprecated_entry_file_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
631 objfile
->ei
.deprecated_entry_file_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
634 if (objfile
->ei
.main_func_lowpc
!= INVALID_ENTRY_LOWPC
)
636 objfile
->ei
.main_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
637 objfile
->ei
.main_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
640 /* Relocate breakpoints as necessary, after things are relocated. */
641 breakpoint_re_set ();
644 /* Many places in gdb want to test just to see if we have any partial
645 symbols available. This function returns zero if none are currently
646 available, nonzero otherwise. */
649 have_partial_symbols (void)
655 if (ofp
->psymtabs
!= NULL
)
663 /* Many places in gdb want to test just to see if we have any full
664 symbols available. This function returns zero if none are currently
665 available, nonzero otherwise. */
668 have_full_symbols (void)
674 if (ofp
->symtabs
!= NULL
)
683 /* This operations deletes all objfile entries that represent solibs that
684 weren't explicitly loaded by the user, via e.g., the add-symbol-file
688 objfile_purge_solibs (void)
690 struct objfile
*objf
;
691 struct objfile
*temp
;
693 ALL_OBJFILES_SAFE (objf
, temp
)
695 /* We assume that the solib package has been purged already, or will
698 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
704 /* Many places in gdb want to test just to see if we have any minimal
705 symbols available. This function returns zero if none are currently
706 available, nonzero otherwise. */
709 have_minimal_symbols (void)
715 if (ofp
->minimal_symbol_count
> 0)
723 /* Returns a section whose range includes PC and SECTION, or NULL if
724 none found. Note the distinction between the return type, struct
725 obj_section (which is defined in gdb), and the input type "struct
726 bfd_section" (which is a bfd-defined data type). The obj_section
727 contains a pointer to the "struct bfd_section". */
730 find_pc_sect_section (CORE_ADDR pc
, struct bfd_section
*section
)
732 struct obj_section
*s
;
733 struct objfile
*objfile
;
735 ALL_OBJSECTIONS (objfile
, s
)
736 if ((section
== 0 || section
== s
->the_bfd_section
) &&
737 s
->addr
<= pc
&& pc
< s
->endaddr
)
743 /* Returns a section whose range includes PC or NULL if none found.
744 Backward compatibility, no section. */
747 find_pc_section (CORE_ADDR pc
)
749 return find_pc_sect_section (pc
, find_pc_mapped_section (pc
));
753 /* In SVR4, we recognize a trampoline by it's section name.
754 That is, if the pc is in a section named ".plt" then we are in
758 in_plt_section (CORE_ADDR pc
, char *name
)
760 struct obj_section
*s
;
763 s
= find_pc_section (pc
);
766 && s
->the_bfd_section
->name
!= NULL
767 && strcmp (s
->the_bfd_section
->name
, ".plt") == 0);
771 /* Return nonzero if NAME is in the import list of OBJFILE. Else
775 is_in_import_list (char *name
, struct objfile
*objfile
)
779 if (!objfile
|| !name
|| !*name
)
782 for (i
= 0; i
< objfile
->import_list_size
; i
++)
783 if (objfile
->import_list
[i
] && DEPRECATED_STREQ (name
, objfile
->import_list
[i
]))
789 /* Keep a registry of per-objfile data-pointers required by other GDB
797 struct objfile_data_registration
799 struct objfile_data
*data
;
800 struct objfile_data_registration
*next
;
803 struct objfile_data_registry
805 struct objfile_data_registration
*registrations
;
806 unsigned num_registrations
;
809 static struct objfile_data_registry objfile_data_registry
= { NULL
, 0 };
811 const struct objfile_data
*
812 register_objfile_data (void)
814 struct objfile_data_registration
**curr
;
816 /* Append new registration. */
817 for (curr
= &objfile_data_registry
.registrations
;
818 *curr
!= NULL
; curr
= &(*curr
)->next
);
820 *curr
= XMALLOC (struct objfile_data_registration
);
821 (*curr
)->next
= NULL
;
822 (*curr
)->data
= XMALLOC (struct objfile_data
);
823 (*curr
)->data
->index
= objfile_data_registry
.num_registrations
++;
825 return (*curr
)->data
;
829 objfile_alloc_data (struct objfile
*objfile
)
831 gdb_assert (objfile
->data
== NULL
);
832 objfile
->num_data
= objfile_data_registry
.num_registrations
;
833 objfile
->data
= XCALLOC (objfile
->num_data
, void *);
837 objfile_free_data (struct objfile
*objfile
)
839 gdb_assert (objfile
->data
!= NULL
);
840 xfree (objfile
->data
);
841 objfile
->data
= NULL
;
845 clear_objfile_data (struct objfile
*objfile
)
847 gdb_assert (objfile
->data
!= NULL
);
848 memset (objfile
->data
, 0, objfile
->num_data
* sizeof (void *));
852 set_objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
,
855 gdb_assert (data
->index
< objfile
->num_data
);
856 objfile
->data
[data
->index
] = value
;
860 objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
)
862 gdb_assert (data
->index
< objfile
->num_data
);
863 return objfile
->data
[data
->index
];