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

Subversion Repositories openrisc_me

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

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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