OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [symmisc.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Do various things to symbol tables (other than lookup), for GDB.
2
 
3
   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4
   1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2007, 2008
5
   Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "symtab.h"
24
#include "gdbtypes.h"
25
#include "bfd.h"
26
#include "symfile.h"
27
#include "objfiles.h"
28
#include "breakpoint.h"
29
#include "command.h"
30
#include "gdb_obstack.h"
31
#include "exceptions.h"
32
#include "language.h"
33
#include "bcache.h"
34
#include "block.h"
35
#include "gdb_regex.h"
36
#include "gdb_stat.h"
37
#include "dictionary.h"
38
 
39
#include "gdb_string.h"
40
#include "readline/readline.h"
41
 
42
#ifndef DEV_TTY
43
#define DEV_TTY "/dev/tty"
44
#endif
45
 
46
/* Unfortunately for debugging, stderr is usually a macro.  This is painful
47
   when calling functions that take FILE *'s from the debugger.
48
   So we make a variable which has the same value and which is accessible when
49
   debugging GDB with itself.  Because stdin et al need not be constants,
50
   we initialize them in the _initialize_symmisc function at the bottom
51
   of the file.  */
52
FILE *std_in;
53
FILE *std_out;
54
FILE *std_err;
55
 
56
/* Prototypes for local functions */
57
 
58
static void dump_symtab (struct objfile *, struct symtab *,
59
                         struct ui_file *);
60
 
61
static void dump_psymtab (struct objfile *, struct partial_symtab *,
62
                          struct ui_file *);
63
 
64
static void dump_msymbols (struct objfile *, struct ui_file *);
65
 
66
static void dump_objfile (struct objfile *);
67
 
68
static int block_depth (struct block *);
69
 
70
static void print_partial_symbols (struct partial_symbol **, int,
71
                                   char *, struct ui_file *);
72
 
73
static void free_symtab_block (struct objfile *, struct block *);
74
 
75
void _initialize_symmisc (void);
76
 
77
struct print_symbol_args
78
  {
79
    struct symbol *symbol;
80
    int depth;
81
    struct ui_file *outfile;
82
  };
83
 
84
static int print_symbol (void *);
85
 
86
static void free_symtab_block (struct objfile *, struct block *);
87
 
88
 
89
/* Free a struct block <- B and all the symbols defined in that block.  */
90
 
91
/* FIXME: carlton/2003-04-28: I don't believe this is currently ever
92
   used.  */
93
 
94
static void
95
free_symtab_block (struct objfile *objfile, struct block *b)
96
{
97
  struct dict_iterator iter;
98
  struct symbol *sym;
99
 
100
  ALL_BLOCK_SYMBOLS (b, iter, sym)
101
    {
102
      xfree (DEPRECATED_SYMBOL_NAME (sym));
103
      xfree (sym);
104
    }
105
 
106
  dict_free (BLOCK_DICT (b));
107
  xfree (b);
108
}
109
 
110
/* Free all the storage associated with the struct symtab <- S.
111
   Note that some symtabs have contents malloc'ed structure by structure,
112
   while some have contents that all live inside one big block of memory,
113
   and some share the contents of another symbol table and so you should
114
   not free the contents on their behalf (except sometimes the linetable,
115
   which maybe per symtab even when the rest is not).
116
   It is s->free_code that says which alternative to use.  */
117
 
118
void
119
free_symtab (struct symtab *s)
120
{
121
  int i, n;
122
  struct blockvector *bv;
123
 
124
  switch (s->free_code)
125
    {
126
    case free_nothing:
127
      /* All the contents are part of a big block of memory (an obstack),
128
         and some other symtab is in charge of freeing that block.
129
         Therefore, do nothing.  */
130
      break;
131
 
132
    case free_contents:
133
      /* Here all the contents were malloc'ed structure by structure
134
         and must be freed that way.  */
135
      /* First free the blocks (and their symbols.  */
136
      bv = BLOCKVECTOR (s);
137
      n = BLOCKVECTOR_NBLOCKS (bv);
138
      for (i = 0; i < n; i++)
139
        free_symtab_block (s->objfile, BLOCKVECTOR_BLOCK (bv, i));
140
      /* Free the blockvector itself.  */
141
      xfree (bv);
142
      /* Also free the linetable.  */
143
 
144
    case free_linetable:
145
      /* Everything will be freed either by our `free_func'
146
         or by some other symtab, except for our linetable.
147
         Free that now.  */
148
      if (LINETABLE (s))
149
        xfree (LINETABLE (s));
150
      break;
151
    }
152
 
153
  /* If there is a single block of memory to free, free it.  */
154
  if (s->free_func != NULL)
155
    s->free_func (s);
156
 
157
  /* Free source-related stuff */
158
  if (s->line_charpos != NULL)
159
    xfree (s->line_charpos);
160
  if (s->fullname != NULL)
161
    xfree (s->fullname);
162
  if (s->debugformat != NULL)
163
    xfree (s->debugformat);
164
  xfree (s);
165
}
166
 
167
void
168
print_symbol_bcache_statistics (void)
169
{
170
  struct objfile *objfile;
171
 
172
  immediate_quit++;
173
  ALL_OBJFILES (objfile)
174
  {
175
    printf_filtered (_("Byte cache statistics for '%s':\n"), objfile->name);
176
    print_bcache_statistics (objfile->psymbol_cache, "partial symbol cache");
177
  }
178
  immediate_quit--;
179
}
180
 
181
void
182
print_objfile_statistics (void)
183
{
184
  struct objfile *objfile;
185
  struct symtab *s;
186
  struct partial_symtab *ps;
187
  int i, linetables, blockvectors;
188
 
189
  immediate_quit++;
190
  ALL_OBJFILES (objfile)
191
  {
192
    printf_filtered (_("Statistics for '%s':\n"), objfile->name);
193
    if (OBJSTAT (objfile, n_stabs) > 0)
194
      printf_filtered (_("  Number of \"stab\" symbols read: %d\n"),
195
                       OBJSTAT (objfile, n_stabs));
196
    if (OBJSTAT (objfile, n_minsyms) > 0)
197
      printf_filtered (_("  Number of \"minimal\" symbols read: %d\n"),
198
                       OBJSTAT (objfile, n_minsyms));
199
    if (OBJSTAT (objfile, n_psyms) > 0)
200
      printf_filtered (_("  Number of \"partial\" symbols read: %d\n"),
201
                       OBJSTAT (objfile, n_psyms));
202
    if (OBJSTAT (objfile, n_syms) > 0)
203
      printf_filtered (_("  Number of \"full\" symbols read: %d\n"),
204
                       OBJSTAT (objfile, n_syms));
205
    if (OBJSTAT (objfile, n_types) > 0)
206
      printf_filtered (_("  Number of \"types\" defined: %d\n"),
207
                       OBJSTAT (objfile, n_types));
208
    i = 0;
209
    ALL_OBJFILE_PSYMTABS (objfile, ps)
210
      {
211
        if (ps->readin == 0)
212
          i++;
213
      }
214
    printf_filtered (_("  Number of psym tables (not yet expanded): %d\n"), i);
215
    i = linetables = blockvectors = 0;
216
    ALL_OBJFILE_SYMTABS (objfile, s)
217
      {
218
        i++;
219
        if (s->linetable != NULL)
220
          linetables++;
221
        if (s->primary == 1)
222
          blockvectors++;
223
      }
224
    printf_filtered (_("  Number of symbol tables: %d\n"), i);
225
    printf_filtered (_("  Number of symbol tables with line tables: %d\n"),
226
                     linetables);
227
    printf_filtered (_("  Number of symbol tables with blockvectors: %d\n"),
228
                     blockvectors);
229
 
230
    if (OBJSTAT (objfile, sz_strtab) > 0)
231
      printf_filtered (_("  Space used by a.out string tables: %d\n"),
232
                       OBJSTAT (objfile, sz_strtab));
233
    printf_filtered (_("  Total memory used for objfile obstack: %d\n"),
234
                     obstack_memory_used (&objfile->objfile_obstack));
235
    printf_filtered (_("  Total memory used for psymbol cache: %d\n"),
236
                     bcache_memory_used (objfile->psymbol_cache));
237
    printf_filtered (_("  Total memory used for macro cache: %d\n"),
238
                     bcache_memory_used (objfile->macro_cache));
239
  }
240
  immediate_quit--;
241
}
242
 
243
static void
244
dump_objfile (struct objfile *objfile)
245
{
246
  struct symtab *symtab;
247
  struct partial_symtab *psymtab;
248
 
249
  printf_filtered ("\nObject file %s:  ", objfile->name);
250
  printf_filtered ("Objfile at ");
251
  gdb_print_host_address (objfile, gdb_stdout);
252
  printf_filtered (", bfd at ");
253
  gdb_print_host_address (objfile->obfd, gdb_stdout);
254
  printf_filtered (", %d minsyms\n\n",
255
                   objfile->minimal_symbol_count);
256
 
257
  if (objfile->psymtabs)
258
    {
259
      printf_filtered ("Psymtabs:\n");
260
      for (psymtab = objfile->psymtabs;
261
           psymtab != NULL;
262
           psymtab = psymtab->next)
263
        {
264
          printf_filtered ("%s at ",
265
                           psymtab->filename);
266
          gdb_print_host_address (psymtab, gdb_stdout);
267
          printf_filtered (", ");
268
          if (psymtab->objfile != objfile)
269
            {
270
              printf_filtered ("NOT ON CHAIN!  ");
271
            }
272
          wrap_here ("  ");
273
        }
274
      printf_filtered ("\n\n");
275
    }
276
 
277
  if (objfile->symtabs)
278
    {
279
      printf_filtered ("Symtabs:\n");
280
      for (symtab = objfile->symtabs;
281
           symtab != NULL;
282
           symtab = symtab->next)
283
        {
284
          printf_filtered ("%s at ", symtab->filename);
285
          gdb_print_host_address (symtab, gdb_stdout);
286
          printf_filtered (", ");
287
          if (symtab->objfile != objfile)
288
            {
289
              printf_filtered ("NOT ON CHAIN!  ");
290
            }
291
          wrap_here ("  ");
292
        }
293
      printf_filtered ("\n\n");
294
    }
295
}
296
 
297
/* Print minimal symbols from this objfile.  */
298
 
299
static void
300
dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
301
{
302
  struct minimal_symbol *msymbol;
303
  int index;
304
  char ms_type;
305
 
306
  fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile->name);
307
  if (objfile->minimal_symbol_count == 0)
308
    {
309
      fprintf_filtered (outfile, "No minimal symbols found.\n");
310
      return;
311
    }
312
  for (index = 0, msymbol = objfile->msymbols;
313
       DEPRECATED_SYMBOL_NAME (msymbol) != NULL; msymbol++, index++)
314
    {
315
      switch (msymbol->type)
316
        {
317
        case mst_unknown:
318
          ms_type = 'u';
319
          break;
320
        case mst_text:
321
          ms_type = 'T';
322
          break;
323
        case mst_solib_trampoline:
324
          ms_type = 'S';
325
          break;
326
        case mst_data:
327
          ms_type = 'D';
328
          break;
329
        case mst_bss:
330
          ms_type = 'B';
331
          break;
332
        case mst_abs:
333
          ms_type = 'A';
334
          break;
335
        case mst_file_text:
336
          ms_type = 't';
337
          break;
338
        case mst_file_data:
339
          ms_type = 'd';
340
          break;
341
        case mst_file_bss:
342
          ms_type = 'b';
343
          break;
344
        default:
345
          ms_type = '?';
346
          break;
347
        }
348
      fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
349
      fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (msymbol)), outfile);
