1 /* GDB routines for manipulating objfiles.
3 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 2001, 2002, 2003 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
->psymbol_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 psymbol_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
->psymbol_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
->psymbol_obstack
, 0, 0, xmalloc
,
170 obstack_specify_allocation (&objfile
->symbol_obstack
, 0, 0, xmalloc
,
172 obstack_specify_allocation (&objfile
->type_obstack
, 0, 0, xmalloc
,
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 xmfree (objfile
->md
, objfile
->name
);
191 objfile
->name
= mstrsave (objfile
->md
, bfd_get_filename (abfd
));
192 objfile
->mtime
= bfd_get_mtime (abfd
);
194 /* Build section table. */
196 if (build_objfile_section_table (objfile
))
198 error ("Can't find the file sections in `%s': %s",
199 objfile
->name
, bfd_errmsg (bfd_get_error ()));
204 objfile
->name
= mstrsave (objfile
->md
, "<<anonymous objfile>>");
207 /* Initialize the section indexes for this objfile, so that we can
208 later detect if they are used w/o being properly assigned to. */
210 objfile
->sect_index_text
= -1;
211 objfile
->sect_index_data
= -1;
212 objfile
->sect_index_bss
= -1;
213 objfile
->sect_index_rodata
= -1;
215 /* We don't yet have a C++-specific namespace symtab. */
217 objfile
->cp_namespace_symtab
= NULL
;
219 /* Add this file onto the tail of the linked list of other such files. */
221 objfile
->next
= NULL
;
222 if (object_files
== NULL
)
223 object_files
= objfile
;
226 for (last_one
= object_files
;
228 last_one
= last_one
->next
);
229 last_one
->next
= objfile
;
232 /* Save passed in flag bits. */
233 objfile
->flags
|= flags
;
239 /* Create the terminating entry of OBJFILE's minimal symbol table.
240 If OBJFILE->msymbols is zero, allocate a single entry from
241 OBJFILE->symbol_obstack; otherwise, just initialize
242 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */
244 terminate_minimal_symbol_table (struct objfile
*objfile
)
246 if (! objfile
->msymbols
)
247 objfile
->msymbols
= ((struct minimal_symbol
*)
248 obstack_alloc (&objfile
->symbol_obstack
,
249 sizeof (objfile
->msymbols
[0])));
252 struct minimal_symbol
*m
253 = &objfile
->msymbols
[objfile
->minimal_symbol_count
];
255 memset (m
, 0, sizeof (*m
));
256 DEPRECATED_SYMBOL_NAME (m
) = NULL
;
257 SYMBOL_VALUE_ADDRESS (m
) = 0;
258 MSYMBOL_INFO (m
) = NULL
;
259 MSYMBOL_SIZE (m
) = 0;
260 MSYMBOL_TYPE (m
) = mst_unknown
;
261 SYMBOL_INIT_LANGUAGE_SPECIFIC (m
, language_unknown
);
266 /* Put one object file before a specified on in the global list.
267 This can be used to make sure an object file is destroyed before
268 another when using ALL_OBJFILES_SAFE to free all objfiles. */
270 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
272 struct objfile
**objp
;
274 unlink_objfile (objfile
);
276 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
278 if (*objp
== before_this
)
280 objfile
->next
= *objp
;
286 internal_error (__FILE__
, __LINE__
,
287 "put_objfile_before: before objfile not in list");
290 /* Put OBJFILE at the front of the list. */
293 objfile_to_front (struct objfile
*objfile
)
295 struct objfile
**objp
;
296 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
298 if (*objp
== objfile
)
300 /* Unhook it from where it is. */
301 *objp
= objfile
->next
;
302 /* Put it in the front. */
303 objfile
->next
= object_files
;
304 object_files
= objfile
;
310 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
313 It is not a bug, or error, to call this function if OBJFILE is not known
314 to be in the current list. This is done in the case of mapped objfiles,
315 for example, just to ensure that the mapped objfile doesn't appear twice
316 in the list. Since the list is threaded, linking in a mapped objfile
317 twice would create a circular list.
319 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
320 unlinking it, just to ensure that we have completely severed any linkages
321 between the OBJFILE and the list. */
324 unlink_objfile (struct objfile
*objfile
)
326 struct objfile
**objpp
;
328 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
330 if (*objpp
== objfile
)
332 *objpp
= (*objpp
)->next
;
333 objfile
->next
= NULL
;
338 internal_error (__FILE__
, __LINE__
,
339 "unlink_objfile: objfile already unlinked");
343 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
344 that as much as possible is allocated on the symbol_obstack and
345 psymbol_obstack, so that the memory can be efficiently freed.
347 Things which we do NOT free because they are not in malloc'd memory
348 or not in memory specific to the objfile include:
352 FIXME: If the objfile is using reusable symbol information (via mmalloc),
353 then we need to take into account the fact that more than one process
354 may be using the symbol information at the same time (when mmalloc is
355 extended to support cooperative locking). When more than one process
356 is using the mapped symbol info, we need to be more careful about when
357 we free objects in the reusable area. */
360 free_objfile (struct objfile
*objfile
)
362 if (objfile
->separate_debug_objfile
)
364 free_objfile (objfile
->separate_debug_objfile
);
367 if (objfile
->separate_debug_objfile_backlink
)
369 /* We freed the separate debug file, make sure the base objfile
370 doesn't reference it. */
371 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
= NULL
;
374 /* First do any symbol file specific actions required when we are
375 finished with a particular symbol file. Note that if the objfile
376 is using reusable symbol information (via mmalloc) then each of
377 these routines is responsible for doing the correct thing, either
378 freeing things which are valid only during this particular gdb
379 execution, or leaving them to be reused during the next one. */
381 if (objfile
->sf
!= NULL
)
383 (*objfile
->sf
->sym_finish
) (objfile
);
386 /* We always close the bfd. */
388 if (objfile
->obfd
!= NULL
)
390 char *name
= bfd_get_filename (objfile
->obfd
);
391 if (!bfd_close (objfile
->obfd
))
392 warning ("cannot close \"%s\": %s",
393 name
, bfd_errmsg (bfd_get_error ()));
397 /* Remove it from the chain of all objfiles. */
399 unlink_objfile (objfile
);
401 /* If we are going to free the runtime common objfile, mark it
404 if (objfile
== rt_common_objfile
)
405 rt_common_objfile
= NULL
;
407 /* Before the symbol table code was redone to make it easier to
408 selectively load and remove information particular to a specific
409 linkage unit, gdb used to do these things whenever the monolithic
410 symbol table was blown away. How much still needs to be done
411 is unknown, but we play it safe for now and keep each action until
412 it is shown to be no longer needed. */
414 /* I *think* all our callers call clear_symtab_users. If so, no need
415 to call this here. */
416 clear_pc_function_cache ();
418 /* The last thing we do is free the objfile struct itself. */
420 objfile_free_data (objfile
);
421 if (objfile
->name
!= NULL
)
423 xmfree (objfile
->md
, objfile
->name
);
425 if (objfile
->global_psymbols
.list
)
426 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
427 if (objfile
->static_psymbols
.list
)
428 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
429 /* Free the obstacks for non-reusable objfiles */
430 bcache_xfree (objfile
->psymbol_cache
);
431 bcache_xfree (objfile
->macro_cache
);
432 if (objfile
->demangled_names_hash
)
433 htab_delete (objfile
->demangled_names_hash
);
434 obstack_free (&objfile
->psymbol_obstack
, 0);
435 obstack_free (&objfile
->symbol_obstack
, 0);
436 obstack_free (&objfile
->type_obstack
, 0);
437 xmfree (objfile
->md
, objfile
);
442 do_free_objfile_cleanup (void *obj
)
448 make_cleanup_free_objfile (struct objfile
*obj
)
450 return make_cleanup (do_free_objfile_cleanup
, obj
);
453 /* Free all the object files at once and clean up their users. */
456 free_all_objfiles (void)
458 struct objfile
*objfile
, *temp
;
460 ALL_OBJFILES_SAFE (objfile
, temp
)
462 free_objfile (objfile
);
464 clear_symtab_users ();
467 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
468 entries in new_offsets. */
470 objfile_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
)
472 struct section_offsets
*delta
=
473 ((struct section_offsets
*)
474 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
478 int something_changed
= 0;
479 for (i
= 0; i
< objfile
->num_sections
; ++i
)
482 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
483 if (ANOFFSET (delta
, i
) != 0)
484 something_changed
= 1;
486 if (!something_changed
)
490 /* OK, get all the symtabs. */
494 ALL_OBJFILE_SYMTABS (objfile
, s
)
497 struct blockvector
*bv
;
500 /* First the line table. */
504 for (i
= 0; i
< l
->nitems
; ++i
)
505 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
508 /* Don't relocate a shared blockvector more than once. */
512 bv
= BLOCKVECTOR (s
);
513 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
517 struct dict_iterator iter
;
519 b
= BLOCKVECTOR_BLOCK (bv
, i
);
520 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
521 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
523 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
525 fixup_symbol_section (sym
, objfile
);
527 /* The RS6000 code from which this was taken skipped
528 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
529 But I'm leaving out that test, on the theory that
530 they can't possibly pass the tests below. */
531 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
532 || SYMBOL_CLASS (sym
) == LOC_STATIC
533 || SYMBOL_CLASS (sym
) == LOC_INDIRECT
)
534 && SYMBOL_SECTION (sym
) >= 0)
536 SYMBOL_VALUE_ADDRESS (sym
) +=
537 ANOFFSET (delta
, SYMBOL_SECTION (sym
));
539 #ifdef MIPS_EFI_SYMBOL_NAME
540 /* Relocate Extra Function Info for ecoff. */
542 else if (SYMBOL_CLASS (sym
) == LOC_CONST
543 && SYMBOL_DOMAIN (sym
) == LABEL_DOMAIN
544 && strcmp (DEPRECATED_SYMBOL_NAME (sym
), MIPS_EFI_SYMBOL_NAME
) == 0)
545 ecoff_relocate_efi (sym
, ANOFFSET (delta
,
546 s
->block_line_section
));
554 struct partial_symtab
*p
;
556 ALL_OBJFILE_PSYMTABS (objfile
, p
)
558 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
559 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
564 struct partial_symbol
**psym
;
566 for (psym
= objfile
->global_psymbols
.list
;
567 psym
< objfile
->global_psymbols
.next
;
570 fixup_psymbol_section (*psym
, objfile
);
571 if (SYMBOL_SECTION (*psym
) >= 0)
572 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
573 SYMBOL_SECTION (*psym
));
575 for (psym
= objfile
->static_psymbols
.list
;
576 psym
< objfile
->static_psymbols
.next
;
579 fixup_psymbol_section (*psym
, objfile
);
580 if (SYMBOL_SECTION (*psym
) >= 0)
581 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
582 SYMBOL_SECTION (*psym
));
587 struct minimal_symbol
*msym
;
588 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
589 if (SYMBOL_SECTION (msym
) >= 0)
590 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
592 /* Relocating different sections by different amounts may cause the symbols
593 to be out of order. */
594 msymbols_sort (objfile
);
598 for (i
= 0; i
< objfile
->num_sections
; ++i
)
599 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
602 if (objfile
->ei
.entry_point
!= ~(CORE_ADDR
) 0)
604 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
605 only as a fallback. */
606 struct obj_section
*s
;
607 s
= find_pc_section (objfile
->ei
.entry_point
);
609 objfile
->ei
.entry_point
+= ANOFFSET (delta
, s
->the_bfd_section
->index
);
611 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
615 struct obj_section
*s
;
618 abfd
= objfile
->obfd
;
620 ALL_OBJFILE_OSECTIONS (objfile
, s
)
622 int idx
= s
->the_bfd_section
->index
;
624 s
->addr
+= ANOFFSET (delta
, idx
);
625 s
->endaddr
+= ANOFFSET (delta
, idx
);
629 if (objfile
->ei
.entry_func_lowpc
!= INVALID_ENTRY_LOWPC
)
631 objfile
->ei
.entry_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
632 objfile
->ei
.entry_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
635 if (objfile
->ei
.deprecated_entry_file_lowpc
!= INVALID_ENTRY_LOWPC
)
637 objfile
->ei
.deprecated_entry_file_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
638 objfile
->ei
.deprecated_entry_file_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
641 if (objfile
->ei
.main_func_lowpc
!= INVALID_ENTRY_LOWPC
)
643 objfile
->ei
.main_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
644 objfile
->ei
.main_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
647 /* Relocate breakpoints as necessary, after things are relocated. */
648 breakpoint_re_set ();
651 /* Many places in gdb want to test just to see if we have any partial
652 symbols available. This function returns zero if none are currently
653 available, nonzero otherwise. */
656 have_partial_symbols (void)
662 if (ofp
->psymtabs
!= NULL
)
670 /* Many places in gdb want to test just to see if we have any full
671 symbols available. This function returns zero if none are currently
672 available, nonzero otherwise. */
675 have_full_symbols (void)
681 if (ofp
->symtabs
!= NULL
)
690 /* This operations deletes all objfile entries that represent solibs that
691 weren't explicitly loaded by the user, via e.g., the add-symbol-file
695 objfile_purge_solibs (void)
697 struct objfile
*objf
;
698 struct objfile
*temp
;
700 ALL_OBJFILES_SAFE (objf
, temp
)
702 /* We assume that the solib package has been purged already, or will
705 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
711 /* Many places in gdb want to test just to see if we have any minimal
712 symbols available. This function returns zero if none are currently
713 available, nonzero otherwise. */
716 have_minimal_symbols (void)
722 if (ofp
->minimal_symbol_count
> 0)
730 /* Returns a section whose range includes PC and SECTION, or NULL if
731 none found. Note the distinction between the return type, struct
732 obj_section (which is defined in gdb), and the input type "struct
733 bfd_section" (which is a bfd-defined data type). The obj_section
734 contains a pointer to the "struct bfd_section". */
737 find_pc_sect_section (CORE_ADDR pc
, struct bfd_section
*section
)
739 struct obj_section
*s
;
740 struct objfile
*objfile
;
742 ALL_OBJSECTIONS (objfile
, s
)
743 if ((section
== 0 || section
== s
->the_bfd_section
) &&
744 s
->addr
<= pc
&& pc
< s
->endaddr
)
750 /* Returns a section whose range includes PC or NULL if none found.
751 Backward compatibility, no section. */
754 find_pc_section (CORE_ADDR pc
)
756 return find_pc_sect_section (pc
, find_pc_mapped_section (pc
));
760 /* In SVR4, we recognize a trampoline by it's section name.
761 That is, if the pc is in a section named ".plt" then we are in
765 in_plt_section (CORE_ADDR pc
, char *name
)
767 struct obj_section
*s
;
770 s
= find_pc_section (pc
);
773 && s
->the_bfd_section
->name
!= NULL
774 && strcmp (s
->the_bfd_section
->name
, ".plt") == 0);
778 /* Return nonzero if NAME is in the import list of OBJFILE. Else
782 is_in_import_list (char *name
, struct objfile
*objfile
)
786 if (!objfile
|| !name
|| !*name
)
789 for (i
= 0; i
< objfile
->import_list_size
; i
++)
790 if (objfile
->import_list
[i
] && DEPRECATED_STREQ (name
, objfile
->import_list
[i
]))
796 /* Keep a registry of per-objfile data-pointers required by other GDB
804 struct objfile_data_registration
806 struct objfile_data
*data
;
807 struct objfile_data_registration
*next
;
810 struct objfile_data_registry
812 struct objfile_data_registration
*registrations
;
813 unsigned num_registrations
;
816 static struct objfile_data_registry objfile_data_registry
= { NULL
, 0 };
818 const struct objfile_data
*
819 register_objfile_data (void)
821 struct objfile_data_registration
**curr
;
823 /* Append new registration. */
824 for (curr
= &objfile_data_registry
.registrations
;
825 *curr
!= NULL
; curr
= &(*curr
)->next
);
827 *curr
= XMALLOC (struct objfile_data_registration
);
828 (*curr
)->next
= NULL
;
829 (*curr
)->data
= XMALLOC (struct objfile_data
);
830 (*curr
)->data
->index
= objfile_data_registry
.num_registrations
++;
832 return (*curr
)->data
;
836 objfile_alloc_data (struct objfile
*objfile
)
838 gdb_assert (objfile
->data
== NULL
);
839 objfile
->num_data
= objfile_data_registry
.num_registrations
;
840 objfile
->data
= XCALLOC (objfile
->num_data
, void *);
844 objfile_free_data (struct objfile
*objfile
)
846 gdb_assert (objfile
->data
!= NULL
);
847 xfree (objfile
->data
);
848 objfile
->data
= NULL
;
852 clear_objfile_data (struct objfile
*objfile
)
854 gdb_assert (objfile
->data
!= NULL
);
855 memset (objfile
->data
, 0, objfile
->num_data
* sizeof (void *));
859 set_objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
,
862 gdb_assert (data
->index
< objfile
->num_data
);
863 objfile
->data
[data
->index
] = value
;
867 objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
)
869 gdb_assert (data
->index
< objfile
->num_data
);
870 return objfile
->data
[data
->index
];