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
;
234 /* Initialize entry point information for this objfile. */
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
);
250 /* Examination of non-executable.o files. Short-circuit this stuff. */
251 objfile
->ei
.entry_point
= INVALID_ENTRY_POINT
;
253 objfile
->ei
.deprecated_entry_file_lowpc
= INVALID_ENTRY_LOWPC
;
254 objfile
->ei
.deprecated_entry_file_highpc
= INVALID_ENTRY_HIGHPC
;
255 objfile
->ei
.entry_func_lowpc
= INVALID_ENTRY_LOWPC
;
256 objfile
->ei
.entry_func_highpc
= INVALID_ENTRY_HIGHPC
;
257 objfile
->ei
.main_func_lowpc
= INVALID_ENTRY_LOWPC
;
258 objfile
->ei
.main_func_highpc
= INVALID_ENTRY_HIGHPC
;
261 /* Get current entry point address. */
264 entry_point_address (void)
266 return symfile_objfile
? symfile_objfile
->ei
.entry_point
: 0;
269 /* Create the terminating entry of OBJFILE's minimal symbol table.
270 If OBJFILE->msymbols is zero, allocate a single entry from
271 OBJFILE->objfile_obstack; otherwise, just initialize
272 OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */
274 terminate_minimal_symbol_table (struct objfile
*objfile
)
276 if (! objfile
->msymbols
)
277 objfile
->msymbols
= ((struct minimal_symbol
*)
278 obstack_alloc (&objfile
->objfile_obstack
,
279 sizeof (objfile
->msymbols
[0])));
282 struct minimal_symbol
*m
283 = &objfile
->msymbols
[objfile
->minimal_symbol_count
];
285 memset (m
, 0, sizeof (*m
));
286 DEPRECATED_SYMBOL_NAME (m
) = NULL
;
287 SYMBOL_VALUE_ADDRESS (m
) = 0;
288 MSYMBOL_INFO (m
) = NULL
;
289 MSYMBOL_SIZE (m
) = 0;
290 MSYMBOL_TYPE (m
) = mst_unknown
;
291 SYMBOL_INIT_LANGUAGE_SPECIFIC (m
, language_unknown
);
296 /* Put one object file before a specified on in the global list.
297 This can be used to make sure an object file is destroyed before
298 another when using ALL_OBJFILES_SAFE to free all objfiles. */
300 put_objfile_before (struct objfile
*objfile
, struct objfile
*before_this
)
302 struct objfile
**objp
;
304 unlink_objfile (objfile
);
306 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
308 if (*objp
== before_this
)
310 objfile
->next
= *objp
;
316 internal_error (__FILE__
, __LINE__
,
317 "put_objfile_before: before objfile not in list");
320 /* Put OBJFILE at the front of the list. */
323 objfile_to_front (struct objfile
*objfile
)
325 struct objfile
**objp
;
326 for (objp
= &object_files
; *objp
!= NULL
; objp
= &((*objp
)->next
))
328 if (*objp
== objfile
)
330 /* Unhook it from where it is. */
331 *objp
= objfile
->next
;
332 /* Put it in the front. */
333 objfile
->next
= object_files
;
334 object_files
= objfile
;
340 /* Unlink OBJFILE from the list of known objfiles, if it is found in the
343 It is not a bug, or error, to call this function if OBJFILE is not known
344 to be in the current list. This is done in the case of mapped objfiles,
345 for example, just to ensure that the mapped objfile doesn't appear twice
346 in the list. Since the list is threaded, linking in a mapped objfile
347 twice would create a circular list.
349 If OBJFILE turns out to be in the list, we zap it's NEXT pointer after
350 unlinking it, just to ensure that we have completely severed any linkages
351 between the OBJFILE and the list. */
354 unlink_objfile (struct objfile
*objfile
)
356 struct objfile
**objpp
;
358 for (objpp
= &object_files
; *objpp
!= NULL
; objpp
= &((*objpp
)->next
))
360 if (*objpp
== objfile
)
362 *objpp
= (*objpp
)->next
;
363 objfile
->next
= NULL
;
368 internal_error (__FILE__
, __LINE__
,
369 "unlink_objfile: objfile already unlinked");
373 /* Destroy an objfile and all the symtabs and psymtabs under it. Note
374 that as much as possible is allocated on the objfile_obstack
375 so that the memory can be efficiently freed.
377 Things which we do NOT free because they are not in malloc'd memory
378 or not in memory specific to the objfile include:
382 FIXME: If the objfile is using reusable symbol information (via mmalloc),
383 then we need to take into account the fact that more than one process
384 may be using the symbol information at the same time (when mmalloc is
385 extended to support cooperative locking). When more than one process
386 is using the mapped symbol info, we need to be more careful about when
387 we free objects in the reusable area. */
390 free_objfile (struct objfile
*objfile
)
392 if (objfile
->separate_debug_objfile
)
394 free_objfile (objfile
->separate_debug_objfile
);
397 if (objfile
->separate_debug_objfile_backlink
)
399 /* We freed the separate debug file, make sure the base objfile
400 doesn't reference it. */
401 objfile
->separate_debug_objfile_backlink
->separate_debug_objfile
= NULL
;
404 /* First do any symbol file specific actions required when we are
405 finished with a particular symbol file. Note that if the objfile
406 is using reusable symbol information (via mmalloc) then each of
407 these routines is responsible for doing the correct thing, either
408 freeing things which are valid only during this particular gdb
409 execution, or leaving them to be reused during the next one. */
411 if (objfile
->sf
!= NULL
)
413 (*objfile
->sf
->sym_finish
) (objfile
);
416 /* We always close the bfd. */
418 if (objfile
->obfd
!= NULL
)
420 char *name
= bfd_get_filename (objfile
->obfd
);
421 if (!bfd_close (objfile
->obfd
))
422 warning ("cannot close \"%s\": %s",
423 name
, bfd_errmsg (bfd_get_error ()));
427 /* Remove it from the chain of all objfiles. */
429 unlink_objfile (objfile
);
431 /* If we are going to free the runtime common objfile, mark it
434 if (objfile
== rt_common_objfile
)
435 rt_common_objfile
= NULL
;
437 /* Before the symbol table code was redone to make it easier to
438 selectively load and remove information particular to a specific
439 linkage unit, gdb used to do these things whenever the monolithic
440 symbol table was blown away. How much still needs to be done
441 is unknown, but we play it safe for now and keep each action until
442 it is shown to be no longer needed. */
444 /* I *think* all our callers call clear_symtab_users. If so, no need
445 to call this here. */
446 clear_pc_function_cache ();
448 /* The last thing we do is free the objfile struct itself. */
450 objfile_free_data (objfile
);
451 if (objfile
->name
!= NULL
)
453 xmfree (objfile
->md
, objfile
->name
);
455 if (objfile
->global_psymbols
.list
)
456 xmfree (objfile
->md
, objfile
->global_psymbols
.list
);
457 if (objfile
->static_psymbols
.list
)
458 xmfree (objfile
->md
, objfile
->static_psymbols
.list
);
459 /* Free the obstacks for non-reusable objfiles */
460 bcache_xfree (objfile
->psymbol_cache
);
461 bcache_xfree (objfile
->macro_cache
);
462 if (objfile
->demangled_names_hash
)
463 htab_delete (objfile
->demangled_names_hash
);
464 obstack_free (&objfile
->objfile_obstack
, 0);
465 xmfree (objfile
->md
, objfile
);
470 do_free_objfile_cleanup (void *obj
)
476 make_cleanup_free_objfile (struct objfile
*obj
)
478 return make_cleanup (do_free_objfile_cleanup
, obj
);
481 /* Free all the object files at once and clean up their users. */
484 free_all_objfiles (void)
486 struct objfile
*objfile
, *temp
;
488 ALL_OBJFILES_SAFE (objfile
, temp
)
490 free_objfile (objfile
);
492 clear_symtab_users ();
495 /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
496 entries in new_offsets. */
498 objfile_relocate (struct objfile
*objfile
, struct section_offsets
*new_offsets
)
500 struct section_offsets
*delta
=
501 ((struct section_offsets
*)
502 alloca (SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
)));
506 int something_changed
= 0;
507 for (i
= 0; i
< objfile
->num_sections
; ++i
)
510 ANOFFSET (new_offsets
, i
) - ANOFFSET (objfile
->section_offsets
, i
);
511 if (ANOFFSET (delta
, i
) != 0)
512 something_changed
= 1;
514 if (!something_changed
)
518 /* OK, get all the symtabs. */
522 ALL_OBJFILE_SYMTABS (objfile
, s
)
525 struct blockvector
*bv
;
528 /* First the line table. */
532 for (i
= 0; i
< l
->nitems
; ++i
)
533 l
->item
[i
].pc
+= ANOFFSET (delta
, s
->block_line_section
);
536 /* Don't relocate a shared blockvector more than once. */
540 bv
= BLOCKVECTOR (s
);
541 for (i
= 0; i
< BLOCKVECTOR_NBLOCKS (bv
); ++i
)
545 struct dict_iterator iter
;
547 b
= BLOCKVECTOR_BLOCK (bv
, i
);
548 BLOCK_START (b
) += ANOFFSET (delta
, s
->block_line_section
);
549 BLOCK_END (b
) += ANOFFSET (delta
, s
->block_line_section
);
551 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
553 fixup_symbol_section (sym
, objfile
);
555 /* The RS6000 code from which this was taken skipped
556 any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN.
557 But I'm leaving out that test, on the theory that
558 they can't possibly pass the tests below. */
559 if ((SYMBOL_CLASS (sym
) == LOC_LABEL
560 || SYMBOL_CLASS (sym
) == LOC_STATIC
561 || SYMBOL_CLASS (sym
) == LOC_INDIRECT
)
562 && SYMBOL_SECTION (sym
) >= 0)
564 SYMBOL_VALUE_ADDRESS (sym
) +=
565 ANOFFSET (delta
, SYMBOL_SECTION (sym
));
567 #ifdef MIPS_EFI_SYMBOL_NAME
568 /* Relocate Extra Function Info for ecoff. */
570 else if (SYMBOL_CLASS (sym
) == LOC_CONST
571 && SYMBOL_DOMAIN (sym
) == LABEL_DOMAIN
572 && strcmp (DEPRECATED_SYMBOL_NAME (sym
), MIPS_EFI_SYMBOL_NAME
) == 0)
573 ecoff_relocate_efi (sym
, ANOFFSET (delta
,
574 s
->block_line_section
));
582 struct partial_symtab
*p
;
584 ALL_OBJFILE_PSYMTABS (objfile
, p
)
586 p
->textlow
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
587 p
->texthigh
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
592 struct partial_symbol
**psym
;
594 for (psym
= objfile
->global_psymbols
.list
;
595 psym
< objfile
->global_psymbols
.next
;
598 fixup_psymbol_section (*psym
, objfile
);
599 if (SYMBOL_SECTION (*psym
) >= 0)
600 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
601 SYMBOL_SECTION (*psym
));
603 for (psym
= objfile
->static_psymbols
.list
;
604 psym
< objfile
->static_psymbols
.next
;
607 fixup_psymbol_section (*psym
, objfile
);
608 if (SYMBOL_SECTION (*psym
) >= 0)
609 SYMBOL_VALUE_ADDRESS (*psym
) += ANOFFSET (delta
,
610 SYMBOL_SECTION (*psym
));
615 struct minimal_symbol
*msym
;
616 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
617 if (SYMBOL_SECTION (msym
) >= 0)
618 SYMBOL_VALUE_ADDRESS (msym
) += ANOFFSET (delta
, SYMBOL_SECTION (msym
));
620 /* Relocating different sections by different amounts may cause the symbols
621 to be out of order. */
622 msymbols_sort (objfile
);
626 for (i
= 0; i
< objfile
->num_sections
; ++i
)
627 (objfile
->section_offsets
)->offsets
[i
] = ANOFFSET (new_offsets
, i
);
630 if (objfile
->ei
.entry_point
!= ~(CORE_ADDR
) 0)
632 /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
633 only as a fallback. */
634 struct obj_section
*s
;
635 s
= find_pc_section (objfile
->ei
.entry_point
);
637 objfile
->ei
.entry_point
+= ANOFFSET (delta
, s
->the_bfd_section
->index
);
639 objfile
->ei
.entry_point
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
643 struct obj_section
*s
;
646 abfd
= objfile
->obfd
;
648 ALL_OBJFILE_OSECTIONS (objfile
, s
)
650 int idx
= s
->the_bfd_section
->index
;
652 s
->addr
+= ANOFFSET (delta
, idx
);
653 s
->endaddr
+= ANOFFSET (delta
, idx
);
657 if (objfile
->ei
.entry_func_lowpc
!= INVALID_ENTRY_LOWPC
)
659 objfile
->ei
.entry_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
660 objfile
->ei
.entry_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
663 if (objfile
->ei
.deprecated_entry_file_lowpc
!= INVALID_ENTRY_LOWPC
)
665 objfile
->ei
.deprecated_entry_file_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
666 objfile
->ei
.deprecated_entry_file_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
669 if (objfile
->ei
.main_func_lowpc
!= INVALID_ENTRY_LOWPC
)
671 objfile
->ei
.main_func_lowpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
672 objfile
->ei
.main_func_highpc
+= ANOFFSET (delta
, SECT_OFF_TEXT (objfile
));
675 /* Relocate breakpoints as necessary, after things are relocated. */
676 breakpoint_re_set ();
679 /* Many places in gdb want to test just to see if we have any partial
680 symbols available. This function returns zero if none are currently
681 available, nonzero otherwise. */
684 have_partial_symbols (void)
690 if (ofp
->psymtabs
!= NULL
)
698 /* Many places in gdb want to test just to see if we have any full
699 symbols available. This function returns zero if none are currently
700 available, nonzero otherwise. */
703 have_full_symbols (void)
709 if (ofp
->symtabs
!= NULL
)
718 /* This operations deletes all objfile entries that represent solibs that
719 weren't explicitly loaded by the user, via e.g., the add-symbol-file
723 objfile_purge_solibs (void)
725 struct objfile
*objf
;
726 struct objfile
*temp
;
728 ALL_OBJFILES_SAFE (objf
, temp
)
730 /* We assume that the solib package has been purged already, or will
733 if (!(objf
->flags
& OBJF_USERLOADED
) && (objf
->flags
& OBJF_SHARED
))
739 /* Many places in gdb want to test just to see if we have any minimal
740 symbols available. This function returns zero if none are currently
741 available, nonzero otherwise. */
744 have_minimal_symbols (void)
750 if (ofp
->minimal_symbol_count
> 0)
758 /* Returns a section whose range includes PC and SECTION, or NULL if
759 none found. Note the distinction between the return type, struct
760 obj_section (which is defined in gdb), and the input type "struct
761 bfd_section" (which is a bfd-defined data type). The obj_section
762 contains a pointer to the "struct bfd_section". */
765 find_pc_sect_section (CORE_ADDR pc
, struct bfd_section
*section
)
767 struct obj_section
*s
;
768 struct objfile
*objfile
;
770 ALL_OBJSECTIONS (objfile
, s
)
771 if ((section
== 0 || section
== s
->the_bfd_section
) &&
772 s
->addr
<= pc
&& pc
< s
->endaddr
)
778 /* Returns a section whose range includes PC or NULL if none found.
779 Backward compatibility, no section. */
782 find_pc_section (CORE_ADDR pc
)
784 return find_pc_sect_section (pc
, find_pc_mapped_section (pc
));
788 /* In SVR4, we recognize a trampoline by it's section name.
789 That is, if the pc is in a section named ".plt" then we are in
793 in_plt_section (CORE_ADDR pc
, char *name
)
795 struct obj_section
*s
;
798 s
= find_pc_section (pc
);
801 && s
->the_bfd_section
->name
!= NULL
802 && strcmp (s
->the_bfd_section
->name
, ".plt") == 0);
806 /* Return nonzero if NAME is in the import list of OBJFILE. Else
810 is_in_import_list (char *name
, struct objfile
*objfile
)
814 if (!objfile
|| !name
|| !*name
)
817 for (i
= 0; i
< objfile
->import_list_size
; i
++)
818 if (objfile
->import_list
[i
] && DEPRECATED_STREQ (name
, objfile
->import_list
[i
]))
824 /* Keep a registry of per-objfile data-pointers required by other GDB
832 struct objfile_data_registration
834 struct objfile_data
*data
;
835 struct objfile_data_registration
*next
;
838 struct objfile_data_registry
840 struct objfile_data_registration
*registrations
;
841 unsigned num_registrations
;
844 static struct objfile_data_registry objfile_data_registry
= { NULL
, 0 };
846 const struct objfile_data
*
847 register_objfile_data (void)
849 struct objfile_data_registration
**curr
;
851 /* Append new registration. */
852 for (curr
= &objfile_data_registry
.registrations
;
853 *curr
!= NULL
; curr
= &(*curr
)->next
);
855 *curr
= XMALLOC (struct objfile_data_registration
);
856 (*curr
)->next
= NULL
;
857 (*curr
)->data
= XMALLOC (struct objfile_data
);
858 (*curr
)->data
->index
= objfile_data_registry
.num_registrations
++;
860 return (*curr
)->data
;
864 objfile_alloc_data (struct objfile
*objfile
)
866 gdb_assert (objfile
->data
== NULL
);
867 objfile
->num_data
= objfile_data_registry
.num_registrations
;
868 objfile
->data
= XCALLOC (objfile
->num_data
, void *);
872 objfile_free_data (struct objfile
*objfile
)
874 gdb_assert (objfile
->data
!= NULL
);
875 xfree (objfile
->data
);
876 objfile
->data
= NULL
;
880 clear_objfile_data (struct objfile
*objfile
)
882 gdb_assert (objfile
->data
!= NULL
);
883 memset (objfile
->data
, 0, objfile
->num_data
* sizeof (void *));
887 set_objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
,
890 gdb_assert (data
->index
< objfile
->num_data
);
891 objfile
->data
[data
->index
] = value
;
895 objfile_data (struct objfile
*objfile
, const struct objfile_data
*data
)
897 gdb_assert (data
->index
< objfile
->num_data
);
898 return objfile
->data
[data
->index
];