350
      fprintf_filtered (outfile, " %s", DEPRECATED_SYMBOL_NAME (msymbol));
351
      if (SYMBOL_BFD_SECTION (msymbol))
352
        fprintf_filtered (outfile, " section %s",
353
                          bfd_section_name (objfile->obfd,
354
                                            SYMBOL_BFD_SECTION (msymbol)));
355
      if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL)
356
        {
357
          fprintf_filtered (outfile, "  %s", SYMBOL_DEMANGLED_NAME (msymbol));
358
        }
359
      if (msymbol->filename)
360
        fprintf_filtered (outfile, "  %s", msymbol->filename);
361
      fputs_filtered ("\n", outfile);
362
    }
363
  if (objfile->minimal_symbol_count != index)
364
    {
365
      warning (_("internal error:  minimal symbol count %d != %d"),
366
               objfile->minimal_symbol_count, index);
367
    }
368
  fprintf_filtered (outfile, "\n");
369
}
370
 
371
static void
372
dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
373
              struct ui_file *outfile)
374
{
375
  int i;
376
 
377
  fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
378
                    psymtab->filename);
379
  fprintf_filtered (outfile, "(object ");
380
  gdb_print_host_address (psymtab, outfile);
381
  fprintf_filtered (outfile, ")\n\n");
