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 /* We could use obstack_specify_allocation here instead, but
169 gdb_obstack.h specifies the alloc/dealloc functions. */
170 obstack_init (&objfile
->objfile_obstack
);
171 terminate_minimal_symbol_table (objfile
);
174 objfile_alloc_data (objfile
);
176 /* Update the per-objfile information that comes from the bfd, ensuring
177 that any data that is reference is saved in the per-objfile data
180 objfile
->obfd
= abfd
;
181 if (objfile
->name
!= NULL
)
183 xmfree (objfile
->md
, objfile
->name
);
187 objfile
->name
= mstrsave (objfile
->md
, bfd_get_filename (abfd
));
188 objfile
->mtime
= bfd_get_mtime (abfd
);
190 /* Build section table. */
192 if (build_objfile_section_table (objfile
))
194 error ("Can't find the file sections in `%s': %s",
195 objfile
->name
, bfd_errmsg (bfd_get_error ()));
200 objfile
->name
= mstrsave (objfile
->md
, "<<anonymous objfile>>");
203 /* Initialize the section indexes for this objfile, so that we can
204 later detect if they are used w/o being properly assigned to. */
206 objfile
->sect_index_text
= -1;
207 objfile
->sect_index_data
= -1;
208 objfile
->sect_index_bss
= -1;
209 objfile
->sect_index_rodata
= -1;
211 /* We don't yet have a C++-specific namespace symtab. */
213 objfile
->cp_namespace_symtab
= NULL
;
215 /* Add this file onto the tail of the linked list of other such files. */
217 objfile
->next
= NULL
;
218 if (object_files
== NULL
)
219 object_files
= objfile
;
222 for (last_one
= object_files
;
224 last_one
= last_one
->next
);
225 last_one
->next
= objfile
;
228 /* Save passed in flag bits. */
229 objfile
->flags
|= flags
;
235 /* Create the terminating entry of OBJFILE's minimal symbol table.
236 If OBJFILE->msymbols is zero, allocate a single entry from
237 OBJFILE->objfile_obstack; otherwise, just initialize
238 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */
240 terminate_minimal_symbol_table (struct objfile
*objfile
)
242 if (! objfile
->msymbols
)
243 objfile
->msymbols
= ((struct minimal_symbol
*)
244 obstack_alloc (&objfile
->objfile_obstack
,
245 sizeof (objfile
->msymbols
[0])));
248 struct minimal_symbol
*m
249 = &objfile
->msymbols
[objfile
->minimal_symbol_count
];
251 memset (m
, 0, sizeof (*m
));
252 DEPRECATED_SYMBOL_NAME (m
) = NULL
;
253 SYMBOL_VALUE_ADDRESS (m
) = 0;
254 MSYMBOL_INFO (m
) = NULL
;
255 MSYMBOL_SIZE (m
) = 0;
256 MSYMBOL_TYPE (m
) = mst_unknown
;
257 SYMBOL_INIT_LANGUAGE_SPECIFIC (m
, language_unknown
);
262 /* Put one object file before a specified on in the global list.
263 This can be used to make sure an object file is destroyed before
264 another when using ALL_OBJFILES_SAFE to free all objfiles. */
266 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
268 struct objfile
**objp
;
270 unlink_objfile (objfile
);
272 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
274 if (*objp
== before_this
)
276 objfile
->next
= *objp
;
282 internal_error (__FILE__
, __LINE__
,
283 "put_objfile_before: before objfile not in list");
286 /* Put OBJFILE at the front of the list. */
289 objfile_to_front (struct objfile
*objfile
)
291 struct objfile
**objp
;
292 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
294 if (*objp
== objfile
)
296 /* Unhook it from where it is. */
297 *objp
= objfile
->next
;
298 /* Put it in the front. */
299 objfile
->next
= object_files
;
300 object_files
= objfile
;
306 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
309 It is not a bug, or error, to call this function if OBJFILE is not known
310 to be in the current list. This is done in the case of mapped objfiles,
311 for example, just to ensure that the mapped objfile doesn't appear twice
312 in the list. Since the list is threaded, linking in a mapped objfile
313 twice would create a circular list.
315 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
316 unlinking it, just to ensure that we have completely severed any linkages
317 between the OBJFILE and the list. */
320 unlink_objfile (struct objfile
*objfile
)
322 struct objfile
**objpp
;
324 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
326 if (*objpp
== objfile
)
328 *objpp
= (*objpp
)->next
;
329 objfile
->next
= NULL
;
334 internal_error (__FILE__
, __LINE__
,
335 "unlink_objfile: objfile already unlinked");
339 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
340 that as much as possible is allocated on the objfile_obstack
341 so that the memory can be efficiently freed.
343 Things which we do NOT free because they are not in malloc'd memory
344 or not in memory specific to the objfile include:
348 FIXME: If the objfile is using reusable symbol information (via mmalloc),
349 then we need to take into account the fact that more than one process
350 may be using the symbol information at the same time (when mmalloc is
351 extended to support cooperative locking). When more than one process
352 is using the mapped symbol info, we need to be more careful about when
353 we free objects in the reusable area. */
356 free_objfile (struct objfile
*objfile
)
358 if (objfile
->separate_debug_objfile
)
360 free_objfile (objfile
->separate_debug_objfile
);
363 if (objfile
->separate_debug_objfile_backlink
)
365 /* We freed the separate debug file, make sure the base objfile
366 doesn't reference it. */
367 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
= NULL
;
370 /* First do any symbol file specific actions required when we are
371 finished with a particular symbol file. Note that if the objfile
372 is using reusable symbol information (via mmalloc) then each of
373 these routines is responsible for doing the correct thing, either
374 freeing things which are valid only during this particular gdb
375 execution, or leaving them to be reused during the next one. */
377 if (objfile
->sf
!= NULL
)
379 (*objfile
->sf
->sym_finish
) (objfile
);
382 /* We always close the bfd. */
384 if (objfile
->obfd
!= NULL
)
386 char *name
= bfd_get_filename (objfile
->obfd
);
387 if (!bfd_close (objfile
->obfd
))
388 warning ("cannot close \"%s\": %s",
389 name
, bfd_errmsg (bfd_get_error ()));
393 /* Remove it from the chain of all objfiles. */
395 unlink_objfile (objfile
);
397 /* If we are going to free the runtime common objfile, mark it
400 if (objfile
== rt_common_objfile
)
401 rt_common_objfile
= NULL
;
403 /* Before the symbol table code was redone to make it easier to
404 selectively load and remove information particular to a specific
405 linkage unit, gdb used to do these things whenever the monolithic
406 symbol table was blown away. How much still needs to be done
407 is unknown, but we play it safe for now and keep each action until
408 it is shown to be no longer needed. */
410 /* I *think* all our callers call clear_symtab_users. If so, no need
411 to call this here. */
412 clear_pc_function_cache ();
414 /* The last thing we do is free the objfile struct itself. */
416 objfile_free_data (objfile
);
417 if (objfile
->name
!= NULL
)
419 xmfree (objfile
->md
, objfile
->name
);
421 if (objfile
->global_psymbols
.list
)
422 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
423 if (objfile
->static_psymbols
.list
)
424 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
425 /* Free the obstacks for non-reusable objfiles */
426 bcache_xfree (objfile
->psymbol_cache
);
427 bcache_xfree (objfile
->macro_cache
);
428 if (objfile
->demangled_names_hash
)
429 htab_delete (objfile
->demangled_names_hash
);
430 obstack_free (&objfile
->objfile_obstack
, 0);
431 xmfree (objfile
->md
, objfile
);
436 do_free_objfile_cleanup (void *obj
)
442 make_cleanup_free_objfile (struct objfile
*obj
)
444 return make_cleanup (do_free_objfile_cleanup
, obj
);
447 /* Free all the object files at once and clean up their users. */
450 free_all_objfiles (void)
452 struct objfile
*objfile
, *temp
;
454 ALL_OBJFILES_SAFE (objfile
, temp
)
456 free_objfile (objfile
);
458 clear_symtab_users ();
461 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
462 entries in new_offsets. */
464 objfile_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
)
466 struct section_offsets
*delta
=
467 ((struct section_offsets
*)
468 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
472 int something_changed
= 0;
473 for (i
= 0; i
< objfile
->num_sections
; ++i
)
476 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
477 if (ANOFFSET (delta
, i
) != 0)
478 something_changed
= 1;
480 if (!something_changed
)
484 /* OK, get all the symtabs. */
488 ALL_OBJFILE_SYMTABS (objfile
, s
)
491 struct blockvector
*bv
;
494 /* First the line table. */
498 for (i
= 0; i
< l
->nitems
; ++i
)
499 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
502 /* Don't relocate a shared blockvector more than once. */
506 bv
= BLOCKVECTOR (s
);
507 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
511 struct dict_iterator iter
;
513 b
= BLOCKVECTOR_BLOCK (bv
, i
);
514 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
515 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
517 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
519 fixup_symbol_section (sym
, objfile
);
521 /* The RS6000 code from which this was taken skipped
522 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
523 But I'm leaving out that test, on the theory that
524 they can't possibly pass the tests below. */
525 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
526 || SYMBOL_CLASS (sym
) == LOC_STATIC
527 || SYMBOL_CLASS (sym
) == LOC_INDIRECT
)
528 && SYMBOL_SECTION (sym
) >= 0)
530 SYMBOL_VALUE_ADDRESS (sym
) +=
531 ANOFFSET (delta
, SYMBOL_SECTION (sym
));
533 #ifdef MIPS_EFI_SYMBOL_NAME
534 /* Relocate Extra Function Info for ecoff. */
536 else if (SYMBOL_CLASS (sym
) == LOC_CONST
537 && SYMBOL_DOMAIN (sym
) == LABEL_DOMAIN
538 && strcmp (DEPRECATED_SYMBOL_NAME (sym
), MIPS_EFI_SYMBOL_NAME
) == 0)
539 ecoff_relocate_efi (sym
, ANOFFSET (delta
,
540 s
->block_line_section
));
548 struct partial_symtab
*p
;
550 ALL_OBJFILE_PSYMTABS (objfile
, p
)
552 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
553 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
558 struct partial_symbol
**psym
;
560 for (psym
= objfile
->global_psymbols
.list
;
561 psym
< objfile
->global_psymbols
.next
;
564 fixup_psymbol_section (*psym
, objfile
);
565 if (SYMBOL_SECTION (*psym
) >= 0)
566 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
567 SYMBOL_SECTION (*psym
));
569 for (psym
= objfile
->static_psymbols
.list
;
570 psym
< objfile
->static_psymbols
.next
;
573 fixup_psymbol_section (*psym
, objfile
);
574 if (SYMBOL_SECTION (*psym
) >= 0)
575 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
576 SYMBOL_SECTION (*psym
));
581 struct minimal_symbol
*msym
;
582 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
583 if (SYMBOL_SECTION (msym
) >= 0)
584 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
586 /* Relocating different sections by different amounts may cause the symbols
587 to be out of order. */
588 msymbols_sort (objfile
);
592 for (i
= 0; i
< objfile
->num_sections
; ++i
)
593 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
596 if (objfile
->ei
.entry_point
!= ~(CORE_ADDR
) 0)
598 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
599 only as a fallback. */
600 struct obj_section
*s
;
601 s
= find_pc_section (objfile
->ei
.entry_point
);
603 objfile
->ei
.entry_point
+= ANOFFSET (delta
, s
->the_bfd_section
->index
);
605 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
609 struct obj_section
*s
;
612 abfd
= objfile
->obfd
;
614 ALL_OBJFILE_OSECTIONS (objfile
, s
)
616 int idx
= s
->the_bfd_section
->index
;
618 s
->addr
+= ANOFFSET (delta
, idx
);
619 s
->endaddr
+= ANOFFSET (delta
, idx
);
623 if (objfile
->ei
.entry_func_lowpc
!= INVALID_ENTRY_LOWPC
)
625 objfile
->ei
.entry_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
626 objfile
->ei
.entry_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
629 if (objfile
->ei
.deprecated_entry_file_lowpc
!= INVALID_ENTRY_LOWPC
)
631 objfile
->ei
.deprecated_entry_file_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
632 objfile
->ei
.deprecated_entry_file_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
635 if (objfile
->ei
.main_func_lowpc
!= INVALID_ENTRY_LOWPC
)
637 objfile
->ei
.main_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
638 objfile
->ei
.main_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
641 /* Relocate breakpoints as necessary, after things are relocated. */
642 breakpoint_re_set ();
645 /* Many places in gdb want to test just to see if we have any partial
646 symbols available. This function returns zero if none are currently
647 available, nonzero otherwise. */
650 have_partial_symbols (void)
656 if (ofp
->psymtabs
!= NULL
)
664 /* Many places in gdb want to test just to see if we have any full
665 symbols available. This function returns zero if none are currently
666 available, nonzero otherwise. */
669 have_full_symbols (void)
675 if (ofp
->symtabs
!= NULL
)
684 /* This operations deletes all objfile entries that represent solibs that
685 weren't explicitly loaded by the user, via e.g., the add-symbol-file
689 objfile_purge_solibs (void)
691 struct objfile
*objf
;
692 struct objfile
*temp
;
694 ALL_OBJFILES_SAFE (objf
, temp
)
696 /* We assume that the solib package has been purged already, or will
699 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
705 /* Many places in gdb want to test just to see if we have any minimal
706 symbols available. This function returns zero if none are currently
707 available, nonzero otherwise. */
710 have_minimal_symbols (void)
716 if (ofp
->minimal_symbol_count
> 0)
724 /* Returns a section whose range includes PC and SECTION, or NULL if
725 none found. Note the distinction between the return type, struct
726 obj_section (which is defined in gdb), and the input type "struct
727 bfd_section" (which is a bfd-defined data type). The obj_section
728 contains a pointer to the "struct bfd_section". */
731 find_pc_sect_section (CORE_ADDR pc
, struct bfd_section
*section
)
733 struct obj_section
*s
;
734 struct objfile
*objfile
;
736 ALL_OBJSECTIONS (objfile
, s
)
737 if ((section
== 0 || section
== s
->the_bfd_section
) &&
738 s
->addr
<= pc
&& pc
< s
->endaddr
)
744 /* Returns a section whose range includes PC or NULL if none found.
745 Backward compatibility, no section. */
748 find_pc_section (CORE_ADDR pc
)
750 return find_pc_sect_section (pc
, find_pc_mapped_section (pc
));
754 /* In SVR4, we recognize a trampoline by it's section name.
755 That is, if the pc is in a section named ".plt" then we are in
759 in_plt_section (CORE_ADDR pc
, char *name
)
761 struct obj_section
*s
;
764 s
= find_pc_section (pc
);
767 && s
->the_bfd_section
->name
!= NULL
768 && strcmp (s
->the_bfd_section
->name
, ".plt") == 0);
772 /* Return nonzero if NAME is in the import list of OBJFILE. Else
776 is_in_import_list (char *name
, struct objfile
*objfile
)
780 if (!objfile
|| !name
|| !*name
)
783 for (i
= 0; i
< objfile
->import_list_size
; i
++)
784 if (objfile
->import_list
[i
] && DEPRECATED_STREQ (name
, objfile
->import_list
[i
]))
790 /* Keep a registry of per-objfile data-pointers required by other GDB
798 struct objfile_data_registration
800 struct objfile_data
*data
;
801 struct objfile_data_registration
*next
;
804 struct objfile_data_registry
806 struct objfile_data_registration
*registrations
;
807 unsigned num_registrations
;
810 static struct objfile_data_registry objfile_data_registry
= { NULL
, 0 };
812 const struct objfile_data
*
813 register_objfile_data (void)
815 struct objfile_data_registration
**curr
;
817 /* Append new registration. */
818 for (curr
= &objfile_data_registry
.registrations
;
819 *curr
!= NULL
; curr
= &(*curr
)->next
);
821 *curr
= XMALLOC (struct objfile_data_registration
);
822 (*curr
)->next
= NULL
;
823 (*curr
)->data
= XMALLOC (struct objfile_data
);
824 (*curr
)->data
->index
= objfile_data_registry
.num_registrations
++;
826 return (*curr
)->data
;
830 objfile_alloc_data (struct objfile
*objfile
)
832 gdb_assert (objfile
->data
== NULL
);
833 objfile
->num_data
= objfile_data_registry
.num_registrations
;
834 objfile
->data
= XCALLOC (objfile
->num_data
, void *);
838 objfile_free_data (struct objfile
*objfile
)
840 gdb_assert (objfile
->data
!= NULL
);
841 xfree (objfile
->data
);
842 objfile
->data
= NULL
;
846 clear_objfile_data (struct objfile
*objfile
)
848 gdb_assert (objfile
->data
!= NULL
);
849 memset (objfile
->data
, 0, objfile
->num_data
* sizeof (void *));
853 set_objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
,
856 gdb_assert (data
->index
< objfile
->num_data
);
857 objfile
->data
[data
->index
] = value
;
861 objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
)
863 gdb_assert (data
->index
< objfile
->num_data
);
864 return objfile
->data
[data
->index
];