File: | src/gnu/usr.bin/binutils/gdb/objfiles.c |
Warning: | line 645, column 5 Value stored to 'abfd' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* GDB routines for manipulating objfiles. |
2 | |
3 | Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, |
4 | 2001, 2002, 2003, 2004 Free Software Foundation, Inc. |
5 | |
6 | Contributed by Cygnus Support, using pieces from other GDB modules. |
7 | |
8 | This file is part of GDB. |
9 | |
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. |
14 | |
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. |
19 | |
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. */ |
24 | |
25 | /* This file contains support routines for creating, manipulating, and |
26 | destroying objfile structures. */ |
27 | |
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" |
36 | |
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" |
44 | |
45 | #include "breakpoint.h" |
46 | #include "block.h" |
47 | #include "dictionary.h" |
48 | #include "auxv.h" |
49 | |
50 | #include "elf/common.h" |
51 | |
52 | /* Prototypes for local functions */ |
53 | |
54 | static void objfile_alloc_data (struct objfile *objfile); |
55 | static void objfile_free_data (struct objfile *objfile); |
56 | |
57 | /* Externally visible variables that are owned by this module. |
58 | See declarations in objfile.h for more info. */ |
59 | |
60 | struct objfile *object_files; /* Linked list of all objfiles */ |
61 | struct objfile *current_objfile; /* For symbol file being read in */ |
62 | struct objfile *symfile_objfile; /* Main symbol table loaded from */ |
63 | struct objfile *rt_common_objfile; /* For runtime common symbols */ |
64 | |
65 | /* Locate all mappable sections of a BFD file. |
66 | objfile_p_char is a char * to get it through |
67 | bfd_map_over_sections; we cast it back to its proper type. */ |
68 | |
69 | #ifndef TARGET_KEEP_SECTION |
70 | #define TARGET_KEEP_SECTION(ASECT)0 0 |
71 | #endif |
72 | |
73 | /* Called via bfd_map_over_sections to build up the section table that |
74 | the objfile references. The objfile contains pointers to the start |
75 | of the table (objfile->sections) and to the first location after |
76 | the end of the table (objfile->sections_end). */ |
77 | |
78 | static void |
79 | add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect, |
80 | void *objfile_p_char) |
81 | { |
82 | struct objfile *objfile = (struct objfile *) objfile_p_char; |
83 | struct obj_section section; |
84 | flagword aflag; |
85 | |
86 | aflag = bfd_get_section_flags (abfd, asect)((asect)->flags + 0); |
87 | |
88 | if (!(aflag & SEC_ALLOC0x001) && !(TARGET_KEEP_SECTION (asect)0)) |
89 | return; |
90 | |
91 | if (0 == bfd_section_size (abfd, asect)((asect)->_raw_size)) |
92 | return; |
93 | section.offset = 0; |
94 | section.objfile = objfile; |
95 | section.the_bfd_section = asect; |
96 | section.ovly_mapped = 0; |
97 | section.addr = bfd_section_vma (abfd, asect)((asect)->vma); |
98 | section.endaddr = section.addr + bfd_section_size (abfd, asect)((asect)->_raw_size); |
99 | obstack_grow (&objfile->objfile_obstack, (char *) §ion, sizeof (section))__extension__ ({ struct obstack *__o = (&objfile->objfile_obstack ); int __len = (sizeof (section)); if (__o->next_free + __len > __o->chunk_limit) _obstack_newchunk (__o, __len); memcpy ((__o->next_free), (((char *) §ion)), (__len)); __o ->next_free += __len; (void) 0; }); |
100 | objfile->sections_end = (struct obj_section *) (((unsigned long) objfile->sections_end) + 1); |
101 | } |
102 | |
103 | /* Builds a section table for OBJFILE. |
104 | Returns 0 if OK, 1 on error (in which case bfd_error contains the |
105 | error). |
106 | |
107 | Note that while we are building the table, which goes into the |
108 | psymbol obstack, we hijack the sections_end pointer to instead hold |
109 | a count of the number of sections. When bfd_map_over_sections |
110 | returns, this count is used to compute the pointer to the end of |
111 | the sections table, which then overwrites the count. |
112 | |
113 | Also note that the OFFSET and OVLY_MAPPED in each table entry |
114 | are initialized to zero. |
115 | |
116 | Also note that if anything else writes to the psymbol obstack while |
117 | we are building the table, we're pretty much hosed. */ |
118 | |
119 | int |
120 | build_objfile_section_table (struct objfile *objfile) |
121 | { |
122 | /* objfile->sections can be already set when reading a mapped symbol |
123 | file. I believe that we do need to rebuild the section table in |
124 | this case (we rebuild other things derived from the bfd), but we |
125 | can't free the old one (it's in the objfile_obstack). So we just |
126 | waste some memory. */ |
127 | |
128 | objfile->sections_end = 0; |
129 | bfd_map_over_sections (objfile->obfd, add_to_objfile_sections, (char *) objfile); |
130 | objfile->sections = (struct obj_section *) |
131 | obstack_finish (&objfile->objfile_obstack)__extension__ ({ struct obstack *__o1 = (&objfile->objfile_obstack ); void *value; value = (void *) __o1->object_base; if (__o1 ->next_free == value) __o1->maybe_empty_object = 1; __o1 ->next_free = (((((__o1->next_free) - (char *) 0)+__o1-> alignment_mask) & ~ (__o1->alignment_mask)) + (char *) 0); if (__o1->next_free - (char *)__o1->chunk > __o1 ->chunk_limit - (char *)__o1->chunk) __o1->next_free = __o1->chunk_limit; __o1->object_base = __o1->next_free ; value; }); |
132 | objfile->sections_end = objfile->sections + (unsigned long) objfile->sections_end; |
133 | return (0); |
134 | } |
135 | |
136 | /* Given a pointer to an initialized bfd (ABFD) and some flag bits |
137 | allocate a new objfile struct, fill it in as best we can, link it |
138 | into the list of all known objfiles, and return a pointer to the |
139 | new objfile struct. |
140 | |
141 | The FLAGS word contains various bits (OBJF_*) that can be taken as |
142 | requests for specific operations. Other bits like OBJF_SHARED are |
143 | simply copied through to the new objfile flags member. */ |
144 | |
145 | /* NOTE: carlton/2003-02-04: This function is called with args NULL, 0 |
146 | by jv-lang.c, to create an artificial objfile used to hold |
147 | information about dynamically-loaded Java classes. Unfortunately, |
148 | that branch of this function doesn't get tested very frequently, so |
149 | it's prone to breakage. (E.g. at one time the name was set to NULL |
150 | in that situation, which broke a loop over all names in the dynamic |
151 | library loader.) If you change this function, please try to leave |
152 | things in a consistent state even if abfd is NULL. */ |
153 | |
154 | struct objfile * |
155 | allocate_objfile (bfd *abfd, int flags) |
156 | { |
157 | struct objfile *objfile = NULL((void*)0); |
158 | struct objfile *last_one = NULL((void*)0); |
159 | |
160 | /* If we don't support mapped symbol files, didn't ask for the file to be |
161 | mapped, or failed to open the mapped file for some reason, then revert |
162 | back to an unmapped objfile. */ |
163 | |
164 | if (objfile == NULL((void*)0)) |
165 | { |
166 | objfile = (struct objfile *) xmalloc (sizeof (struct objfile)); |
167 | memset (objfile, 0, sizeof (struct objfile)); |
168 | objfile->md = NULL((void*)0); |
169 | objfile->psymbol_cache = bcache_xmalloc (); |
170 | objfile->macro_cache = bcache_xmalloc (); |
171 | /* We could use obstack_specify_allocation here instead, but |
172 | gdb_obstack.h specifies the alloc/dealloc functions. */ |
173 | obstack_init (&objfile->objfile_obstack)_obstack_begin ((&objfile->objfile_obstack), 0, 0, (void *(*) (long)) xmalloc, (void (*) (void *)) xfree); |
174 | terminate_minimal_symbol_table (objfile); |
175 | } |
176 | |
177 | objfile_alloc_data (objfile); |
178 | |
179 | /* Update the per-objfile information that comes from the bfd, ensuring |
180 | that any data that is reference is saved in the per-objfile data |
181 | region. */ |
182 | |
183 | objfile->obfd = abfd; |
184 | if (objfile->name != NULL((void*)0)) |
185 | { |
186 | xfree (objfile->name); |
187 | } |
188 | if (abfd != NULL((void*)0)) |
189 | { |
190 | objfile->name = xstrdup (bfd_get_filename (abfd)((char *) (abfd)->filename)); |
191 | objfile->mtime = bfd_get_mtime (abfd); |
192 | |
193 | /* Build section table. */ |
194 | |
195 | if (build_objfile_section_table (objfile)) |
196 | { |
197 | error ("Can't find the file sections in `%s': %s", |
198 | objfile->name, bfd_errmsg (bfd_get_error ())); |
199 | } |
200 | } |
201 | else |
202 | { |
203 | objfile->name = xstrdup ("<<anonymous objfile>>"); |
204 | } |
205 | |
206 | /* Initialize the section indexes for this objfile, so that we can |
207 | later detect if they are used w/o being properly assigned to. */ |
208 | |
209 | objfile->sect_index_text = -1; |
210 | objfile->sect_index_data = -1; |
211 | objfile->sect_index_bss = -1; |
212 | objfile->sect_index_rodata = -1; |
213 | |
214 | /* We don't yet have a C++-specific namespace symtab. */ |
215 | |
216 | objfile->cp_namespace_symtab = NULL((void*)0); |
217 | |
218 | /* Add this file onto the tail of the linked list of other such files. */ |
219 | |
220 | objfile->next = NULL((void*)0); |
221 | if (object_files == NULL((void*)0)) |
222 | object_files = objfile; |
223 | else |
224 | { |
225 | for (last_one = object_files; |
226 | last_one->next; |
227 | last_one = last_one->next); |
228 | last_one->next = objfile; |
229 | } |
230 | |
231 | /* Save passed in flag bits. */ |
232 | objfile->flags |= flags; |
233 | |
234 | return (objfile); |
235 | } |
236 | |
237 | /* Initialize entry point information for this objfile. */ |
238 | |
239 | void |
240 | init_entry_point_info (struct objfile *objfile) |
241 | { |
242 | /* Save startup file's range of PC addresses to help blockframe.c |
243 | decide where the bottom of the stack is. */ |
244 | |
245 | if (bfd_get_file_flags (objfile->obfd)((objfile->obfd)->flags) & EXEC_P0x02) |
246 | { |
247 | /* Executable file -- record its entry point so we'll recognize |
248 | the startup file because it contains the entry point. */ |
249 | objfile->ei.entry_point = bfd_get_start_address (objfile->obfd)((objfile->obfd)->start_address); |
250 | } |
251 | else |
252 | { |
253 | /* Examination of non-executable.o files. Short-circuit this stuff. */ |
254 | objfile->ei.entry_point = INVALID_ENTRY_POINT(~0); |
255 | } |
256 | } |
257 | |
258 | /* Get current entry point address. */ |
259 | |
260 | CORE_ADDR |
261 | entry_point_address (void) |
262 | { |
263 | CORE_ADDR entry_addr = symfile_objfile ? symfile_objfile->ei.entry_point : 0; |
264 | |
265 | /* Find the address of the entry point of the program from the |
266 | auxv vector. */ |
267 | target_auxv_search (¤t_target, AT_ENTRY9, &entry_addr); |
268 | return entry_addr; |
269 | } |
270 | |
271 | /* Create the terminating entry of OBJFILE's minimal symbol table. |
272 | If OBJFILE->msymbols is zero, allocate a single entry from |
273 | OBJFILE->objfile_obstack; otherwise, just initialize |
274 | OBJFILE->msymbols[OBJFILE->minimal_symbol_count]. */ |
275 | void |
276 | terminate_minimal_symbol_table (struct objfile *objfile) |
277 | { |
278 | if (! objfile->msymbols) |
279 | objfile->msymbols = ((struct minimal_symbol *) |
280 | obstack_alloc (&objfile->objfile_obstack,__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack ); __extension__ ({ struct obstack *__o = (__h); int __len = ( (sizeof (objfile->msymbols[0]))); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len) ; ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *value; value = (void * ) __o1->object_base; if (__o1->next_free == value) __o1 ->maybe_empty_object = 1; __o1->next_free = (((((__o1-> next_free) - (char *) 0)+__o1->alignment_mask) & ~ (__o1 ->alignment_mask)) + (char *) 0); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1 ->chunk) __o1->next_free = __o1->chunk_limit; __o1-> object_base = __o1->next_free; value; }); }) |
281 | sizeof (objfile->msymbols[0]))__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack ); __extension__ ({ struct obstack *__o = (__h); int __len = ( (sizeof (objfile->msymbols[0]))); if (__o->chunk_limit - __o->next_free < __len) _obstack_newchunk (__o, __len) ; ((__o)->next_free += (__len)); (void) 0; }); __extension__ ({ struct obstack *__o1 = (__h); void *value; value = (void * ) __o1->object_base; if (__o1->next_free == value) __o1 ->maybe_empty_object = 1; __o1->next_free = (((((__o1-> next_free) - (char *) 0)+__o1->alignment_mask) & ~ (__o1 ->alignment_mask)) + (char *) 0); if (__o1->next_free - (char *)__o1->chunk > __o1->chunk_limit - (char *)__o1 ->chunk) __o1->next_free = __o1->chunk_limit; __o1-> object_base = __o1->next_free; value; }); })); |
282 | |
283 | { |
284 | struct minimal_symbol *m |
285 | = &objfile->msymbols[objfile->minimal_symbol_count]; |
286 | |
287 | memset (m, 0, sizeof (*m)); |
288 | /* Don't rely on these enumeration values being 0's. */ |
289 | MSYMBOL_TYPE (m)(m)->type = mst_unknown; |
290 | SYMBOL_INIT_LANGUAGE_SPECIFIC (m, language_unknown)(symbol_init_language_specific (&(m)->ginfo, (language_unknown ))); |
291 | } |
292 | } |
293 | |
294 | |
295 | /* Put one object file before a specified on in the global list. |
296 | This can be used to make sure an object file is destroyed before |
297 | another when using ALL_OBJFILES_SAFE to free all objfiles. */ |
298 | void |
299 | put_objfile_before (struct objfile *objfile, struct objfile *before_this) |
300 | { |
301 | struct objfile **objp; |
302 | |
303 | unlink_objfile (objfile); |
304 | |
305 | for (objp = &object_files; *objp != NULL((void*)0); objp = &((*objp)->next)) |
306 | { |
307 | if (*objp == before_this) |
308 | { |
309 | objfile->next = *objp; |
310 | *objp = objfile; |
311 | return; |
312 | } |
313 | } |
314 | |
315 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c", __LINE__315, |
316 | "put_objfile_before: before objfile not in list"); |
317 | } |
318 | |
319 | /* Put OBJFILE at the front of the list. */ |
320 | |
321 | void |
322 | objfile_to_front (struct objfile *objfile) |
323 | { |
324 | struct objfile **objp; |
325 | for (objp = &object_files; *objp != NULL((void*)0); objp = &((*objp)->next)) |
326 | { |
327 | if (*objp == objfile) |
328 | { |
329 | /* Unhook it from where it is. */ |
330 | *objp = objfile->next; |
331 | /* Put it in the front. */ |
332 | objfile->next = object_files; |
333 | object_files = objfile; |
334 | break; |
335 | } |
336 | } |
337 | } |
338 | |
339 | /* Unlink OBJFILE from the list of known objfiles, if it is found in the |
340 | list. |
341 | |
342 | It is not a bug, or error, to call this function if OBJFILE is not known |
343 | to be in the current list. This is done in the case of mapped objfiles, |
344 | for example, just to ensure that the mapped objfile doesn't appear twice |
345 | in the list. Since the list is threaded, linking in a mapped objfile |
346 | twice would create a circular list. |
347 | |
348 | If OBJFILE turns out to be in the list, we zap it's NEXT pointer after |
349 | unlinking it, just to ensure that we have completely severed any linkages |
350 | between the OBJFILE and the list. */ |
351 | |
352 | void |
353 | unlink_objfile (struct objfile *objfile) |
354 | { |
355 | struct objfile **objpp; |
356 | |
357 | for (objpp = &object_files; *objpp != NULL((void*)0); objpp = &((*objpp)->next)) |
358 | { |
359 | if (*objpp == objfile) |
360 | { |
361 | *objpp = (*objpp)->next; |
362 | objfile->next = NULL((void*)0); |
363 | return; |
364 | } |
365 | } |
366 | |
367 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c", __LINE__367, |
368 | "unlink_objfile: objfile already unlinked"); |
369 | } |
370 | |
371 | |
372 | /* Destroy an objfile and all the symtabs and psymtabs under it. Note |
373 | that as much as possible is allocated on the objfile_obstack |
374 | so that the memory can be efficiently freed. |
375 | |
376 | Things which we do NOT free because they are not in malloc'd memory |
377 | or not in memory specific to the objfile include: |
378 | |
379 | objfile -> sf |
380 | |
381 | FIXME: If the objfile is using reusable symbol information (via mmalloc), |
382 | then we need to take into account the fact that more than one process |
383 | may be using the symbol information at the same time (when mmalloc is |
384 | extended to support cooperative locking). When more than one process |
385 | is using the mapped symbol info, we need to be more careful about when |
386 | we free objects in the reusable area. */ |
387 | |
388 | void |
389 | free_objfile (struct objfile *objfile) |
390 | { |
391 | if (objfile->separate_debug_objfile) |
392 | { |
393 | free_objfile (objfile->separate_debug_objfile); |
394 | } |
395 | |
396 | if (objfile->separate_debug_objfile_backlink) |
397 | { |
398 | /* We freed the separate debug file, make sure the base objfile |
399 | doesn't reference it. */ |
400 | objfile->separate_debug_objfile_backlink->separate_debug_objfile = NULL((void*)0); |
401 | } |
402 | |
403 | /* First do any symbol file specific actions required when we are |
404 | finished with a particular symbol file. Note that if the objfile |
405 | is using reusable symbol information (via mmalloc) then each of |
406 | these routines is responsible for doing the correct thing, either |
407 | freeing things which are valid only during this particular gdb |
408 | execution, or leaving them to be reused during the next one. */ |
409 | |
410 | if (objfile->sf != NULL((void*)0)) |
411 | { |
412 | (*objfile->sf->sym_finish) (objfile); |
413 | } |
414 | |
415 | /* We always close the bfd. */ |
416 | |
417 | if (objfile->obfd != NULL((void*)0)) |
418 | { |
419 | char *name = bfd_get_filename (objfile->obfd)((char *) (objfile->obfd)->filename); |
420 | if (!bfd_close (objfile->obfd)) |
421 | warning ("cannot close \"%s\": %s", |
422 | name, bfd_errmsg (bfd_get_error ())); |
423 | xfree (name); |
424 | } |
425 | |
426 | /* Remove it from the chain of all objfiles. */ |
427 | |
428 | unlink_objfile (objfile); |
429 | |
430 | /* If we are going to free the runtime common objfile, mark it |
431 | as unallocated. */ |
432 | |
433 | if (objfile == rt_common_objfile) |
434 | rt_common_objfile = NULL((void*)0); |
435 | |
436 | /* Before the symbol table code was redone to make it easier to |
437 | selectively load and remove information particular to a specific |
438 | linkage unit, gdb used to do these things whenever the monolithic |
439 | symbol table was blown away. How much still needs to be done |
440 | is unknown, but we play it safe for now and keep each action until |
441 | it is shown to be no longer needed. */ |
442 | |
443 | /* I *think* all our callers call clear_symtab_users. If so, no need |
444 | to call this here. */ |
445 | clear_pc_function_cache (); |
446 | |
447 | /* The last thing we do is free the objfile struct itself. */ |
448 | |
449 | objfile_free_data (objfile); |
450 | if (objfile->name != NULL((void*)0)) |
451 | { |
452 | xfree (objfile->name); |
453 | } |
454 | if (objfile->global_psymbols.list) |
455 | xfree (objfile->global_psymbols.list); |
456 | if (objfile->static_psymbols.list) |
457 | xfree (objfile->static_psymbols.list); |
458 | /* Free the obstacks for non-reusable objfiles */ |
459 | bcache_xfree (objfile->psymbol_cache); |
460 | bcache_xfree (objfile->macro_cache); |
461 | if (objfile->demangled_names_hash) |
462 | htab_delete (objfile->demangled_names_hash); |
463 | obstack_free (&objfile->objfile_obstack, 0)__extension__ ({ struct obstack *__o = (&objfile->objfile_obstack ); void *__obj = (0); if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit) __o->next_free = __o ->object_base = __obj; else (obstack_free) (__o, __obj); } ); |
464 | xfree (objfile); |
465 | objfile = NULL((void*)0); |
466 | } |
467 | |
468 | static void |
469 | do_free_objfile_cleanup (void *obj) |
470 | { |
471 | free_objfile (obj); |
472 | } |
473 | |
474 | struct cleanup * |
475 | make_cleanup_free_objfile (struct objfile *obj) |
476 | { |
477 | return make_cleanup (do_free_objfile_cleanup, obj); |
478 | } |
479 | |
480 | /* Free all the object files at once and clean up their users. */ |
481 | |
482 | void |
483 | free_all_objfiles (void) |
484 | { |
485 | struct objfile *objfile, *temp; |
486 | |
487 | ALL_OBJFILES_SAFE (objfile, temp)for ((objfile) = object_files; (objfile) != ((void*)0)? ((temp )=(objfile)->next,1) :0; (objfile) = (temp)) |
488 | { |
489 | free_objfile (objfile); |
490 | } |
491 | clear_symtab_users (); |
492 | } |
493 | |
494 | /* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS |
495 | entries in new_offsets. */ |
496 | void |
497 | objfile_relocate (struct objfile *objfile, struct section_offsets *new_offsets) |
498 | { |
499 | struct section_offsets *delta = |
500 | ((struct section_offsets *) |
501 | alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections))__builtin_alloca((sizeof (struct section_offsets) + sizeof (( (struct section_offsets *) 0)->offsets) * ((objfile->num_sections )-1)))); |
502 | |
503 | { |
504 | int i; |
505 | int something_changed = 0; |
506 | for (i = 0; i < objfile->num_sections; ++i) |
507 | { |
508 | delta->offsets[i] = |
509 | ANOFFSET (new_offsets, i)((i == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 509, "Section index is uninitialized"), -1) : new_offsets-> offsets[i]) - ANOFFSET (objfile->section_offsets, i)((i == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 509, "Section index is uninitialized"), -1) : objfile->section_offsets ->offsets[i]); |
510 | if (ANOFFSET (delta, i)((i == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 510, "Section index is uninitialized"), -1) : delta->offsets [i]) != 0) |
511 | something_changed = 1; |
512 | } |
513 | if (!something_changed) |
514 | return; |
515 | } |
516 | |
517 | /* OK, get all the symtabs. */ |
518 | { |
519 | struct symtab *s; |
520 | |
521 | ALL_OBJFILE_SYMTABS (objfile, s)for ((s) = (objfile) -> symtabs; (s) != ((void*)0); (s) = ( s) -> next) |
522 | { |
523 | struct linetable *l; |
524 | struct blockvector *bv; |
525 | int i; |
526 | |
527 | /* First the line table. */ |
528 | l = LINETABLE (s)(s)->linetable; |
529 | if (l) |
530 | { |
531 | for (i = 0; i < l->nitems; ++i) |
532 | l->item[i].pc += ANOFFSET (delta, s->block_line_section)((s->block_line_section == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 532, "Section index is uninitialized"), -1) : delta->offsets [s->block_line_section]); |
533 | } |
534 | |
535 | /* Don't relocate a shared blockvector more than once. */ |
536 | if (!s->primary) |
537 | continue; |
538 | |
539 | bv = BLOCKVECTOR (s)(s)->blockvector; |
540 | for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv)(bv)->nblocks; ++i) |
541 | { |
542 | struct block *b; |
543 | struct symbol *sym; |
544 | struct dict_iterator iter; |
545 | |
546 | b = BLOCKVECTOR_BLOCK (bv, i)(bv)->block[i]; |
547 | BLOCK_START (b)(b)->startaddr += ANOFFSET (delta, s->block_line_section)((s->block_line_section == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 547, "Section index is uninitialized"), -1) : delta->offsets [s->block_line_section]); |
548 | BLOCK_END (b)(b)->endaddr += ANOFFSET (delta, s->block_line_section)((s->block_line_section == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 548, "Section index is uninitialized"), -1) : delta->offsets [s->block_line_section]); |
549 | |
550 | ALL_BLOCK_SYMBOLS (b, iter, sym)for ((sym) = dict_iterator_first (((b)->dict), &(iter) ); (sym); (sym) = dict_iterator_next (&(iter))) |
551 | { |
552 | fixup_symbol_section (sym, objfile); |
553 | |
554 | /* The RS6000 code from which this was taken skipped |
555 | any symbols in STRUCT_DOMAIN or UNDEF_DOMAIN. |
556 | But I'm leaving out that test, on the theory that |
557 | they can't possibly pass the tests below. */ |
558 | if ((SYMBOL_CLASS (sym)(sym)->aclass == LOC_LABEL |
559 | || SYMBOL_CLASS (sym)(sym)->aclass == LOC_STATIC |
560 | || SYMBOL_CLASS (sym)(sym)->aclass == LOC_INDIRECT) |
561 | && SYMBOL_SECTION (sym)(sym)->ginfo.section >= 0) |
562 | { |
563 | SYMBOL_VALUE_ADDRESS (sym)(sym)->ginfo.value.address += |
564 | ANOFFSET (delta, SYMBOL_SECTION (sym))(((sym)->ginfo.section == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 564, "Section index is uninitialized"), -1) : delta->offsets [(sym)->ginfo.section]); |
565 | } |
566 | #ifdef MIPS_EFI_SYMBOL_NAME |
567 | /* Relocate Extra Function Info for ecoff. */ |
568 | |
569 | else if (SYMBOL_CLASS (sym)(sym)->aclass == LOC_CONST |
570 | && SYMBOL_DOMAIN (sym)(sym)->domain == LABEL_DOMAIN |
571 | && strcmp (DEPRECATED_SYMBOL_NAME (sym)(sym)->ginfo.name, MIPS_EFI_SYMBOL_NAME) == 0) |
572 | ecoff_relocate_efi (sym, ANOFFSET (delta,((s->block_line_section == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 573, "Section index is uninitialized"), -1) : delta->offsets [s->block_line_section]) |
573 | s->block_line_section)((s->block_line_section == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 573, "Section index is uninitialized"), -1) : delta->offsets [s->block_line_section])); |
574 | #endif |
575 | } |
576 | } |
577 | } |
578 | } |
579 | |
580 | { |
581 | struct partial_symtab *p; |
582 | |
583 | ALL_OBJFILE_PSYMTABS (objfile, p)for ((p) = (objfile) -> psymtabs; (p) != ((void*)0); (p) = (p) -> next) |
584 | { |
585 | p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile))((((objfile->sect_index_text == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 585, "sect_index_text not initialized"), -1) : objfile-> sect_index_text) == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 585, "Section index is uninitialized"), -1) : delta->offsets [((objfile->sect_index_text == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 585, "sect_index_text not initialized"), -1) : objfile-> sect_index_text)]); |
586 | p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile))((((objfile->sect_index_text == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 586, "sect_index_text not initialized"), -1) : objfile-> sect_index_text) == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 586, "Section index is uninitialized"), -1) : delta->offsets [((objfile->sect_index_text == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 586, "sect_index_text not initialized"), -1) : objfile-> sect_index_text)]); |
587 | } |
588 | } |
589 | |
590 | { |
591 | struct partial_symbol **psym; |
592 | |
593 | for (psym = objfile->global_psymbols.list; |
594 | psym < objfile->global_psymbols.next; |
595 | psym++) |
596 | { |
597 | fixup_psymbol_section (*psym, objfile); |
598 | if (SYMBOL_SECTION (*psym)(*psym)->ginfo.section >= 0) |
599 | SYMBOL_VALUE_ADDRESS (*psym)(*psym)->ginfo.value.address += ANOFFSET (delta,(((*psym)->ginfo.section == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 600, "Section index is uninitialized"), -1) : delta->offsets [(*psym)->ginfo.section]) |
600 | SYMBOL_SECTION (*psym))(((*psym)->ginfo.section == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 600, "Section index is uninitialized"), -1) : delta->offsets [(*psym)->ginfo.section]); |
601 | } |
602 | for (psym = objfile->static_psymbols.list; |
603 | psym < objfile->static_psymbols.next; |
604 | psym++) |
605 | { |
606 | fixup_psymbol_section (*psym, objfile); |
607 | if (SYMBOL_SECTION (*psym)(*psym)->ginfo.section >= 0) |
608 | SYMBOL_VALUE_ADDRESS (*psym)(*psym)->ginfo.value.address += ANOFFSET (delta,(((*psym)->ginfo.section == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 609, "Section index is uninitialized"), -1) : delta->offsets [(*psym)->ginfo.section]) |
609 | SYMBOL_SECTION (*psym))(((*psym)->ginfo.section == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 609, "Section index is uninitialized"), -1) : delta->offsets [(*psym)->ginfo.section]); |
610 | } |
611 | } |
612 | |
613 | { |
614 | struct minimal_symbol *msym; |
615 | ALL_OBJFILE_MSYMBOLS (objfile, msym)for ((msym) = (objfile) -> msymbols; (msym)->ginfo.name != ((void*)0); (msym)++) |
616 | if (SYMBOL_SECTION (msym)(msym)->ginfo.section >= 0) |
617 | SYMBOL_VALUE_ADDRESS (msym)(msym)->ginfo.value.address += ANOFFSET (delta, SYMBOL_SECTION (msym))(((msym)->ginfo.section == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 617, "Section index is uninitialized"), -1) : delta->offsets [(msym)->ginfo.section]); |
618 | } |
619 | /* Relocating different sections by different amounts may cause the symbols |
620 | to be out of order. */ |
621 | msymbols_sort (objfile); |
622 | |
623 | { |
624 | int i; |
625 | for (i = 0; i < objfile->num_sections; ++i) |
626 | (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i)((i == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 626, "Section index is uninitialized"), -1) : new_offsets-> offsets[i]); |
627 | } |
628 | |
629 | if (objfile->ei.entry_point != ~(CORE_ADDR) 0) |
630 | { |
631 | /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT |
632 | only as a fallback. */ |
633 | struct obj_section *s; |
634 | s = find_pc_section (objfile->ei.entry_point); |
635 | if (s) |
636 | objfile->ei.entry_point += ANOFFSET (delta, s->the_bfd_section->index)((s->the_bfd_section->index == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 636, "Section index is uninitialized"), -1) : delta->offsets [s->the_bfd_section->index]); |
637 | else |
638 | objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile))((((objfile->sect_index_text == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 638, "sect_index_text not initialized"), -1) : objfile-> sect_index_text) == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 638, "Section index is uninitialized"), -1) : delta->offsets [((objfile->sect_index_text == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 638, "sect_index_text not initialized"), -1) : objfile-> sect_index_text)]); |
639 | } |
640 | |
641 | { |
642 | struct obj_section *s; |
643 | bfd *abfd; |
644 | |
645 | abfd = objfile->obfd; |
Value stored to 'abfd' is never read | |
646 | |
647 | ALL_OBJFILE_OSECTIONS (objfile, s)for (s = objfile->sections; s < objfile->sections_end ; s++) |
648 | { |
649 | int idx = s->the_bfd_section->index; |
650 | |
651 | s->addr += ANOFFSET (delta, idx)((idx == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 651, "Section index is uninitialized"), -1) : delta->offsets [idx]); |
652 | s->endaddr += ANOFFSET (delta, idx)((idx == -1) ? (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c" , 652, "Section index is uninitialized"), -1) : delta->offsets [idx]); |
653 | } |
654 | } |
655 | |
656 | /* Relocate breakpoints as necessary, after things are relocated. */ |
657 | breakpoint_re_set (); |
658 | } |
659 | |
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. */ |
663 | |
664 | int |
665 | have_partial_symbols (void) |
666 | { |
667 | struct objfile *ofp; |
668 | |
669 | ALL_OBJFILES (ofp)for ((ofp) = object_files; (ofp) != ((void*)0); (ofp) = (ofp) ->next) |
670 | { |
671 | if (ofp->psymtabs != NULL((void*)0)) |
672 | { |
673 | return 1; |
674 | } |
675 | } |
676 | return 0; |
677 | } |
678 | |
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. */ |
682 | |
683 | int |
684 | have_full_symbols (void) |
685 | { |
686 | struct objfile *ofp; |
687 | |
688 | ALL_OBJFILES (ofp)for ((ofp) = object_files; (ofp) != ((void*)0); (ofp) = (ofp) ->next) |
689 | { |
690 | if (ofp->symtabs != NULL((void*)0)) |
691 | { |
692 | return 1; |
693 | } |
694 | } |
695 | return 0; |
696 | } |
697 | |
698 | |
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. |
702 | */ |
703 | void |
704 | objfile_purge_solibs (void) |
705 | { |
706 | struct objfile *objf; |
707 | struct objfile *temp; |
708 | |
709 | ALL_OBJFILES_SAFE (objf, temp)for ((objf) = object_files; (objf) != ((void*)0)? ((temp)=(objf )->next,1) :0; (objf) = (temp)) |
710 | { |
711 | /* We assume that the solib package has been purged already, or will |
712 | be soon. |
713 | */ |
714 | if (!(objf->flags & OBJF_USERLOADED(1 << 5)) && (objf->flags & OBJF_SHARED(1 << 3))) |
715 | free_objfile (objf); |
716 | } |
717 | } |
718 | |
719 | |
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. */ |
723 | |
724 | int |
725 | have_minimal_symbols (void) |
726 | { |
727 | struct objfile *ofp; |
728 | |
729 | ALL_OBJFILES (ofp)for ((ofp) = object_files; (ofp) != ((void*)0); (ofp) = (ofp) ->next) |
730 | { |
731 | if (ofp->minimal_symbol_count > 0) |
732 | { |
733 | return 1; |
734 | } |
735 | } |
736 | return 0; |
737 | } |
738 | |
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". */ |
744 | |
745 | struct obj_section * |
746 | find_pc_sect_section (CORE_ADDR pc, struct bfd_section *section) |
747 | { |
748 | struct obj_section *s; |
749 | struct objfile *objfile; |
750 | |
751 | ALL_OBJSECTIONS (objfile, s)for ((objfile) = object_files; (objfile) != ((void*)0); (objfile ) = (objfile)->next) for (s = objfile->sections; s < objfile->sections_end; s++) |
752 | if ((section == 0 || section == s->the_bfd_section) && |
753 | s->addr <= pc && pc < s->endaddr) |
754 | return (s); |
755 | |
756 | return (NULL((void*)0)); |
757 | } |
758 | |
759 | /* Returns a section whose range includes PC or NULL if none found. |
760 | Backward compatibility, no section. */ |
761 | |
762 | struct obj_section * |
763 | find_pc_section (CORE_ADDR pc) |
764 | { |
765 | return find_pc_sect_section (pc, find_pc_mapped_section (pc)); |
766 | } |
767 | |
768 | |
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. */ |
772 | |
773 | int |
774 | in_plt_section (CORE_ADDR pc, char *name) |
775 | { |
776 | struct obj_section *s; |
777 | int retval = 0; |
778 | |
779 | s = find_pc_section (pc); |
780 | |
781 | retval = (s != NULL((void*)0) |
782 | && s->the_bfd_section->name != NULL((void*)0) |
783 | && strcmp (s->the_bfd_section->name, ".plt") == 0); |
784 | return (retval); |
785 | } |
786 | |
787 | /* Return nonzero if NAME is in the import list of OBJFILE. Else |
788 | return zero. */ |
789 | |
790 | int |
791 | is_in_import_list (char *name, struct objfile *objfile) |
792 | { |
793 | int i; |
794 | |
795 | if (!objfile || !name || !*name) |
796 | return 0; |
797 | |
798 | for (i = 0; i < objfile->import_list_size; i++) |
799 | if (objfile->import_list[i] && DEPRECATED_STREQ (name, objfile->import_list[i])(strcmp ((name), (objfile->import_list[i])) == 0)) |
800 | return 1; |
801 | return 0; |
802 | } |
803 | |
804 | |
805 | /* Keep a registry of per-objfile data-pointers required by other GDB |
806 | modules. */ |
807 | |
808 | struct objfile_data |
809 | { |
810 | unsigned index; |
811 | }; |
812 | |
813 | struct objfile_data_registration |
814 | { |
815 | struct objfile_data *data; |
816 | struct objfile_data_registration *next; |
817 | }; |
818 | |
819 | struct objfile_data_registry |
820 | { |
821 | struct objfile_data_registration *registrations; |
822 | unsigned num_registrations; |
823 | }; |
824 | |
825 | static struct objfile_data_registry objfile_data_registry = { NULL((void*)0), 0 }; |
826 | |
827 | const struct objfile_data * |
828 | register_objfile_data (void) |
829 | { |
830 | struct objfile_data_registration **curr; |
831 | |
832 | /* Append new registration. */ |
833 | for (curr = &objfile_data_registry.registrations; |
834 | *curr != NULL((void*)0); curr = &(*curr)->next); |
835 | |
836 | *curr = XMALLOC (struct objfile_data_registration)((struct objfile_data_registration*) xmalloc (sizeof (struct objfile_data_registration ))); |
837 | (*curr)->next = NULL((void*)0); |
838 | (*curr)->data = XMALLOC (struct objfile_data)((struct objfile_data*) xmalloc (sizeof (struct objfile_data) )); |
839 | (*curr)->data->index = objfile_data_registry.num_registrations++; |
840 | |
841 | return (*curr)->data; |
842 | } |
843 | |
844 | static void |
845 | objfile_alloc_data (struct objfile *objfile) |
846 | { |
847 | gdb_assert (objfile->data == NULL)((void) ((objfile->data == ((void*)0)) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c", 847, "%s: Assertion `%s' failed." , __PRETTY_FUNCTION__, "objfile->data == NULL"), 0))); |
848 | objfile->num_data = objfile_data_registry.num_registrations; |
849 | objfile->data = XCALLOC (objfile->num_data, void *)((void **) xcalloc ((objfile->num_data), sizeof (void *))); |
850 | } |
851 | |
852 | static void |
853 | objfile_free_data (struct objfile *objfile) |
854 | { |
855 | gdb_assert (objfile->data != NULL)((void) ((objfile->data != ((void*)0)) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c", 855, "%s: Assertion `%s' failed." , __PRETTY_FUNCTION__, "objfile->data != NULL"), 0))); |
856 | xfree (objfile->data); |
857 | objfile->data = NULL((void*)0); |
858 | } |
859 | |
860 | void |
861 | clear_objfile_data (struct objfile *objfile) |
862 | { |
863 | gdb_assert (objfile->data != NULL)((void) ((objfile->data != ((void*)0)) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c", 863, "%s: Assertion `%s' failed." , __PRETTY_FUNCTION__, "objfile->data != NULL"), 0))); |
864 | memset (objfile->data, 0, objfile->num_data * sizeof (void *)); |
865 | } |
866 | |
867 | void |
868 | set_objfile_data (struct objfile *objfile, const struct objfile_data *data, |
869 | void *value) |
870 | { |
871 | gdb_assert (data->index < objfile->num_data)((void) ((data->index < objfile->num_data) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c", 871, "%s: Assertion `%s' failed." , __PRETTY_FUNCTION__, "data->index < objfile->num_data" ), 0))); |
872 | objfile->data[data->index] = value; |
873 | } |
874 | |
875 | void * |
876 | objfile_data (struct objfile *objfile, const struct objfile_data *data) |
877 | { |
878 | gdb_assert (data->index < objfile->num_data)((void) ((data->index < objfile->num_data) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/objfiles.c", 878, "%s: Assertion `%s' failed." , __PRETTY_FUNCTION__, "data->index < objfile->num_data" ), 0))); |
879 | return objfile->data[data->index]; |
880 | } |