382
  fprintf_unfiltered (outfile, "  Read from object file %s (",
383
                      objfile->name);
384
  gdb_print_host_address (objfile, outfile);
385
  fprintf_unfiltered (outfile, ")\n");
386
 
387
  if (psymtab->readin)
388
    {
389
      fprintf_filtered (outfile,
390
                        "  Full symtab was read (at ");
391
      gdb_print_host_address (psymtab->symtab, outfile);
392
      fprintf_filtered (outfile, " by function at ");
393
      gdb_print_host_address (psymtab->read_symtab, outfile);
394
      fprintf_filtered (outfile, ")\n");
395
    }
396
 
397
  fprintf_filtered (outfile, "  Relocate symbols by ");
398
  for (i = 0; i < psymtab->objfile->num_sections; ++i)
399
    {
400
      if (i != 0)
401
        fprintf_filtered (outfile, ", ");
402
      wrap_here ("    ");
403
      fputs_filtered (paddress (ANOFFSET (psymtab->section_offsets, i)),
404
                      outfile);
405
    }
406
  fprintf_filtered (outfile, "\n");
407
 
408
  fprintf_filtered (outfile, "  Symbols cover text addresses ");
409
  fputs_filtered (paddress (psymtab->textlow), outfile);
410
  fprintf_filtered (outfile, "-");
411
  fputs_filtered (paddress (psymtab->texthigh), outfile);
412
  fprintf_filtered (outfile, "\n");
413
  fprintf_filtered (outfile, "  Depends on %d other partial symtabs.\n",
414
                    psymtab->number_of_dependencies);
415
  for (i = 0; i < psymtab->number_of_dependencies; i++)
416
    {
417
      fprintf_filtered (outfile, "    %d ", i);
418
      gdb_print_host_address (psymtab->dependencies[i], outfile);
419
      fprintf_filtered (outfile, " %s\n",
420
                        psymtab->dependencies[i]->filename);
421
    }
422
  if (psymtab->n_global_syms > 0)
423
    {
424
      print_partial_symbols (objfile->global_psymbols.list
425
                             + psymtab->globals_offset,
426
                             psymtab->n_global_syms, "Global", outfile);
427
    }
428
  if (psymtab->n_static_syms > 0)
429
    {
430
      print_partial_symbols (objfile->static_psymbols.list
431
                             + psymtab->statics_offset,
432
                             psymtab->n_static_syms, "Static", outfile);
433
    }
434
  fprintf_filtered (outfile, "\n");
435
}
436
 
437
static void
438
dump_symtab_1 (struct objfile *objfile, struct symtab *symtab,
439
               struct ui_file *outfile)
