File: | src/gnu/usr.bin/binutils/gdb/buildsym.c |
Warning: | line 977, column 8 Null pointer passed as 1st argument to string copy function |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* Support routines for building symbol tables in GDB's internal format. | |||
2 | Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, | |||
3 | 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 | |||
4 | Free Software Foundation, Inc. | |||
5 | ||||
6 | This file is part of GDB. | |||
7 | ||||
8 | This program is free software; you can redistribute it and/or modify | |||
9 | it under the terms of the GNU General Public License as published by | |||
10 | the Free Software Foundation; either version 2 of the License, or | |||
11 | (at your option) any later version. | |||
12 | ||||
13 | This program is distributed in the hope that it will be useful, | |||
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
16 | GNU General Public License for more details. | |||
17 | ||||
18 | You should have received a copy of the GNU General Public License | |||
19 | along with this program; if not, write to the Free Software | |||
20 | Foundation, Inc., 59 Temple Place - Suite 330, | |||
21 | Boston, MA 02111-1307, USA. */ | |||
22 | ||||
23 | /* This module provides subroutines used for creating and adding to | |||
24 | the symbol table. These routines are called from various symbol- | |||
25 | file-reading routines. | |||
26 | ||||
27 | Routines to support specific debugging information formats (stabs, | |||
28 | DWARF, etc) belong somewhere else. */ | |||
29 | ||||
30 | #include "defs.h" | |||
31 | #include "bfd.h" | |||
32 | #include "gdb_obstack.h" | |||
33 | #include "symtab.h" | |||
34 | #include "symfile.h" | |||
35 | #include "objfiles.h" | |||
36 | #include "gdbtypes.h" | |||
37 | #include "gdb_assert.h" | |||
38 | #include "complaints.h" | |||
39 | #include "gdb_string.h" | |||
40 | #include "expression.h" /* For "enum exp_opcode" used by... */ | |||
41 | #include "bcache.h" | |||
42 | #include "filenames.h" /* For DOSish file names */ | |||
43 | #include "macrotab.h" | |||
44 | #include "demangle.h" /* Needed by SYMBOL_INIT_DEMANGLED_NAME. */ | |||
45 | #include "block.h" | |||
46 | #include "cp-support.h" | |||
47 | #include "dictionary.h" | |||
48 | ||||
49 | /* Ask buildsym.h to define the vars it normally declares `extern'. */ | |||
50 | #define EXTERN | |||
51 | /**/ | |||
52 | #include "buildsym.h" /* Our own declarations */ | |||
53 | #undef EXTERN | |||
54 | ||||
55 | /* For cleanup_undefined_types and finish_global_stabs (somewhat | |||
56 | questionable--see comment where we call them). */ | |||
57 | ||||
58 | #include "stabsread.h" | |||
59 | ||||
60 | /* List of free `struct pending' structures for reuse. */ | |||
61 | ||||
62 | static struct pending *free_pendings; | |||
63 | ||||
64 | /* Non-zero if symtab has line number info. This prevents an | |||
65 | otherwise empty symtab from being tossed. */ | |||
66 | ||||
67 | static int have_line_numbers; | |||
68 | ||||
69 | static int compare_line_numbers (const void *ln1p, const void *ln2p); | |||
70 | ||||
71 | ||||
72 | /* Initial sizes of data structures. These are realloc'd larger if | |||
73 | needed, and realloc'd down to the size actually used, when | |||
74 | completed. */ | |||
75 | ||||
76 | #define INITIAL_CONTEXT_STACK_SIZE10 10 | |||
77 | #define INITIAL_LINE_VECTOR_LENGTH1000 1000 | |||
78 | ||||
79 | ||||
80 | /* maintain the lists of symbols and blocks */ | |||
81 | ||||
82 | /* Add a pending list to free_pendings. */ | |||
83 | void | |||
84 | add_free_pendings (struct pending *list) | |||
85 | { | |||
86 | struct pending *link = list; | |||
87 | ||||
88 | if (list) | |||
89 | { | |||
90 | while (link->next) link = link->next; | |||
91 | link->next = free_pendings; | |||
92 | free_pendings = list; | |||
93 | } | |||
94 | } | |||
95 | ||||
96 | /* Add a symbol to one of the lists of symbols. While we're at it, if | |||
97 | we're in the C++ case and don't have full namespace debugging info, | |||
98 | check to see if it references an anonymous namespace; if so, add an | |||
99 | appropriate using directive. */ | |||
100 | ||||
101 | void | |||
102 | add_symbol_to_list (struct symbol *symbol, struct pending **listhead) | |||
103 | { | |||
104 | struct pending *link; | |||
105 | ||||
106 | /* If this is an alias for another symbol, don't add it. */ | |||
107 | if (symbol->ginfo.name && symbol->ginfo.name[0] == '#') | |||
108 | return; | |||
109 | ||||
110 | /* We keep PENDINGSIZE symbols in each link of the list. If we | |||
111 | don't have a link with room in it, add a new link. */ | |||
112 | if (*listhead == NULL((void*)0) || (*listhead)->nsyms == PENDINGSIZE100) | |||
113 | { | |||
114 | if (free_pendings) | |||
115 | { | |||
116 | link = free_pendings; | |||
117 | free_pendings = link->next; | |||
118 | } | |||
119 | else | |||
120 | { | |||
121 | link = (struct pending *) xmalloc (sizeof (struct pending)); | |||
122 | } | |||
123 | ||||
124 | link->next = *listhead; | |||
125 | *listhead = link; | |||
126 | link->nsyms = 0; | |||
127 | } | |||
128 | ||||
129 | (*listhead)->symbol[(*listhead)->nsyms++] = symbol; | |||
130 | ||||
131 | /* Check to see if we might need to look for a mention of anonymous | |||
132 | namespaces. */ | |||
133 | ||||
134 | if (SYMBOL_LANGUAGE (symbol)(symbol)->ginfo.language == language_cplus) | |||
135 | cp_scan_for_anonymous_namespaces (symbol); | |||
136 | } | |||
137 | ||||
138 | /* Find a symbol named NAME on a LIST. NAME need not be | |||
139 | '\0'-terminated; LENGTH is the length of the name. */ | |||
140 | ||||
141 | struct symbol * | |||
142 | find_symbol_in_list (struct pending *list, char *name, int length) | |||
143 | { | |||
144 | int j; | |||
145 | char *pp; | |||
146 | ||||
147 | while (list != NULL((void*)0)) | |||
148 | { | |||
149 | for (j = list->nsyms; --j >= 0;) | |||
150 | { | |||
151 | pp = DEPRECATED_SYMBOL_NAME (list->symbol[j])(list->symbol[j])->ginfo.name; | |||
152 | if (*pp == *name && strncmp (pp, name, length) == 0 && | |||
153 | pp[length] == '\0') | |||
154 | { | |||
155 | return (list->symbol[j]); | |||
156 | } | |||
157 | } | |||
158 | list = list->next; | |||
159 | } | |||
160 | return (NULL((void*)0)); | |||
161 | } | |||
162 | ||||
163 | /* At end of reading syms, or in case of quit, really free as many | |||
164 | `struct pending's as we can easily find. */ | |||
165 | ||||
166 | void | |||
167 | really_free_pendings (void *dummy) | |||
168 | { | |||
169 | struct pending *next, *next1; | |||
170 | ||||
171 | for (next = free_pendings; next; next = next1) | |||
172 | { | |||
173 | next1 = next->next; | |||
174 | xfree ((void *) next); | |||
175 | } | |||
176 | free_pendings = NULL((void*)0); | |||
177 | ||||
178 | free_pending_blocks (); | |||
179 | ||||
180 | for (next = file_symbols; next != NULL((void*)0); next = next1) | |||
181 | { | |||
182 | next1 = next->next; | |||
183 | xfree ((void *) next); | |||
184 | } | |||
185 | file_symbols = NULL((void*)0); | |||
186 | ||||
187 | for (next = global_symbols; next != NULL((void*)0); next = next1) | |||
188 | { | |||
189 | next1 = next->next; | |||
190 | xfree ((void *) next); | |||
191 | } | |||
192 | global_symbols = NULL((void*)0); | |||
193 | ||||
194 | if (pending_macros) | |||
195 | free_macro_table (pending_macros); | |||
196 | } | |||
197 | ||||
198 | /* This function is called to discard any pending blocks. */ | |||
199 | ||||
200 | void | |||
201 | free_pending_blocks (void) | |||
202 | { | |||
203 | #if 0 /* Now we make the links in the | |||
204 | objfile_obstack, so don't free | |||
205 | them. */ | |||
206 | struct pending_block *bnext, *bnext1; | |||
207 | ||||
208 | for (bnext = pending_blocks; bnext; bnext = bnext1) | |||
209 | { | |||
210 | bnext1 = bnext->next; | |||
211 | xfree ((void *) bnext); | |||
212 | } | |||
213 | #endif | |||
214 | pending_blocks = NULL((void*)0); | |||
215 | } | |||
216 | ||||
217 | /* Take one of the lists of symbols and make a block from it. Keep | |||
218 | the order the symbols have in the list (reversed from the input | |||
219 | file). Put the block on the list of pending blocks. */ | |||
220 | ||||
221 | void | |||
222 | finish_block (struct symbol *symbol, struct pending **listhead, | |||
223 | struct pending_block *old_blocks, | |||
224 | CORE_ADDR start, CORE_ADDR end, | |||
225 | struct objfile *objfile) | |||
226 | { | |||
227 | struct pending *next, *next1; | |||
228 | struct block *block; | |||
229 | struct pending_block *pblock; | |||
230 | struct pending_block *opblock; | |||
231 | ||||
232 | block = allocate_block (&objfile->objfile_obstack); | |||
233 | ||||
234 | if (symbol) | |||
235 | { | |||
236 | BLOCK_DICT (block)(block)->dict = dict_create_linear (&objfile->objfile_obstack, | |||
237 | *listhead); | |||
238 | } | |||
239 | else | |||
240 | { | |||
241 | BLOCK_DICT (block)(block)->dict = dict_create_hashed (&objfile->objfile_obstack, | |||
242 | *listhead); | |||
243 | } | |||
244 | ||||
245 | BLOCK_START (block)(block)->startaddr = start; | |||
246 | BLOCK_END (block)(block)->endaddr = end; | |||
247 | /* Superblock filled in when containing block is made */ | |||
248 | BLOCK_SUPERBLOCK (block)(block)->superblock = NULL((void*)0); | |||
249 | BLOCK_NAMESPACE (block)(block)->language_specific.cplus_specific.namespace = NULL((void*)0); | |||
250 | ||||
251 | BLOCK_GCC_COMPILED (block)(block)->gcc_compile_flag = processing_gcc_compilation; | |||
252 | ||||
253 | /* Put the block in as the value of the symbol that names it. */ | |||
254 | ||||
255 | if (symbol) | |||
256 | { | |||
257 | struct type *ftype = SYMBOL_TYPE (symbol)(symbol)->type; | |||
258 | struct dict_iterator iter; | |||
259 | SYMBOL_BLOCK_VALUE (symbol)(symbol)->ginfo.value.block = block; | |||
260 | BLOCK_FUNCTION (block)(block)->function = symbol; | |||
261 | ||||
262 | if (TYPE_NFIELDS (ftype)(ftype)->main_type->nfields <= 0) | |||
263 | { | |||
264 | /* No parameter type information is recorded with the | |||
265 | function's type. Set that from the type of the | |||
266 | parameter symbols. */ | |||
267 | int nparams = 0, iparams; | |||
268 | struct symbol *sym; | |||
269 | ALL_BLOCK_SYMBOLS (block, iter, sym)for ((sym) = dict_iterator_first (((block)->dict), &(iter )); (sym); (sym) = dict_iterator_next (&(iter))) | |||
270 | { | |||
271 | switch (SYMBOL_CLASS (sym)(sym)->aclass) | |||
272 | { | |||
273 | case LOC_ARG: | |||
274 | case LOC_REF_ARG: | |||
275 | case LOC_REGPARM: | |||
276 | case LOC_REGPARM_ADDR: | |||
277 | case LOC_BASEREG_ARG: | |||
278 | case LOC_LOCAL_ARG: | |||
279 | case LOC_COMPUTED_ARG: | |||
280 | nparams++; | |||
281 | break; | |||
282 | case LOC_UNDEF: | |||
283 | case LOC_CONST: | |||
284 | case LOC_STATIC: | |||
285 | case LOC_INDIRECT: | |||
286 | case LOC_REGISTER: | |||
287 | case LOC_LOCAL: | |||
288 | case LOC_TYPEDEF: | |||
289 | case LOC_LABEL: | |||
290 | case LOC_BLOCK: | |||
291 | case LOC_CONST_BYTES: | |||
292 | case LOC_BASEREG: | |||
293 | case LOC_UNRESOLVED: | |||
294 | case LOC_OPTIMIZED_OUT: | |||
295 | case LOC_COMPUTED: | |||
296 | default: | |||
297 | break; | |||
298 | } | |||
299 | } | |||
300 | if (nparams > 0) | |||
301 | { | |||
302 | TYPE_NFIELDS (ftype)(ftype)->main_type->nfields = nparams; | |||
303 | TYPE_FIELDS (ftype)(ftype)->main_type->fields = (struct field *) | |||
304 | TYPE_ALLOC (ftype, nparams * sizeof (struct field))((ftype)->main_type->objfile != ((void*)0) ? __extension__ ({ struct obstack *__h = (&(ftype)->main_type->objfile -> objfile_obstack); __extension__ ({ struct obstack *__o = (__h); int __len = ((nparams * sizeof (struct field))); 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; }); }) : xmalloc (nparams * sizeof (struct field))); | |||
305 | ||||
306 | iparams = 0; | |||
307 | ALL_BLOCK_SYMBOLS (block, iter, sym)for ((sym) = dict_iterator_first (((block)->dict), &(iter )); (sym); (sym) = dict_iterator_next (&(iter))) | |||
308 | { | |||
309 | if (iparams == nparams) | |||
310 | break; | |||
311 | ||||
312 | switch (SYMBOL_CLASS (sym)(sym)->aclass) | |||
313 | { | |||
314 | case LOC_ARG: | |||
315 | case LOC_REF_ARG: | |||
316 | case LOC_REGPARM: | |||
317 | case LOC_REGPARM_ADDR: | |||
318 | case LOC_BASEREG_ARG: | |||
319 | case LOC_LOCAL_ARG: | |||
320 | case LOC_COMPUTED_ARG: | |||
321 | TYPE_FIELD_TYPE (ftype, iparams)(((ftype)->main_type->fields[iparams]).type) = SYMBOL_TYPE (sym)(sym)->type; | |||
322 | TYPE_FIELD_ARTIFICIAL (ftype, iparams)(((ftype)->main_type->fields[iparams]).artificial) = 0; | |||
323 | iparams++; | |||
324 | break; | |||
325 | case LOC_UNDEF: | |||
326 | case LOC_CONST: | |||
327 | case LOC_STATIC: | |||
328 | case LOC_INDIRECT: | |||
329 | case LOC_REGISTER: | |||
330 | case LOC_LOCAL: | |||
331 | case LOC_TYPEDEF: | |||
332 | case LOC_LABEL: | |||
333 | case LOC_BLOCK: | |||
334 | case LOC_CONST_BYTES: | |||
335 | case LOC_BASEREG: | |||
336 | case LOC_UNRESOLVED: | |||
337 | case LOC_OPTIMIZED_OUT: | |||
338 | case LOC_COMPUTED: | |||
339 | default: | |||
340 | break; | |||
341 | } | |||
342 | } | |||
343 | } | |||
344 | } | |||
345 | ||||
346 | /* If we're in the C++ case, set the block's scope. */ | |||
347 | if (SYMBOL_LANGUAGE (symbol)(symbol)->ginfo.language == language_cplus) | |||
348 | { | |||
349 | cp_set_block_scope (symbol, block, &objfile->objfile_obstack); | |||
350 | } | |||
351 | } | |||
352 | else | |||
353 | { | |||
354 | BLOCK_FUNCTION (block)(block)->function = NULL((void*)0); | |||
355 | } | |||
356 | ||||
357 | /* Now "free" the links of the list, and empty the list. */ | |||
358 | ||||
359 | for (next = *listhead; next; next = next1) | |||
360 | { | |||
361 | next1 = next->next; | |||
362 | next->next = free_pendings; | |||
363 | free_pendings = next; | |||
364 | } | |||
365 | *listhead = NULL((void*)0); | |||
366 | ||||
367 | #if 1 | |||
368 | /* Check to be sure that the blocks have an end address that is | |||
369 | greater than starting address */ | |||
370 | ||||
371 | if (BLOCK_END (block)(block)->endaddr < BLOCK_START (block)(block)->startaddr) | |||
372 | { | |||
373 | if (symbol) | |||
374 | { | |||
375 | complaint (&symfile_complaints, | |||
376 | "block end address less than block start address in %s (patched it)", | |||
377 | SYMBOL_PRINT_NAME (symbol)(demangle ? (symbol_natural_name (&(symbol)->ginfo)) : (symbol)->ginfo.name)); | |||
378 | } | |||
379 | else | |||
380 | { | |||
381 | complaint (&symfile_complaints, | |||
382 | "block end address 0x%s less than block start address 0x%s (patched it)", | |||
383 | paddr_nz (BLOCK_END (block)(block)->endaddr), paddr_nz (BLOCK_START (block)(block)->startaddr)); | |||
384 | } | |||
385 | /* Better than nothing */ | |||
386 | BLOCK_END (block)(block)->endaddr = BLOCK_START (block)(block)->startaddr; | |||
387 | } | |||
388 | #endif | |||
389 | ||||
390 | /* Install this block as the superblock of all blocks made since the | |||
391 | start of this scope that don't have superblocks yet. */ | |||
392 | ||||
393 | opblock = NULL((void*)0); | |||
394 | for (pblock = pending_blocks; | |||
395 | pblock && pblock != old_blocks; | |||
396 | pblock = pblock->next) | |||
397 | { | |||
398 | if (BLOCK_SUPERBLOCK (pblock->block)(pblock->block)->superblock == NULL((void*)0)) | |||
399 | { | |||
400 | #if 1 | |||
401 | /* Check to be sure the blocks are nested as we receive | |||
402 | them. If the compiler/assembler/linker work, this just | |||
403 | burns a small amount of time. */ | |||
404 | if (BLOCK_START (pblock->block)(pblock->block)->startaddr < BLOCK_START (block)(block)->startaddr || | |||
405 | BLOCK_END (pblock->block)(pblock->block)->endaddr > BLOCK_END (block)(block)->endaddr) | |||
406 | { | |||
407 | if (symbol) | |||
408 | { | |||
409 | complaint (&symfile_complaints, | |||
410 | "inner block not inside outer block in %s", | |||
411 | SYMBOL_PRINT_NAME (symbol)(demangle ? (symbol_natural_name (&(symbol)->ginfo)) : (symbol)->ginfo.name)); | |||
412 | } | |||
413 | else | |||
414 | { | |||
415 | complaint (&symfile_complaints, | |||
416 | "inner block (0x%s-0x%s) not inside outer block (0x%s-0x%s)", | |||
417 | paddr_nz (BLOCK_START (pblock->block)(pblock->block)->startaddr), | |||
418 | paddr_nz (BLOCK_END (pblock->block)(pblock->block)->endaddr), | |||
419 | paddr_nz (BLOCK_START (block)(block)->startaddr), | |||
420 | paddr_nz (BLOCK_END (block)(block)->endaddr)); | |||
421 | } | |||
422 | if (BLOCK_START (pblock->block)(pblock->block)->startaddr < BLOCK_START (block)(block)->startaddr) | |||
423 | BLOCK_START (pblock->block)(pblock->block)->startaddr = BLOCK_START (block)(block)->startaddr; | |||
424 | if (BLOCK_END (pblock->block)(pblock->block)->endaddr > BLOCK_END (block)(block)->endaddr) | |||
425 | BLOCK_END (pblock->block)(pblock->block)->endaddr = BLOCK_END (block)(block)->endaddr; | |||
426 | } | |||
427 | #endif | |||
428 | BLOCK_SUPERBLOCK (pblock->block)(pblock->block)->superblock = block; | |||
429 | } | |||
430 | opblock = pblock; | |||
431 | } | |||
432 | ||||
433 | record_pending_block (objfile, block, opblock); | |||
434 | } | |||
435 | ||||
436 | ||||
437 | /* Record BLOCK on the list of all blocks in the file. Put it after | |||
438 | OPBLOCK, or at the beginning if opblock is NULL. This puts the | |||
439 | block in the list after all its subblocks. | |||
440 | ||||
441 | Allocate the pending block struct in the objfile_obstack to save | |||
442 | time. This wastes a little space. FIXME: Is it worth it? */ | |||
443 | ||||
444 | void | |||
445 | record_pending_block (struct objfile *objfile, struct block *block, | |||
446 | struct pending_block *opblock) | |||
447 | { | |||
448 | struct pending_block *pblock; | |||
449 | ||||
450 | pblock = (struct pending_block *) | |||
451 | obstack_alloc (&objfile->objfile_obstack, sizeof (struct pending_block))__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack ); __extension__ ({ struct obstack *__o = (__h); int __len = ( (sizeof (struct pending_block))); 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; }); }); | |||
452 | pblock->block = block; | |||
453 | if (opblock) | |||
454 | { | |||
455 | pblock->next = opblock->next; | |||
456 | opblock->next = pblock; | |||
457 | } | |||
458 | else | |||
459 | { | |||
460 | pblock->next = pending_blocks; | |||
461 | pending_blocks = pblock; | |||
462 | } | |||
463 | } | |||
464 | ||||
465 | static struct blockvector * | |||
466 | make_blockvector (struct objfile *objfile) | |||
467 | { | |||
468 | struct pending_block *next; | |||
469 | struct blockvector *blockvector; | |||
470 | int i; | |||
471 | ||||
472 | /* Count the length of the list of blocks. */ | |||
473 | ||||
474 | for (next = pending_blocks, i = 0; next; next = next->next, i++) | |||
475 | {; | |||
476 | } | |||
477 | ||||
478 | blockvector = (struct blockvector *) | |||
479 | obstack_alloc (&objfile->objfile_obstack,__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack ); __extension__ ({ struct obstack *__o = (__h); int __len = ( ((sizeof (struct blockvector) + (i - 1) * sizeof (struct block *)))); 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; }); }) | |||
480 | (sizeof (struct blockvector)__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack ); __extension__ ({ struct obstack *__o = (__h); int __len = ( ((sizeof (struct blockvector) + (i - 1) * sizeof (struct block *)))); 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; }); }) | |||
481 | + (i - 1) * sizeof (struct block *)))__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack ); __extension__ ({ struct obstack *__o = (__h); int __len = ( ((sizeof (struct blockvector) + (i - 1) * sizeof (struct block *)))); 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; }); }); | |||
482 | ||||
483 | /* Copy the blocks into the blockvector. This is done in reverse | |||
484 | order, which happens to put the blocks into the proper order | |||
485 | (ascending starting address). finish_block has hair to insert | |||
486 | each block into the list after its subblocks in order to make | |||
487 | sure this is true. */ | |||
488 | ||||
489 | BLOCKVECTOR_NBLOCKS (blockvector)(blockvector)->nblocks = i; | |||
490 | for (next = pending_blocks; next; next = next->next) | |||
491 | { | |||
492 | BLOCKVECTOR_BLOCK (blockvector, --i)(blockvector)->block[--i] = next->block; | |||
493 | } | |||
494 | ||||
495 | #if 0 /* Now we make the links in the | |||
496 | obstack, so don't free them. */ | |||
497 | /* Now free the links of the list, and empty the list. */ | |||
498 | ||||
499 | for (next = pending_blocks; next; next = next1) | |||
500 | { | |||
501 | next1 = next->next; | |||
502 | xfree (next); | |||
503 | } | |||
504 | #endif | |||
505 | pending_blocks = NULL((void*)0); | |||
506 | ||||
507 | #if 1 /* FIXME, shut this off after a while | |||
508 | to speed up symbol reading. */ | |||
509 | /* Some compilers output blocks in the wrong order, but we depend on | |||
510 | their being in the right order so we can binary search. Check the | |||
511 | order and moan about it. FIXME. */ | |||
512 | if (BLOCKVECTOR_NBLOCKS (blockvector)(blockvector)->nblocks > 1) | |||
513 | { | |||
514 | for (i = 1; i < BLOCKVECTOR_NBLOCKS (blockvector)(blockvector)->nblocks; i++) | |||
515 | { | |||
516 | if (BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i - 1))((blockvector)->block[i - 1])->startaddr | |||
517 | > BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i))((blockvector)->block[i])->startaddr) | |||
518 | { | |||
519 | CORE_ADDR start | |||
520 | = BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i))((blockvector)->block[i])->startaddr; | |||
521 | ||||
522 | complaint (&symfile_complaints, "block at %s out of order", | |||
523 | hex_string ((LONGESTlong) start)); | |||
524 | } | |||
525 | } | |||
526 | } | |||
527 | #endif | |||
528 | ||||
529 | return (blockvector); | |||
530 | } | |||
531 | ||||
532 | /* Start recording information about source code that came from an | |||
533 | included (or otherwise merged-in) source file with a different | |||
534 | name. NAME is the name of the file (cannot be NULL), DIRNAME is | |||
535 | the directory in which it resides (or NULL if not known). */ | |||
536 | ||||
537 | void | |||
538 | start_subfile (char *name, char *dirname) | |||
539 | { | |||
540 | struct subfile *subfile; | |||
541 | ||||
542 | /* See if this subfile is already known as a subfile of the current | |||
543 | main source file. */ | |||
544 | ||||
545 | for (subfile = subfiles; subfile; subfile = subfile->next) | |||
546 | { | |||
547 | if (FILENAME_CMP (subfile->name, name)strcmp(subfile->name, name) == 0) | |||
548 | { | |||
549 | current_subfile = subfile; | |||
550 | return; | |||
551 | } | |||
552 | } | |||
553 | ||||
554 | /* This subfile is not known. Add an entry for it. Make an entry | |||
555 | for this subfile in the list of all subfiles of the current main | |||
556 | source file. */ | |||
557 | ||||
558 | subfile = (struct subfile *) xmalloc (sizeof (struct subfile)); | |||
559 | memset ((char *) subfile, 0, sizeof (struct subfile)); | |||
560 | subfile->next = subfiles; | |||
561 | subfiles = subfile; | |||
562 | current_subfile = subfile; | |||
563 | ||||
564 | /* Save its name and compilation directory name */ | |||
565 | subfile->name = (name == NULL((void*)0)) ? NULL((void*)0) : savestring (name, strlen (name)); | |||
566 | subfile->dirname = | |||
567 | (dirname == NULL((void*)0)) ? NULL((void*)0) : savestring (dirname, strlen (dirname)); | |||
568 | ||||
569 | /* Initialize line-number recording for this subfile. */ | |||
570 | subfile->line_vector = NULL((void*)0); | |||
571 | ||||
572 | /* Default the source language to whatever can be deduced from the | |||
573 | filename. If nothing can be deduced (such as for a C/C++ include | |||
574 | file with a ".h" extension), then inherit whatever language the | |||
575 | previous subfile had. This kludgery is necessary because there | |||
576 | is no standard way in some object formats to record the source | |||
577 | language. Also, when symtabs are allocated we try to deduce a | |||
578 | language then as well, but it is too late for us to use that | |||
579 | information while reading symbols, since symtabs aren't allocated | |||
580 | until after all the symbols have been processed for a given | |||
581 | source file. */ | |||
582 | ||||
583 | subfile->language = deduce_language_from_filename (subfile->name); | |||
584 | if (subfile->language == language_unknown && | |||
585 | subfile->next != NULL((void*)0)) | |||
586 | { | |||
587 | subfile->language = subfile->next->language; | |||
588 | } | |||
589 | ||||
590 | /* Initialize the debug format string to NULL. We may supply it | |||
591 | later via a call to record_debugformat. */ | |||
592 | subfile->debugformat = NULL((void*)0); | |||
593 | ||||
594 | /* If the filename of this subfile ends in .C, then change the | |||
595 | language of any pending subfiles from C to C++. We also accept | |||
596 | any other C++ suffixes accepted by deduce_language_from_filename. */ | |||
597 | /* Likewise for f2c. */ | |||
598 | ||||
599 | if (subfile->name) | |||
600 | { | |||
601 | struct subfile *s; | |||
602 | enum language sublang = deduce_language_from_filename (subfile->name); | |||
603 | ||||
604 | if (sublang == language_cplus || sublang == language_fortran) | |||
605 | for (s = subfiles; s != NULL((void*)0); s = s->next) | |||
606 | if (s->language == language_c) | |||
607 | s->language = sublang; | |||
608 | } | |||
609 | ||||
610 | /* And patch up this file if necessary. */ | |||
611 | if (subfile->language == language_c | |||
612 | && subfile->next != NULL((void*)0) | |||
613 | && (subfile->next->language == language_cplus | |||
614 | || subfile->next->language == language_fortran)) | |||
615 | { | |||
616 | subfile->language = subfile->next->language; | |||
617 | } | |||
618 | } | |||
619 | ||||
620 | /* For stabs readers, the first N_SO symbol is assumed to be the | |||
621 | source file name, and the subfile struct is initialized using that | |||
622 | assumption. If another N_SO symbol is later seen, immediately | |||
623 | following the first one, then the first one is assumed to be the | |||
624 | directory name and the second one is really the source file name. | |||
625 | ||||
626 | So we have to patch up the subfile struct by moving the old name | |||
627 | value to dirname and remembering the new name. Some sanity | |||
628 | checking is performed to ensure that the state of the subfile | |||
629 | struct is reasonable and that the old name we are assuming to be a | |||
630 | directory name actually is (by checking for a trailing '/'). */ | |||
631 | ||||
632 | void | |||
633 | patch_subfile_names (struct subfile *subfile, char *name) | |||
634 | { | |||
635 | if (subfile != NULL((void*)0) && subfile->dirname == NULL((void*)0) && subfile->name != NULL((void*)0) | |||
636 | && subfile->name[strlen (subfile->name) - 1] == '/') | |||
637 | { | |||
638 | subfile->dirname = subfile->name; | |||
639 | subfile->name = savestring (name, strlen (name)); | |||
640 | last_source_file = name; | |||
641 | ||||
642 | /* Default the source language to whatever can be deduced from | |||
643 | the filename. If nothing can be deduced (such as for a C/C++ | |||
644 | include file with a ".h" extension), then inherit whatever | |||
645 | language the previous subfile had. This kludgery is | |||
646 | necessary because there is no standard way in some object | |||
647 | formats to record the source language. Also, when symtabs | |||
648 | are allocated we try to deduce a language then as well, but | |||
649 | it is too late for us to use that information while reading | |||
650 | symbols, since symtabs aren't allocated until after all the | |||
651 | symbols have been processed for a given source file. */ | |||
652 | ||||
653 | subfile->language = deduce_language_from_filename (subfile->name); | |||
654 | if (subfile->language == language_unknown && | |||
655 | subfile->next != NULL((void*)0)) | |||
656 | { | |||
657 | subfile->language = subfile->next->language; | |||
658 | } | |||
659 | } | |||
660 | } | |||
661 | ||||
662 | /* Handle the N_BINCL and N_EINCL symbol types that act like N_SOL for | |||
663 | switching source files (different subfiles, as we call them) within | |||
664 | one object file, but using a stack rather than in an arbitrary | |||
665 | order. */ | |||
666 | ||||
667 | void | |||
668 | push_subfile (void) | |||
669 | { | |||
670 | struct subfile_stack *tem | |||
671 | = (struct subfile_stack *) xmalloc (sizeof (struct subfile_stack)); | |||
672 | ||||
673 | tem->next = subfile_stack; | |||
674 | subfile_stack = tem; | |||
675 | if (current_subfile == NULL((void*)0) || current_subfile->name == NULL((void*)0)) | |||
676 | { | |||
677 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/buildsym.c", __LINE__677, "failed internal consistency check"); | |||
678 | } | |||
679 | tem->name = current_subfile->name; | |||
680 | } | |||
681 | ||||
682 | char * | |||
683 | pop_subfile (void) | |||
684 | { | |||
685 | char *name; | |||
686 | struct subfile_stack *link = subfile_stack; | |||
687 | ||||
688 | if (link == NULL((void*)0)) | |||
689 | { | |||
690 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/buildsym.c", __LINE__690, "failed internal consistency check"); | |||
691 | } | |||
692 | name = link->name; | |||
693 | subfile_stack = link->next; | |||
694 | xfree ((void *) link); | |||
695 | return (name); | |||
696 | } | |||
697 | ||||
698 | /* Add a linetable entry for line number LINE and address PC to the | |||
699 | line vector for SUBFILE. */ | |||
700 | ||||
701 | void | |||
702 | record_line (struct subfile *subfile, int line, CORE_ADDR pc) | |||
703 | { | |||
704 | struct linetable_entry *e; | |||
705 | /* Ignore the dummy line number in libg.o */ | |||
706 | ||||
707 | if (line == 0xffff) | |||
708 | { | |||
709 | return; | |||
710 | } | |||
711 | ||||
712 | /* Make sure line vector exists and is big enough. */ | |||
713 | if (!subfile->line_vector) | |||
714 | { | |||
715 | subfile->line_vector_length = INITIAL_LINE_VECTOR_LENGTH1000; | |||
716 | subfile->line_vector = (struct linetable *) | |||
717 | xmalloc (sizeof (struct linetable) | |||
718 | + subfile->line_vector_length * sizeof (struct linetable_entry)); | |||
719 | subfile->line_vector->nitems = 0; | |||
720 | have_line_numbers = 1; | |||
721 | } | |||
722 | ||||
723 | if (subfile->line_vector->nitems + 1 >= subfile->line_vector_length) | |||
724 | { | |||
725 | subfile->line_vector_length *= 2; | |||
726 | subfile->line_vector = (struct linetable *) | |||
727 | xrealloc ((char *) subfile->line_vector, | |||
728 | (sizeof (struct linetable) | |||
729 | + (subfile->line_vector_length | |||
730 | * sizeof (struct linetable_entry)))); | |||
731 | } | |||
732 | ||||
733 | e = subfile->line_vector->item + subfile->line_vector->nitems++; | |||
734 | e->line = line; | |||
735 | e->pc = ADDR_BITS_REMOVE(pc)(gdbarch_addr_bits_remove (current_gdbarch, pc)); | |||
736 | } | |||
737 | ||||
738 | /* Needed in order to sort line tables from IBM xcoff files. Sigh! */ | |||
739 | ||||
740 | static int | |||
741 | compare_line_numbers (const void *ln1p, const void *ln2p) | |||
742 | { | |||
743 | struct linetable_entry *ln1 = (struct linetable_entry *) ln1p; | |||
744 | struct linetable_entry *ln2 = (struct linetable_entry *) ln2p; | |||
745 | ||||
746 | /* Note: this code does not assume that CORE_ADDRs can fit in ints. | |||
747 | Please keep it that way. */ | |||
748 | if (ln1->pc < ln2->pc) | |||
749 | return -1; | |||
750 | ||||
751 | if (ln1->pc > ln2->pc) | |||
752 | return 1; | |||
753 | ||||
754 | /* If pc equal, sort by line. I'm not sure whether this is optimum | |||
755 | behavior (see comment at struct linetable in symtab.h). */ | |||
756 | return ln1->line - ln2->line; | |||
757 | } | |||
758 | ||||
759 | /* Start a new symtab for a new source file. Called, for example, | |||
760 | when a stabs symbol of type N_SO is seen, or when a DWARF | |||
761 | TAG_compile_unit DIE is seen. It indicates the start of data for | |||
762 | one original source file. */ | |||
763 | ||||
764 | void | |||
765 | start_symtab (char *name, char *dirname, CORE_ADDR start_addr) | |||
766 | { | |||
767 | ||||
768 | last_source_file = name; | |||
769 | last_source_start_addr = start_addr; | |||
770 | file_symbols = NULL((void*)0); | |||
771 | global_symbols = NULL((void*)0); | |||
772 | within_function = 0; | |||
773 | have_line_numbers = 0; | |||
774 | ||||
775 | /* Context stack is initially empty. Allocate first one with room | |||
776 | for 10 levels; reuse it forever afterward. */ | |||
777 | if (context_stack == NULL((void*)0)) | |||
778 | { | |||
779 | context_stack_size = INITIAL_CONTEXT_STACK_SIZE10; | |||
780 | context_stack = (struct context_stack *) | |||
781 | xmalloc (context_stack_size * sizeof (struct context_stack)); | |||
782 | } | |||
783 | context_stack_depth = 0; | |||
784 | ||||
785 | /* Set up support for C++ namespace support, in case we need it. */ | |||
786 | ||||
787 | cp_initialize_namespace (); | |||
788 | ||||
789 | /* Initialize the list of sub source files with one entry for this | |||
790 | file (the top-level source file). */ | |||
791 | ||||
792 | subfiles = NULL((void*)0); | |||
793 | current_subfile = NULL((void*)0); | |||
794 | start_subfile (name, dirname); | |||
795 | } | |||
796 | ||||
797 | /* Finish the symbol definitions for one main source file, close off | |||
798 | all the lexical contexts for that file (creating struct block's for | |||
799 | them), then make the struct symtab for that file and put it in the | |||
800 | list of all such. | |||
801 | ||||
802 | END_ADDR is the address of the end of the file's text. SECTION is | |||
803 | the section number (in objfile->section_offsets) of the blockvector | |||
804 | and linetable. | |||
805 | ||||
806 | Note that it is possible for end_symtab() to return NULL. In | |||
807 | particular, for the DWARF case at least, it will return NULL when | |||
808 | it finds a compilation unit that has exactly one DIE, a | |||
809 | TAG_compile_unit DIE. This can happen when we link in an object | |||
810 | file that was compiled from an empty source file. Returning NULL | |||
811 | is probably not the correct thing to do, because then gdb will | |||
812 | never know about this empty file (FIXME). */ | |||
813 | ||||
814 | struct symtab * | |||
815 | end_symtab (CORE_ADDR end_addr, struct objfile *objfile, int section) | |||
816 | { | |||
817 | struct symtab *symtab = NULL((void*)0); | |||
818 | struct blockvector *blockvector; | |||
819 | struct subfile *subfile; | |||
820 | struct context_stack *cstk; | |||
821 | struct subfile *nextsub; | |||
822 | ||||
823 | /* Finish the lexical context of the last function in the file; pop | |||
824 | the context stack. */ | |||
825 | ||||
826 | if (context_stack_depth > 0) | |||
| ||||
827 | { | |||
828 | cstk = pop_context (); | |||
829 | /* Make a block for the local symbols within. */ | |||
830 | finish_block (cstk->name, &local_symbols, cstk->old_blocks, | |||
831 | cstk->start_addr, end_addr, objfile); | |||
832 | ||||
833 | if (context_stack_depth > 0) | |||
834 | { | |||
835 | /* This is said to happen with SCO. The old coffread.c | |||
836 | code simply emptied the context stack, so we do the | |||
837 | same. FIXME: Find out why it is happening. This is not | |||
838 | believed to happen in most cases (even for coffread.c); | |||
839 | it used to be an abort(). */ | |||
840 | complaint (&symfile_complaints, | |||
841 | "Context stack not empty in end_symtab"); | |||
842 | context_stack_depth = 0; | |||
843 | } | |||
844 | } | |||
845 | ||||
846 | /* Reordered executables may have out of order pending blocks; if | |||
847 | OBJF_REORDERED is true, then sort the pending blocks. */ | |||
848 | if ((objfile->flags & OBJF_REORDERED(1 << 2)) && pending_blocks) | |||
849 | { | |||
850 | /* FIXME! Remove this horrid bubble sort and use merge sort!!! */ | |||
851 | int swapped; | |||
852 | do | |||
853 | { | |||
854 | struct pending_block *pb, *pbnext; | |||
855 | ||||
856 | pb = pending_blocks; | |||
857 | pbnext = pb->next; | |||
858 | swapped = 0; | |||
859 | ||||
860 | while (pbnext) | |||
861 | { | |||
862 | /* swap blocks if unordered! */ | |||
863 | ||||
864 | if (BLOCK_START (pb->block)(pb->block)->startaddr < BLOCK_START (pbnext->block)(pbnext->block)->startaddr) | |||
865 | { | |||
866 | struct block *tmp = pb->block; | |||
867 | pb->block = pbnext->block; | |||
868 | pbnext->block = tmp; | |||
869 | swapped = 1; | |||
870 | } | |||
871 | pb = pbnext; | |||
872 | pbnext = pbnext->next; | |||
873 | } | |||
874 | } | |||
875 | while (swapped); | |||
876 | } | |||
877 | ||||
878 | /* Cleanup any undefined types that have been left hanging around | |||
879 | (this needs to be done before the finish_blocks so that | |||
880 | file_symbols is still good). | |||
881 | ||||
882 | Both cleanup_undefined_types and finish_global_stabs are stabs | |||
883 | specific, but harmless for other symbol readers, since on gdb | |||
884 | startup or when finished reading stabs, the state is set so these | |||
885 | are no-ops. FIXME: Is this handled right in case of QUIT? Can | |||
886 | we make this cleaner? */ | |||
887 | ||||
888 | cleanup_undefined_types (); | |||
889 | finish_global_stabs (objfile); | |||
890 | ||||
891 | if (pending_blocks == NULL((void*)0) | |||
892 | && file_symbols == NULL((void*)0) | |||
893 | && global_symbols == NULL((void*)0) | |||
894 | && have_line_numbers == 0 | |||
895 | && pending_macros == NULL((void*)0)) | |||
896 | { | |||
897 | /* Ignore symtabs that have no functions with real debugging | |||
898 | info. */ | |||
899 | blockvector = NULL((void*)0); | |||
900 | } | |||
901 | else | |||
902 | { | |||
903 | /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the | |||
904 | blockvector. */ | |||
905 | finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr, | |||
906 | objfile); | |||
907 | finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr, | |||
908 | objfile); | |||
909 | blockvector = make_blockvector (objfile); | |||
910 | cp_finalize_namespace (BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK)(blockvector)->block[STATIC_BLOCK], | |||
911 | &objfile->objfile_obstack); | |||
912 | } | |||
913 | ||||
914 | #ifndef PROCESS_LINENUMBER_HOOK | |||
915 | #define PROCESS_LINENUMBER_HOOK() | |||
916 | #endif | |||
917 | PROCESS_LINENUMBER_HOOK (); /* Needed for xcoff. */ | |||
918 | ||||
919 | /* Now create the symtab objects proper, one for each subfile. */ | |||
920 | /* (The main file is the last one on the chain.) */ | |||
921 | ||||
922 | for (subfile = subfiles; subfile; subfile = nextsub) | |||
923 | { | |||
924 | int linetablesize = 0; | |||
925 | symtab = NULL((void*)0); | |||
926 | ||||
927 | /* If we have blocks of symbols, make a symtab. Otherwise, just | |||
928 | ignore this file and any line number info in it. */ | |||
929 | if (blockvector
| |||
930 | { | |||
931 | if (subfile->line_vector) | |||
932 | { | |||
933 | linetablesize = sizeof (struct linetable) + | |||
934 | subfile->line_vector->nitems * sizeof (struct linetable_entry); | |||
935 | #if 0 | |||
936 | /* I think this is artifact from before it went on the | |||
937 | obstack. I doubt we'll need the memory between now | |||
938 | and when we free it later in this function. */ | |||
939 | /* First, shrink the linetable to make more memory. */ | |||
940 | subfile->line_vector = (struct linetable *) | |||
941 | xrealloc ((char *) subfile->line_vector, linetablesize); | |||
942 | #endif | |||
943 | ||||
944 | /* Like the pending blocks, the line table may be | |||
945 | scrambled in reordered executables. Sort it if | |||
946 | OBJF_REORDERED is true. */ | |||
947 | if (objfile->flags & OBJF_REORDERED(1 << 2)) | |||
948 | qsort (subfile->line_vector->item, | |||
949 | subfile->line_vector->nitems, | |||
950 | sizeof (struct linetable_entry), compare_line_numbers); | |||
951 | } | |||
952 | ||||
953 | /* Now, allocate a symbol table. */ | |||
954 | symtab = allocate_symtab (subfile->name, objfile); | |||
955 | ||||
956 | /* Fill in its components. */ | |||
957 | symtab->blockvector = blockvector; | |||
958 | symtab->macro_table = pending_macros; | |||
959 | if (subfile->line_vector
| |||
960 | { | |||
961 | /* Reallocate the line table on the symbol obstack */ | |||
962 | symtab->linetable = (struct linetable *) | |||
963 | obstack_alloc (&objfile->objfile_obstack, linetablesize)__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack ); __extension__ ({ struct obstack *__o = (__h); int __len = ( (linetablesize)); 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; }); }); | |||
964 | memcpy (symtab->linetable, subfile->line_vector, linetablesize); | |||
965 | } | |||
966 | else | |||
967 | { | |||
968 | symtab->linetable = NULL((void*)0); | |||
969 | } | |||
970 | symtab->block_line_section = section; | |||
971 | if (subfile->dirname) | |||
972 | { | |||
973 | /* Reallocate the dirname on the symbol obstack */ | |||
974 | symtab->dirname = (char *) | |||
975 | obstack_alloc (&objfile->objfile_obstack,__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack ); __extension__ ({ struct obstack *__o = (__h); int __len = ( (strlen (subfile->dirname) + 1)); 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; }); }) | |||
976 | strlen (subfile->dirname) + 1)__extension__ ({ struct obstack *__h = (&objfile->objfile_obstack ); __extension__ ({ struct obstack *__o = (__h); int __len = ( (strlen (subfile->dirname) + 1)); 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; }); }); | |||
977 | strcpy (symtab->dirname, subfile->dirname); | |||
| ||||
978 | } | |||
979 | else | |||
980 | { | |||
981 | symtab->dirname = NULL((void*)0); | |||
982 | } | |||
983 | symtab->free_code = free_linetable; | |||
984 | symtab->free_func = NULL((void*)0); | |||
985 | ||||
986 | /* Use whatever language we have been using for this | |||
987 | subfile, not the one that was deduced in allocate_symtab | |||
988 | from the filename. We already did our own deducing when | |||
989 | we created the subfile, and we may have altered our | |||
990 | opinion of what language it is from things we found in | |||
991 | the symbols. */ | |||
992 | symtab->language = subfile->language; | |||
993 | ||||
994 | /* Save the debug format string (if any) in the symtab */ | |||
995 | if (subfile->debugformat != NULL((void*)0)) | |||
996 | { | |||
997 | symtab->debugformat = obsavestring (subfile->debugformat, | |||
998 | strlen (subfile->debugformat), | |||
999 | &objfile->objfile_obstack); | |||
1000 | } | |||
1001 | ||||
1002 | /* All symtabs for the main file and the subfiles share a | |||
1003 | blockvector, so we need to clear primary for everything | |||
1004 | but the main file. */ | |||
1005 | ||||
1006 | symtab->primary = 0; | |||
1007 | } | |||
1008 | if (subfile->name != NULL((void*)0)) | |||
1009 | { | |||
1010 | xfree ((void *) subfile->name); | |||
1011 | } | |||
1012 | if (subfile->dirname != NULL((void*)0)) | |||
1013 | { | |||
1014 | xfree ((void *) subfile->dirname); | |||
1015 | } | |||
1016 | if (subfile->line_vector != NULL((void*)0)) | |||
1017 | { | |||
1018 | xfree ((void *) subfile->line_vector); | |||
1019 | } | |||
1020 | if (subfile->debugformat != NULL((void*)0)) | |||
1021 | { | |||
1022 | xfree ((void *) subfile->debugformat); | |||
1023 | } | |||
1024 | ||||
1025 | nextsub = subfile->next; | |||
1026 | xfree ((void *) subfile); | |||
1027 | } | |||
1028 | ||||
1029 | /* Set this for the main source file. */ | |||
1030 | if (symtab) | |||
1031 | { | |||
1032 | symtab->primary = 1; | |||
1033 | } | |||
1034 | ||||
1035 | last_source_file = NULL((void*)0); | |||
1036 | current_subfile = NULL((void*)0); | |||
1037 | pending_macros = NULL((void*)0); | |||
1038 | ||||
1039 | return symtab; | |||
1040 | } | |||
1041 | ||||
1042 | /* Push a context block. Args are an identifying nesting level | |||
1043 | (checkable when you pop it), and the starting PC address of this | |||
1044 | context. */ | |||
1045 | ||||
1046 | struct context_stack * | |||
1047 | push_context (int desc, CORE_ADDR valu) | |||
1048 | { | |||
1049 | struct context_stack *new; | |||
1050 | ||||
1051 | if (context_stack_depth == context_stack_size) | |||
1052 | { | |||
1053 | context_stack_size *= 2; | |||
1054 | context_stack = (struct context_stack *) | |||
1055 | xrealloc ((char *) context_stack, | |||
1056 | (context_stack_size * sizeof (struct context_stack))); | |||
1057 | } | |||
1058 | ||||
1059 | new = &context_stack[context_stack_depth++]; | |||
1060 | new->depth = desc; | |||
1061 | new->locals = local_symbols; | |||
1062 | new->params = param_symbols; | |||
1063 | new->old_blocks = pending_blocks; | |||
1064 | new->start_addr = valu; | |||
1065 | new->name = NULL((void*)0); | |||
1066 | ||||
1067 | local_symbols = NULL((void*)0); | |||
1068 | param_symbols = NULL((void*)0); | |||
1069 | ||||
1070 | return new; | |||
1071 | } | |||
1072 | ||||
1073 | /* Pop a context block. Returns the address of the context block just | |||
1074 | popped. */ | |||
1075 | ||||
1076 | struct context_stack * | |||
1077 | pop_context (void) | |||
1078 | { | |||
1079 | gdb_assert (context_stack_depth > 0)((void) ((context_stack_depth > 0) ? 0 : (internal_error ( "/usr/src/gnu/usr.bin/binutils/gdb/buildsym.c", 1079, "%s: Assertion `%s' failed." , __PRETTY_FUNCTION__, "context_stack_depth > 0"), 0))); | |||
1080 | return (&context_stack[--context_stack_depth]); | |||
1081 | } | |||
1082 | ||||
1083 | ||||
1084 | ||||
1085 | /* Compute a small integer hash code for the given name. */ | |||
1086 | ||||
1087 | int | |||
1088 | hashname (char *name) | |||
1089 | { | |||
1090 | return (hash(name,strlen(name)) % HASHSIZE127); | |||
1091 | } | |||
1092 | ||||
1093 | ||||
1094 | void | |||
1095 | record_debugformat (char *format) | |||
1096 | { | |||
1097 | current_subfile->debugformat = savestring (format, strlen (format)); | |||
1098 | } | |||
1099 | ||||
1100 | /* Merge the first symbol list SRCLIST into the second symbol list | |||
1101 | TARGETLIST by repeated calls to add_symbol_to_list(). This | |||
1102 | procedure "frees" each link of SRCLIST by adding it to the | |||
1103 | free_pendings list. Caller must set SRCLIST to a null list after | |||
1104 | calling this function. | |||
1105 | ||||
1106 | Void return. */ | |||
1107 | ||||
1108 | void | |||
1109 | merge_symbol_lists (struct pending **srclist, struct pending **targetlist) | |||
1110 | { | |||
1111 | int i; | |||
1112 | ||||
1113 | if (!srclist || !*srclist) | |||
1114 | return; | |||
1115 | ||||
1116 | /* Merge in elements from current link. */ | |||
1117 | for (i = 0; i < (*srclist)->nsyms; i++) | |||
1118 | add_symbol_to_list ((*srclist)->symbol[i], targetlist); | |||
1119 | ||||
1120 | /* Recurse on next. */ | |||
1121 | merge_symbol_lists (&(*srclist)->next, targetlist); | |||
1122 | ||||
1123 | /* "Free" the current link. */ | |||
1124 | (*srclist)->next = free_pendings; | |||
1125 | free_pendings = (*srclist); | |||
1126 | } | |||
1127 | ||||
1128 | /* Initialize anything that needs initializing when starting to read a | |||
1129 | fresh piece of a symbol file, e.g. reading in the stuff | |||
1130 | corresponding to a psymtab. */ | |||
1131 | ||||
1132 | void | |||
1133 | buildsym_init (void) | |||
1134 | { | |||
1135 | free_pendings = NULL((void*)0); | |||
1136 | file_symbols = NULL((void*)0); | |||
1137 | global_symbols = NULL((void*)0); | |||
1138 | pending_blocks = NULL((void*)0); | |||
1139 | pending_macros = NULL((void*)0); | |||
1140 | } | |||
1141 | ||||
1142 | /* Initialize anything that needs initializing when a completely new | |||
1143 | symbol file is specified (not just adding some symbols from another | |||
1144 | file, e.g. a shared library). */ | |||
1145 | ||||
1146 | void | |||
1147 | buildsym_new_init (void) | |||
1148 | { | |||
1149 | buildsym_init (); | |||
1150 | } |