dma: beautify queue listing output
[dragonfly.git] / contrib / gdb-6.2.1 / gdb / objfiles.c
blob48d695456df9931e87b2e907e73ead141e0720da
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. */
28 #include "defs.h"
29 #include "bfd.h" /* Binary File Description */
30 #include "symtab.h"
31 #include "symfile.h"
32 #include "objfiles.h"
33 #include "gdb-stabs.h"
34 #include "target.h"
35 #include "bcache.h"
37 #include "gdb_assert.h"
38 #include <sys/types.h>
39 #include "gdb_stat.h"
40 #include <fcntl.h>
41 #include "gdb_obstack.h"
42 #include "gdb_string.h"
43 #include "hashtab.h"
45 #include "breakpoint.h"
46 #include "block.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
68 #endif
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). */
75 static void
76 add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
77 void *objfile_p_char)
79 struct objfile *objfile = (struct objfile *) objfile_p_char;
80 struct obj_section section;
81 flagword aflag;
83 aflag = bfd_get_section_flags (abfd, asect);
85 if (!(aflag & SEC_ALLOC) && !(TARGET_KEEP_SECTION (asect)))
86 return;
88 if (0 == bfd_section_size (abfd, asect))
89 return;
90 section.offset = 0;
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 *) &section, 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
102 error).
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;
130 return (0);
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
136 new objfile struct.
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. */
151 struct objfile *
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. */
161 if (objfile == NULL)
163 objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
164 memset (objfile, 0, sizeof (struct objfile));
165 objfile->md = NULL;
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
178 region. */
180 objfile->obfd = abfd;
181 if (objfile->name != NULL)
183 xmfree (objfile->md, objfile->name);
185 if (abfd != NULL)
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 ()));
198 else
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;
220 else
222 for (last_one = object_files;
223 last_one->next;
224 last_one = last_one->next);
225 last_one->next = objfile;
228 /* Save passed in flag bits. */
229 objfile->flags |= flags;
231 return (objfile);
234 /* Initialize entry point information for this objfile. */
236 void
237 init_entry_point_info (struct objfile *objfile)
239 /* Save startup file's range of PC addresses to help blockframe.c
240 decide where the bottom of the stack is. */
242 if (bfd_get_file_flags (objfile->obfd) & EXEC_P)
244 /* Executable file -- record its entry point so we'll recognize
245 the startup file because it contains the entry point. */
246 objfile->ei.entry_point = bfd_get_start_address (objfile->obfd);
248 else
250 /* Examination of non-executable.o files. Short-circuit this stuff. */
251 objfile->ei.entry_point = INVALID_ENTRY_POINT;
253 objfile->ei.main_func_lowpc = INVALID_ENTRY_LOWPC;
254 objfile->ei.main_func_highpc = INVALID_ENTRY_HIGHPC;
257 /* Get current entry point address. */
259 CORE_ADDR
260 entry_point_address (void)
262 return symfile_objfile ? symfile_objfile->ei.entry_point : 0;
265 /* Create the terminating entry of OBJFILE's minimal symbol table.
266 If OBJFILE->msymbols is zero, allocate a single entry from
267 OBJFILE->objfile_obstack; otherwise, just initialize
268 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */
269 void
270 terminate_minimal_symbol_table (struct objfile *objfile)
272 if (! objfile->msymbols)
273 objfile->msymbols = ((struct minimal_symbol *)
274 obstack_alloc (&objfile->objfile_obstack,
275 sizeof (objfile->msymbols[0])));
278 struct minimal_symbol *m
279 = &objfile->msymbols[objfile->minimal_symbol_count];
281 memset (m, 0, sizeof (*m));
282 /* Don't rely on these enumeration values being 0's. */
283 MSYMBOL_TYPE (m) = mst_unknown;
284 SYMBOL_INIT_LANGUAGE_SPECIFIC (m, language_unknown);
289 /* Put one object file before a specified on in the global list.
290 This can be used to make sure an object file is destroyed before
291 another when using ALL_OBJFILES_SAFE to free all objfiles. */
292 void
293 put_objfile_before (struct objfile *objfile, struct objfile *before_this)
295 struct objfile **objp;
297 unlink_objfile (objfile);
299 for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
301 if (*objp == before_this)
303 objfile->next = *objp;
304 *objp = objfile;
305 return;
309 internal_error (__FILE__, __LINE__,
310 "put_objfile_before: before objfile not in list");
313 /* Put OBJFILE at the front of the list. */
315 void
316 objfile_to_front (struct objfile *objfile)
318 struct objfile **objp;
319 for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
321 if (*objp == objfile)
323 /* Unhook it from where it is. */
324 *objp = objfile->next;
325 /* Put it in the front. */
326 objfile->next = object_files;
327 object_files = objfile;
328 break;
333 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
334 list.
336 It is not a bug, or error, to call this function if OBJFILE is not known
337 to be in the current list. This is done in the case of mapped objfiles,
338 for example, just to ensure that the mapped objfile doesn't appear twice
339 in the list. Since the list is threaded, linking in a mapped objfile
340 twice would create a circular list.
342 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
343 unlinking it, just to ensure that we have completely severed any linkages
344 between the OBJFILE and the list. */
346 void
347 unlink_objfile (struct objfile *objfile)
349 struct objfile **objpp;
351 for (objpp = &object_files; *objpp != NULL; objpp = &((*objpp)->next))
353 if (*objpp == objfile)
355 *objpp = (*objpp)->next;
356 objfile->next = NULL;
357 return;
361 internal_error (__FILE__, __LINE__,
362 "unlink_objfile: objfile already unlinked");
366 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
367 that as much as possible is allocated on the objfile_obstack
368 so that the memory can be efficiently freed.
370 Things which we do NOT free because they are not in malloc'd memory
371 or not in memory specific to the objfile include:
373 objfile -> sf
375 FIXME: If the objfile is using reusable symbol information (via mmalloc),
376 then we need to take into account the fact that more than one process
377 may be using the symbol information at the same time (when mmalloc is
378 extended to support cooperative locking). When more than one process
379 is using the mapped symbol info, we need to be more careful about when
380 we free objects in the reusable area. */
382 void
383 free_objfile (struct objfile *objfile)
385 if (objfile->separate_debug_objfile)
387 free_objfile (objfile->separate_debug_objfile);
390 if (objfile->separate_debug_objfile_backlink)
392 /* We freed the separate debug file, make sure the base objfile
393 doesn't reference it. */
394 objfile->separate_debug_objfile_backlink->separate_debug_objfile = NULL;
397 /* First do any symbol file specific actions required when we are
398 finished with a particular symbol file. Note that if the objfile
399 is using reusable symbol information (via mmalloc) then each of
400 these routines is responsible for doing the correct thing, either
401 freeing things which are valid only during this particular gdb
402 execution, or leaving them to be reused during the next one. */
404 if (objfile->sf != NULL)
406 (*objfile->sf->sym_finish) (objfile);
409 /* We always close the bfd. */
411 if (objfile->obfd != NULL)
413 char *name = bfd_get_filename (objfile->obfd);
414 if (!bfd_close (objfile->obfd))
415 warning ("cannot close \"%s\": %s",
416 name, bfd_errmsg (bfd_get_error ()));
417 xfree (name);
420 /* Remove it from the chain of all objfiles. */
422 unlink_objfile (objfile);
424 /* If we are going to free the runtime common objfile, mark it
425 as unallocated. */
427 if (objfile == rt_common_objfile)
428 rt_common_objfile = NULL;
430 /* Before the symbol table code was redone to make it easier to
431 selectively load and remove information particular to a specific
432 linkage unit, gdb used to do these things whenever the monolithic
433 symbol table was blown away. How much still needs to be done
434 is unknown, but we play it safe for now and keep each action until
435 it is shown to be no longer needed. */
437 /* I *think* all our callers call clear_symtab_users. If so, no need
438 to call this here. */
439 clear_pc_function_cache ();
441 /* The last thing we do is free the objfile struct itself. */
443 objfile_free_data (objfile);
444 if (objfile->name != NULL)
446 xmfree (objfile->md, objfile->name);
448 if (objfile->global_psymbols.list)
449 xmfree (objfile->md, objfile->global_psymbols.list);
450 if (objfile->static_psymbols.list)
451 xmfree (objfile->md, objfile->static_psymbols.list);
452 /* Free the obstacks for non-reusable objfiles */
453 bcache_xfree (objfile->psymbol_cache);
454 bcache_xfree (objfile->macro_cache);
455 if (objfile->demangled_names_hash)
456 htab_delete (objfile->demangled_names_hash);
457 obstack_free (&objfile->objfile_obstack, 0);
458 xmfree (objfile->md, objfile);
459 objfile = NULL;
462 static void
463 do_free_objfile_cleanup (void *obj)
465 free_objfile (obj);
468 struct cleanup *
469 make_cleanup_free_objfile (struct objfile *obj)
471 return make_cleanup (do_free_objfile_cleanup, obj);
474 /* Free all the object files at once and clean up their users. */
476 void
477 free_all_objfiles (void)
479 struct objfile *objfile, *temp;
481 ALL_OBJFILES_SAFE (objfile, temp)
483 free_objfile (objfile);
485 clear_symtab_users ();
488 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
489 entries in new_offsets. */
490 void
491 objfile_relocate (struct objfile *objfile, struct section_offsets *new_offsets)
493 struct section_offsets *delta =
494 ((struct section_offsets *)
495 alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
498 int i;
499 int something_changed = 0;
500 for (i = 0; i < objfile->num_sections; ++i)
502 delta->offsets[i] =
503 ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
504 if (ANOFFSET (delta, i) != 0)
505 something_changed = 1;
507 if (!something_changed)
508 return;
511 /* OK, get all the symtabs. */
513 struct symtab *s;
515 ALL_OBJFILE_SYMTABS (objfile, s)
517 struct linetable *l;
518 struct blockvector *bv;
519 int i;
521 /* First the line table. */
522 l = LINETABLE (s);
523 if (l)
525 for (i = 0; i < l->nitems; ++i)
526 l->item[i].pc += ANOFFSET (delta, s->block_line_section);
529 /* Don't relocate a shared blockvector more than once. */
530 if (!s->primary)
531 continue;
533 bv = BLOCKVECTOR (s);
534 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
536 struct block *b;
537 struct symbol *sym;
538 struct dict_iterator iter;
540 b = BLOCKVECTOR_BLOCK (bv, i);
541 BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
542 BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
544 ALL_BLOCK_SYMBOLS (b, iter, sym)
546 fixup_symbol_section (sym, objfile);
548 /* The RS6000 code from which this was taken skipped
549 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
550 But I'm leaving out that test, on the theory that
551 they can't possibly pass the tests below. */
552 if ((SYMBOL_CLASS (sym) == LOC_LABEL
553 || SYMBOL_CLASS (sym) == LOC_STATIC
554 || SYMBOL_CLASS (sym) == LOC_INDIRECT)
555 && SYMBOL_SECTION (sym) >= 0)
557 SYMBOL_VALUE_ADDRESS (sym) +=
558 ANOFFSET (delta, SYMBOL_SECTION (sym));
560 #ifdef MIPS_EFI_SYMBOL_NAME
561 /* Relocate Extra Function Info for ecoff. */
563 else if (SYMBOL_CLASS (sym) == LOC_CONST
564 && SYMBOL_DOMAIN (sym) == LABEL_DOMAIN
565 && strcmp (DEPRECATED_SYMBOL_NAME (sym), MIPS_EFI_SYMBOL_NAME) == 0)
566 ecoff_relocate_efi (sym, ANOFFSET (delta,
567 s->block_line_section));
568 #endif
575 struct partial_symtab *p;
577 ALL_OBJFILE_PSYMTABS (objfile, p)
579 p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
580 p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
585 struct partial_symbol **psym;
587 for (psym = objfile->global_psymbols.list;
588 psym < objfile->global_psymbols.next;
589 psym++)
591 fixup_psymbol_section (*psym, objfile);
592 if (SYMBOL_SECTION (*psym) >= 0)
593 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
594 SYMBOL_SECTION (*psym));
596 for (psym = objfile->static_psymbols.list;
597 psym < objfile->static_psymbols.next;
598 psym++)
600 fixup_psymbol_section (*psym, objfile);
601 if (SYMBOL_SECTION (*psym) >= 0)
602 SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
603 SYMBOL_SECTION (*psym));
608 struct minimal_symbol *msym;
609 ALL_OBJFILE_MSYMBOLS (objfile, msym)
610 if (SYMBOL_SECTION (msym) >= 0)
611 SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym));
613 /* Relocating different sections by different amounts may cause the symbols
614 to be out of order. */
615 msymbols_sort (objfile);
618 int i;
619 for (i = 0; i < objfile->num_sections; ++i)
620 (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
623 if (objfile->ei.entry_point != ~(CORE_ADDR) 0)
625 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
626 only as a fallback. */
627 struct obj_section *s;
628 s = find_pc_section (objfile->ei.entry_point);
629 if (s)
630 objfile->ei.entry_point += ANOFFSET (delta, s->the_bfd_section->index);
631 else
632 objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
636 struct obj_section *s;
637 bfd *abfd;
639 abfd = objfile->obfd;
641 ALL_OBJFILE_OSECTIONS (objfile, s)
643 int idx = s->the_bfd_section->index;
645 s->addr += ANOFFSET (delta, idx);
646 s->endaddr += ANOFFSET (delta, idx);
650 if (objfile->ei.main_func_lowpc != INVALID_ENTRY_LOWPC)
652 objfile->ei.main_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
653 objfile->ei.main_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
656 /* Relocate breakpoints as necessary, after things are relocated. */
657 breakpoint_re_set ();
660 /* Many places in gdb want to test just to see if we have any partial
661 symbols available. This function returns zero if none are currently
662 available, nonzero otherwise. */
665 have_partial_symbols (void)
667 struct objfile *ofp;
669 ALL_OBJFILES (ofp)
671 if (ofp->psymtabs != NULL)
673 return 1;
676 return 0;
679 /* Many places in gdb want to test just to see if we have any full
680 symbols available. This function returns zero if none are currently
681 available, nonzero otherwise. */
684 have_full_symbols (void)
686 struct objfile *ofp;
688 ALL_OBJFILES (ofp)
690 if (ofp->symtabs != NULL)
692 return 1;
695 return 0;
699 /* This operations deletes all objfile entries that represent solibs that
700 weren't explicitly loaded by the user, via e.g., the add-symbol-file
701 command.
703 void
704 objfile_purge_solibs (void)
706 struct objfile *objf;
707 struct objfile *temp;
709 ALL_OBJFILES_SAFE (objf, temp)
711 /* We assume that the solib package has been purged already, or will
712 be soon.
714 if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
715 free_objfile (objf);
720 /* Many places in gdb want to test just to see if we have any minimal
721 symbols available. This function returns zero if none are currently
722 available, nonzero otherwise. */
725 have_minimal_symbols (void)
727 struct objfile *ofp;
729 ALL_OBJFILES (ofp)
731 if (ofp->minimal_symbol_count > 0)
733 return 1;
736 return 0;
739 /* Returns a section whose range includes PC and SECTION, or NULL if
740 none found. Note the distinction between the return type, struct
741 obj_section (which is defined in gdb), and the input type "struct
742 bfd_section" (which is a bfd-defined data type). The obj_section
743 contains a pointer to the "struct bfd_section". */
745 struct obj_section *
746 find_pc_sect_section (CORE_ADDR pc, struct bfd_section *section)
748 struct obj_section *s;
749 struct objfile *objfile;
751 ALL_OBJSECTIONS (objfile, s)
752 if ((section == 0 || section == s->the_bfd_section) &&
753 s->addr <= pc && pc < s->endaddr)
754 return (s);
756 return (NULL);
759 /* Returns a section whose range includes PC or NULL if none found.
760 Backward compatibility, no section. */
762 struct obj_section *
763 find_pc_section (CORE_ADDR pc)
765 return find_pc_sect_section (pc, find_pc_mapped_section (pc));
769 /* In SVR4, we recognize a trampoline by it's section name.
770 That is, if the pc is in a section named ".plt" then we are in
771 a trampoline. */
774 in_plt_section (CORE_ADDR pc, char *name)
776 struct obj_section *s;
777 int retval = 0;
779 s = find_pc_section (pc);
781 retval = (s != NULL
782 && s->the_bfd_section->name != NULL
783 && strcmp (s->the_bfd_section->name, ".plt") == 0);
784 return (retval);
787 /* Return nonzero if NAME is in the import list of OBJFILE. Else
788 return zero. */
791 is_in_import_list (char *name, struct objfile *objfile)
793 int i;
795 if (!objfile || !name || !*name)
796 return 0;
798 for (i = 0; i < objfile->import_list_size; i++)
799 if (objfile->import_list[i] && DEPRECATED_STREQ (name, objfile->import_list[i]))
800 return 1;
801 return 0;
805 /* Keep a registry of per-objfile data-pointers required by other GDB
806 modules. */
808 struct objfile_data
810 unsigned index;
813 struct objfile_data_registration
815 struct objfile_data *data;
816 struct objfile_data_registration *next;
819 struct objfile_data_registry
821 struct objfile_data_registration *registrations;
822 unsigned num_registrations;
825 static struct objfile_data_registry objfile_data_registry = { NULL, 0 };
827 const struct objfile_data *
828 register_objfile_data (void)
830 struct objfile_data_registration **curr;
832 /* Append new registration. */
833 for (curr = &objfile_data_registry.registrations;
834 *curr != NULL; curr = &(*curr)->next);
836 *curr = XMALLOC (struct objfile_data_registration);
837 (*curr)->next = NULL;
838 (*curr)->data = XMALLOC (struct objfile_data);
839 (*curr)->data->index = objfile_data_registry.num_registrations++;
841 return (*curr)->data;
844 static void
845 objfile_alloc_data (struct objfile *objfile)
847 gdb_assert (objfile->data == NULL);
848 objfile->num_data = objfile_data_registry.num_registrations;
849 objfile->data = XCALLOC (objfile->num_data, void *);
852 static void
853 objfile_free_data (struct objfile *objfile)
855 gdb_assert (objfile->data != NULL);
856 xfree (objfile->data);
857 objfile->data = NULL;
860 void
861 clear_objfile_data (struct objfile *objfile)
863 gdb_assert (objfile->data != NULL);
864 memset (objfile->data, 0, objfile->num_data * sizeof (void *));
867 void
868 set_objfile_data (struct objfile *objfile, const struct objfile_data *data,
869 void *value)
871 gdb_assert (data->index < objfile->num_data);
872 objfile->data[data->index] = value;
875 void *
876 objfile_data (struct objfile *objfile, const struct objfile_data *data)
878 gdb_assert (data->index < objfile->num_data);
879 return objfile->data[data->index];