440
{
441
  int i;
442
  struct dict_iterator iter;
443
  int len, blen;
444
  struct linetable *l;
445
  struct blockvector *bv;
446
  struct symbol *sym;
447
  struct block *b;
448
  int depth;
449
 
450
  fprintf_filtered (outfile, "\nSymtab for file %s\n", symtab->filename);
451
  if (symtab->dirname)
452
    fprintf_filtered (outfile, "Compilation directory is %s\n",
453
                      symtab->dirname);
454
  fprintf_filtered (outfile, "Read from object file %s (", objfile->name);
455
  gdb_print_host_address (objfile, outfile);
456
  fprintf_filtered (outfile, ")\n");
457
  fprintf_filtered (outfile, "Language: %s\n", language_str (symtab->language));
458
 
459
  /* First print the line table.  */
460
  l = LINETABLE (symtab);
461
  if (l)
462
    {
463
      fprintf_filtered (outfile, "\nLine table:\n\n");
464
      len = l->nitems;
465
      for (i = 0; i < len; i++)
466
        {
467
          fprintf_filtered (outfile, " line %d at ", l->item[i].line);
468
          fputs_filtered (paddress (l->item[i].pc), outfile);
469
          fprintf_filtered (outfile, "\n");
470
        }
471
    }
472
  /* Now print the block info, but only for primary symtabs since we will
473
     print lots of duplicate info otherwise. */
474
  if (symtab->primary)
475
    {
476
      fprintf_filtered (outfile, "\nBlockvector:\n\n");
477
      bv = BLOCKVECTOR (symtab);
478
      len = BLOCKVECTOR_NBLOCKS (bv);
479
      for (i = 0; i < len; i++)
480
        {
481
          b = BLOCKVECTOR_BLOCK (bv, i);
482
          depth = block_depth (b) * 2;
483
          print_spaces (depth, outfile);
484
          fprintf_filtered (outfile, "block #%03d, object at ", i);
485
          gdb_print_host_address (b, outfile);
486
          if (BLOCK_SUPERBLOCK (b))
487
            {
488
              fprintf_filtered (outfile, " under ");
489
              gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
490
            }
491
          /* drow/2002-07-10: We could save the total symbols count
492
             even if we're using a hashtable, but nothing else but this message
493
             wants it.  */
494
          fprintf_filtered (outfile, ", %d syms/buckets in ",
495
                            dict_size (BLOCK_DICT (b)));
496
          fputs_filtered (paddress (BLOCK_START (b)), outfile);
497
          fprintf_filtered (outfile, "..");
498
          fputs_filtered (paddress (BLOCK_END (b)), outfile);
499
          if (BLOCK_FUNCTION (b))
500
            {
501
              fprintf_filtered (outfile, ", function %s", DEPRECATED_SYMBOL_NAME (BLOCK_FUNCTION (b)));
502
              if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
503
                {
504
                  fprintf_filtered (outfile, ", %s",
505
                                SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
506
                }
507
            }
508
          fprintf_filtered (outfile, "\n");
509
          /* Now print each symbol in this block (in no particular order, if
510
             we're using a hashtable).  */
511
          ALL_BLOCK_SYMBOLS (b, iter, sym)
512
            {
513
              struct print_symbol_args s;
514
              s.symbol = sym;
515
              s.depth = depth + 1;
516
              s.outfile = outfile;
517
              catch_errors (print_symbol, &s, "Error printing symbol:\n",
518
                            RETURN_MASK_ERROR);
519
            }
520
        }
521
      fprintf_filtered (outfile, "\n");
522
    }
523
  else
524
    {
525
      fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n");
526
    }
527
}
528
 
529
static void
530
dump_symtab (struct objfile *objfile, struct symtab *symtab,
531
             struct ui_file *outfile)
532
{
533
  enum language saved_lang;
534
 
535
  /* Set the current language to the language of the symtab we're dumping
536
     because certain routines used during dump_symtab() use the current
537
     language to print an image of the symbol.  We'll restore it later.  */
538
  saved_lang = set_language (symtab->language);
539
 
540
  dump_symtab_1 (objfile, symtab, outfile);
541
 
542
  set_language (saved_lang);
543
}
544
 
545
void
546
maintenance_print_symbols (char *args, int from_tty)
547
{
548
  char **argv;
549
  struct ui_file *outfile;
550
  struct cleanup *cleanups;
551
  char *symname = NULL;
552
  char *filename = DEV_TTY;
553
  struct objfile *objfile;
554
  struct symtab *s;
555
 
556
  dont_repeat ();
557
 
558
  if (args == NULL)
559
    {
560
      error (_("\
561
Arguments missing: an output file name and an optional symbol file name"));
562
    }
563
  else if ((argv = buildargv (args)) == NULL)
564
    {
565
      nomem (0);
566
    }
567
  cleanups = make_cleanup_freeargv (argv);
568
 
569
  if (argv[0] != NULL)
570
    {
571
      filename = argv[0];
572
      /* If a second arg is supplied, it is a source file name to match on */
573
      if (argv[1] != NULL)
574
        {
575
          symname = argv[1];
576
        }
577
    }
578
 
579
  filename = tilde_expand (filename);
580
  make_cleanup (xfree, filename);
581
 
582
  outfile = gdb_fopen (filename, FOPEN_WT);
583
  if (outfile == 0)
584
    perror_with_name (filename);
585
  make_cleanup_ui_file_delete (outfile);
586
 
587
  immediate_quit++;
588
  ALL_SYMTABS (objfile, s)
589
    if (symname == NULL || strcmp (symname, s->filename) == 0)
590
    dump_symtab (objfile, s, outfile);
591
  immediate_quit--;
592
  do_cleanups (cleanups);
593
}
594
 
595
/* Print symbol ARGS->SYMBOL on ARGS->OUTFILE.  ARGS->DEPTH says how
596
   far to indent.  ARGS is really a struct print_symbol_args *, but is
597
   declared as char * to get it past catch_errors.  Returns 0 for error,
598
   1 for success.  */
599
 
600
static int
601
print_symbol (void *args)
602
{
603
  struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
604
  int depth = ((struct print_symbol_args *) args)->depth;
605
  struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
606
 
607
  print_spaces (depth, outfile);
608
  if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
609
    {
610
      fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
611
      fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol)), outfile);
612
      if (SYMBOL_BFD_SECTION (symbol))
613
        fprintf_filtered (outfile, " section %s\n",
614
                       bfd_section_name (SYMBOL_BFD_SECTION (symbol)->owner,
615
                                         SYMBOL_BFD_SECTION (symbol)));
616
      else
617
        fprintf_filtered (outfile, "\n");
618
      return 1;
619
    }
620
  if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
621
    {
622
      if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
623
        {
624
          LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
625
        }
626
      else
627
        {
628
          fprintf_filtered (outfile, "%s %s = ",
629
                         (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
630
                          ? "enum"
631
                     : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
632
                        ? "struct" : "union")),
633
                            DEPRECATED_SYMBOL_NAME (symbol));
634
          LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
635
        }
636
      fprintf_filtered (outfile, ";\n");
637
    }
638
  else
639
    {
640
      if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
641
        fprintf_filtered (outfile, "typedef ");
642
      if (SYMBOL_TYPE (symbol))
643
        {
644
          /* Print details of types, except for enums where it's clutter.  */
645
          LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
646
                         outfile,
647
                         TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
648
                         depth);
649
          fprintf_filtered (outfile, "; ");
650
        }
