For PPC64/ELFv1: Introduce mst_data_gnu_ifunc
[external/binutils.git] / gdb / symmisc.c
1 /* Do various things to symbol tables (other than lookup), for GDB.
2
3    Copyright (C) 1986-2018 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "symtab.h"
22 #include "gdbtypes.h"
23 #include "bfd.h"
24 #include "filenames.h"
25 #include "symfile.h"
26 #include "objfiles.h"
27 #include "breakpoint.h"
28 #include "command.h"
29 #include "gdb_obstack.h"
30 #include "language.h"
31 #include "bcache.h"
32 #include "block.h"
33 #include "gdb_regex.h"
34 #include <sys/stat.h>
35 #include "dictionary.h"
36 #include "typeprint.h"
37 #include "gdbcmd.h"
38 #include "source.h"
39 #include "readline/readline.h"
40
41 #include "psymtab.h"
42
43 /* Unfortunately for debugging, stderr is usually a macro.  This is painful
44    when calling functions that take FILE *'s from the debugger.
45    So we make a variable which has the same value and which is accessible when
46    debugging GDB with itself.  Because stdin et al need not be constants,
47    we initialize them in the _initialize_symmisc function at the bottom
48    of the file.  */
49 FILE *std_in;
50 FILE *std_out;
51 FILE *std_err;
52
53 /* Prototypes for local functions */
54
55 static int block_depth (struct block *);
56
57 static void print_symbol (struct gdbarch *gdbarch, struct symbol *symbol,
58                           int depth, ui_file *outfile);
59 \f
60
61 void
62 print_symbol_bcache_statistics (void)
63 {
64   struct program_space *pspace;
65   struct objfile *objfile;
66
67   ALL_PSPACES (pspace)
68     ALL_PSPACE_OBJFILES (pspace, objfile)
69   {
70     QUIT;
71     printf_filtered (_("Byte cache statistics for '%s':\n"),
72                      objfile_name (objfile));
73     print_bcache_statistics (psymbol_bcache_get_bcache (objfile->psymbol_cache),
74                              "partial symbol cache");
75     print_bcache_statistics (objfile->per_bfd->macro_cache,
76                              "preprocessor macro cache");
77     print_bcache_statistics (objfile->per_bfd->filename_cache,
78                              "file name cache");
79   }
80 }
81
82 void
83 print_objfile_statistics (void)
84 {
85   struct program_space *pspace;
86   struct objfile *objfile;
87   struct compunit_symtab *cu;
88   struct symtab *s;
89   int i, linetables, blockvectors;
90
91   ALL_PSPACES (pspace)
92     ALL_PSPACE_OBJFILES (pspace, objfile)
93   {
94     QUIT;
95     printf_filtered (_("Statistics for '%s':\n"), objfile_name (objfile));
96     if (OBJSTAT (objfile, n_stabs) > 0)
97       printf_filtered (_("  Number of \"stab\" symbols read: %d\n"),
98                        OBJSTAT (objfile, n_stabs));
99     if (objfile->per_bfd->n_minsyms > 0)
100       printf_filtered (_("  Number of \"minimal\" symbols read: %d\n"),
101                        objfile->per_bfd->n_minsyms);
102     if (OBJSTAT (objfile, n_psyms) > 0)
103       printf_filtered (_("  Number of \"partial\" symbols read: %d\n"),
104                        OBJSTAT (objfile, n_psyms));
105     if (OBJSTAT (objfile, n_syms) > 0)
106       printf_filtered (_("  Number of \"full\" symbols read: %d\n"),
107                        OBJSTAT (objfile, n_syms));
108     if (OBJSTAT (objfile, n_types) > 0)
109       printf_filtered (_("  Number of \"types\" defined: %d\n"),
110                        OBJSTAT (objfile, n_types));
111     if (objfile->sf)
112       objfile->sf->qf->print_stats (objfile);
113     i = linetables = blockvectors = 0;
114     ALL_OBJFILE_FILETABS (objfile, cu, s)
115       {
116         i++;
117         if (SYMTAB_LINETABLE (s) != NULL)
118           linetables++;
119       }
120     ALL_OBJFILE_COMPUNITS (objfile, cu)
121       blockvectors++;
122     printf_filtered (_("  Number of symbol tables: %d\n"), i);
123     printf_filtered (_("  Number of symbol tables with line tables: %d\n"),
124                      linetables);
125     printf_filtered (_("  Number of symbol tables with blockvectors: %d\n"),
126                      blockvectors);
127
128     if (OBJSTAT (objfile, sz_strtab) > 0)
129       printf_filtered (_("  Space used by string tables: %d\n"),
130                        OBJSTAT (objfile, sz_strtab));
131     printf_filtered (_("  Total memory used for objfile obstack: %s\n"),
132                      pulongest (obstack_memory_used (&objfile
133                                                      ->objfile_obstack)));
134     printf_filtered (_("  Total memory used for BFD obstack: %s\n"),
135                      pulongest (obstack_memory_used (&objfile->per_bfd
136                                                      ->storage_obstack)));
137     printf_filtered (_("  Total memory used for psymbol cache: %d\n"),
138                      bcache_memory_used (psymbol_bcache_get_bcache
139                                           (objfile->psymbol_cache)));
140     printf_filtered (_("  Total memory used for macro cache: %d\n"),
141                      bcache_memory_used (objfile->per_bfd->macro_cache));
142     printf_filtered (_("  Total memory used for file name cache: %d\n"),
143                      bcache_memory_used (objfile->per_bfd->filename_cache));
144   }
145 }
146
147 static void
148 dump_objfile (struct objfile *objfile)
149 {
150   struct compunit_symtab *cust;
151   struct symtab *symtab;
152
153   printf_filtered ("\nObject file %s:  ", objfile_name (objfile));
154   printf_filtered ("Objfile at ");
155   gdb_print_host_address (objfile, gdb_stdout);
156   printf_filtered (", bfd at ");
157   gdb_print_host_address (objfile->obfd, gdb_stdout);
158   printf_filtered (", %d minsyms\n\n",
159                    objfile->per_bfd->minimal_symbol_count);
160
161   if (objfile->sf)
162     objfile->sf->qf->dump (objfile);
163
164   if (objfile->compunit_symtabs != NULL)
165     {
166       printf_filtered ("Symtabs:\n");
167       ALL_OBJFILE_FILETABS (objfile, cust, symtab)
168         {
169           printf_filtered ("%s at ", symtab_to_filename_for_display (symtab));
170           gdb_print_host_address (symtab, gdb_stdout);
171           printf_filtered (", ");
172           if (SYMTAB_OBJFILE (symtab) != objfile)
173             {
174               printf_filtered ("NOT ON CHAIN!  ");
175             }
176           wrap_here ("  ");
177         }
178       printf_filtered ("\n\n");
179     }
180 }
181
182 /* Print minimal symbols from this objfile.  */
183
184 static void
185 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
186 {
187   struct gdbarch *gdbarch = get_objfile_arch (objfile);
188   struct minimal_symbol *msymbol;
189   int index;
190   char ms_type;
191
192   fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile_name (objfile));
193   if (objfile->per_bfd->minimal_symbol_count == 0)
194     {
195       fprintf_filtered (outfile, "No minimal symbols found.\n");
196       return;
197     }
198   index = 0;
199   ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
200     {
201       struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
202
203       switch (MSYMBOL_TYPE (msymbol))
204         {
205         case mst_unknown:
206           ms_type = 'u';
207           break;
208         case mst_text:
209           ms_type = 'T';
210           break;
211         case mst_text_gnu_ifunc:
212         case mst_data_gnu_ifunc:
213           ms_type = 'i';
214           break;
215         case mst_solib_trampoline:
216           ms_type = 'S';
217           break;
218         case mst_data:
219           ms_type = 'D';
220           break;
221         case mst_bss:
222           ms_type = 'B';
223           break;
224         case mst_abs:
225           ms_type = 'A';
226           break;
227         case mst_file_text:
228           ms_type = 't';
229           break;
230         case mst_file_data:
231           ms_type = 'd';
232           break;
233         case mst_file_bss:
234           ms_type = 'b';
235           break;
236         default:
237           ms_type = '?';
238           break;
239         }
240       fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
241       fputs_filtered (paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (objfile,
242                                                                 msymbol)),
243                       outfile);
244       fprintf_filtered (outfile, " %s", MSYMBOL_LINKAGE_NAME (msymbol));
245       if (section)
246         {
247           if (section->the_bfd_section != NULL)
248             fprintf_filtered (outfile, " section %s",
249                               bfd_section_name (objfile->obfd,
250                                                 section->the_bfd_section));
251           else
252             fprintf_filtered (outfile, " spurious section %ld",
253                               (long) (section - objfile->sections));
254         }
255       if (MSYMBOL_DEMANGLED_NAME (msymbol) != NULL)
256         {
257           fprintf_filtered (outfile, "  %s", MSYMBOL_DEMANGLED_NAME (msymbol));
258         }
259       if (msymbol->filename)
260         fprintf_filtered (outfile, "  %s", msymbol->filename);
261       fputs_filtered ("\n", outfile);
262       index++;
263     }
264   if (objfile->per_bfd->minimal_symbol_count != index)
265     {
266       warning (_("internal error:  minimal symbol count %d != %d"),
267                objfile->per_bfd->minimal_symbol_count, index);
268     }
269   fprintf_filtered (outfile, "\n");
270 }
271
272 static void
273 dump_symtab_1 (struct symtab *symtab, struct ui_file *outfile)
274 {
275   struct objfile *objfile = SYMTAB_OBJFILE (symtab);
276   struct gdbarch *gdbarch = get_objfile_arch (objfile);
277   int i;
278   struct dict_iterator iter;
279   int len;
280   struct linetable *l;
281   const struct blockvector *bv;
282   struct symbol *sym;
283   struct block *b;
284   int depth;
285
286   fprintf_filtered (outfile, "\nSymtab for file %s\n",
287                     symtab_to_filename_for_display (symtab));
288   if (SYMTAB_DIRNAME (symtab) != NULL)
289     fprintf_filtered (outfile, "Compilation directory is %s\n",
290                       SYMTAB_DIRNAME (symtab));
291   fprintf_filtered (outfile, "Read from object file %s (",
292                     objfile_name (objfile));
293   gdb_print_host_address (objfile, outfile);
294   fprintf_filtered (outfile, ")\n");
295   fprintf_filtered (outfile, "Language: %s\n",
296                     language_str (symtab->language));
297
298   /* First print the line table.  */
299   l = SYMTAB_LINETABLE (symtab);
300   if (l)
301     {
302       fprintf_filtered (outfile, "\nLine table:\n\n");
303       len = l->nitems;
304       for (i = 0; i < len; i++)
305         {
306           fprintf_filtered (outfile, " line %d at ", l->item[i].line);
307           fputs_filtered (paddress (gdbarch, l->item[i].pc), outfile);
308           fprintf_filtered (outfile, "\n");
309         }
310     }
311   /* Now print the block info, but only for compunit symtabs since we will
312      print lots of duplicate info otherwise.  */
313   if (symtab == COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab)))
314     {
315       fprintf_filtered (outfile, "\nBlockvector:\n\n");
316       bv = SYMTAB_BLOCKVECTOR (symtab);
317       len = BLOCKVECTOR_NBLOCKS (bv);
318       for (i = 0; i < len; i++)
319         {
320           b = BLOCKVECTOR_BLOCK (bv, i);
321           depth = block_depth (b) * 2;
322           print_spaces (depth, outfile);
323           fprintf_filtered (outfile, "block #%03d, object at ", i);
324           gdb_print_host_address (b, outfile);
325           if (BLOCK_SUPERBLOCK (b))
326             {
327               fprintf_filtered (outfile, " under ");
328               gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
329             }
330           /* drow/2002-07-10: We could save the total symbols count
331              even if we're using a hashtable, but nothing else but this message
332              wants it.  */
333           fprintf_filtered (outfile, ", %d syms/buckets in ",
334                             dict_size (BLOCK_DICT (b)));
335           fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile);
336           fprintf_filtered (outfile, "..");
337           fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile);
338           if (BLOCK_FUNCTION (b))
339             {
340               fprintf_filtered (outfile, ", function %s",
341                                 SYMBOL_LINKAGE_NAME (BLOCK_FUNCTION (b)));
342               if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
343                 {
344                   fprintf_filtered (outfile, ", %s",
345                                 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
346                 }
347             }
348           fprintf_filtered (outfile, "\n");
349           /* Now print each symbol in this block (in no particular order, if
350              we're using a hashtable).  Note that we only want this
351              block, not any blocks from included symtabs.  */
352           ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
353             {
354               TRY
355                 {
356                   print_symbol (gdbarch, sym, depth + 1, outfile);
357                 }
358               CATCH (ex, RETURN_MASK_ERROR)
359                 {
360                   exception_fprintf (gdb_stderr, ex,
361                                      "Error printing symbol:\n");
362                 }
363               END_CATCH
364             }
365         }
366       fprintf_filtered (outfile, "\n");
367     }
368   else
369     {
370       const char *compunit_filename
371         = symtab_to_filename_for_display (COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab)));
372
373       fprintf_filtered (outfile,
374                         "\nBlockvector same as owning compunit: %s\n\n",
375                         compunit_filename);
376     }
377 }
378
379 static void
380 dump_symtab (struct symtab *symtab, struct ui_file *outfile)
381 {
382   /* Set the current language to the language of the symtab we're dumping
383      because certain routines used during dump_symtab() use the current
384      language to print an image of the symbol.  We'll restore it later.
385      But use only real languages, not placeholders.  */
386   if (symtab->language != language_unknown
387       && symtab->language != language_auto)
388     {
389       enum language saved_lang;
390
391       saved_lang = set_language (symtab->language);
392
393       dump_symtab_1 (symtab, outfile);
394
395       set_language (saved_lang);
396     }
397   else
398     dump_symtab_1 (symtab, outfile);
399 }
400
401 static void
402 maintenance_print_symbols (const char *args, int from_tty)
403 {
404   struct ui_file *outfile = gdb_stdout;
405   char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
406   int i, outfile_idx;
407
408   dont_repeat ();
409
410   gdb_argv argv (args);
411
412   for (i = 0; argv != NULL && argv[i] != NULL; ++i)
413     {
414       if (strcmp (argv[i], "-pc") == 0)
415         {
416           if (argv[i + 1] == NULL)
417             error (_("Missing pc value"));
418           address_arg = argv[++i];
419         }
420       else if (strcmp (argv[i], "-source") == 0)
421         {
422           if (argv[i + 1] == NULL)
423             error (_("Missing source file"));
424           source_arg = argv[++i];
425         }
426       else if (strcmp (argv[i], "-objfile") == 0)
427         {
428           if (argv[i + 1] == NULL)
429             error (_("Missing objfile name"));
430           objfile_arg = argv[++i];
431         }
432       else if (strcmp (argv[i], "--") == 0)
433         {
434           /* End of options.  */
435           ++i;
436           break;
437         }
438       else if (argv[i][0] == '-')
439         {
440           /* Future proofing: Don't allow OUTFILE to begin with "-".  */
441           error (_("Unknown option: %s"), argv[i]);
442         }
443       else
444         break;
445     }
446   outfile_idx = i;
447
448   if (address_arg != NULL && source_arg != NULL)
449     error (_("Must specify at most one of -pc and -source"));
450
451   stdio_file arg_outfile;
452
453   if (argv != NULL && argv[outfile_idx] != NULL)
454     {
455       if (argv[outfile_idx + 1] != NULL)
456         error (_("Junk at end of command"));
457       gdb::unique_xmalloc_ptr<char> outfile_name
458         (tilde_expand (argv[outfile_idx]));
459       if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
460         perror_with_name (outfile_name.get ());
461       outfile = &arg_outfile;
462     }
463
464   if (address_arg != NULL)
465     {
466       CORE_ADDR pc = parse_and_eval_address (address_arg);
467       struct symtab *s = find_pc_line_symtab (pc);
468
469       if (s == NULL)
470         error (_("No symtab for address: %s"), address_arg);
471       dump_symtab (s, outfile);
472     }
473   else
474     {
475       struct objfile *objfile;
476       struct compunit_symtab *cu;
477       struct symtab *s;
478       int found = 0;
479
480       ALL_OBJFILES (objfile)
481         {
482           int print_for_objfile = 1;
483
484           if (objfile_arg != NULL)
485             print_for_objfile
486               = compare_filenames_for_search (objfile_name (objfile),
487                                               objfile_arg);
488           if (!print_for_objfile)
489             continue;
490
491           ALL_OBJFILE_FILETABS (objfile, cu, s)
492             {
493               int print_for_source = 0;
494
495               QUIT;
496               if (source_arg != NULL)
497                 {
498                   print_for_source
499                     = compare_filenames_for_search
500                         (symtab_to_filename_for_display (s), source_arg);
501                   found = 1;
502                 }
503               if (source_arg == NULL
504                   || print_for_source)
505                 dump_symtab (s, outfile);
506             }
507         }
508
509       if (source_arg != NULL && !found)
510         error (_("No symtab for source file: %s"), source_arg);
511     }
512 }
513
514 /* Print symbol SYMBOL on OUTFILE.  DEPTH says how far to indent.  */
515
516 static void
517 print_symbol (struct gdbarch *gdbarch, struct symbol *symbol,
518               int depth, ui_file *outfile)
519 {
520   struct obj_section *section;
521
522   if (SYMBOL_OBJFILE_OWNED (symbol))
523     section = SYMBOL_OBJ_SECTION (symbol_objfile (symbol), symbol);
524   else
525     section = NULL;
526
527   print_spaces (depth, outfile);
528   if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
529     {
530       fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
531       fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
532                       outfile);
533       if (section)
534         fprintf_filtered (outfile, " section %s\n",
535                           bfd_section_name (section->the_bfd_section->owner,
536                                             section->the_bfd_section));
537       else
538         fprintf_filtered (outfile, "\n");
539       return;
540     }
541
542   if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
543     {
544       if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
545         {
546           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
547                          &type_print_raw_options);
548         }
549       else
550         {
551           fprintf_filtered (outfile, "%s %s = ",
552                          (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
553                           ? "enum"
554                      : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
555                         ? "struct" : "union")),
556                             SYMBOL_LINKAGE_NAME (symbol));
557           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
558                          &type_print_raw_options);
559         }
560       fprintf_filtered (outfile, ";\n");
561     }
562   else
563     {
564       if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
565         fprintf_filtered (outfile, "typedef ");
566       if (SYMBOL_TYPE (symbol))
567         {
568           /* Print details of types, except for enums where it's clutter.  */
569           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
570                          outfile,
571                          TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
572                          depth,
573                          &type_print_raw_options);
574           fprintf_filtered (outfile, "; ");
575         }
576       else
577         fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
578
579       switch (SYMBOL_CLASS (symbol))
580         {
581         case LOC_CONST:
582           fprintf_filtered (outfile, "const %s (%s)",
583                             plongest (SYMBOL_VALUE (symbol)),
584                             hex_string (SYMBOL_VALUE (symbol)));
585           break;
586
587         case LOC_CONST_BYTES:
588           {
589             unsigned i;
590             struct type *type = check_typedef (SYMBOL_TYPE (symbol));
591
592             fprintf_filtered (outfile, "const %u hex bytes:",
593                               TYPE_LENGTH (type));
594             for (i = 0; i < TYPE_LENGTH (type); i++)
595               fprintf_filtered (outfile, " %02x",
596                                 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
597           }
598           break;
599
600         case LOC_STATIC:
601           fprintf_filtered (outfile, "static at ");
602           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
603                           outfile);
604           if (section)
605             fprintf_filtered (outfile, " section %s",
606                               bfd_section_name (section->the_bfd_section->owner,
607                                                 section->the_bfd_section));
608           break;
609
610         case LOC_REGISTER:
611           if (SYMBOL_IS_ARGUMENT (symbol))
612             fprintf_filtered (outfile, "parameter register %s",
613                               plongest (SYMBOL_VALUE (symbol)));
614           else
615             fprintf_filtered (outfile, "register %s",
616                               plongest (SYMBOL_VALUE (symbol)));
617           break;
618
619         case LOC_ARG:
620           fprintf_filtered (outfile, "arg at offset %s",
621                             hex_string (SYMBOL_VALUE (symbol)));
622           break;
623
624         case LOC_REF_ARG:
625           fprintf_filtered (outfile, "reference arg at %s",
626                             hex_string (SYMBOL_VALUE (symbol)));
627           break;
628
629         case LOC_REGPARM_ADDR:
630           fprintf_filtered (outfile, "address parameter register %s",
631                             plongest (SYMBOL_VALUE (symbol)));
632           break;
633
634         case LOC_LOCAL:
635           fprintf_filtered (outfile, "local at offset %s",
636                             hex_string (SYMBOL_VALUE (symbol)));
637           break;
638
639         case LOC_TYPEDEF:
640           break;
641
642         case LOC_LABEL:
643           fprintf_filtered (outfile, "label at ");
644           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
645                           outfile);
646           if (section)
647             fprintf_filtered (outfile, " section %s",
648                               bfd_section_name (section->the_bfd_section->owner,
649                                                 section->the_bfd_section));
650           break;
651
652         case LOC_BLOCK:
653           fprintf_filtered (outfile, "block object ");
654           gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
655           fprintf_filtered (outfile, ", ");
656           fputs_filtered (paddress (gdbarch,
657                                     BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
658                           outfile);
659           fprintf_filtered (outfile, "..");
660           fputs_filtered (paddress (gdbarch,
661                                     BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
662                           outfile);
663           if (section)
664             fprintf_filtered (outfile, " section %s",
665                               bfd_section_name (section->the_bfd_section->owner,
666                                                 section->the_bfd_section));
667           break;
668
669         case LOC_COMPUTED:
670           fprintf_filtered (outfile, "computed at runtime");
671           break;
672
673         case LOC_UNRESOLVED:
674           fprintf_filtered (outfile, "unresolved");
675           break;
676
677         case LOC_OPTIMIZED_OUT:
678           fprintf_filtered (outfile, "optimized out");
679           break;
680
681         default:
682           fprintf_filtered (outfile, "botched symbol class %x",
683                             SYMBOL_CLASS (symbol));
684           break;
685         }
686     }
687   fprintf_filtered (outfile, "\n");
688 }
689
690 static void
691 maintenance_print_msymbols (const char *args, int from_tty)
692 {
693   struct ui_file *outfile = gdb_stdout;
694   char *objfile_arg = NULL;
695   struct objfile *objfile;
696   int i, outfile_idx;
697
698   dont_repeat ();
699
700   gdb_argv argv (args);
701
702   for (i = 0; argv != NULL && argv[i] != NULL; ++i)
703     {
704       if (strcmp (argv[i], "-objfile") == 0)
705         {
706           if (argv[i + 1] == NULL)
707             error (_("Missing objfile name"));
708           objfile_arg = argv[++i];
709         }
710       else if (strcmp (argv[i], "--") == 0)
711         {
712           /* End of options.  */
713           ++i;
714           break;
715         }
716       else if (argv[i][0] == '-')
717         {
718           /* Future proofing: Don't allow OUTFILE to begin with "-".  */
719           error (_("Unknown option: %s"), argv[i]);
720         }
721       else
722         break;
723     }
724   outfile_idx = i;
725
726   stdio_file arg_outfile;
727
728   if (argv != NULL && argv[outfile_idx] != NULL)
729     {
730       if (argv[outfile_idx + 1] != NULL)
731         error (_("Junk at end of command"));
732       gdb::unique_xmalloc_ptr<char> outfile_name
733         (tilde_expand (argv[outfile_idx]));
734       if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
735         perror_with_name (outfile_name.get ());
736       outfile = &arg_outfile;
737     }
738
739   ALL_OBJFILES (objfile)
740   {
741     QUIT;
742     if (objfile_arg == NULL
743         || compare_filenames_for_search (objfile_name (objfile), objfile_arg))
744       dump_msymbols (objfile, outfile);
745   }
746 }
747
748 static void
749 maintenance_print_objfiles (const char *regexp, int from_tty)
750 {
751   struct program_space *pspace;
752   struct objfile *objfile;
753
754   dont_repeat ();
755
756   if (regexp)
757     re_comp (regexp);
758
759   ALL_PSPACES (pspace)
760     ALL_PSPACE_OBJFILES (pspace, objfile)
761       {
762         QUIT;
763         if (! regexp
764             || re_exec (objfile_name (objfile)))
765           dump_objfile (objfile);
766       }
767 }
768
769 /* List all the symbol tables whose names match REGEXP (optional).  */
770
771 static void
772 maintenance_info_symtabs (const char *regexp, int from_tty)
773 {
774   struct program_space *pspace;
775   struct objfile *objfile;
776
777   dont_repeat ();
778
779   if (regexp)
780     re_comp (regexp);
781
782   ALL_PSPACES (pspace)
783     ALL_PSPACE_OBJFILES (pspace, objfile)
784     {
785       struct compunit_symtab *cust;
786       struct symtab *symtab;
787
788       /* We don't want to print anything for this objfile until we
789          actually find a symtab whose name matches.  */
790       int printed_objfile_start = 0;
791
792       ALL_OBJFILE_COMPUNITS (objfile, cust)
793         {
794           int printed_compunit_symtab_start = 0;
795
796           ALL_COMPUNIT_FILETABS (cust, symtab)
797             {
798               QUIT;
799
800               if (! regexp
801                   || re_exec (symtab_to_filename_for_display (symtab)))
802                 {
803                   if (! printed_objfile_start)
804                     {
805                       printf_filtered ("{ objfile %s ", objfile_name (objfile));
806                       wrap_here ("  ");
807                       printf_filtered ("((struct objfile *) %s)\n",
808                                        host_address_to_string (objfile));
809                       printed_objfile_start = 1;
810                     }
811                   if (! printed_compunit_symtab_start)
812                     {
813                       printf_filtered ("  { ((struct compunit_symtab *) %s)\n",
814                                        host_address_to_string (cust));
815                       printf_filtered ("    debugformat %s\n",
816                                        COMPUNIT_DEBUGFORMAT (cust));
817                       printf_filtered ("    producer %s\n",
818                                        COMPUNIT_PRODUCER (cust) != NULL
819                                        ? COMPUNIT_PRODUCER (cust)
820                                        : "(null)");
821                       printf_filtered ("    dirname %s\n",
822                                        COMPUNIT_DIRNAME (cust) != NULL
823                                        ? COMPUNIT_DIRNAME (cust)
824                                        : "(null)");
825                       printf_filtered ("    blockvector"
826                                        " ((struct blockvector *) %s)\n",
827                                        host_address_to_string
828                                          (COMPUNIT_BLOCKVECTOR (cust)));
829                       printed_compunit_symtab_start = 1;
830                     }
831
832                   printf_filtered ("\t{ symtab %s ",
833                                    symtab_to_filename_for_display (symtab));
834                   wrap_here ("    ");
835                   printf_filtered ("((struct symtab *) %s)\n",
836                                    host_address_to_string (symtab));
837                   printf_filtered ("\t  fullname %s\n",
838                                    symtab->fullname != NULL
839                                    ? symtab->fullname
840                                    : "(null)");
841                   printf_filtered ("\t  "
842                                    "linetable ((struct linetable *) %s)\n",
843                                    host_address_to_string (symtab->linetable));
844                   printf_filtered ("\t}\n");
845                 }
846             }
847
848           if (printed_compunit_symtab_start)
849             printf_filtered ("  }\n");
850         }
851
852       if (printed_objfile_start)
853         printf_filtered ("}\n");
854     }
855 }
856
857 /* Check consistency of symtabs.
858    An example of what this checks for is NULL blockvectors.
859    They can happen if there's a bug during debug info reading.
860    GDB assumes they are always non-NULL.
861
862    Note: This does not check for psymtab vs symtab consistency.
863    Use "maint check-psymtabs" for that.  */
864
865 static void
866 maintenance_check_symtabs (const char *ignore, int from_tty)
867 {
868   struct program_space *pspace;
869   struct objfile *objfile;
870
871   ALL_PSPACES (pspace)
872     ALL_PSPACE_OBJFILES (pspace, objfile)
873     {
874       struct compunit_symtab *cust;
875
876       /* We don't want to print anything for this objfile until we
877          actually find something worth printing.  */
878       int printed_objfile_start = 0;
879
880       ALL_OBJFILE_COMPUNITS (objfile, cust)
881         {
882           int found_something = 0;
883           struct symtab *symtab = compunit_primary_filetab (cust);
884
885           QUIT;
886
887           if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
888             found_something = 1;
889           /* Add more checks here.  */
890
891           if (found_something)
892             {
893               if (! printed_objfile_start)
894                 {
895                   printf_filtered ("{ objfile %s ", objfile_name (objfile));
896                   wrap_here ("  ");
897                   printf_filtered ("((struct objfile *) %s)\n",
898                                    host_address_to_string (objfile));
899                   printed_objfile_start = 1;
900                 }
901               printf_filtered ("  { symtab %s\n",
902                                symtab_to_filename_for_display (symtab));
903               if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
904                 printf_filtered ("    NULL blockvector\n");
905               printf_filtered ("  }\n");
906             }
907         }
908
909       if (printed_objfile_start)
910         printf_filtered ("}\n");
911     }
912 }
913
914 /* Expand all symbol tables whose name matches an optional regexp.  */
915
916 static void
917 maintenance_expand_symtabs (const char *args, int from_tty)
918 {
919   struct program_space *pspace;
920   struct objfile *objfile;
921   char *regexp = NULL;
922
923   /* We use buildargv here so that we handle spaces in the regexp
924      in a way that allows adding more arguments later.  */
925   gdb_argv argv (args);
926
927   if (argv != NULL)
928     {
929       if (argv[0] != NULL)
930         {
931           regexp = argv[0];
932           if (argv[1] != NULL)
933             error (_("Extra arguments after regexp."));
934         }
935     }
936
937   if (regexp)
938     re_comp (regexp);
939
940   ALL_PSPACES (pspace)
941     ALL_PSPACE_OBJFILES (pspace, objfile)
942     {
943       if (objfile->sf)
944         {
945           objfile->sf->qf->expand_symtabs_matching
946             (objfile,
947              [&] (const char *filename, bool basenames)
948              {
949                /* KISS: Only apply the regexp to the complete file name.  */
950                return (!basenames
951                        && (regexp == NULL || re_exec (filename)));
952              },
953              lookup_name_info::match_any (),
954              [] (const char *symname)
955              {
956                /* Since we're not searching on symbols, just return true.  */
957                return true;
958              },
959              NULL,
960              ALL_DOMAIN);
961         }
962     }
963 }
964 \f
965
966 /* Return the nexting depth of a block within other blocks in its symtab.  */
967
968 static int
969 block_depth (struct block *block)
970 {
971   int i = 0;
972
973   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
974     {
975       i++;
976     }
977   return i;
978 }
979 \f
980
981 /* Used by MAINTENANCE_INFO_LINE_TABLES to print the information about a
982    single line table.  */
983
984 static int
985 maintenance_print_one_line_table (struct symtab *symtab, void *data)
986 {
987   struct linetable *linetable;
988   struct objfile *objfile;
989
990   objfile = symtab->compunit_symtab->objfile;
991   printf_filtered (_("objfile: %s ((struct objfile *) %s)\n"),
992                    objfile_name (objfile),
993                    host_address_to_string (objfile));
994   printf_filtered (_("compunit_symtab: ((struct compunit_symtab *) %s)\n"),
995                    host_address_to_string (symtab->compunit_symtab));
996   printf_filtered (_("symtab: %s ((struct symtab *) %s)\n"),
997                    symtab_to_fullname (symtab),
998                    host_address_to_string (symtab));
999   linetable = SYMTAB_LINETABLE (symtab);
1000   printf_filtered (_("linetable: ((struct linetable *) %s):\n"),
1001                    host_address_to_string (linetable));
1002
1003   if (linetable == NULL)
1004     printf_filtered (_("No line table.\n"));
1005   else if (linetable->nitems <= 0)
1006     printf_filtered (_("Line table has no lines.\n"));
1007   else
1008     {
1009       int i;
1010
1011       /* Leave space for 6 digits of index and line number.  After that the
1012          tables will just not format as well.  */
1013       printf_filtered (_("%-6s %6s %s\n"),
1014                        _("INDEX"), _("LINE"), _("ADDRESS"));
1015
1016       for (i = 0; i < linetable->nitems; ++i)
1017         {
1018           struct linetable_entry *item;
1019
1020           item = &linetable->item [i];
1021           printf_filtered (_("%-6d %6d %s\n"), i, item->line,
1022                            core_addr_to_string (item->pc));
1023         }
1024     }
1025
1026   return 0;
1027 }
1028
1029 /* Implement the 'maint info line-table' command.  */
1030
1031 static void
1032 maintenance_info_line_tables (const char *regexp, int from_tty)
1033 {
1034   struct program_space *pspace;
1035   struct objfile *objfile;
1036
1037   dont_repeat ();
1038
1039   if (regexp != NULL)
1040     re_comp (regexp);
1041
1042   ALL_PSPACES (pspace)
1043     ALL_PSPACE_OBJFILES (pspace, objfile)
1044     {
1045       struct compunit_symtab *cust;
1046       struct symtab *symtab;
1047
1048       ALL_OBJFILE_COMPUNITS (objfile, cust)
1049         {
1050           ALL_COMPUNIT_FILETABS (cust, symtab)
1051             {
1052               QUIT;
1053
1054               if (regexp == NULL
1055                   || re_exec (symtab_to_filename_for_display (symtab)))
1056                 maintenance_print_one_line_table (symtab, NULL);
1057             }
1058         }
1059     }
1060 }
1061
1062 \f
1063
1064 /* Do early runtime initializations.  */
1065
1066 void
1067 _initialize_symmisc (void)
1068 {
1069   std_in = stdin;
1070   std_out = stdout;
1071   std_err = stderr;
1072
1073   add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
1074 Print dump of current symbol definitions.\n\
1075 Usage: mt print symbols [-pc address] [--] [outfile]\n\
1076        mt print symbols [-objfile objfile] [-source source] [--] [outfile]\n\
1077 Entries in the full symbol table are dumped to file OUTFILE,\n\
1078 or the terminal if OUTFILE is unspecified.\n\
1079 If ADDRESS is provided, dump only the file for that address.\n\
1080 If SOURCE is provided, dump only that file's symbols.\n\
1081 If OBJFILE is provided, dump only that file's minimal symbols."),
1082            &maintenanceprintlist);
1083
1084   add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
1085 Print dump of current minimal symbol definitions.\n\
1086 Usage: mt print msymbols [-objfile objfile] [--] [outfile]\n\
1087 Entries in the minimal symbol table are dumped to file OUTFILE,\n\
1088 or the terminal if OUTFILE is unspecified.\n\
1089 If OBJFILE is provided, dump only that file's minimal symbols."),
1090            &maintenanceprintlist);
1091
1092   add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
1093            _("Print dump of current object file definitions.\n\
1094 With an argument REGEXP, list the object files with matching names."),
1095            &maintenanceprintlist);
1096
1097   add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
1098 List the full symbol tables for all object files.\n\
1099 This does not include information about individual symbols, blocks, or\n\
1100 linetables --- just the symbol table structures themselves.\n\
1101 With an argument REGEXP, list the symbol tables with matching names."),
1102            &maintenanceinfolist);
1103
1104   add_cmd ("line-table", class_maintenance, maintenance_info_line_tables, _("\
1105 List the contents of all line tables, from all symbol tables.\n\
1106 With an argument REGEXP, list just the line tables for the symbol\n\
1107 tables with matching names."),
1108            &maintenanceinfolist);
1109
1110   add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
1111            _("\
1112 Check consistency of currently expanded symtabs."),
1113            &maintenancelist);
1114
1115   add_cmd ("expand-symtabs", class_maintenance, maintenance_expand_symtabs,
1116            _("Expand symbol tables.\n\
1117 With an argument REGEXP, only expand the symbol tables with matching names."),
1118            &maintenancelist);
1119 }