GDB (xrefs)

/tmp/gdb-8.1/gdb/buildsym.c
Go to the documentation of this file.
1 /* Support routines for building symbol tables in GDB's internal format.
2 Copyright (C) 1986-2018 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
18
19 /* This module provides subroutines used for creating and adding to
20 the symbol table. These routines are called from various symbol-
21 file-reading routines.
22
23 Routines to support specific debugging information formats (stabs,
24 DWARF, etc) belong somewhere else.
25
26 The basic way this module is used is as follows:
27
28 buildsym_init ();
29 scoped_free_pendings free_pending;
30 cust = start_symtab (...);
31 ... read debug info ...
32 cust = end_symtab (...);
33
34 The compunit symtab pointer ("cust") is returned from both start_symtab
35 and end_symtab to simplify the debug info readers.
36
37 There are minor variations on this, e.g., dwarf2read.c splits end_symtab
38 into two calls: end_symtab_get_static_block, end_symtab_from_static_block,
39 but all debug info readers follow this basic flow.
40
41 Reading DWARF Type Units is another variation:
42
43 buildsym_init ();
44 scoped_free_pendings free_pending;
45 cust = start_symtab (...);
46 ... read debug info ...
47 cust = end_expandable_symtab (...);
48
49 And then reading subsequent Type Units within the containing "Comp Unit"
50 will use a second flow:
51
52 buildsym_init ();
53 scoped_free_pendings free_pending;
54 cust = restart_symtab (...);
55 ... read debug info ...
56 cust = augment_type_symtab (...);
57
58 dbxread.c and xcoffread.c use another variation:
59
60 buildsym_init ();
61 scoped_free_pendings free_pending;
62 cust = start_symtab (...);
63 ... read debug info ...
64 cust = end_symtab (...);
65 ... start_symtab + read + end_symtab repeated ...
66 */
67
68 #include "defs.h"
69 #include "bfd.h"
70 #include "gdb_obstack.h"
71 #include "symtab.h"
72 #include "symfile.h"
73 #include "objfiles.h"
74 #include "gdbtypes.h"
75 #include "complaints.h"
76 #include "expression.h" /* For "enum exp_opcode" used by... */
77 #include "bcache.h"
78 #include "filenames.h" /* For DOSish file names. */
79 #include "macrotab.h"
80 #include "demangle.h" /* Needed by SYMBOL_INIT_DEMANGLED_NAME. */
81 #include "block.h"
82 #include "cp-support.h"
83 #include "dictionary.h"
84 #include "addrmap.h"
85 #include <algorithm>
86
87 /* Ask buildsym.h to define the vars it normally declares `extern'. */
88 #define EXTERN
89
90 #include "buildsym.h" /* Our own declarations. */
91 #undef EXTERN
92
93 /* For cleanup_undefined_stabs_types and finish_global_stabs (somewhat
94 questionable--see comment where we call them). */
95
96 #include "stabsread.h"
97
98 /* Buildsym's counterpart to struct compunit_symtab.
99 TODO(dje): Move all related global state into here. */
100
101 struct buildsym_compunit
102 {
103 /* The objfile we're reading debug info from. */
104 struct objfile *objfile;
105
106 /* List of subfiles (source files).
107 Files are added to the front of the list.
108 This is important mostly for the language determination hacks we use,
109 which iterate over previously added files. */
110 struct subfile *subfiles;
111
112 /* The subfile of the main source file. */
113 struct subfile *main_subfile;
114
115 /* E.g., DW_AT_comp_dir if DWARF. Space for this is malloc'd. */
116 char *comp_dir;
117
118 /* Space for this is not malloc'd, and is assumed to have at least
119 the same lifetime as objfile. */
120 const char *producer;
121
122 /* Space for this is not malloc'd, and is assumed to have at least
123 the same lifetime as objfile. */
124 const char *debugformat;
125
126 /* The compunit we are building. */
127 struct compunit_symtab *compunit_symtab;
128
129 /* Language of this compunit_symtab. */
130 enum language language;
131 };
132
133 /* The work-in-progress of the compunit we are building.
134 This is created first, before any subfiles by start_symtab. */
135
136 static struct buildsym_compunit *buildsym_compunit;
137
138 /* List of free `struct pending' structures for reuse. */
139
140 static struct pending *free_pendings;
141
142 /* Non-zero if symtab has line number info. This prevents an
143 otherwise empty symtab from being tossed. */
144
145 static int have_line_numbers;
146
147 /* The mutable address map for the compilation unit whose symbols
148 we're currently reading. The symtabs' shared blockvector will
149 point to a fixed copy of this. */
150 static struct addrmap *pending_addrmap;
151
152 /* The obstack on which we allocate pending_addrmap.
153 If pending_addrmap is NULL, this is uninitialized; otherwise, it is
154 initialized (and holds pending_addrmap). */
155 static struct obstack pending_addrmap_obstack;
156
157 /* Non-zero if we recorded any ranges in the addrmap that are
158 different from those in the blockvector already. We set this to
159 zero when we start processing a symfile, and if it's still zero at
160 the end, then we just toss the addrmap. */
161 static int pending_addrmap_interesting;
162
163 /* An obstack used for allocating pending blocks. */
164
165 static struct obstack pending_block_obstack;
166
167 /* List of blocks already made (lexical contexts already closed).
168 This is used at the end to make the blockvector. */
169
170 struct pending_block
171 {
172 struct pending_block *next;
173 struct block *block;
174 };
175
176 /* Pointer to the head of a linked list of symbol blocks which have
177 already been finalized (lexical contexts already closed) and which
178 are just waiting to be built into a blockvector when finalizing the
179 associated symtab. */
180
181 static struct pending_block *pending_blocks;
182
183 struct subfile_stack
184 {
185 struct subfile_stack *next;
186 char *name;
187 };
188
189 static struct subfile_stack *subfile_stack;
190
191 /* The macro table for the compilation unit whose symbols we're
192 currently reading. */
193 static struct macro_table *pending_macros;
194
195 static void free_buildsym_compunit (void);
196
197 static int compare_line_numbers (const void *ln1p, const void *ln2p);
198
199 static void record_pending_block (struct objfile *objfile,
200 struct block *block,
201 struct pending_block *opblock);
202
203 /* Initial sizes of data structures. These are realloc'd larger if
204 needed, and realloc'd down to the size actually used, when
205 completed. */
206
207 #define INITIAL_CONTEXT_STACK_SIZE 10
208 #define INITIAL_LINE_VECTOR_LENGTH 1000
209
210
211 /* Maintain the lists of symbols and blocks. */
212
213 /* Add a symbol to one of the lists of symbols. */
214
215 void
216 add_symbol_to_list (struct symbol *symbol, struct pending **listhead)
217 {
218 struct pending *link;
219
220 /* If this is an alias for another symbol, don't add it. */
221 if (symbol->ginfo.name && symbol->ginfo.name[0] == '#')
222 return;
223
224 /* We keep PENDINGSIZE symbols in each link of the list. If we
225 don't have a link with room in it, add a new link. */
226 if (*listhead == NULL || (*listhead)->nsyms == PENDINGSIZE)
227 {
228 if (free_pendings)
229 {
230 link = free_pendings;
231 free_pendings = link->next;
232 }
233 else
234 {
235 link = XNEW (struct pending);
236 }
237
238 link->next = *listhead;
239 *listhead = link;
240 link->nsyms = 0;
241 }
242
243 (*listhead)->symbol[(*listhead)->nsyms++] = symbol;
244 }
245
246 /* Find a symbol named NAME on a LIST. NAME need not be
247 '\0'-terminated; LENGTH is the length of the name. */
248
249 struct symbol *
250 find_symbol_in_list (struct pending *list, char *name, int length)
251 {
252 int j;
253 const char *pp;
254
255 while (list != NULL)
256 {
257 for (j = list->nsyms; --j >= 0;)
258 {
259 pp = SYMBOL_LINKAGE_NAME (list->symbol[j]);
260 if (*pp == *name && strncmp (pp, name, length) == 0
261 && pp[length] == '\0')
262 {
263 return (list->symbol[j]);
264 }
265 }
266 list = list->next;
267 }
268 return (NULL);
269 }
270
271 /* At end of reading syms, or in case of quit, ensure everything
272 associated with building symtabs is freed.
273
274 N.B. This is *not* intended to be used when building psymtabs. Some debug
275 info readers call this anyway, which is harmless if confusing. */
276
277 scoped_free_pendings::~scoped_free_pendings ()
278 {
279 struct pending *next, *next1;
280
281 for (next = free_pendings; next; next = next1)
282 {
283 next1 = next->next;
284 xfree ((void *) next);
285 }
286 free_pendings = NULL;
287
288 free_pending_blocks ();
289
290 for (next = file_symbols; next != NULL; next = next1)
291 {
292 next1 = next->next;
293 xfree ((void *) next);
294 }
295 file_symbols = NULL;
296
297 for (next = global_symbols; next != NULL; next = next1)
298 {
299 next1 = next->next;
300 xfree ((void *) next);
301 }
302 global_symbols = NULL;
303
304 if (pending_macros)
305 free_macro_table (pending_macros);
306 pending_macros = NULL;
307
308 if (pending_addrmap)
309 obstack_free (&pending_addrmap_obstack, NULL);
310 pending_addrmap = NULL;
311
312 free_buildsym_compunit ();
313 }
314
315 /* This function is called to discard any pending blocks. */
316
317 void
318 free_pending_blocks (void)
319 {
320 if (pending_blocks != NULL)
321 {
322 obstack_free (&pending_block_obstack, NULL);
323 pending_blocks = NULL;
324 }
325 }
326
327 /* Take one of the lists of symbols and make a block from it. Keep
328 the order the symbols have in the list (reversed from the input
329 file). Put the block on the list of pending blocks. */
330
331 static struct block *
332 finish_block_internal (struct symbol *symbol,
333 struct pending **listhead,
334 struct pending_block *old_blocks,
335 const struct dynamic_prop *static_link,
336 CORE_ADDR start, CORE_ADDR end,
337 int is_global, int expandable)
338 {
339 struct objfile *objfile = buildsym_compunit->objfile;
340 struct gdbarch *gdbarch = get_objfile_arch (objfile);
341 struct pending *next, *next1;
342 struct block *block;
343 struct pending_block *pblock;
344 struct pending_block *opblock;
345
346 block = (is_global
347 ? allocate_global_block (&objfile->objfile_obstack)
348 : allocate_block (&objfile->objfile_obstack));
349
350 if (symbol)
351 {
352 BLOCK_DICT (block)
353 = dict_create_linear (&objfile->objfile_obstack,
354 buildsym_compunit->language, *listhead);
355 }
356 else
357 {
358 if (expandable)
359 {
360 BLOCK_DICT (block)
361 = dict_create_hashed_expandable (buildsym_compunit->language);
362 dict_add_pending (BLOCK_DICT (block), *listhead);
363 }
364 else
365 {
366 BLOCK_DICT (block) =
367 dict_create_hashed (&objfile->objfile_obstack,
368 buildsym_compunit->language, *listhead);
369 }
370 }
371
372 BLOCK_START (block) = start;
373 BLOCK_END (block) = end;
374
375 /* Put the block in as the value of the symbol that names it. */
376
377 if (symbol)
378 {
379 struct type *ftype = SYMBOL_TYPE (symbol);
380 struct dict_iterator iter;
381 SYMBOL_BLOCK_VALUE (symbol) = block;
382 BLOCK_FUNCTION (block) = symbol;
383
384 if (TYPE_NFIELDS (ftype) <= 0)
385 {
386 /* No parameter type information is recorded with the
387 function's type. Set that from the type of the
388 parameter symbols. */
389 int nparams = 0, iparams;
390 struct symbol *sym;
391
392 /* Here we want to directly access the dictionary, because
393 we haven't fully initialized the block yet. */
394 ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
395 {
396 if (SYMBOL_IS_ARGUMENT (sym))
397 nparams++;
398 }
399 if (nparams > 0)
400 {
401 TYPE_NFIELDS (ftype) = nparams;
402 TYPE_FIELDS (ftype) = (struct field *)
403 TYPE_ALLOC (ftype, nparams * sizeof (struct field));
404
405 iparams = 0;
406 /* Here we want to directly access the dictionary, because
407 we haven't fully initialized the block yet. */
408 ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
409 {
410 if (iparams == nparams)
411 break;
412
413 if (SYMBOL_IS_ARGUMENT (sym))
414 {
415 TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
416 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
417 iparams++;
418 }
419 }
420 }
421 }
422 }
423 else
424 {
425 BLOCK_FUNCTION (block) = NULL;
426 }
427
428 if (static_link != NULL)
429 objfile_register_static_link (objfile, block, static_link);
430
431 /* Now "free" the links of the list, and empty the list. */
432
433 for (next = *listhead; next; next = next1)
434 {
435 next1 = next->next;
436 next->next = free_pendings;
437 free_pendings = next;
438 }
439 *listhead = NULL;
440
441 /* Check to be sure that the blocks have an end address that is
442 greater than starting address. */
443
444 if (BLOCK_END (block) < BLOCK_START (block))
445 {
446 if (symbol)
447 {
448 complaint (&symfile_complaints,
449 _("block end address less than block "
450 "start address in %s (patched it)"),
451 SYMBOL_PRINT_NAME (symbol));
452 }
453 else
454 {
455 complaint (&symfile_complaints,
456 _("block end address %s less than block "
457 "start address %s (patched it)"),
458 paddress (gdbarch, BLOCK_END (block)),
459 paddress (gdbarch, BLOCK_START (block)));
460 }
461 /* Better than nothing. */
462 BLOCK_END (block) = BLOCK_START (block);
463 }
464
465 /* Install this block as the superblock of all blocks made since the
466 start of this scope that don't have superblocks yet. */
467
468 opblock = NULL;
469 for (pblock = pending_blocks;
470 pblock && pblock != old_blocks;
471 pblock = pblock->next)
472 {
473 if (BLOCK_SUPERBLOCK (pblock->block) == NULL)
474 {
475 /* Check to be sure the blocks are nested as we receive
476 them. If the compiler/assembler/linker work, this just
477 burns a small amount of time.
478
479 Skip blocks which correspond to a function; they're not
480 physically nested inside this other blocks, only
481 lexically nested. */
482 if (BLOCK_FUNCTION (pblock->block) == NULL
483 && (BLOCK_START (pblock->block) < BLOCK_START (block)
484 || BLOCK_END (pblock->block) > BLOCK_END (block)))
485 {
486 if (symbol)
487 {
488 complaint (&symfile_complaints,
489 _("inner block not inside outer block in %s"),
490 SYMBOL_PRINT_NAME (symbol));
491 }
492 else
493 {
494 complaint (&symfile_complaints,
495 _("inner block (%s-%s) not "
496 "inside outer block (%s-%s)"),
497 paddress (gdbarch, BLOCK_START (pblock->block)),
498 paddress (gdbarch, BLOCK_END (pblock->block)),
499 paddress (gdbarch, BLOCK_START (block)),
500 paddress (gdbarch, BLOCK_END (block)));
501 }
502 if (BLOCK_START (pblock->block) < BLOCK_START (block))
503 BLOCK_START (pblock->block) = BLOCK_START (block);
504 if (BLOCK_END (pblock->block) > BLOCK_END (block))
505 BLOCK_END (pblock->block) = BLOCK_END (block);
506 }
507 BLOCK_SUPERBLOCK (pblock->block) = block;
508 }
509 opblock = pblock;
510 }
511
512 block_set_using (block,
513 (is_global
514 ? global_using_directives
515 : local_using_directives),
516 &objfile->objfile_obstack);
517 if (is_global)
518 global_using_directives = NULL;
519 else
520 local_using_directives = NULL;
521
522 record_pending_block (objfile, block, opblock);
523
524 return block;
525 }
526
527 struct block *
528 finish_block (struct symbol *symbol,
529 struct pending **listhead,
530 struct pending_block *old_blocks,
531 const struct dynamic_prop *static_link,
532 CORE_ADDR start, CORE_ADDR end)
533 {
534 return finish_block_internal (symbol, listhead, old_blocks, static_link,
535 start, end, 0, 0);
536 }
537
538 /* Record BLOCK on the list of all blocks in the file. Put it after
539 OPBLOCK, or at the beginning if opblock is NULL. This puts the
540 block in the list after all its subblocks.
541
542 Allocate the pending block struct in the objfile_obstack to save
543 time. This wastes a little space. FIXME: Is it worth it? */
544
545 static void
546 record_pending_block (struct objfile *objfile, struct block *block,
547 struct pending_block *opblock)
548 {
549 struct pending_block *pblock;
550
551 if (pending_blocks == NULL)
552 obstack_init (&pending_block_obstack);
553
554 pblock = XOBNEW (&pending_block_obstack, struct pending_block);
555 pblock->block = block;
556 if (opblock)
557 {
558 pblock->next = opblock->next;
559 opblock->next = pblock;
560 }
561 else
562 {
563 pblock->next = pending_blocks;
564 pending_blocks = pblock;
565 }
566 }
567
568
569 /* Record that the range of addresses from START to END_INCLUSIVE
570 (inclusive, like it says) belongs to BLOCK. BLOCK's start and end
571 addresses must be set already. You must apply this function to all
572 BLOCK's children before applying it to BLOCK.
573
574 If a call to this function complicates the picture beyond that
575 already provided by BLOCK_START and BLOCK_END, then we create an
576 address map for the block. */
577 void
578 record_block_range (struct block *block,
579 CORE_ADDR start, CORE_ADDR end_inclusive)
580 {
581 /* If this is any different from the range recorded in the block's
582 own BLOCK_START and BLOCK_END, then note that the address map has
583 become interesting. Note that even if this block doesn't have
584 any "interesting" ranges, some later block might, so we still
585 need to record this block in the addrmap. */
586 if (start != BLOCK_START (block)
587 || end_inclusive + 1 != BLOCK_END (block))
588 pending_addrmap_interesting = 1;
589
590 if (! pending_addrmap)
591 {
592 obstack_init (&pending_addrmap_obstack);
593 pending_addrmap = addrmap_create_mutable (&pending_addrmap_obstack);
594 }
595
596 addrmap_set_empty (pending_addrmap, start, end_inclusive, block);
597 }
598
599 static struct blockvector *
600 make_blockvector (void)
601 {
602 struct objfile *objfile = buildsym_compunit->objfile;
603 struct pending_block *next;
604 struct blockvector *blockvector;
605 int i;
606
607 /* Count the length of the list of blocks. */
608
609 for (next = pending_blocks, i = 0; next; next = next->next, i++)
610 {;
611 }
612
613 blockvector = (struct blockvector *)
614 obstack_alloc (&objfile->objfile_obstack,
615 (sizeof (struct blockvector)
616 + (i - 1) * sizeof (struct block *)));
617
618 /* Copy the blocks into the blockvector. This is done in reverse
619 order, which happens to put the blocks into the proper order
620 (ascending starting address). finish_block has hair to insert
621 each block into the list after its subblocks in order to make
622 sure this is true. */
623
624 BLOCKVECTOR_NBLOCKS (blockvector) = i;
625 for (next = pending_blocks; next; next = next->next)
626 {
627 BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
628 }
629
630 free_pending_blocks ();
631
632 /* If we needed an address map for this symtab, record it in the
633 blockvector. */
634 if (pending_addrmap && pending_addrmap_interesting)
635 BLOCKVECTOR_MAP (blockvector)
636 = addrmap_create_fixed (pending_addrmap, &objfile->objfile_obstack);
637 else
638 BLOCKVECTOR_MAP (blockvector) = 0;
639
640 /* Some compilers output blocks in the wrong order, but we depend on
641 their being in the right order so we can binary search. Check the
642 order and moan about it.
643 Note: Remember that the first two blocks are the global and static
644 blocks. We could special case that fact and begin checking at block 2.
645 To avoid making that assumption we do not. */
646 if (BLOCKVECTOR_NBLOCKS (blockvector) > 1)
647 {
648 for (i = 1; i < BLOCKVECTOR_NBLOCKS (blockvector); i++)
649 {
650 if (BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i - 1))
651 > BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i)))
652 {
653 CORE_ADDR start
654 = BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i));
655
656 complaint (&symfile_complaints, _("block at %s out of order"),
657 hex_string ((LONGEST) start));
658 }
659 }
660 }
661
662 return (blockvector);
663 }
664
665 /* Start recording information about source code that came from an
666 included (or otherwise merged-in) source file with a different
667 name. NAME is the name of the file (cannot be NULL). */
668
669 void
670 start_subfile (const char *name)
671 {
672 const char *subfile_dirname;
673 struct subfile *subfile;
674
675 gdb_assert (buildsym_compunit != NULL);
676
677 subfile_dirname = buildsym_compunit->comp_dir;
678
679 /* See if this subfile is already registered. */
680
681 for (subfile = buildsym_compunit->subfiles; subfile; subfile = subfile->next)
682 {
683 char *subfile_name;
684
685 /* If NAME is an absolute path, and this subfile is not, then
686 attempt to create an absolute path to compare. */
687 if (IS_ABSOLUTE_PATH (name)
688 && !IS_ABSOLUTE_PATH (subfile->name)
689 && subfile_dirname != NULL)
690 subfile_name = concat (subfile_dirname, SLASH_STRING,
691 subfile->name, (char *) NULL);
692 else
693 subfile_name = subfile->name;
694
695 if (FILENAME_CMP (subfile_name, name) == 0)
696 {
697 current_subfile = subfile;
698 if (subfile_name != subfile->name)
699 xfree (subfile_name);
700 return;
701 }
702 if (subfile_name != subfile->name)
703 xfree (subfile_name);
704 }
705
706 /* This subfile is not known. Add an entry for it. */
707
708 subfile = XNEW (struct subfile);
709 memset (subfile, 0, sizeof (struct subfile));
710 subfile->buildsym_compunit = buildsym_compunit;
711
712 subfile->next = buildsym_compunit->subfiles;
713 buildsym_compunit->subfiles = subfile;
714
715 current_subfile = subfile;
716
717 subfile->name = xstrdup (name);
718
719 /* Initialize line-number recording for this subfile. */
720 subfile->line_vector = NULL;
721
722 /* Default the source language to whatever can be deduced from the
723 filename. If nothing can be deduced (such as for a C/C++ include
724 file with a ".h" extension), then inherit whatever language the
725 previous subfile had. This kludgery is necessary because there
726 is no standard way in some object formats to record the source
727 language. Also, when symtabs are allocated we try to deduce a
728 language then as well, but it is too late for us to use that
729 information while reading symbols, since symtabs aren't allocated
730 until after all the symbols have been processed for a given
731 source file. */
732
733 subfile->language = deduce_language_from_filename (subfile->name);
734 if (subfile->language == language_unknown
735 && subfile->next != NULL)
736 {
737 subfile->language = subfile->next->language;
738 }
739
740 /* If the filename of this subfile ends in .C, then change the
741 language of any pending subfiles from C to C++. We also accept
742 any other C++ suffixes accepted by deduce_language_from_filename. */
743 /* Likewise for f2c. */
744
745 if (subfile->name)
746 {
747 struct subfile *s;
748 enum language sublang = deduce_language_from_filename (subfile->name);
749
750 if (sublang == language_cplus || sublang == language_fortran)
751 for (s = buildsym_compunit->subfiles; s != NULL; s = s->next)
752 if (s->language == language_c)
753 s->language = sublang;
754 }
755
756 /* And patch up this file if necessary. */
757 if (subfile->language == language_c
758 && subfile->next != NULL
759 && (subfile->next->language == language_cplus
760 || subfile->next->language == language_fortran))
761 {
762 subfile->language = subfile->next->language;
763 }
764 }
765
766 /* Start recording information about a primary source file (IOW, not an
767 included source file).
768 COMP_DIR is the directory in which the compilation unit was compiled
769 (or NULL if not known). */
770
771 static struct buildsym_compunit *
772 start_buildsym_compunit (struct objfile *objfile, const char *comp_dir,
773 enum language language)
774 {
775 struct buildsym_compunit *bscu;
776
777 bscu = XNEW (struct buildsym_compunit);
778 memset (bscu, 0, sizeof (struct buildsym_compunit));
779
780 bscu->objfile = objfile;
781 bscu->comp_dir = (comp_dir == NULL) ? NULL : xstrdup (comp_dir);
782 bscu->language = language;
783
784 /* Initialize the debug format string to NULL. We may supply it
785 later via a call to record_debugformat. */
786 bscu->debugformat = NULL;
787
788 /* Similarly for the producer. */
789 bscu->producer = NULL;
790
791 return bscu;
792 }
793
794 /* Delete the buildsym compunit. */
795
796 static void
797 free_buildsym_compunit (void)
798 {
799 struct subfile *subfile, *nextsub;
800
801 if (buildsym_compunit == NULL)
802 return;
803 for (subfile = buildsym_compunit->subfiles;
804 subfile != NULL;
805 subfile = nextsub)
806 {
807 nextsub = subfile->next;
808 xfree (subfile->name);
809 xfree (subfile->line_vector);
810 xfree (subfile);
811 }
812 xfree (buildsym_compunit->comp_dir);
813 xfree (buildsym_compunit);
814 buildsym_compunit = NULL;
815 current_subfile = NULL;
816 }
817
818 /* For stabs readers, the first N_SO symbol is assumed to be the
819 source file name, and the subfile struct is initialized using that
820 assumption. If another N_SO symbol is later seen, immediately
821 following the first one, then the first one is assumed to be the
822 directory name and the second one is really the source file name.
823
824 So we have to patch up the subfile struct by moving the old name
825 value to dirname and remembering the new name. Some sanity
826 checking is performed to ensure that the state of the subfile
827 struct is reasonable and that the old name we are assuming to be a
828 directory name actually is (by checking for a trailing '/'). */
829
830 void
831 patch_subfile_names (struct subfile *subfile, const char *name)
832 {
833 if (subfile != NULL
834 && buildsym_compunit->comp_dir == NULL
835 && subfile->name != NULL
836 && IS_DIR_SEPARATOR (subfile->name[strlen (subfile->name) - 1]))
837 {
838 buildsym_compunit->comp_dir = subfile->name;
839 subfile->name = xstrdup (name);
840 set_last_source_file (name);
841
842 /* Default the source language to whatever can be deduced from
843 the filename. If nothing can be deduced (such as for a C/C++
844 include file with a ".h" extension), then inherit whatever
845 language the previous subfile had. This kludgery is
846 necessary because there is no standard way in some object
847 formats to record the source language. Also, when symtabs
848 are allocated we try to deduce a language then as well, but
849 it is too late for us to use that information while reading
850 symbols, since symtabs aren't allocated until after all the
851 symbols have been processed for a given source file. */
852
853 subfile->language = deduce_language_from_filename (subfile->name);
854 if (subfile->language == language_unknown
855 && subfile->next != NULL)
856 {
857 subfile->language = subfile->next->language;
858 }
859 }
860 }
861
862 /* Handle the N_BINCL and N_EINCL symbol types that act like N_SOL for
863 switching source files (different subfiles, as we call them) within
864 one object file, but using a stack rather than in an arbitrary
865 order. */
866
867 void
868 push_subfile (void)
869 {
870 struct subfile_stack *tem = XNEW (struct subfile_stack);
871
872 tem->next = subfile_stack;
873 subfile_stack = tem;
874 if (current_subfile == NULL || current_subfile->name == NULL)
875 {
876 internal_error (__FILE__, __LINE__,
877 _("failed internal consistency check"));
878 }
879 tem->name = current_subfile->name;
880 }
881
882 char *
883 pop_subfile (void)
884 {
885 char *name;
886 struct subfile_stack *link = subfile_stack;
887
888 if (link == NULL)
889 {
890 internal_error (__FILE__, __LINE__,
891 _("failed internal consistency check"));
892 }
893 name = link->name;
894 subfile_stack = link->next;
895 xfree ((void *) link);
896 return (name);
897 }
898
899 /* Add a linetable entry for line number LINE and address PC to the
900 line vector for SUBFILE. */
901
902 void
903 record_line (struct subfile *subfile, int line, CORE_ADDR pc)
904 {
905 struct linetable_entry *e;
906
907 /* Ignore the dummy line number in libg.o */
908 if (line == 0xffff)
909 {
910 return;
911 }
912
913 /* Make sure line vector exists and is big enough. */
914 if (!subfile->line_vector)
915 {
916 subfile->line_vector_length = INITIAL_LINE_VECTOR_LENGTH;
917 subfile->line_vector = (struct linetable *)
918 xmalloc (sizeof (struct linetable)
919 + subfile->line_vector_length * sizeof (struct linetable_entry));
920 subfile->line_vector->nitems = 0;
921 have_line_numbers = 1;
922 }
923
924 if (subfile->line_vector->nitems + 1 >= subfile->line_vector_length)
925 {
926 subfile->line_vector_length *= 2;
927 subfile->line_vector = (struct linetable *)
928 xrealloc ((char *) subfile->line_vector,
929 (sizeof (struct linetable)
930 + (subfile->line_vector_length
931 * sizeof (struct linetable_entry))));
932 }
933
934 /* Normally, we treat lines as unsorted. But the end of sequence
935 marker is special. We sort line markers at the same PC by line
936 number, so end of sequence markers (which have line == 0) appear
937 first. This is right if the marker ends the previous function,
938 and there is no padding before the next function. But it is
939 wrong if the previous line was empty and we are now marking a
940 switch to a different subfile. We must leave the end of sequence
941 marker at the end of this group of lines, not sort the empty line
942 to after the marker. The easiest way to accomplish this is to
943 delete any empty lines from our table, if they are followed by
944 end of sequence markers. All we lose is the ability to set
945 breakpoints at some lines which contain no instructions
946 anyway. */
947 if (line == 0 && subfile->line_vector->nitems > 0)
948 {
949 e = subfile->line_vector->item + subfile->line_vector->nitems - 1;
950 while (subfile->line_vector->nitems > 0 && e->pc == pc)
951 {
952 e--;
953 subfile->line_vector->nitems--;
954 }
955 }
956
957 e = subfile->line_vector->item + subfile->line_vector->nitems++;
958 e->line = line;
959 e->pc = pc;
960 }
961
962 /* Needed in order to sort line tables from IBM xcoff files. Sigh! */
963
964 static int
965 compare_line_numbers (const void *ln1p, const void *ln2p)
966 {
967 struct linetable_entry *ln1 = (struct linetable_entry *) ln1p;
968 struct linetable_entry *ln2 = (struct linetable_entry *) ln2p;
969
970 /* Note: this code does not assume that CORE_ADDRs can fit in ints.
971 Please keep it that way. */
972 if (ln1->pc < ln2->pc)
973 return -1;
974
975 if (ln1->pc > ln2->pc)
976 return 1;
977
978 /* If pc equal, sort by line. I'm not sure whether this is optimum
979 behavior (see comment at struct linetable in symtab.h). */
980 return ln1->line - ln2->line;
981 }
982
983 /* See buildsym.h. */
984
985 struct compunit_symtab *
986 buildsym_compunit_symtab (void)
987 {
988 gdb_assert (buildsym_compunit != NULL);
989
990 return buildsym_compunit->compunit_symtab;
991 }
992
993 /* See buildsym.h. */
994
995 struct macro_table *
996 get_macro_table (void)
997 {
998 struct objfile *objfile;
999
1000 gdb_assert (buildsym_compunit != NULL);
1001
1002 objfile = buildsym_compunit->objfile;
1003
1004 if (! pending_macros)
1005 {
1006 pending_macros = new_macro_table (&objfile->per_bfd->storage_obstack,
1007 objfile->per_bfd->macro_cache,
1008 buildsym_compunit->compunit_symtab);
1009 }
1010
1011 return pending_macros;
1012 }
1013
1014 /* Init state to prepare for building a symtab.
1015 Note: This can't be done in buildsym_init because dbxread.c and xcoffread.c
1016 can call start_symtab+end_symtab multiple times after one call to
1017 buildsym_init. */
1018
1019 static void
1020 prepare_for_building (const char *name, CORE_ADDR start_addr)
1021 {
1022 set_last_source_file (name);
1023 last_source_start_addr = start_addr;
1024
1025 local_symbols = NULL;
1026 local_using_directives = NULL;
1027 within_function = 0;
1028 have_line_numbers = 0;
1029
1030 context_stack_depth = 0;
1031
1032 /* These should have been reset either by successful completion of building
1033 a symtab, or by the scoped_free_pendings destructor. */
1034 gdb_assert (file_symbols == NULL);
1035 gdb_assert (global_symbols == NULL);
1036 gdb_assert (global_using_directives == NULL);
1037 gdb_assert (pending_macros == NULL);
1038 gdb_assert (pending_addrmap == NULL);
1039 gdb_assert (current_subfile == NULL);
1040 }
1041
1042 /* Start a new symtab for a new source file in OBJFILE. Called, for example,
1043 when a stabs symbol of type N_SO is seen, or when a DWARF
1044 TAG_compile_unit DIE is seen. It indicates the start of data for
1045 one original source file.
1046
1047 NAME is the name of the file (cannot be NULL). COMP_DIR is the
1048 directory in which the file was compiled (or NULL if not known).
1049 START_ADDR is the lowest address of objects in the file (or 0 if
1050 not known). LANGUAGE is the language of the source file, or
1051 language_unknown if not known, in which case it'll be deduced from
1052 the filename. */
1053
1054 struct compunit_symtab *
1055 start_symtab (struct objfile *objfile, const char *name, const char *comp_dir,
1056 CORE_ADDR start_addr, enum language language)
1057 {
1058 prepare_for_building (name, start_addr);
1059
1060 buildsym_compunit = start_buildsym_compunit (objfile, comp_dir, language);
1061
1062 /* Allocate the compunit symtab now. The caller needs it to allocate
1063 non-primary symtabs. It is also needed by get_macro_table. */
1064 buildsym_compunit->compunit_symtab = allocate_compunit_symtab (objfile,
1065 name);
1066
1067 /* Build the subfile for NAME (the main source file) so that we can record
1068 a pointer to it for later.
1069 IMPORTANT: Do not allocate a struct symtab for NAME here.
1070 It can happen that the debug info provides a different path to NAME than
1071 DIRNAME,NAME. We cope with this in watch_main_source_file_lossage but
1072 that only works if the main_subfile doesn't have a symtab yet. */
1073 start_subfile (name);
1074 /* Save this so that we don't have to go looking for it at the end
1075 of the subfiles list. */
1076 buildsym_compunit->main_subfile = current_subfile;
1077
1078 return buildsym_compunit->compunit_symtab;
1079 }
1080
1081 /* Restart compilation for a symtab.
1082 CUST is the result of end_expandable_symtab.
1083 NAME, START_ADDR are the source file we are resuming with.
1084
1085 This is used when a symtab is built from multiple sources.
1086 The symtab is first built with start_symtab/end_expandable_symtab
1087 and then for each additional piece call restart_symtab/augment_*_symtab.
1088 Note: At the moment there is only augment_type_symtab. */
1089
1090 void
1091 restart_symtab (struct compunit_symtab *cust,
1092 const char *name, CORE_ADDR start_addr)
1093 {
1094 prepare_for_building (name, start_addr);
1095
1096 buildsym_compunit = start_buildsym_compunit (COMPUNIT_OBJFILE (cust),
1097 COMPUNIT_DIRNAME (cust),
1098 compunit_language (cust));
1099 buildsym_compunit->compunit_symtab = cust;
1100 }
1101
1102 /* Subroutine of end_symtab to simplify it. Look for a subfile that
1103 matches the main source file's basename. If there is only one, and
1104 if the main source file doesn't have any symbol or line number
1105 information, then copy this file's symtab and line_vector to the
1106 main source file's subfile and discard the other subfile. This can
1107 happen because of a compiler bug or from the user playing games
1108 with #line or from things like a distributed build system that
1109 manipulates the debug info. This can also happen from an innocent
1110 symlink in the paths, we don't canonicalize paths here. */
1111
1112 static void
1113 watch_main_source_file_lossage (void)
1114 {
1115 struct subfile *mainsub, *subfile;
1116
1117 /* We have to watch for buildsym_compunit == NULL here. It's a quirk of
1118 end_symtab, it can return NULL so there may not be a main subfile. */
1119 if (buildsym_compunit == NULL)
1120 return;
1121
1122 /* Get the main source file. */
1123 mainsub = buildsym_compunit->main_subfile;
1124
1125 /* If the main source file doesn't have any line number or symbol
1126 info, look for an alias in another subfile. */
1127
1128 if (mainsub->line_vector == NULL
1129 && mainsub->symtab == NULL)
1130 {
1131 const char *mainbase = lbasename (mainsub->name);
1132 int nr_matches = 0;
1133 struct subfile *prevsub;
1134 struct subfile *mainsub_alias = NULL;
1135 struct subfile *prev_mainsub_alias = NULL;
1136
1137 prevsub = NULL;
1138 for (subfile = buildsym_compunit->subfiles;
1139 subfile != NULL;
1140 subfile = subfile->next)
1141 {
1142 if (subfile == mainsub)
1143 continue;
1144 if (filename_cmp (lbasename (subfile->name), mainbase) == 0)
1145 {
1146 ++nr_matches;
1147 mainsub_alias = subfile;
1148 prev_mainsub_alias = prevsub;
1149 }
1150 prevsub = subfile;
1151 }
1152
1153 if (nr_matches == 1)
1154 {
1155 gdb_assert (mainsub_alias != NULL && mainsub_alias != mainsub);
1156
1157 /* Found a match for the main source file.
1158 Copy its line_vector and symtab to the main subfile
1159 and then discard it. */
1160
1161 mainsub->line_vector = mainsub_alias->line_vector;
1162 mainsub->line_vector_length = mainsub_alias->line_vector_length;
1163 mainsub->symtab = mainsub_alias->symtab;
1164
1165 if (prev_mainsub_alias == NULL)
1166 buildsym_compunit->subfiles = mainsub_alias->next;
1167 else
1168 prev_mainsub_alias->next = mainsub_alias->next;
1169 xfree (mainsub_alias->name);
1170 xfree (mainsub_alias);
1171 }
1172 }
1173 }
1174
1175 /* Reset state after a successful building of a symtab.
1176 This exists because dbxread.c and xcoffread.c can call
1177 start_symtab+end_symtab multiple times after one call to buildsym_init,
1178 and before the scoped_free_pendings destructor is called.
1179 We keep the free_pendings list around for dbx/xcoff sake. */
1180
1181 static void
1182 reset_symtab_globals (void)
1183 {
1184 set_last_source_file (NULL);
1185
1186 local_symbols = NULL;
1187 local_using_directives = NULL;
1188 file_symbols = NULL;
1189 global_symbols = NULL;
1190 global_using_directives = NULL;
1191
1192 /* We don't free pending_macros here because if the symtab was successfully
1193 built then ownership was transferred to the symtab. */
1194 pending_macros = NULL;
1195
1196 if (pending_addrmap)
1197 obstack_free (&pending_addrmap_obstack, NULL);
1198 pending_addrmap = NULL;
1199
1200 free_buildsym_compunit ();
1201 }
1202
1203 /* Implementation of the first part of end_symtab. It allows modifying
1204 STATIC_BLOCK before it gets finalized by end_symtab_from_static_block.
1205 If the returned value is NULL there is no blockvector created for
1206 this symtab (you still must call end_symtab_from_static_block).
1207
1208 END_ADDR is the same as for end_symtab: the address of the end of the
1209 file's text.
1210
1211 If EXPANDABLE is non-zero the STATIC_BLOCK dictionary is made
1212 expandable.
1213
1214 If REQUIRED is non-zero, then a symtab is created even if it does
1215 not contain any symbols. */
1216
1217 struct block *
1218 end_symtab_get_static_block (CORE_ADDR end_addr, int expandable, int required)
1219 {
1220 struct objfile *objfile = buildsym_compunit->objfile;
1221
1222 /* Finish the lexical context of the last function in the file; pop
1223 the context stack. */
1224
1225 if (context_stack_depth > 0)
1226 {
1227 struct context_stack *cstk = pop_context ();
1228
1229 /* Make a block for the local symbols within. */
1230 finish_block (cstk->name, &local_symbols, cstk->old_blocks, NULL,
1231 cstk->start_addr, end_addr);
1232
1233 if (context_stack_depth > 0)
1234 {
1235 /* This is said to happen with SCO. The old coffread.c
1236 code simply emptied the context stack, so we do the
1237 same. FIXME: Find out why it is happening. This is not
1238 believed to happen in most cases (even for coffread.c);
1239 it used to be an abort(). */
1240 complaint (&symfile_complaints,
1241 _("Context stack not empty in end_symtab"));
1242 context_stack_depth = 0;
1243 }
1244 }
1245
1246 /* Reordered executables may have out of order pending blocks; if
1247 OBJF_REORDERED is true, then sort the pending blocks. */
1248
1249 if ((objfile->flags & OBJF_REORDERED) && pending_blocks)
1250 {
1251 struct pending_block *pb;
1252
1253 std::vector<block *> barray;
1254
1255 for (pb = pending_blocks; pb != NULL; pb = pb->next)
1256 barray.push_back (pb->block);
1257
1258 /* Sort blocks by start address in descending order. Blocks with the
1259 same start address must remain in the original order to preserve
1260 inline function caller/callee relationships. */
1261 std::stable_sort (barray.begin (), barray.end (),
1262 [] (const block *a, const block *b)
1263 {
1264 return BLOCK_START (a) > BLOCK_START (b);
1265 });
1266
1267 int i = 0;
1268 for (pb = pending_blocks; pb != NULL; pb = pb->next)
1269 pb->block = barray[i++];
1270 }
1271
1272 /* Cleanup any undefined types that have been left hanging around
1273 (this needs to be done before the finish_blocks so that
1274 file_symbols is still good).
1275
1276 Both cleanup_undefined_stabs_types and finish_global_stabs are stabs
1277 specific, but harmless for other symbol readers, since on gdb
1278 startup or when finished reading stabs, the state is set so these
1279 are no-ops. FIXME: Is this handled right in case of QUIT? Can
1280 we make this cleaner? */
1281
1282 cleanup_undefined_stabs_types (objfile);
1283 finish_global_stabs (objfile);
1284
1285 if (!required
1286 && pending_blocks == NULL
1287 && file_symbols == NULL
1288 && global_symbols == NULL
1289 && have_line_numbers == 0
1290 && pending_macros == NULL
1291 && global_using_directives == NULL)
1292 {
1293 /* Ignore symtabs that have no functions with real debugging info. */
1294 return NULL;
1295 }
1296 else
1297 {
1298 /* Define the STATIC_BLOCK. */
1299 return finish_block_internal (NULL, &file_symbols, NULL, NULL,
1300 last_source_start_addr, end_addr,
1301 0, expandable);
1302 }
1303 }
1304
1305 /* Subroutine of end_symtab_from_static_block to simplify it.
1306 Handle the "have blockvector" case.
1307 See end_symtab_from_static_block for a description of the arguments. */
1308
1309 static struct compunit_symtab *
1310 end_symtab_with_blockvector (struct block *static_block,
1311 int section, int expandable)
1312 {
1313 struct objfile *objfile = buildsym_compunit->objfile;
1314 struct compunit_symtab *cu = buildsym_compunit->compunit_symtab;
1315 struct symtab *symtab;
1316 struct blockvector *blockvector;
1317 struct subfile *subfile;
1318 CORE_ADDR end_addr;
1319
1320 gdb_assert (static_block != NULL);
1321 gdb_assert (buildsym_compunit != NULL);
1322 gdb_assert (buildsym_compunit->subfiles != NULL);
1323
1324 end_addr = BLOCK_END (static_block);
1325
1326 /* Create the GLOBAL_BLOCK and build the blockvector. */
1327 finish_block_internal (NULL, &global_symbols, NULL, NULL,
1328 last_source_start_addr, end_addr,
1329 1, expandable);
1330 blockvector = make_blockvector ();
1331
1332 /* Read the line table if it has to be read separately.
1333 This is only used by xcoffread.c. */
1334 if (objfile->sf->sym_read_linetable != NULL)
1335 objfile->sf->sym_read_linetable (objfile);
1336
1337 /* Handle the case where the debug info specifies a different path
1338 for the main source file. It can cause us to lose track of its
1339 line number information. */
1340 watch_main_source_file_lossage ();
1341
1342 /* Now create the symtab objects proper, if not already done,
1343 one for each subfile. */
1344
1345 for (subfile = buildsym_compunit->subfiles;
1346 subfile != NULL;
1347 subfile = subfile->next)
1348 {
1349 int linetablesize = 0;
1350
1351 if (subfile->line_vector)
1352 {
1353 linetablesize = sizeof (struct linetable) +
1354 subfile->line_vector->nitems * sizeof (struct linetable_entry);
1355
1356 /* Like the pending blocks, the line table may be
1357 scrambled in reordered executables. Sort it if
1358 OBJF_REORDERED is true. */
1359 if (objfile->flags & OBJF_REORDERED)
1360 qsort (subfile->line_vector->item,
1361 subfile->line_vector->nitems,
1362 sizeof (struct linetable_entry), compare_line_numbers);
1363 }
1364
1365 /* Allocate a symbol table if necessary. */
1366 if (subfile->symtab == NULL)
1367 subfile->symtab = allocate_symtab (cu, subfile->name);
1368 symtab = subfile->symtab;
1369
1370 /* Fill in its components. */
1371
1372 if (subfile->line_vector)
1373 {
1374 /* Reallocate the line table on the symbol obstack. */
1375 SYMTAB_LINETABLE (symtab) = (struct linetable *)
1376 obstack_alloc (&objfile->objfile_obstack, linetablesize);
1377 memcpy (SYMTAB_LINETABLE (symtab), subfile->line_vector,
1378 linetablesize);
1379 }
1380 else
1381 {
1382 SYMTAB_LINETABLE (symtab) = NULL;
1383 }
1384
1385 /* Use whatever language we have been using for this
1386 subfile, not the one that was deduced in allocate_symtab
1387 from the filename. We already did our own deducing when
1388 we created the subfile, and we may have altered our
1389 opinion of what language it is from things we found in
1390 the symbols. */
1391 symtab->language = subfile->language;
1392 }
1393
1394 /* Make sure the symtab of main_subfile is the first in its list. */
1395 {
1396 struct symtab *main_symtab, *prev_symtab;
1397
1398 main_symtab = buildsym_compunit->main_subfile->symtab;
1399 prev_symtab = NULL;
1400 ALL_COMPUNIT_FILETABS (cu, symtab)
1401 {
1402 if (symtab == main_symtab)
1403 {
1404 if (prev_symtab != NULL)
1405 {
1406 prev_symtab->next = main_symtab->next;
1407 main_symtab->next = COMPUNIT_FILETABS (cu);
1408 COMPUNIT_FILETABS (cu) = main_symtab;
1409 }
1410 break;
1411 }
1412 prev_symtab = symtab;
1413 }
1414 gdb_assert (main_symtab == COMPUNIT_FILETABS (cu));
1415 }
1416
1417 /* Fill out the compunit symtab. */
1418
1419 if (buildsym_compunit->comp_dir != NULL)
1420 {
1421 /* Reallocate the dirname on the symbol obstack. */
1422 COMPUNIT_DIRNAME (cu)
1423 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
1424 buildsym_compunit->comp_dir,
1425 strlen (buildsym_compunit->comp_dir));
1426 }
1427
1428 /* Save the debug format string (if any) in the symtab. */
1429 COMPUNIT_DEBUGFORMAT (cu) = buildsym_compunit->debugformat;
1430
1431 /* Similarly for the producer. */
1432 COMPUNIT_PRODUCER (cu) = buildsym_compunit->producer;
1433
1434 COMPUNIT_BLOCKVECTOR (cu) = blockvector;
1435 {
1436 struct block *b = BLOCKVECTOR_BLOCK (blockvector, GLOBAL_BLOCK);
1437
1438 set_block_compunit_symtab (b, cu);
1439 }
1440
1441 COMPUNIT_BLOCK_LINE_SECTION (cu) = section;
1442
1443 COMPUNIT_MACRO_TABLE (cu) = pending_macros;
1444
1445 /* Default any symbols without a specified symtab to the primary symtab. */
1446 {
1447 int block_i;
1448
1449 /* The main source file's symtab. */
1450 symtab = COMPUNIT_FILETABS (cu);
1451
1452 for (block_i = 0; block_i < BLOCKVECTOR_NBLOCKS (blockvector); block_i++)
1453 {
1454 struct block *block = BLOCKVECTOR_BLOCK (blockvector, block_i);
1455 struct symbol *sym;
1456 struct dict_iterator iter;
1457
1458 /* Inlined functions may have symbols not in the global or
1459 static symbol lists. */
1460 if (BLOCK_FUNCTION (block) != NULL)
1461 if (symbol_symtab (BLOCK_FUNCTION (block)) == NULL)
1462 symbol_set_symtab (BLOCK_FUNCTION (block), symtab);
1463
1464 /* Note that we only want to fix up symbols from the local
1465 blocks, not blocks coming from included symtabs. That is why
1466 we use ALL_DICT_SYMBOLS here and not ALL_BLOCK_SYMBOLS. */
1467 ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
1468 if (symbol_symtab (sym) == NULL)
1469 symbol_set_symtab (sym, symtab);
1470 }
1471 }
1472
1473 add_compunit_symtab_to_objfile (cu);
1474
1475 return cu;
1476 }
1477
1478 /* Implementation of the second part of end_symtab. Pass STATIC_BLOCK
1479 as value returned by end_symtab_get_static_block.
1480
1481 SECTION is the same as for end_symtab: the section number
1482 (in objfile->section_offsets) of the blockvector and linetable.
1483
1484 If EXPANDABLE is non-zero the GLOBAL_BLOCK dictionary is made
1485 expandable. */
1486
1487 struct compunit_symtab *
1488 end_symtab_from_static_block (struct block *static_block,
1489 int section, int expandable)
1490 {
1491 struct compunit_symtab *cu;
1492
1493 if (static_block == NULL)
1494 {
1495 /* Handle the "no blockvector" case.
1496 When this happens there is nothing to record, so there's nothing
1497 to do: memory will be freed up later.
1498
1499 Note: We won't be adding a compunit to the objfile's list of
1500 compunits, so there's nothing to unchain. However, since each symtab
1501 is added to the objfile's obstack we can't free that space.
1502 We could do better, but this is believed to be a sufficiently rare
1503 event. */
1504 cu = NULL;
1505 }
1506 else
1507 cu = end_symtab_with_blockvector (static_block, section, expandable);
1508
1509 reset_symtab_globals ();
1510
1511 return cu;
1512 }
1513
1514 /* Finish the symbol definitions for one main source file, close off
1515 all the lexical contexts for that file (creating struct block's for
1516 them), then make the struct symtab for that file and put it in the
1517 list of all such.
1518
1519 END_ADDR is the address of the end of the file's text. SECTION is
1520 the section number (in objfile->section_offsets) of the blockvector
1521 and linetable.
1522
1523 Note that it is possible for end_symtab() to return NULL. In
1524 particular, for the DWARF case at least, it will return NULL when
1525 it finds a compilation unit that has exactly one DIE, a
1526 TAG_compile_unit DIE. This can happen when we link in an object
1527 file that was compiled from an empty source file. Returning NULL
1528 is probably not the correct thing to do, because then gdb will
1529 never know about this empty file (FIXME).
1530
1531 If you need to modify STATIC_BLOCK before it is finalized you should
1532 call end_symtab_get_static_block and end_symtab_from_static_block
1533 yourself. */
1534
1535 struct compunit_symtab *
1536 end_symtab (CORE_ADDR end_addr, int section)
1537 {
1538 struct block *static_block;
1539
1540 static_block = end_symtab_get_static_block (end_addr, 0, 0);
1541 return end_symtab_from_static_block (static_block, section, 0);
1542 }
1543
1544 /* Same as end_symtab except create a symtab that can be later added to. */
1545
1546 struct compunit_symtab *
1547 end_expandable_symtab (CORE_ADDR end_addr, int section)
1548 {
1549 struct block *static_block;
1550
1551 static_block = end_symtab_get_static_block (end_addr, 1, 0);
1552 return end_symtab_from_static_block (static_block, section, 1);
1553 }
1554
1555 /* Subroutine of augment_type_symtab to simplify it.
1556 Attach the main source file's symtab to all symbols in PENDING_LIST that
1557 don't have one. */
1558
1559 static void
1560 set_missing_symtab (struct pending *pending_list,
1561 struct compunit_symtab *cu)
1562 {
1563 struct pending *pending;
1564 int i;
1565
1566 for (pending = pending_list; pending != NULL; pending = pending->next)
1567 {
1568 for (i = 0; i < pending->nsyms; ++i)
1569 {
1570 if (symbol_symtab (pending->symbol[i]) == NULL)
1571 symbol_set_symtab (pending->symbol[i], COMPUNIT_FILETABS (cu));
1572 }
1573 }
1574 }
1575
1576 /* Same as end_symtab, but for the case where we're adding more symbols
1577 to an existing symtab that is known to contain only type information.
1578 This is the case for DWARF4 Type Units. */
1579
1580 void
1581 augment_type_symtab (void)
1582 {
1583 struct compunit_symtab *cust = buildsym_compunit->compunit_symtab;
1584 const struct blockvector *blockvector = COMPUNIT_BLOCKVECTOR (cust);
1585
1586 if (context_stack_depth > 0)
1587 {
1588 complaint (&symfile_complaints,
1589 _("Context stack not empty in augment_type_symtab"));
1590 context_stack_depth = 0;
1591 }
1592 if (pending_blocks != NULL)
1593 complaint (&symfile_complaints, _("Blocks in a type symtab"));
1594 if (pending_macros != NULL)
1595 complaint (&symfile_complaints, _("Macro in a type symtab"));
1596 if (have_line_numbers)
1597 complaint (&symfile_complaints,
1598 _("Line numbers recorded in a type symtab"));
1599
1600 if (file_symbols != NULL)
1601 {
1602 struct block *block = BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK);
1603
1604 /* First mark any symbols without a specified symtab as belonging
1605 to the primary symtab. */
1606 set_missing_symtab (file_symbols, cust);
1607
1608 dict_add_pending (BLOCK_DICT (block), file_symbols);
1609 }
1610
1611 if (global_symbols != NULL)
1612 {
1613 struct block *block = BLOCKVECTOR_BLOCK (blockvector, GLOBAL_BLOCK);
1614
1615 /* First mark any symbols without a specified symtab as belonging
1616 to the primary symtab. */
1617 set_missing_symtab (global_symbols, cust);
1618
1619 dict_add_pending (BLOCK_DICT (block), global_symbols);
1620 }
1621
1622 reset_symtab_globals ();
1623 }
1624
1625 /* Push a context block. Args are an identifying nesting level
1626 (checkable when you pop it), and the starting PC address of this
1627 context. */
1628
1629 struct context_stack *
1630 push_context (int desc, CORE_ADDR valu)
1631 {
1632 struct context_stack *newobj;
1633
1634 if (context_stack_depth == context_stack_size)
1635 {
1636 context_stack_size *= 2;
1637 context_stack = (struct context_stack *)
1638 xrealloc ((char *) context_stack,
1639 (context_stack_size * sizeof (struct context_stack)));
1640 }
1641
1642 newobj = &context_stack[context_stack_depth++];
1643 newobj->depth = desc;
1644 newobj->locals = local_symbols;
1645 newobj->old_blocks = pending_blocks;
1646 newobj->start_addr = valu;
1647 newobj->local_using_directives = local_using_directives;
1648 newobj->name = NULL;
1649
1650 local_symbols = NULL;
1651 local_using_directives = NULL;
1652
1653 return newobj;
1654 }
1655
1656 /* Pop a context block. Returns the address of the context block just
1657 popped. */
1658
1659 struct context_stack *
1660 pop_context (void)
1661 {
1662 gdb_assert (context_stack_depth > 0);
1663 return (&context_stack[--context_stack_depth]);
1664 }
1665
1666
1667
1668 /* Compute a small integer hash code for the given name. */
1669
1670 int
1671 hashname (const char *name)
1672 {
1673 return (hash(name,strlen(name)) % HASHSIZE);
1674 }
1675
1676
1677 void
1678 record_debugformat (const char *format)
1679 {
1680 buildsym_compunit->debugformat = format;
1681 }
1682
1683 void
1684 record_producer (const char *producer)
1685 {
1686 buildsym_compunit->producer = producer;
1687 }
1688
1689 /* Merge the first symbol list SRCLIST into the second symbol list
1690 TARGETLIST by repeated calls to add_symbol_to_list(). This
1691 procedure "frees" each link of SRCLIST by adding it to the
1692 free_pendings list. Caller must set SRCLIST to a null list after
1693 calling this function.
1694
1695 Void return. */
1696
1697 void
1698 merge_symbol_lists (struct pending **srclist, struct pending **targetlist)
1699 {
1700 int i;
1701
1702 if (!srclist || !*srclist)
1703 return;
1704
1705 /* Merge in elements from current link. */
1706 for (i = 0; i < (*srclist)->nsyms; i++)
1707 add_symbol_to_list ((*srclist)->symbol[i], targetlist);
1708
1709 /* Recurse on next. */
1710 merge_symbol_lists (&(*srclist)->next, targetlist);
1711
1712 /* "Free" the current link. */
1713 (*srclist)->next = free_pendings;
1714 free_pendings = (*srclist);
1715 }
1716
1717
1718 /* Name of source file whose symbol data we are now processing. This
1719 comes from a symbol of type N_SO for stabs. For Dwarf it comes
1720 from the DW_AT_name attribute of a DW_TAG_compile_unit DIE. */
1721
1722 static char *last_source_file;
1723
1724 /* See buildsym.h. */
1725
1726 void
1727 set_last_source_file (const char *name)
1728 {
1729 xfree (last_source_file);
1730 last_source_file = name == NULL ? NULL : xstrdup (name);
1731 }
1732
1733 /* See buildsym.h. */
1734
1735 const char *
1736 get_last_source_file (void)
1737 {
1738 return last_source_file;
1739 }
1740
1741
1742
1743 /* Initialize anything that needs initializing when starting to read a
1744 fresh piece of a symbol file, e.g. reading in the stuff
1745 corresponding to a psymtab. */
1746
1747 void
1748 buildsym_init (void)
1749 {
1750 subfile_stack = NULL;
1751
1752 pending_addrmap_interesting = 0;
1753
1754 /* Context stack is initially empty. Allocate first one with room
1755 for a few levels; reuse it forever afterward. */
1756 if (context_stack == NULL)
1757 {
1758 context_stack_size = INITIAL_CONTEXT_STACK_SIZE;
1759 context_stack = XNEWVEC (struct context_stack, context_stack_size);
1760 }
1761
1762 /* Ensure the scoped_free_pendings destructor was called after
1763 the last time. */
1764 gdb_assert (free_pendings == NULL);
1765 gdb_assert (pending_blocks == NULL);
1766 gdb_assert (file_symbols == NULL);
1767 gdb_assert (global_symbols == NULL);
1768 gdb_assert (global_using_directives == NULL);
1769 gdb_assert (pending_macros == NULL);
1770 gdb_assert (pending_addrmap == NULL);
1771 gdb_assert (buildsym_compunit == NULL);
1772 }
1773
1774 /* Initialize anything that needs initializing when a completely new
1775 symbol file is specified (not just adding some symbols from another
1776 file, e.g. a shared library). */
1777
1778 void
1779 buildsym_new_init (void)
1780 {
1781 buildsym_init ();
1782 }
buildsym_compunit
static struct buildsym_compunit * buildsym_compunit
Definition: buildsym.c:136
gdbarch
Definition: gdbarch.c:127
objfile::flags
objfile_flags flags
Definition: objfiles.h:311
context_stack
EXTERN struct context_stack * context_stack
Definition: buildsym.h:170
hex_string
char * hex_string(LONGEST num)
Definition: print-utils.c:220
prepare_for_building
static void prepare_for_building(const char *name, CORE_ADDR start_addr)
Definition: buildsym.c:1020
symtab::next
struct symtab * next
Definition: symtab.h:1296
pending_block
Definition: buildsym.c:170
subfile_stack::name
char * name
Definition: buildsym.c:186
gdb_obstack.h
set_missing_symtab
static void set_missing_symtab(struct pending *pending_list, struct compunit_symtab *cu)
Definition: buildsym.c:1560
finish_block
struct block * finish_block(struct symbol *symbol, struct pending **listhead, struct pending_block *old_blocks, const struct dynamic_prop *static_link, CORE_ADDR start, CORE_ADDR end)
Definition: buildsym.c:528
buildsym_compunit::debugformat
const char * debugformat
Definition: buildsym.c:124
COMPUNIT_DEBUGFORMAT
#define COMPUNIT_DEBUGFORMAT(cust)
Definition: symtab.h:1462
PENDINGSIZE
#define PENDINGSIZE
Definition: buildsym.h:99
SYMBOL_PRINT_NAME
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:542
symbol_set_symtab
void symbol_set_symtab(struct symbol *symbol, struct symtab *symtab)
Definition: symtab.c:5812
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
linetable::item
struct linetable_entry item[1]
Definition: symtab.h:1258
record_block_range
void record_block_range(struct block *block, CORE_ADDR start, CORE_ADDR end_inclusive)
Definition: buildsym.c:578
compare_line_numbers
static int compare_line_numbers(const void *ln1p, const void *ln2p)
Definition: buildsym.c:965
pop_subfile
char * pop_subfile(void)
Definition: buildsym.c:883
xfree
void xfree(void *)
hashname
int hashname(const char *name)
Definition: buildsym.c:1671
context_stack::local_using_directives
struct using_direct * local_using_directives
Definition: buildsym.h:141
buildsym_compunit::main_subfile
struct subfile * main_subfile
Definition: buildsym.c:113
add_symbol_to_list
void add_symbol_to_list(struct symbol *symbol, struct pending **listhead)
Definition: buildsym.c:216
subfile
Definition: buildsym.h:62
TYPE_FIELD_ARTIFICIAL
#define TYPE_FIELD_ARTIFICIAL(thistype, n)
Definition: gdbtypes.h:1379
dict_create_linear
struct dictionary * dict_create_linear(struct obstack *obstack, enum language language, const struct pending *symbol_list)
Definition: dictionary.c:409
patch_subfile_names
void patch_subfile_names(struct subfile *subfile, const char *name)
Definition: buildsym.c:831
set_last_source_file
void set_last_source_file(const char *name)
Definition: buildsym.c:1727
global_using_directives
EXTERN struct using_direct * global_using_directives
Definition: buildsym.h:128
allocate_compunit_symtab
struct compunit_symtab * allocate_compunit_symtab(struct objfile *objfile, const char *name)
Definition: symfile.c:2842
pending_addrmap_interesting
static int pending_addrmap_interesting
Definition: buildsym.c:161
end_symtab
struct compunit_symtab * end_symtab(CORE_ADDR end_addr, int section)
Definition: buildsym.c:1536
COMPUNIT_MACRO_TABLE
#define COMPUNIT_MACRO_TABLE(cust)
Definition: symtab.h:1470
memset
void * memset(T *s, int c, size_t n)=delete
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
file_symbols
EXTERN struct pending * file_symbols
Definition: buildsym.h:112
buildsym_compunit::comp_dir
char * comp_dir
Definition: buildsym.c:116
ALL_DICT_SYMBOLS
#define ALL_DICT_SYMBOLS(dict, iter, sym)
Definition: dictionary.h:162
pending_block::block
struct block * block
Definition: buildsym.c:173
subfile::name
char * name
Definition: buildsym.h:66
pending::symbol
struct symbol * symbol[PENDINGSIZE]
Definition: buildsym.h:105
augment_type_symtab
void augment_type_symtab(void)
Definition: buildsym.c:1581
cp-support.h
compunit_symtab
Definition: symtab.h:1380
reset_symtab_globals
static void reset_symtab_globals(void)
Definition: buildsym.c:1182
BLOCKVECTOR_BLOCK
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:125
dynamic_prop
Definition: gdbtypes.h:398
free_pendings
static struct pending * free_pendings
Definition: buildsym.c:140
finish_block_internal
static struct block * finish_block_internal(struct symbol *symbol, struct pending **listhead, struct pending_block *old_blocks, const struct dynamic_prop *static_link, CORE_ADDR start, CORE_ADDR end, int is_global, int expandable)
Definition: buildsym.c:332
_
#define _(String)
Definition: gdb_locale.h:35
context_stack_depth
EXTERN int context_stack_depth
Definition: buildsym.h:174
record_line
void record_line(struct subfile *subfile, int line, CORE_ADDR pc)
Definition: buildsym.c:903
defs.h
BLOCK_START
#define BLOCK_START(bl)
Definition: block.h:105
macro_table
Definition: macrotab.c:35
COMPUNIT_DIRNAME
#define COMPUNIT_DIRNAME(cust)
Definition: symtab.h:1464
free_buildsym_compunit
static void free_buildsym_compunit(void)
Definition: buildsym.c:797
TYPE_FIELD_TYPE
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1371
start_buildsym_compunit
static struct buildsym_compunit * start_buildsym_compunit(struct objfile *objfile, const char *comp_dir, enum language language)
Definition: buildsym.c:772
free_pending_blocks
void free_pending_blocks(void)
Definition: buildsym.c:318
objfile::per_bfd
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:347
get_macro_table
struct macro_table * get_macro_table(void)
Definition: buildsym.c:996
buildsym_compunit_symtab
struct compunit_symtab * buildsym_compunit_symtab(void)
Definition: buildsym.c:986
restart_symtab
void restart_symtab(struct compunit_symtab *cust, const char *name, CORE_ADDR start_addr)
Definition: buildsym.c:1091
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
objfiles.h
XNEW
#define XNEW(T)
Definition: poison.h:109
buildsym_compunit::compunit_symtab
struct compunit_symtab * compunit_symtab
Definition: buildsym.c:127
end_symtab_get_static_block
struct block * end_symtab_get_static_block(CORE_ADDR end_addr, int expandable, int required)
Definition: buildsym.c:1218
BLOCK_FUNCTION
#define BLOCK_FUNCTION(bl)
Definition: block.h:107
buildsym_compunit::producer
const char * producer
Definition: buildsym.c:120
current_subfile
EXTERN struct subfile * current_subfile
Definition: buildsym.h:76
GLOBAL_BLOCK
Definition: defs.h:686
symtab.h
block_set_using
void block_set_using(struct block *block, struct using_direct *using_decl, struct obstack *obstack)
Definition: block.c:337
context_stack::end_addr
CORE_ADDR end_addr
Definition: buildsym.h:162
pending_addrmap
static struct addrmap * pending_addrmap
Definition: buildsym.c:150
name
const char *const name
Definition: aarch64-tdep.c:76
finish_global_stabs
void finish_global_stabs(struct objfile *objfile)
Definition: stabsread.c:4806
SLASH_STRING
#define SLASH_STRING
Definition: host-defs.h:58
pending_block_obstack
static struct obstack pending_block_obstack
Definition: buildsym.c:165
OBJF_REORDERED
Definition: objfile-flags.h:36
merge_symbol_lists
void merge_symbol_lists(struct pending **srclist, struct pending **targetlist)
Definition: buildsym.c:1698
INITIAL_LINE_VECTOR_LENGTH
#define INITIAL_LINE_VECTOR_LENGTH
Definition: buildsym.c:208
pending::nsyms
int nsyms
Definition: buildsym.h:104
linetable_entry::pc
CORE_ADDR pc
Definition: symtab.h:1231
global_symbols
EXTERN struct pending * global_symbols
Definition: buildsym.h:116
pending::next
struct pending * next
Definition: buildsym.h:103
objfile::objfile
objfile(bfd *, const char *, objfile_flags)
Definition: objfiles.c:373
context_stack::old_blocks
struct pending_block * old_blocks
Definition: buildsym.h:145
dict_add_pending
void dict_add_pending(struct dictionary *dict, const struct pending *symbol_list)
Definition: dictionary.c:490
end_symtab_from_static_block
struct compunit_symtab * end_symtab_from_static_block(struct block *static_block, int section, int expandable)
Definition: buildsym.c:1488
INITIAL_CONTEXT_STACK_SIZE
#define INITIAL_CONTEXT_STACK_SIZE
Definition: buildsym.c:207
subfile::buildsym_compunit
struct buildsym_compunit * buildsym_compunit
Definition: buildsym.h:71
buildsym.h
linetable
Definition: symtab.h:1251
subfile_stack
Definition: buildsym.c:183
expression.h
macrotab.h
cleanup_undefined_stabs_types
void cleanup_undefined_stabs_types(struct objfile *objfile)
Definition: stabsread.c:4610
objfile::sf
const struct sym_fns * sf
Definition: objfiles.h:381
buildsym_new_init
void buildsym_new_init(void)
Definition: buildsym.c:1779
have_line_numbers
static int have_line_numbers
Definition: buildsym.c:145
buildsym_compunit::objfile
struct objfile * objfile
Definition: buildsym.c:104
get_objfile_arch
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:445
local_symbols
EXTERN struct pending * local_symbols
Definition: buildsym.h:120
addrmap_create_mutable
struct addrmap * addrmap_create_mutable(struct obstack *obstack)
Definition: addrmap.c:569
add_compunit_symtab_to_objfile
void add_compunit_symtab_to_objfile(struct compunit_symtab *cu)
Definition: symfile.c:2874
linetable_entry
Definition: symtab.h:1228
type
Definition: gdbtypes.h:749
end_expandable_symtab
struct compunit_symtab * end_expandable_symtab(CORE_ADDR end_addr, int section)
Definition: buildsym.c:1547
pending
Definition: buildsym.h:101
BLOCK_SUPERBLOCK
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:108
pending_block::next
struct pending_block * next
Definition: buildsym.c:172
pop_context
struct context_stack * pop_context(void)
Definition: buildsym.c:1660
symtab::language
enum language language
Definition: symtab.h:1323
COMPUNIT_PRODUCER
#define COMPUNIT_PRODUCER(cust)
Definition: symtab.h:1463
get_last_source_file
const char * get_last_source_file(void)
Definition: buildsym.c:1736
field
Definition: gdbtypes.h:517
SYMBOL_LINKAGE_NAME
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:523
complaint
#define complaint(COMPLAINTS, FMT,...)
Definition: complaints.h:40
buildsym_compunit
Definition: buildsym.c:101
record_pending_block
static void record_pending_block(struct objfile *objfile, struct block *block, struct pending_block *opblock)
Definition: buildsym.c:546
BLOCK_END
#define BLOCK_END(bl)
Definition: block.h:106
language_fortran
Definition: defs.h:212
allocate_block
struct block * allocate_block(struct obstack *obstack)
Definition: block.c:400
BLOCK_DICT
#define BLOCK_DICT(bl)
Definition: block.h:109
TYPE_FIELDS
#define TYPE_FIELDS(thistype)
Definition: gdbtypes.h:1240
objfile_per_bfd_storage::macro_cache
bcache * macro_cache
Definition: objfiles.h:203
addrmap_set_empty
void addrmap_set_empty(struct addrmap *map, CORE_ADDR start, CORE_ADDR end_inclusive, void *obj)
Definition: addrmap.c:50
symtab
Definition: symtab.h:1291
subfile_stack::next
struct subfile_stack * next
Definition: buildsym.c:185
xmalloc
void * xmalloc(YYSIZE_T)
complaints.h
general_symbol_info::name
const char * name
Definition: symtab.h:384
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
dict_iterator
Definition: dictionary.h:106
hash
unsigned long hash(const void *addr, int length)
Definition: bcache.c:98
blockvector
Definition: block.h:112
addrmap.h
context_stack
Definition: buildsym.h:133
xrealloc
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:52
objfile
Definition: objfiles.h:286
COMPUNIT_BLOCKVECTOR
#define COMPUNIT_BLOCKVECTOR(cust)
Definition: symtab.h:1465
pending_list
static struct mdebug_pending ** pending_list
Definition: mdebugread.c:483
sym_fns::sym_read_linetable
void(* sym_read_linetable)(struct objfile *)
Definition: symfile.h:355
XNEWVEC
#define XNEWVEC(T, N)
Definition: poison.h:145
bcache.h
scoped_free_pendings::~scoped_free_pendings
~scoped_free_pendings()
Definition: buildsym.c:277
context_stack::locals
struct pending * locals
Definition: buildsym.h:137
context_stack_size
EXTERN int context_stack_size
Definition: buildsym.h:178
addrmap
Definition: addrmap.c:43
deduce_language_from_filename
enum language deduce_language_from_filename(const char *filename)
Definition: symfile.c:2766
SYMBOL_BLOCK_VALUE
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:467
watch_main_source_file_lossage
static void watch_main_source_file_lossage(void)
Definition: buildsym.c:1113
subfile::line_vector_length
int line_vector_length
Definition: buildsym.h:69
stabsread.h
buildsym_compunit::subfiles
struct subfile * subfiles
Definition: buildsym.c:110
pending_addrmap_obstack
static struct obstack pending_addrmap_obstack
Definition: buildsym.c:155
record_debugformat
void record_debugformat(const char *format)
Definition: buildsym.c:1678
symfile_complaints
struct complaints * symfile_complaints
Definition: complaints.c:96
local_using_directives
EXTERN struct using_direct * local_using_directives
Definition: buildsym.h:124
push_subfile
void push_subfile(void)
Definition: buildsym.c:868
COMPUNIT_BLOCK_LINE_SECTION
#define COMPUNIT_BLOCK_LINE_SECTION(cust)
Definition: symtab.h:1466
COMPUNIT_OBJFILE
#define COMPUNIT_OBJFILE(cust)
Definition: symtab.h:1460
context_stack::depth
int depth
Definition: buildsym.h:166
symbol
const char * symbol
Definition: signals.c:48
allocate_symtab
struct symtab * allocate_symtab(struct compunit_symtab *cust, const char *filename)
Definition: symfile.c:2785
TYPE_NFIELDS
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1239
symbol::ginfo
struct general_symbol_info ginfo
Definition: symtab.h:1054
buildsym_compunit::language
enum language language
Definition: buildsym.c:130
context_stack::start_addr
CORE_ADDR start_addr
Definition: buildsym.h:158
last_source_start_addr
EXTERN CORE_ADDR last_source_start_addr
Definition: buildsym.h:56
qsort
#define qsort
Definition: ada-exp.c:2694
compunit_language
enum language compunit_language(const struct compunit_symtab *cust)
Definition: symtab.c:303
addrmap_create_fixed
struct addrmap * addrmap_create_fixed(struct addrmap *original, struct obstack *obstack)
Definition: addrmap.c:66
COMPUNIT_FILETABS
#define COMPUNIT_FILETABS(cust)
Definition: symtab.h:1461
pending_macros
static struct macro_table * pending_macros
Definition: buildsym.c:193
dict_create_hashed
struct dictionary * dict_create_hashed(struct obstack *obstack, enum language language, const struct pending *symbol_list)
Definition: dictionary.c:349
BLOCKVECTOR_NBLOCKS
#define BLOCKVECTOR_NBLOCKS(blocklist)
Definition: block.h:124
start_subfile
void start_subfile(const char *name)
Definition: buildsym.c:670
free_macro_table
void free_macro_table(struct macro_table *table)
Definition: macrotab.c:1078
HASHSIZE
#define HASHSIZE
Definition: buildsym.h:49
pending_blocks
static struct pending_block * pending_blocks
Definition: buildsym.c:181
set_block_compunit_symtab
void set_block_compunit_symtab(struct block *block, struct compunit_symtab *cu)
Definition: block.c:420
end_symtab_with_blockvector
static struct compunit_symtab * end_symtab_with_blockvector(struct block *static_block, int section, int expandable)
Definition: buildsym.c:1310
gdbtypes.h
context_stack::name
struct symbol * name
Definition: buildsym.h:149
objfile_register_static_link
void objfile_register_static_link(struct objfile *objfile, const struct block *block, const struct dynamic_prop *static_link)
Definition: objfiles.c:252
subfile::next
struct subfile * next
Definition: buildsym.h:64
STATIC_BLOCK
Definition: defs.h:687
language
language
Definition: defs.h:203
buildsym_init
void buildsym_init(void)
Definition: buildsym.c:1748
TYPE_ALLOC
#define TYPE_ALLOC(t, size)
Definition: gdbtypes.h:1652
linetable::nitems
int nitems
Definition: symtab.h:1253
subfile::language
enum language language
Definition: buildsym.h:72
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
symbol
Definition: symtab.h:1049
find_symbol_in_list
struct symbol * find_symbol_in_list(struct pending *list, char *name, int length)
Definition: buildsym.c:250
push_context
struct context_stack * push_context(int desc, CORE_ADDR valu)
Definition: buildsym.c:1630
ALL_COMPUNIT_FILETABS
#define ALL_COMPUNIT_FILETABS(cu, s)
Definition: symtab.h:1474
BLOCKVECTOR_MAP
#define BLOCKVECTOR_MAP(blocklist)
Definition: block.h:126
objfile_per_bfd_storage::storage_obstack
auto_obstack storage_obstack
Definition: objfiles.h:195
subfile_stack
static struct subfile_stack * subfile_stack
Definition: buildsym.c:189
allocate_global_block
struct block * allocate_global_block(struct obstack *obstack)
Definition: block.c:410
linetable_entry::line
int line
Definition: symtab.h:1230
objfile::objfile_obstack
Definition: objfiles.h:357
language_unknown
Definition: defs.h:205
dict_create_hashed_expandable
struct dictionary * dict_create_hashed_expandable(enum language language)
Definition: dictionary.c:392
make_blockvector
static struct blockvector * make_blockvector(void)
Definition: buildsym.c:600
start_symtab
struct compunit_symtab * start_symtab(struct objfile *objfile, const char *name, const char *comp_dir, CORE_ADDR start_addr, enum language language)
Definition: buildsym.c:1055
within_function
EXTERN int within_function
Definition: buildsym.h:186
symbol_symtab
struct symtab * symbol_symtab(const struct symbol *symbol)
Definition: symtab.c:5803
record_producer
void record_producer(const char *producer)
Definition: buildsym.c:1684
SYMTAB_LINETABLE
#define SYMTAB_LINETABLE(symtab)
Definition: symtab.h:1332
subfile::line_vector
struct linetable * line_vector
Definition: buildsym.h:68
language_cplus
Definition: defs.h:209
language_c
Definition: defs.h:207
dictionary.h
new_macro_table
struct macro_table * new_macro_table(struct obstack *obstack, struct bcache *b, struct compunit_symtab *cust)
Definition: macrotab.c:1048
block.h
LONGEST
long long LONGEST
Definition: common-types.h:52
last_source_file
static char * last_source_file
Definition: buildsym.c:1722
SYMBOL_IS_ARGUMENT
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:1157
symfile.h
subfile::symtab
struct symtab * symtab
Definition: buildsym.h:73