651
      else
652
        fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
653
 
654
      switch (SYMBOL_CLASS (symbol))
655
        {
656
        case LOC_CONST:
657
          fprintf_filtered (outfile, "const %ld (0x%lx)",
658
                            SYMBOL_VALUE (symbol),
659
                            SYMBOL_VALUE (symbol));
660
          break;
661
 
662
        case LOC_CONST_BYTES:
663
          {
664
            unsigned i;
665
            struct type *type = check_typedef (SYMBOL_TYPE (symbol));
666
            fprintf_filtered (outfile, "const %u hex bytes:",
667
                              TYPE_LENGTH (type));
668
            for (i = 0; i < TYPE_LENGTH (type); i++)
669
              fprintf_filtered (outfile, " %02x",
670
                                (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
671
          }
672
          break;
673
 
674
        case LOC_STATIC:
675
          fprintf_filtered (outfile, "static at ");
676
          fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol)), outfile);
677
          if (SYMBOL_BFD_SECTION (symbol))
678
            fprintf_filtered (outfile, " section %s",
679
                              bfd_section_name
680
                              (SYMBOL_BFD_SECTION (symbol)->owner,
681
                               SYMBOL_BFD_SECTION (symbol)));
682
          break;
683
 
684
        case LOC_INDIRECT:
685
          fprintf_filtered (outfile, "extern global at *(");
686
          fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol)), outfile);
687
          fprintf_filtered (outfile, "),");
688
          break;
689
 
690
        case LOC_REGISTER:
691
          fprintf_filtered (outfile, "register %ld", SYMBOL_VALUE (symbol));
692
          break;
693
 
694
        case LOC_ARG:
695
          fprintf_filtered (outfile, "arg at offset 0x%lx",
696
                            SYMBOL_VALUE (symbol));
697
          break;
698
 
699
        case LOC_LOCAL_ARG:
700
          fprintf_filtered (outfile, "arg at offset 0x%lx from fp",
701
                            SYMBOL_VALUE (symbol));
702
          break;
703
 
704
        case LOC_REF_ARG:
705
          fprintf_filtered (outfile, "reference arg at 0x%lx", SYMBOL_VALUE (symbol));
706
          break;
707
 
708
        case LOC_REGPARM:
709
          fprintf_filtered (outfile, "parameter register %ld", SYMBOL_VALUE (symbol));
710
          break;
711
 
712
        case LOC_REGPARM_ADDR:
713
          fprintf_filtered (outfile, "address parameter register %ld", SYMBOL_VALUE (symbol));
714
          break;
715
 
716
        case LOC_LOCAL:
717
          fprintf_filtered (outfile, "local at offset 0x%lx",
718
                            SYMBOL_VALUE (symbol));
719
          break;
720
 
721
        case LOC_BASEREG:
722
          fprintf_filtered (outfile, "local at 0x%lx from register %d",
723
                            SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
724
          break;
725
 
726
        case LOC_BASEREG_ARG:
727
          fprintf_filtered (outfile, "arg at 0x%lx from register %d",
728
                            SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
729
          break;
730
 
731
        case LOC_TYPEDEF:
732
          break;
733
 
734
        case LOC_LABEL:
735
          fprintf_filtered (outfile, "label at ");
736
          fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol)), outfile);
737
          if (SYMBOL_BFD_SECTION (symbol))
738
            fprintf_filtered (outfile, " section %s",
739
                              bfd_section_name
740
                              (SYMBOL_BFD_SECTION (symbol)->owner,
741
                               SYMBOL_BFD_SECTION (symbol)));
742
          break;
743
 
744
        case LOC_BLOCK:
745
          fprintf_filtered (outfile, "block object ");
746
          gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
747
          fprintf_filtered (outfile, ", ");
748
          fputs_filtered (paddress (BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
749
                          outfile);
750
          fprintf_filtered (outfile, "..");
751
          fputs_filtered (paddress (BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
752
                          outfile);
753
          if (SYMBOL_BFD_SECTION (symbol))
754
            fprintf_filtered (outfile, " section %s",
755
                              bfd_section_name
756
                              (SYMBOL_BFD_SECTION (symbol)->owner,
757
                               SYMBOL_BFD_SECTION (symbol)));
758
          break;
759
 
760
        case LOC_COMPUTED:
761
        case LOC_COMPUTED_ARG:
762
          fprintf_filtered (outfile, "computed at runtime");
763
          break;
764
 
765
        case LOC_UNRESOLVED:
766
          fprintf_filtered (outfile, "unresolved");
767
          break;
768
 
769
        case LOC_OPTIMIZED_OUT:
770
          fprintf_filtered (outfile, "optimized out");
771
          break;
772
 
773
        default:
774
          fprintf_filtered (outfile, "botched symbol class %x",
775
                            SYMBOL_CLASS (symbol));
776
          break;
777
        }
778
    }
779
  fprintf_filtered (outfile, "\n");
780
  return 1;
781
}
782
 
