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