783
void
784
maintenance_print_psymbols (char *args, int from_tty)
785
{
786
  char **argv;
787
  struct ui_file *outfile;
788
  struct cleanup *cleanups;
789
  char *symname = NULL;
790
  char *filename = DEV_TTY;
791
  struct objfile *objfile;
792
  struct partial_symtab *ps;
793
 
794
  dont_repeat ();
795
 
796
  if (args == NULL)
797
    {
798
      error (_("print-psymbols takes an output file name and optional symbol file name"));
799
    }
800
  else if ((argv = buildargv (args)) == NULL)
801
    {
802
      nomem (0);
803
    }
804
  cleanups = make_cleanup_freeargv (argv);
805
 
806
  if (argv[0] != NULL)
807
    {
808
      filename = argv[0];
809
      /* If a second arg is supplied, it is a source file name to match on */
810
      if (argv[1] != NULL)
811
        {
812
          symname = argv[1];
813
        }
814
    }
815
 
816
  filename = tilde_expand (filename);
817
  make_cleanup (xfree, filename);
818
 
819
  outfile = gdb_fopen (filename, FOPEN_WT);
820
  if (outfile == 0)
821
    perror_with_name (filename);
822
  make_cleanup_ui_file_delete (outfile);
823
 
824
  immediate_quit++;
825
  ALL_PSYMTABS (objfile, ps)
826
    if (symname == NULL || strcmp (symname, ps->filename) == 0)
827
    dump_psymtab (objfile, ps, outfile);
828
  immediate_quit--;
829
  do_cleanups (cleanups);
830
}
831
 
832
static void
833
print_partial_symbols (struct partial_symbol **p, int count, char *what,
834
                       struct ui_file *outfile)
835
{
836
  fprintf_filtered (outfile, "  %s partial symbols:\n", what);
837
  while (count-- > 0)
838
    {
839
      fprintf_filtered (outfile, "    `%s'", DEPRECATED_SYMBOL_NAME (*p));
840
      if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
841
        {
842
          fprintf_filtered (outfile, "  `%s'", SYMBOL_DEMANGLED_NAME (*p));
843
        }
844
      fputs_filtered (", ", outfile);
845
      switch (SYMBOL_DOMAIN (*p))
846
        {
847
        case UNDEF_DOMAIN:
848
          fputs_filtered ("undefined domain, ", outfile);
849
          break;
850
        case VAR_DOMAIN:
851
          /* This is the usual thing -- don't print it */
852
          break;
853
        case STRUCT_DOMAIN:
854
          fputs_filtered ("struct domain, ", outfile);
855
          break;
856
        case LABEL_DOMAIN:
857
          fputs_filtered ("label domain, ", outfile);
858
          break;
859
        default:
860
          fputs_filtered ("<invalid domain>, ", outfile);
861
          break;
862
        }
863
      switch (SYMBOL_CLASS (*p))
864
        {
865
        case LOC_UNDEF:
866
          fputs_filtered ("undefined", outfile);
867
          break;
868
        case LOC_CONST:
869
          fputs_filtered ("constant int", outfile);
870
          break;
871
        case LOC_STATIC:
872
          fputs_filtered ("static", outfile);
873
          break;
874
        case LOC_INDIRECT:
875
          fputs_filtered ("extern global", outfile);
876
          break;
877
        case LOC_REGISTER:
878
          fputs_filtered ("register", outfile);
879
          break;
880
        case LOC_ARG:
881
          fputs_filtered ("pass by value", outfile);
882
          break;
883
        case LOC_REF_ARG:
884
          fputs_filtered ("pass by reference", outfile);
885
          break;
886
        case LOC_REGPARM:
887
          fputs_filtered ("register parameter", outfile);
888
          break;
889
        case LOC_REGPARM_ADDR:
890
          fputs_filtered ("register address parameter", outfile);
891
          break;
892
        case LOC_LOCAL:
893
          fputs_filtered ("stack parameter", outfile);
894
          break;
895
        case LOC_TYPEDEF:
896
          fputs_filtered ("type", outfile);
897
          break;
898
        case LOC_LABEL:
899
          fputs_filtered ("label", outfile);
900
          break;
901
        case LOC_BLOCK:
902
          fputs_filtered ("function", outfile);
903
          break;
904
        case LOC_CONST_BYTES:
905
          fputs_filtered ("constant bytes", outfile);
906
          break;
907
        case LOC_LOCAL_ARG:
908
          fputs_filtered ("shuffled arg", outfile);
909
          break;
910
        case LOC_UNRESOLVED:
911
          fputs_filtered ("unresolved", outfile);
912
          break;
913
        case LOC_OPTIMIZED_OUT:
914
          fputs_filtered ("optimized out", outfile);
915
          break;
916
        case LOC_COMPUTED:
917
        case LOC_COMPUTED_ARG:
918
          fputs_filtered ("computed at runtime", outfile);
919
          break;
920
        default:
921
          fputs_filtered ("<invalid location>", outfile);
922
          break;
923
        }
924
      fputs_filtered (", ", outfile);
925
      fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (*p)), outfile);
926
      fprintf_filtered (outfile, "\n");
927
      p++;
928
    }
929
}
930
 
931
void
932
maintenance_print_msymbols (char *args, int from_tty)
933
{
934
  char **argv;
935
  struct ui_file *outfile;
936
  struct cleanup *cleanups;
937
  char *filename = DEV_TTY;
938
  char *symname = NULL;
939
  struct objfile *objfile;
940
 
941
  struct stat sym_st, obj_st;
942
 
943
  dont_repeat ();
944
 
945
  if (args == NULL)
946
    {
947
      error (_("print-msymbols takes an output file name and optional symbol file name"));
948
    }
949
  else if ((argv = buildargv (args)) == NULL)
950
    {
951
      nomem (0);
952
    }
953
  cleanups = make_cleanup_freeargv (argv);
954
 
955
  if (argv[0] != NULL)
956
    {
957
      filename = argv[0];
958
      /* If a second arg is supplied, it is a source file name to match on */
959
      if (argv[1] != NULL)
960
        {
961
          symname = xfullpath (argv[1]);
962
          make_cleanup (xfree, symname);
963
          if (symname && stat (symname, &sym_st))
964
            perror_with_name (symname);
965
        }
966
    }
967
 
968
  filename = tilde_expand (filename);
969
  make_cleanup (xfree, filename);
970
 
971
  outfile = gdb_fopen (filename, FOPEN_WT);
972
  if (outfile == 0)
973
    perror_with_name (filename);
974
  make_cleanup_ui_file_delete (outfile);
975
 
976
  immediate_quit++;
977
  ALL_OBJFILES (objfile)
978
    if (symname == NULL
979
        || (!stat (objfile->name, &obj_st) && sym_st.st_ino == obj_st.st_ino))
980
      dump_msymbols (objfile, outfile);
981
  immediate_quit--;
982
  fprintf_filtered (outfile, "\n\n");
983
  do_cleanups (cleanups);
984
}
985
 
986
void
987
maintenance_print_objfiles (char *ignore, int from_tty)
988
{
989
  struct objfile *objfile;
990
 
991
  dont_repeat ();
992
 
993
  immediate_quit++;
994
  ALL_OBJFILES (objfile)
995
    dump_objfile (objfile);
996
  immediate_quit--;
997
}
998
 
999
 
1000
/* List all the symbol tables whose names match REGEXP (optional).  */
1001
void
1002
maintenance_info_symtabs (char *regexp, int from_tty)
1003
{
1004
  struct objfile *objfile;
1005
 
1006
  if (regexp)
1007
    re_comp (regexp);
1008
 
1009
  ALL_OBJFILES (objfile)
1010
    {
1011
      struct symtab *symtab;
1012
 
1013
      /* We don't want to print anything for this objfile until we
1014
         actually find a symtab whose name matches.  */
1015
      int printed_objfile_start = 0;
1016
 
1017
      ALL_OBJFILE_SYMTABS (objfile, symtab)
1018
        if (! regexp
1019
            || re_exec (symtab->filename))
1020
          {
1021
            if (! printed_objfile_start)
1022
              {
1023
                printf_filtered ("{ objfile %s ", objfile->name);
1024
                wrap_here ("  ");
1025
                printf_filtered ("((struct objfile *) %p)\n", objfile);
1026
                printed_objfile_start = 1;
1027
              }
1028
 
1029
            printf_filtered ("  { symtab %s ", symtab->filename);
1030
            wrap_here ("    ");
1031
            printf_filtered ("((struct symtab *) %p)\n", symtab);
1032
            printf_filtered ("    dirname %s\n",
1033
                             symtab->dirname ? symtab->dirname : "(null)");
1034
            printf_filtered ("    fullname %s\n",
1035
                             symtab->fullname ? symtab->fullname : "(null)");
1036
            printf_filtered ("    blockvector ((struct blockvector *) %p)%s\n",
1037
                             symtab->blockvector,
1038
                             symtab->primary ? " (primary)" : "");
1039
            printf_filtered ("    linetable ((struct linetable *) %p)\n",
1040
                             symtab->linetable);
1041
            printf_filtered ("    debugformat %s\n", symtab->debugformat);
1042
            printf_filtered ("  }\n");
1043
          }
1044
 
1045
      if (printed_objfile_start)
1046
        printf_filtered ("}\n");
1047
    }
1048
}
1049
 
1050
 
1051
/* List all the partial symbol tables whose names match REGEXP (optional).  */
1052
void
1053
maintenance_info_psymtabs (char *regexp, int from_tty)
1054
{
1055
  struct objfile *objfile;
1056
 
1057
  if (regexp)
1058
    re_comp (regexp);
1059
 
1060
  ALL_OBJFILES (objfile)
1061
    {
1062
      struct partial_symtab *psymtab;
1063
 
1064
      /* We don't want to print anything for this objfile until we
1065
         actually find a symtab whose name matches.  */
1066
      int printed_objfile_start = 0;
1067
 
1068
      ALL_OBJFILE_PSYMTABS (objfile, psymtab)
1069
        if (! regexp
1070
            || re_exec (psymtab->filename))
1071
          {
1072
            if (! printed_objfile_start)
1073
              {
1074
                printf_filtered ("{ objfile %s ", objfile->name);
1075
                wrap_here ("  ");
1076
                printf_filtered ("((struct objfile *) %p)\n", objfile);
1077
                printed_objfile_start = 1;
1078
              }
1079
 
1080
            printf_filtered ("  { psymtab %s ", psymtab->filename);
1081
            wrap_here ("    ");
1082
            printf_filtered ("((struct partial_symtab *) %p)\n", psymtab);
1083
            printf_filtered ("    readin %s\n",
1084
                             psymtab->readin ? "yes" : "no");
1085
            printf_filtered ("    fullname %s\n",
1086
                             psymtab->fullname ? psymtab->fullname : "(null)");
1087
            printf_filtered ("    text addresses ");
1088
            fputs_filtered (paddress (psymtab->textlow), gdb_stdout);
1089
            printf_filtered (" -- ");
1090
            fputs_filtered (paddress (psymtab->texthigh), gdb_stdout);
1091
            printf_filtered ("\n");
1092
            printf_filtered ("    globals ");
1093
            if (psymtab->n_global_syms)
1094
              {
1095
                printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1096
                                 (psymtab->objfile->global_psymbols.list
1097
                                  + psymtab->globals_offset),
1098
                                 psymtab->n_global_syms);
1099
              }
1100
            else
1101
              printf_filtered ("(none)\n");
1102
            printf_filtered ("    statics ");
1103
            if (psymtab->n_static_syms)
1104
              {
1105
                printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1106
                                 (psymtab->objfile->static_psymbols.list
1107
                                  + psymtab->statics_offset),
1108
                                 psymtab->n_static_syms);
1109
              }
1110
            else
1111
              printf_filtered ("(none)\n");
1112
            printf_filtered ("    dependencies ");
1113
            if (psymtab->number_of_dependencies)
1114
              {
1115
                int i;
1116
 
1117
                printf_filtered ("{\n");
1118
                for (i = 0; i < psymtab->number_of_dependencies; i++)
1119
                  {
1120
                    struct partial_symtab *dep = psymtab->dependencies[i];
1121
 
1122
                    /* Note the string concatenation there --- no comma.  */
1123
                    printf_filtered ("      psymtab %s "
1124
                                     "((struct partial_symtab *) %p)\n",
1125
                                     dep->filename, dep);
1126
                  }
1127
                printf_filtered ("    }\n");
1128
              }
1129
            else
1130
              printf_filtered ("(none)\n");
1131
            printf_filtered ("  }\n");
1132
          }
1133
 
1134
      if (printed_objfile_start)
1135
        printf_filtered ("}\n");
1136
    }
1137
}
1138
 
1139
 
1140
/* Check consistency of psymtabs and symtabs.  */
1141
 
1142
void
1143
maintenance_check_symtabs (char *ignore, int from_tty)
1144
{
1145
  struct symbol *sym;
1146
  struct partial_symbol **psym;
1147
  struct symtab *s = NULL;
1148
  struct partial_symtab *ps;
1149
  struct blockvector *bv;
1150
  struct objfile *objfile;
1151
  struct block *b;
1152
  int length;
1153
 
1154
  ALL_PSYMTABS (objfile, ps)
1155
  {
1156
    s = PSYMTAB_TO_SYMTAB (ps);
1157
    if (s == NULL)
1158
      continue;
1159
    bv = BLOCKVECTOR (s);
1160
    b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1161
    psym = ps->objfile->static_psymbols.list + ps->statics_offset;
1162
    length = ps->n_static_syms;
1163
    while (length--)
1164
      {
1165
        sym = lookup_block_symbol (b, DEPRECATED_SYMBOL_NAME (*psym),
1166
                                   NULL, SYMBOL_DOMAIN (*psym));
1167
        if (!sym)
1168
          {
1169
            printf_filtered ("Static symbol `");
1170
            puts_filtered (DEPRECATED_SYMBOL_NAME (*psym));
1171
            printf_filtered ("' only found in ");
1172
            puts_filtered (ps->filename);
1173
            printf_filtered (" psymtab\n");
1174
          }
1175
        psym++;
1176
      }
1177
    b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1178
    psym = ps->objfile->global_psymbols.list + ps->globals_offset;
1179
    length = ps->n_global_syms;
1180
    while (length--)
1181
      {
1182
        sym = lookup_block_symbol (b, DEPRECATED_SYMBOL_NAME (*psym),
1183
                                   NULL, SYMBOL_DOMAIN (*psym));
1184
        if (!sym)
1185
          {
1186
            printf_filtered ("Global symbol `");
1187
            puts_filtered (DEPRECATED_SYMBOL_NAME (*psym));
1188
            printf_filtered ("' only found in ");
1189
            puts_filtered (ps->filename);
1190
            printf_filtered (" psymtab\n");
1191
          }
1192
        psym++;
1193
      }
1194
    if (ps->texthigh < ps->textlow)
1195
      {
1196
        printf_filtered ("Psymtab ");
1197
        puts_filtered (ps->filename);
1198
        printf_filtered (" covers bad range ");
1199
        fputs_filtered (paddress (ps->textlow), gdb_stdout);
1200
        printf_filtered (" - ");
1201
        fputs_filtered (paddress (ps->texthigh), gdb_stdout);
1202
        printf_filtered ("\n");
1203
        continue;
1204
      }
1205
    if (ps->texthigh == 0)
1206
      continue;
1207
    if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
1208
      {
1209
        printf_filtered ("Psymtab ");
1210
        puts_filtered (ps->filename);
1211
        printf_filtered (" covers ");
1212
        fputs_filtered (paddress (ps->textlow), gdb_stdout);
1213
        printf_filtered (" - ");
1214
        fputs_filtered (paddress (ps->texthigh), gdb_stdout);
1215
        printf_filtered (" but symtab covers only ");
1216
        fputs_filtered (paddress (BLOCK_START (b)), gdb_stdout);
1217
        printf_filtered (" - ");
1218
        fputs_filtered (paddress (BLOCK_END (b)), gdb_stdout);
1219
        printf_filtered ("\n");
1220
      }
1221
  }
1222
}
1223
 
1224
 
1225
/* Return the nexting depth of a block within other blocks in its symtab.  */
1226
 
1227
static int
1228
block_depth (struct block *block)
1229
{
1230
  int i = 0;
1231
  while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
1232
    {
1233
      i++;
1234
    }
1235
  return i;
1236
}
1237
 
1238
 
1239
/* Increase the space allocated for LISTP, which is probably
1240
   global_psymbols or static_psymbols. This space will eventually
1241
   be freed in free_objfile().  */
1242
 
1243
void
1244
extend_psymbol_list (struct psymbol_allocation_list *listp,
1245
                     struct objfile *objfile)
1246
{
1247
  int new_size;
1248
  if (listp->size == 0)
1249
    {
1250
      new_size = 255;
1251
      listp->list = (struct partial_symbol **)
1252
        xmalloc (new_size * sizeof (struct partial_symbol *));
1253
    }
1254
  else
1255
    {
1256
      new_size = listp->size * 2;
1257
      listp->list = (struct partial_symbol **)
1258
        xrealloc ((char *) listp->list,
1259
                  new_size * sizeof (struct partial_symbol *));
1260
    }
1261
  /* Next assumes we only went one over.  Should be good if
1262
     program works correctly */
1263
  listp->next = listp->list + listp->size;
1264
  listp->size = new_size;
1265
}
1266
 
1267
 
1268
/* Do early runtime initializations. */
1269
void
1270
_initialize_symmisc (void)
1271
{
1272
  std_in = stdin;
1273
  std_out = stdout;
1274
  std_err = stderr;
1275
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.