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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [mdebugread.c] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Read a symbol table in ECOFF format (Third-Eye).
2
 
3
   Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4
   1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010
5
   Free Software Foundation, Inc.
6
 
7
   Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
8
   CMU.  Major work by Per Bothner, John Gilmore and Ian Lance Taylor
9
   at Cygnus Support.
10
 
11
   This file is part of GDB.
12
 
13
   This program is free software; you can redistribute it and/or modify
14
   it under the terms of the GNU General Public License as published by
15
   the Free Software Foundation; either version 3 of the License, or
16
   (at your option) any later version.
17
 
18
   This program is distributed in the hope that it will be useful,
19
   but WITHOUT ANY WARRANTY; without even the implied warranty of
20
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21
   GNU General Public License for more details.
22
 
23
   You should have received a copy of the GNU General Public License
24
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
25
 
26
/* This module provides the function mdebug_build_psymtabs.  It reads
27
   ECOFF debugging information into partial symbol tables.  The
28
   debugging information is read from two structures.  A struct
29
   ecoff_debug_swap includes the sizes of each ECOFF structure and
30
   swapping routines; these are fixed for a particular target.  A
31
   struct ecoff_debug_info points to the debugging information for a
32
   particular object file.
33
 
34
   ECOFF symbol tables are mostly written in the byte order of the
35
   target machine.  However, one section of the table (the auxiliary
36
   symbol information) is written in the host byte order.  There is a
37
   bit in the other symbol info which describes which host byte order
38
   was used.  ECOFF thereby takes the trophy from Intel `b.out' for
39
   the most brain-dead adaptation of a file format to byte order.
40
 
41
   This module can read all four of the known byte-order combinations,
42
   on any type of host.  */
43
 
44
#include "defs.h"
45
#include "symtab.h"
46
#include "gdbtypes.h"
47
#include "gdbcore.h"
48
#include "objfiles.h"
49
#include "gdb_obstack.h"
50
#include "buildsym.h"
51
#include "stabsread.h"
52
#include "complaints.h"
53
#include "demangle.h"
54
#include "gdb_assert.h"
55
#include "block.h"
56
#include "dictionary.h"
57
#include "mdebugread.h"
58
#include "gdb_stat.h"
59
#include "gdb_string.h"
60
 
61
#include "bfd.h"
62
 
63
#include "coff/ecoff.h"         /* COFF-like aspects of ecoff files */
64
 
65
#include "libaout.h"            /* Private BFD a.out information.  */
66
#include "aout/aout64.h"
67
#include "aout/stab_gnu.h"      /* STABS information */
68
 
69
#include "expression.h"
70
 
71
extern void _initialize_mdebugread (void);
72
 
73
/* Provide a way to test if we have both ECOFF and ELF symbol tables.
74
   We use this define in order to know whether we should override a
75
   symbol's ECOFF section with its ELF section.  This is necessary in
76
   case the symbol's ELF section could not be represented in ECOFF.  */
77
#define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
78
                           && bfd_get_section_by_name (bfd, ".mdebug") != NULL)
79
 
80
 
81
/* We put a pointer to this structure in the read_symtab_private field
82
   of the psymtab.  */
83
 
84
struct symloc
85
  {
86
    /* Index of the FDR that this psymtab represents.  */
87
    int fdr_idx;
88
    /* The BFD that the psymtab was created from.  */
89
    bfd *cur_bfd;
90
    const struct ecoff_debug_swap *debug_swap;
91
    struct ecoff_debug_info *debug_info;
92
    struct mdebug_pending **pending_list;
93
    /* Pointer to external symbols for this file.  */
94
    EXTR *extern_tab;
95
    /* Size of extern_tab.  */
96
    int extern_count;
97
    enum language pst_language;
98
  };
99
 
100
#define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
101
#define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
102
#define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
103
#define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
104
#define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info)
105
#define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list)
106
 
107
#define SC_IS_TEXT(sc) ((sc) == scText \
108
                   || (sc) == scRConst \
109
                   || (sc) == scInit \
110
                   || (sc) == scFini)
111
#define SC_IS_DATA(sc) ((sc) == scData \
112
                   || (sc) == scSData \
113
                   || (sc) == scRData \
114
                   || (sc) == scPData \
115
                   || (sc) == scXData)
116
#define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
117
#define SC_IS_BSS(sc) ((sc) == scBss)
118
#define SC_IS_SBSS(sc) ((sc) == scSBss)
119
#define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
120
 
121
/* Various complaints about symbol reading that don't abort the process */
122
static void
123
index_complaint (const char *arg1)
124
{
125
  complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1);
126
}
127
 
128
static void
129
unknown_ext_complaint (const char *arg1)
130
{
131
  complaint (&symfile_complaints, _("unknown external symbol %s"), arg1);
132
}
133
 
134
static void
135
basic_type_complaint (int arg1, const char *arg2)
136
{
137
  complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"),
138
             arg1, arg2);
139
}
140
 
141
static void
142
bad_tag_guess_complaint (const char *arg1)
143
{
144
  complaint (&symfile_complaints, _("guessed tag type of %s incorrectly"), arg1);
145
}
146
 
147
static void
148
bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3)
149
{
150
  complaint (&symfile_complaints, _("bad rfd entry for %s: file %d, index %d"),
151
             arg1, arg2, arg3);
152
}
153
 
154
static void
155
unexpected_type_code_complaint (const char *arg1)
156
{
157
  complaint (&symfile_complaints, _("unexpected type code for %s"), arg1);
158
}
159
 
160
/* Macros and extra defs */
161
 
162
/* Puns: hard to find whether -g was used and how */
163
 
164
#define MIN_GLEVEL GLEVEL_0
165
#define compare_glevel(a,b)                                     \
166
        (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) :                 \
167
         ((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
168
 
169
/* Things that really are local to this module */
170
 
171
/* Remember what we deduced to be the source language of this psymtab. */
172
 
173
static enum language psymtab_language = language_unknown;
174
 
175
/* Current BFD.  */
176
 
177
static bfd *cur_bfd;
178
 
179
/* How to parse debugging information for CUR_BFD.  */
180
 
181
static const struct ecoff_debug_swap *debug_swap;
182
 
183
/* Pointers to debugging information for CUR_BFD.  */
184
 
185
static struct ecoff_debug_info *debug_info;
186
 
187
/* Pointer to current file decriptor record, and its index */
188
 
189
static FDR *cur_fdr;
190
static int cur_fd;
191
 
192
/* Index of current symbol */
193
 
194
static int cur_sdx;
195
 
196
/* Note how much "debuggable" this image is.  We would like
197
   to see at least one FDR with full symbols */
198
 
199
static int max_gdbinfo;
200
static int max_glevel;
201
 
202
/* When examining .o files, report on undefined symbols */
203
 
204
static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs;
205
 
206
/* Pseudo symbol to use when putting stabs into the symbol table.  */
207
 
208
static char stabs_symbol[] = STABS_SYMBOL;
209
 
210
/* Nonzero if we have seen ecoff debugging info for a file.  */
211
 
212
static int found_ecoff_debugging_info;
213
 
214
/* Forward declarations */
215
 
216
static int upgrade_type (int, struct type **, int, union aux_ext *,
217
                         int, char *);
218
 
219
static void parse_partial_symbols (struct objfile *);
220
 
221
static int has_opaque_xref (FDR *, SYMR *);
222
 
223
static int cross_ref (int, union aux_ext *, struct type **, enum type_code,
224
                      char **, int, char *);
225
 
226
static struct symbol *new_symbol (char *);
227
 
228
static struct type *new_type (char *);
229
 
230
enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK };
231
 
232
static struct block *new_block (enum block_type);
233
 
234
static struct symtab *new_symtab (char *, int, struct objfile *);
235
 
236
static struct linetable *new_linetable (int);
237
 
238
static struct blockvector *new_bvect (int);
239
 
240
static struct type *parse_type (int, union aux_ext *, unsigned int, int *,
241
                                int, char *);
242
 
243
static struct symbol *mylookup_symbol (char *, struct block *, domain_enum,
244
                                       enum address_class);
245
 
246
static void sort_blocks (struct symtab *);
247
 
248
static struct partial_symtab *new_psymtab (char *, struct objfile *);
249
 
250
static void psymtab_to_symtab_1 (struct partial_symtab *, char *);
251
 
252
static void add_block (struct block *, struct symtab *);
253
 
254
static void add_symbol (struct symbol *, struct symtab *, struct block *);
255
 
256
static int add_line (struct linetable *, int, CORE_ADDR, int);
257
 
258
static struct linetable *shrink_linetable (struct linetable *);
259
 
260
static void handle_psymbol_enumerators (struct objfile *, FDR *, int,
261
                                        CORE_ADDR);
262
 
263
static char *mdebug_next_symbol_text (struct objfile *);
264
 
265
/* Exported procedure: Builds a symtab from the PST partial one.
266
   Restores the environment in effect when PST was created, delegates
267
   most of the work to an ancillary procedure, and sorts
268
   and reorders the symtab list at the end */
269
 
270
static void
271
mdebug_psymtab_to_symtab (struct partial_symtab *pst)
272
{
273
 
274
  if (!pst)
275
    return;
276
 
277
  if (info_verbose)
278
    {
279
      printf_filtered (_("Reading in symbols for %s..."), pst->filename);
280
      gdb_flush (gdb_stdout);
281
    }
282
 
283
  next_symbol_text_func = mdebug_next_symbol_text;
284
 
285
  psymtab_to_symtab_1 (pst, pst->filename);
286
 
287
  /* Match with global symbols.  This only needs to be done once,
288
     after all of the symtabs and dependencies have been read in.   */
289
  scan_file_globals (pst->objfile);
290
 
291
  if (info_verbose)
292
    printf_filtered (_("done.\n"));
293
}
294
 
295
/* File-level interface functions */
296
 
297
/* Find a file descriptor given its index RF relative to a file CF */
298
 
299
static FDR *
300
get_rfd (int cf, int rf)
301
{
302
  FDR *fdrs;
303
  FDR *f;
304
  RFDT rfd;
305
 
306
  fdrs = debug_info->fdr;
307
  f = fdrs + cf;
308
  /* Object files do not have the RFD table, all refs are absolute */
309
  if (f->rfdBase == 0)
310
    return fdrs + rf;
311
  (*debug_swap->swap_rfd_in) (cur_bfd,
312
                              ((char *) debug_info->external_rfd
313
                               + ((f->rfdBase + rf)
314
                                  * debug_swap->external_rfd_size)),
315
                              &rfd);
316
  return fdrs + rfd;
317
}
318
 
319
/* Return a safer print NAME for a file descriptor */
320
 
321
static char *
322
fdr_name (FDR *f)
323
{
324
  if (f->rss == -1)
325
    return "<stripped file>";
326
  if (f->rss == 0)
327
    return "<NFY>";
328
  return debug_info->ss + f->issBase + f->rss;
329
}
330
 
331
 
332
/* Read in and parse the symtab of the file OBJFILE.  Symbols from
333
   different sections are relocated via the SECTION_OFFSETS.  */
334
 
335
void
336
mdebug_build_psymtabs (struct objfile *objfile,
337
                       const struct ecoff_debug_swap *swap,
338
                       struct ecoff_debug_info *info)
339
{
340
  cur_bfd = objfile->obfd;
341
  debug_swap = swap;
342
  debug_info = info;
343
 
344
  stabsread_new_init ();
345
  buildsym_new_init ();
346
  free_header_files ();
347
  init_header_files ();
348
 
349
  /* Make sure all the FDR information is swapped in.  */
350
  if (info->fdr == (FDR *) NULL)
351
    {
352
      char *fdr_src;
353
      char *fdr_end;
354
      FDR *fdr_ptr;
355
 
356
      info->fdr = (FDR *) obstack_alloc (&objfile->objfile_obstack,
357
                                         (info->symbolic_header.ifdMax
358
                                          * sizeof (FDR)));
359
      fdr_src = info->external_fdr;
360
      fdr_end = (fdr_src
361
                 + info->symbolic_header.ifdMax * swap->external_fdr_size);
362
      fdr_ptr = info->fdr;
363
      for (; fdr_src < fdr_end; fdr_src += swap->external_fdr_size, fdr_ptr++)
364
        (*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr);
365
    }
366
 
367
  parse_partial_symbols (objfile);
368
 
369
#if 0
370
  /* Check to make sure file was compiled with -g.  If not, warn the
371
     user of this limitation.  */
372
  if (compare_glevel (max_glevel, GLEVEL_2) < 0)
373
    {
374
      if (max_gdbinfo == 0)
375
        printf_unfiltered (_("\n%s not compiled with -g, debugging support is limited.\n"),
376
                           objfile->name);
377
      printf_unfiltered (_("You should compile with -g2 or -g3 for best debugging support.\n"));
378
      gdb_flush (gdb_stdout);
379
    }
380
#endif
381
}
382
 
383
/* Local utilities */
384
 
385
/* Map of FDR indexes to partial symtabs */
386
 
387
struct pst_map
388
{
389
  struct partial_symtab *pst;   /* the psymtab proper */
390
  long n_globals;               /* exported globals (external symbols) */
391
  long globals_offset;          /* cumulative */
392
};
393
 
394
 
395
/* Utility stack, used to nest procedures and blocks properly.
396
   It is a doubly linked list, to avoid too many alloc/free.
397
   Since we might need it quite a few times it is NOT deallocated
398
   after use. */
399
 
400
static struct parse_stack
401
  {
402
    struct parse_stack *next, *prev;
403
    struct symtab *cur_st;      /* Current symtab. */
404
    struct block *cur_block;    /* Block in it. */
405
 
406
    /* What are we parsing.  stFile, or stBlock are for files and
407
       blocks.  stProc or stStaticProc means we have seen the start of a
408
       procedure, but not the start of the block within in.  When we see
409
       the start of that block, we change it to stNil, without pushing a
410
       new block, i.e. stNil means both a procedure and a block.  */
411
 
412
    int blocktype;
413
 
414
    struct type *cur_type;      /* Type we parse fields for. */
415
    int cur_field;              /* Field number in cur_type. */
416
    CORE_ADDR procadr;          /* Start addres of this procedure */
417
    int numargs;                /* Its argument count */
418
  }
419
 
420
 *top_stack;                    /* Top stack ptr */
421
 
422
 
423
/* Enter a new lexical context */
424
 
425
static void
426
push_parse_stack (void)
427
{
428
  struct parse_stack *new;
429
 
430
  /* Reuse frames if possible */
431
  if (top_stack && top_stack->prev)
432
    new = top_stack->prev;
433
  else
434
    new = (struct parse_stack *) xzalloc (sizeof (struct parse_stack));
435
  /* Initialize new frame with previous content */
436
  if (top_stack)
437
    {
438
      struct parse_stack *prev = new->prev;
439
 
440
      *new = *top_stack;
441
      top_stack->prev = new;
442
      new->prev = prev;
443
      new->next = top_stack;
444
    }
445
  top_stack = new;
446
}
447
 
448
/* Exit a lexical context */
449
 
450
static void
451
pop_parse_stack (void)
452
{
453
  if (!top_stack)
454
    return;
455
  if (top_stack->next)
456
    top_stack = top_stack->next;
457
}
458
 
459
 
460
/* Cross-references might be to things we haven't looked at
461
   yet, e.g. type references.  To avoid too many type
462
   duplications we keep a quick fixup table, an array
463
   of lists of references indexed by file descriptor */
464
 
465
struct mdebug_pending
466
{
467
  struct mdebug_pending *next;  /* link */
468
  char *s;                      /* the unswapped symbol */
469
  struct type *t;               /* its partial type descriptor */
470
};
471
 
472
 
473
/* The pending information is kept for an entire object file, and used
474
   to be in the deprecated_sym_private field.  I took it out when I
475
   split mdebugread from mipsread, because this might not be the only
476
   type of symbols read from an object file.  Instead, we allocate the
477
   pending information table when we create the partial symbols, and
478
   we store a pointer to the single table in each psymtab.  */
479
 
480
static struct mdebug_pending **pending_list;
481
 
482
/* Check whether we already saw symbol SH in file FH */
483
 
484
static struct mdebug_pending *
485
is_pending_symbol (FDR *fh, char *sh)
486
{
487
  int f_idx = fh - debug_info->fdr;
488
  struct mdebug_pending *p;
489
 
490
  /* Linear search is ok, list is typically no more than 10 deep */
491
  for (p = pending_list[f_idx]; p; p = p->next)
492
    if (p->s == sh)
493
      break;
494
  return p;
495
}
496
 
497
/* Add a new symbol SH of type T */
498
 
499
static void
500
add_pending (FDR *fh, char *sh, struct type *t)
501
{
502
  int f_idx = fh - debug_info->fdr;
503
  struct mdebug_pending *p = is_pending_symbol (fh, sh);
504
 
505
  /* Make sure we do not make duplicates */
506
  if (!p)
507
    {
508
      p = ((struct mdebug_pending *)
509
           obstack_alloc (&current_objfile->objfile_obstack,
510
                          sizeof (struct mdebug_pending)));
511
      p->s = sh;
512
      p->t = t;
513
      p->next = pending_list[f_idx];
514
      pending_list[f_idx] = p;
515
    }
516
}
517
 
518
 
519
/* Parsing Routines proper. */
520
 
521
/* Parse a single symbol. Mostly just make up a GDB symbol for it.
522
   For blocks, procedures and types we open a new lexical context.
523
   This is basically just a big switch on the symbol's type.  Argument
524
   AX is the base pointer of aux symbols for this file (fh->iauxBase).
525
   EXT_SH points to the unswapped symbol, which is needed for struct,
526
   union, etc., types; it is NULL for an EXTR.  BIGEND says whether
527
   aux symbols are big-endian or little-endian.  Return count of
528
   SYMR's handled (normally one).  */
529
 
530
static int
531
mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
532
{
533
  return gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
534
}
535
 
536
static const struct symbol_register_ops mdebug_register_funcs = {
537
  mdebug_reg_to_regnum
538
};
539
 
540
static int
541
parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
542
              struct section_offsets *section_offsets, struct objfile *objfile)
543
{
544
  struct gdbarch *gdbarch = get_objfile_arch (objfile);
545
  const bfd_size_type external_sym_size = debug_swap->external_sym_size;
546
  void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
547
  char *name;
548
  struct symbol *s;
549
  struct block *b;
550
  struct mdebug_pending *pend;
551
  struct type *t;
552
  struct field *f;
553
  int count = 1;
554
  enum address_class class;
555
  TIR tir;
556
  long svalue = sh->value;
557
  int bitsize;
558
 
559
  if (ext_sh == (char *) NULL)
560
    name = debug_info->ssext + sh->iss;
561
  else
562
    name = debug_info->ss + cur_fdr->issBase + sh->iss;
563
 
564
  switch (sh->sc)
565
    {
566
    case scText:
567
    case scRConst:
568
      /* Do not relocate relative values.
569
         The value of a stEnd symbol is the displacement from the
570
         corresponding start symbol value.
571
         The value of a stBlock symbol is the displacement from the
572
         procedure address.  */
573
      if (sh->st != stEnd && sh->st != stBlock)
574
        sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
575
      break;
576
    case scData:
577
    case scSData:
578
    case scRData:
579
    case scPData:
580
    case scXData:
581
      sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
582
      break;
583
    case scBss:
584
    case scSBss:
585
      sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
586
      break;
587
    }
588
 
589
  switch (sh->st)
590
    {
591
    case stNil:
592
      break;
593
 
594
    case stGlobal:              /* external symbol, goes into global block */
595
      class = LOC_STATIC;
596
      b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
597
                             GLOBAL_BLOCK);
598
      s = new_symbol (name);
599
      SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
600
      goto data;
601
 
602
    case stStatic:              /* static data, goes into current block. */
603
      class = LOC_STATIC;
604
      b = top_stack->cur_block;
605
      s = new_symbol (name);
606
      if (SC_IS_COMMON (sh->sc))
607
        {
608
          /* It is a FORTRAN common block.  At least for SGI Fortran the
609
             address is not in the symbol; we need to fix it later in
610
             scan_file_globals.  */
611
          int bucket = hashname (SYMBOL_LINKAGE_NAME (s));
612
          SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
613
          global_sym_chain[bucket] = s;
614
        }
615
      else
616
        SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
617
      goto data;
618
 
619
    case stLocal:               /* local variable, goes into current block */
620
      b = top_stack->cur_block;
621
      s = new_symbol (name);
622
      SYMBOL_VALUE (s) = svalue;
623
      if (sh->sc == scRegister)
624
        {
625
          class = LOC_REGISTER;
626
          SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
627
        }
628
      else
629
        class = LOC_LOCAL;
630
 
631
    data:                       /* Common code for symbols describing data */
632
      SYMBOL_DOMAIN (s) = VAR_DOMAIN;
633
      SYMBOL_CLASS (s) = class;
634
      add_symbol (s, top_stack->cur_st, b);
635
 
636
      /* Type could be missing if file is compiled without debugging info.  */
637
      if (SC_IS_UNDEF (sh->sc)
638
          || sh->sc == scNil || sh->index == indexNil)
639
        SYMBOL_TYPE (s) = objfile_type (objfile)->nodebug_data_symbol;
640
      else
641
        SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
642
      /* Value of a data symbol is its memory address */
643
      break;
644
 
645
    case stParam:               /* arg to procedure, goes into current block */
646
      max_gdbinfo++;
647
      found_ecoff_debugging_info = 1;
648
      top_stack->numargs++;
649
 
650
      /* Special GNU C++ name.  */
651
      if (is_cplus_marker (name[0]) && name[1] == 't' && name[2] == 0)
652
        name = "this";          /* FIXME, not alloc'd in obstack */
653
      s = new_symbol (name);
654
 
655
      SYMBOL_DOMAIN (s) = VAR_DOMAIN;
656
      SYMBOL_IS_ARGUMENT (s) = 1;
657
      switch (sh->sc)
658
        {
659
        case scRegister:
660
          /* Pass by value in register.  */
661
          SYMBOL_CLASS (s) = LOC_REGISTER;
662
          SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
663
          break;
664
        case scVar:
665
          /* Pass by reference on stack.  */
666
          SYMBOL_CLASS (s) = LOC_REF_ARG;
667
          break;
668
        case scVarRegister:
669
          /* Pass by reference in register.  */
670
          SYMBOL_CLASS (s) = LOC_REGPARM_ADDR;
671
          SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
672
          break;
673
        default:
674
          /* Pass by value on stack.  */
675
          SYMBOL_CLASS (s) = LOC_ARG;
676
          break;
677
        }
678
      SYMBOL_VALUE (s) = svalue;
679
      SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
680
      add_symbol (s, top_stack->cur_st, top_stack->cur_block);
681
      break;
682
 
683
    case stLabel:               /* label, goes into current block */
684
      s = new_symbol (name);
685
      SYMBOL_DOMAIN (s) = VAR_DOMAIN;   /* so that it can be used */
686
      SYMBOL_CLASS (s) = LOC_LABEL;     /* but not misused */
687
      SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
688
      SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int;
689
      add_symbol (s, top_stack->cur_st, top_stack->cur_block);
690
      break;
691
 
692
    case stProc:                /* Procedure, usually goes into global block */
693
    case stStaticProc:          /* Static procedure, goes into current block */
694
      /* For stProc symbol records, we need to check the storage class
695
         as well, as only (stProc, scText) entries represent "real"
696
         procedures - See the Compaq document titled "Object File /
697
         Symbol Table Format Specification" for more information.
698
         If the storage class is not scText, we discard the whole block
699
         of symbol records for this stProc.  */
700
      if (sh->st == stProc && sh->sc != scText)
701
        {
702
          char *ext_tsym = ext_sh;
703
          int keep_counting = 1;
704
          SYMR tsym;
705
 
706
          while (keep_counting)
707
            {
708
              ext_tsym += external_sym_size;
709
              (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
710
              count++;
711
              switch (tsym.st)
712
                {
713
                  case stParam:
714
                    break;
715
                  case stEnd:
716
                    keep_counting = 0;
717
                    break;
718
                  default:
719
                    complaint (&symfile_complaints,
720
                               _("unknown symbol type 0x%x"), sh->st);
721
                    break;
722
                }
723
            }
724
          break;
725
        }
726
      s = new_symbol (name);
727
      SYMBOL_DOMAIN (s) = VAR_DOMAIN;
728
      SYMBOL_CLASS (s) = LOC_BLOCK;
729
      /* Type of the return value */
730
      if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
731
        t = objfile_type (objfile)->builtin_int;
732
      else
733
        {
734
          t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
735
          if (strcmp (name, "malloc") == 0
736
              && TYPE_CODE (t) == TYPE_CODE_VOID)
737
            {
738
              /* I don't know why, but, at least under Alpha GNU/Linux,
739
                 when linking against a malloc without debugging
740
                 symbols, its read as a function returning void---this
741
                 is bad because it means we cannot call functions with
742
                 string arguments interactively; i.e., "call
743
                 printf("howdy\n")" would fail with the error message
744
                 "program has no memory available".  To avoid this, we
745
                 patch up the type and make it void*
746
                 instead. (davidm@azstarnet.com)
747
               */
748
              t = make_pointer_type (t, NULL);
749
            }
750
        }
751
      b = top_stack->cur_block;
752
      if (sh->st == stProc)
753
        {
754
          struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
755
          /* The next test should normally be true, but provides a
756
             hook for nested functions (which we don't want to make
757
             global).  */
758
          if (b == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
759
            b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
760
          /* Irix 5 sometimes has duplicate names for the same
761
             function.  We want to add such names up at the global
762
             level, not as a nested function.  */
763
          else if (sh->value == top_stack->procadr)
764
            b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
765
        }
766
      add_symbol (s, top_stack->cur_st, b);
767
 
768
      /* Make a type for the procedure itself */
769
      SYMBOL_TYPE (s) = lookup_function_type (t);
770
 
771
      /* All functions in C++ have prototypes.  For C we don't have enough
772
         information in the debug info.  */
773
      if (SYMBOL_LANGUAGE (s) == language_cplus)
774
        TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1;
775
 
776
      /* Create and enter a new lexical context */
777
      b = new_block (FUNCTION_BLOCK);
778
      SYMBOL_BLOCK_VALUE (s) = b;
779
      BLOCK_FUNCTION (b) = s;
780
      BLOCK_START (b) = BLOCK_END (b) = sh->value;
781
      BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
782
      add_block (b, top_stack->cur_st);
783
 
784
      /* Not if we only have partial info */
785
      if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
786
        break;
787
 
788
      push_parse_stack ();
789
      top_stack->cur_block = b;
790
      top_stack->blocktype = sh->st;
791
      top_stack->cur_type = SYMBOL_TYPE (s);
792
      top_stack->cur_field = -1;
793
      top_stack->procadr = sh->value;
794
      top_stack->numargs = 0;
795
      break;
796
 
797
      /* Beginning of code for structure, union, and enum definitions.
798
         They all share a common set of local variables, defined here.  */
799
      {
800
        enum type_code type_code;
801
        char *ext_tsym;
802
        int nfields;
803
        long max_value;
804
        struct field *f;
805
 
806
    case stStruct:              /* Start a block defining a struct type */
807
        type_code = TYPE_CODE_STRUCT;
808
        goto structured_common;
809
 
810
    case stUnion:               /* Start a block defining a union type */
811
        type_code = TYPE_CODE_UNION;
812
        goto structured_common;
813
 
814
    case stEnum:                /* Start a block defining an enum type */
815
        type_code = TYPE_CODE_ENUM;
816
        goto structured_common;
817
 
818
    case stBlock:               /* Either a lexical block, or some type */
819
        if (sh->sc != scInfo && !SC_IS_COMMON (sh->sc))
820
          goto case_stBlock_code;       /* Lexical block */
821
 
822
        type_code = TYPE_CODE_UNDEF;    /* We have a type.  */
823
 
824
        /* Common code for handling struct, union, enum, and/or as-yet-
825
           unknown-type blocks of info about structured data.  `type_code'
826
           has been set to the proper TYPE_CODE, if we know it.  */
827
      structured_common:
828
        found_ecoff_debugging_info = 1;
829
        push_parse_stack ();
830
        top_stack->blocktype = stBlock;
831
 
832
        /* First count the number of fields and the highest value. */
833
        nfields = 0;
834
        max_value = 0;
835
        for (ext_tsym = ext_sh + external_sym_size;
836
             ;
837
             ext_tsym += external_sym_size)
838
          {
839
            SYMR tsym;
840
 
841
            (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
842
 
843
            switch (tsym.st)
844
              {
845
              case stEnd:
846
                /* C++ encodes class types as structures where there the
847
                   methods are encoded as stProc. The scope of stProc
848
                   symbols also ends with stEnd, thus creating a risk of
849
                   taking the wrong stEnd symbol record as the end of
850
                   the current struct, which would cause GDB to undercount
851
                   the real number of fields in this struct.  To make sure
852
                   we really reached the right stEnd symbol record, we
853
                   check the associated name, and match it against the
854
                   struct name.  Since method names are mangled while
855
                   the class name is not, there is no risk of having a
856
                   method whose name is identical to the class name
857
                   (in particular constructor method names are different
858
                   from the class name).  There is therefore no risk that
859
                   this check stops the count on the StEnd of a method.
860
 
861
                   Also, assume that we're really at the end when tsym.iss
862
                   is 0 (issNull).  */
863
                if (tsym.iss == issNull
864
                    || strcmp (debug_info->ss + cur_fdr->issBase + tsym.iss,
865
                               name) == 0)
866
                  goto end_of_fields;
867
                break;
868
 
869
              case stMember:
870
                if (nfields == 0 && type_code == TYPE_CODE_UNDEF)
871
                  {
872
                    /* If the type of the member is Nil (or Void),
873
                       without qualifiers, assume the tag is an
874
                       enumeration.
875
                       Alpha cc -migrate enums are recognized by a zero
876
                       index and a zero symbol value.
877
                       DU 4.0 cc enums are recognized by a member type of
878
                       btEnum without qualifiers and a zero symbol value.  */
879
                    if (tsym.index == indexNil
880
                        || (tsym.index == 0 && sh->value == 0))
881
                      type_code = TYPE_CODE_ENUM;
882
                    else
883
                      {
884
                        (*debug_swap->swap_tir_in) (bigend,
885
                                                    &ax[tsym.index].a_ti,
886
                                                    &tir);
887
                        if ((tir.bt == btNil || tir.bt == btVoid
888
                             || (tir.bt == btEnum && sh->value == 0))
889
                            && tir.tq0 == tqNil)
890
                          type_code = TYPE_CODE_ENUM;
891
                      }
892
                  }
893
                nfields++;
894
                if (tsym.value > max_value)
895
                  max_value = tsym.value;
896
                break;
897
 
898
              case stBlock:
899
              case stUnion:
900
              case stEnum:
901
              case stStruct:
902
                {
903
#if 0
904
                  /* This is a no-op; is it trying to tell us something
905
                     we should be checking?  */
906
                  if (tsym.sc == scVariant);    /*UNIMPLEMENTED */
907
#endif
908
                  if (tsym.index != 0)
909
                    {
910
                      /* This is something like a struct within a
911
                         struct.  Skip over the fields of the inner
912
                         struct.  The -1 is because the for loop will
913
                         increment ext_tsym.  */
914
                      ext_tsym = ((char *) debug_info->external_sym
915
                                  + ((cur_fdr->isymBase + tsym.index - 1)
916
                                     * external_sym_size));
917
                    }
918
                }
919
                break;
920
 
921
              case stTypedef:
922
                /* mips cc puts out a typedef for struct x if it is not yet
923
                   defined when it encounters
924
                   struct y { struct x *xp; };
925
                   Just ignore it. */
926
                break;
927
 
928
              case stIndirect:
929
                /* Irix5 cc puts out a stIndirect for struct x if it is not
930
                   yet defined when it encounters
931
                   struct y { struct x *xp; };
932
                   Just ignore it. */
933
                break;
934
 
935
              default:
936
                complaint (&symfile_complaints,
937
                           _("declaration block contains unhandled symbol type %d"),
938
                           tsym.st);
939
              }
940
          }
941
      end_of_fields:;
942
 
943
        /* In an stBlock, there is no way to distinguish structs,
944
           unions, and enums at this point.  This is a bug in the
945
           original design (that has been fixed with the recent
946
           addition of the stStruct, stUnion, and stEnum symbol
947
           types.)  The way you can tell is if/when you see a variable
948
           or field of that type.  In that case the variable's type
949
           (in the AUX table) says if the type is struct, union, or
950
           enum, and points back to the stBlock here.  So you can
951
           patch the tag kind up later - but only if there actually is
952
           a variable or field of that type.
953
 
954
           So until we know for sure, we will guess at this point.
955
           The heuristic is:
956
           If the first member has index==indexNil or a void type,
957
           assume we have an enumeration.
958
           Otherwise, if there is more than one member, and all
959
           the members have offset 0, assume we have a union.
960
           Otherwise, assume we have a struct.
961
 
962
           The heuristic could guess wrong in the case of of an
963
           enumeration with no members or a union with one (or zero)
964
           members, or when all except the last field of a struct have
965
           width zero.  These are uncommon and/or illegal situations,
966
           and in any case guessing wrong probably doesn't matter
967
           much.
968
 
969
           But if we later do find out we were wrong, we fixup the tag
970
           kind.  Members of an enumeration must be handled
971
           differently from struct/union fields, and that is harder to
972
           patch up, but luckily we shouldn't need to.  (If there are
973
           any enumeration members, we can tell for sure it's an enum
974
           here.) */
975
 
976
        if (type_code == TYPE_CODE_UNDEF)
977
          {
978
            if (nfields > 1 && max_value == 0)
979
              type_code = TYPE_CODE_UNION;
980
            else
981
              type_code = TYPE_CODE_STRUCT;
982
          }
983
 
984
        /* Create a new type or use the pending type.  */
985
        pend = is_pending_symbol (cur_fdr, ext_sh);
986
        if (pend == (struct mdebug_pending *) NULL)
987
          {
988
            t = new_type (NULL);
989
            add_pending (cur_fdr, ext_sh, t);
990
          }
991
        else
992
          t = pend->t;
993
 
994
        /* Do not set the tag name if it is a compiler generated tag name
995
           (.Fxx or .xxfake or empty) for unnamed struct/union/enums.
996
           Alpha cc puts out an sh->iss of zero for those.  */
997
        if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
998
          TYPE_TAG_NAME (t) = NULL;
999
        else
1000
          TYPE_TAG_NAME (t) = obconcat (&current_objfile->objfile_obstack,
1001
                                        "", "", name);
1002
 
1003
        TYPE_CODE (t) = type_code;
1004
        TYPE_LENGTH (t) = sh->value;
1005
        TYPE_NFIELDS (t) = nfields;
1006
        TYPE_FIELDS (t) = f = ((struct field *)
1007
                               TYPE_ALLOC (t,
1008
                                           nfields * sizeof (struct field)));
1009
 
1010
        if (type_code == TYPE_CODE_ENUM)
1011
          {
1012
            int unsigned_enum = 1;
1013
 
1014
            /* This is a non-empty enum. */
1015
 
1016
            /* DEC c89 has the number of enumerators in the sh.value field,
1017
               not the type length, so we have to compensate for that
1018
               incompatibility quirk.
1019
               This might do the wrong thing for an enum with one or two
1020
               enumerators and gcc -gcoff -fshort-enums, but these cases
1021
               are hopefully rare enough.
1022
               Alpha cc -migrate has a sh.value field of zero, we adjust
1023
               that too.  */
1024
            if (TYPE_LENGTH (t) == TYPE_NFIELDS (t)
1025
                || TYPE_LENGTH (t) == 0)
1026
              TYPE_LENGTH (t) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
1027
            for (ext_tsym = ext_sh + external_sym_size;
1028
                 ;
1029
                 ext_tsym += external_sym_size)
1030
              {
1031
                SYMR tsym;
1032
                struct symbol *enum_sym;
1033
 
1034
                (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
1035
 
1036
                if (tsym.st != stMember)
1037
                  break;
1038
 
1039
                SET_FIELD_BITPOS (*f, tsym.value);
1040
                FIELD_TYPE (*f) = t;
1041
                FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss;
1042
                FIELD_BITSIZE (*f) = 0;
1043
 
1044
                enum_sym = ((struct symbol *)
1045
                            obstack_alloc (&current_objfile->objfile_obstack,
1046
                                           sizeof (struct symbol)));
1047
                memset (enum_sym, 0, sizeof (struct symbol));
1048
                SYMBOL_SET_LINKAGE_NAME
1049
                  (enum_sym, obsavestring (f->name, strlen (f->name),
1050
                                           &current_objfile->objfile_obstack));
1051
                SYMBOL_CLASS (enum_sym) = LOC_CONST;
1052
                SYMBOL_TYPE (enum_sym) = t;
1053
                SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN;
1054
                SYMBOL_VALUE (enum_sym) = tsym.value;
1055
                if (SYMBOL_VALUE (enum_sym) < 0)
1056
                  unsigned_enum = 0;
1057
                add_symbol (enum_sym, top_stack->cur_st, top_stack->cur_block);
1058
 
1059
                /* Skip the stMembers that we've handled. */
1060
                count++;
1061
                f++;
1062
              }
1063
            if (unsigned_enum)
1064
              TYPE_UNSIGNED (t) = 1;
1065
          }
1066
        /* make this the current type */
1067
        top_stack->cur_type = t;
1068
        top_stack->cur_field = 0;
1069
 
1070
        /* Do not create a symbol for alpha cc unnamed structs.  */
1071
        if (sh->iss == 0)
1072
          break;
1073
 
1074
        /* gcc puts out an empty struct for an opaque struct definitions,
1075
           do not create a symbol for it either.  */
1076
        if (TYPE_NFIELDS (t) == 0)
1077
          {
1078
            TYPE_STUB (t) = 1;
1079
            break;
1080
          }
1081
 
1082
        s = new_symbol (name);
1083
        SYMBOL_DOMAIN (s) = STRUCT_DOMAIN;
1084
        SYMBOL_CLASS (s) = LOC_TYPEDEF;
1085
        SYMBOL_VALUE (s) = 0;
1086
        SYMBOL_TYPE (s) = t;
1087
        add_symbol (s, top_stack->cur_st, top_stack->cur_block);
1088
        break;
1089
 
1090
        /* End of local variables shared by struct, union, enum, and
1091
           block (as yet unknown struct/union/enum) processing.  */
1092
      }
1093
 
1094
    case_stBlock_code:
1095
      found_ecoff_debugging_info = 1;
1096
      /* beginnning of (code) block. Value of symbol
1097
         is the displacement from procedure start */
1098
      push_parse_stack ();
1099
 
1100
      /* Do not start a new block if this is the outermost block of a
1101
         procedure.  This allows the LOC_BLOCK symbol to point to the
1102
         block with the local variables, so funcname::var works.  */
1103
      if (top_stack->blocktype == stProc
1104
          || top_stack->blocktype == stStaticProc)
1105
        {
1106
          top_stack->blocktype = stNil;
1107
          break;
1108
        }
1109
 
1110
      top_stack->blocktype = stBlock;
1111
      b = new_block (NON_FUNCTION_BLOCK);
1112
      BLOCK_START (b) = sh->value + top_stack->procadr;
1113
      BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
1114
      top_stack->cur_block = b;
1115
      add_block (b, top_stack->cur_st);
1116
      break;
1117
 
1118
    case stEnd:         /* end (of anything) */
1119
      if (sh->sc == scInfo || SC_IS_COMMON (sh->sc))
1120
        {
1121
          /* Finished with type */
1122
          top_stack->cur_type = 0;
1123
        }
1124
      else if (sh->sc == scText &&
1125
               (top_stack->blocktype == stProc ||
1126
                top_stack->blocktype == stStaticProc))
1127
        {
1128
          /* Finished with procedure */
1129
          struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
1130
          struct mdebug_extra_func_info *e;
1131
          struct block *b = top_stack->cur_block;
1132
          struct type *ftype = top_stack->cur_type;
1133
          int i;
1134
 
1135
          BLOCK_END (top_stack->cur_block) += sh->value;        /* size */
1136
 
1137
          /* Make up special symbol to contain procedure specific info */
1138
          s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
1139
          SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
1140
          SYMBOL_CLASS (s) = LOC_CONST;
1141
          SYMBOL_TYPE (s) = objfile_type (current_objfile)->builtin_void;
1142
          e = ((struct mdebug_extra_func_info *)
1143
               obstack_alloc (&current_objfile->objfile_obstack,
1144
                              sizeof (struct mdebug_extra_func_info)));
1145
          memset (e, 0, sizeof (struct mdebug_extra_func_info));
1146
          SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
1147
          e->numargs = top_stack->numargs;
1148
          e->pdr.framereg = -1;
1149
          add_symbol (s, top_stack->cur_st, top_stack->cur_block);
1150
 
1151
          /* f77 emits proc-level with address bounds==[0,0],
1152
             So look for such child blocks, and patch them.  */
1153
          for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
1154
            {
1155
              struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i);
1156
              if (BLOCK_SUPERBLOCK (b_bad) == b
1157
                  && BLOCK_START (b_bad) == top_stack->procadr
1158
                  && BLOCK_END (b_bad) == top_stack->procadr)
1159
                {
1160
                  BLOCK_START (b_bad) = BLOCK_START (b);
1161
                  BLOCK_END (b_bad) = BLOCK_END (b);
1162
                }
1163
            }
1164
 
1165
          if (TYPE_NFIELDS (ftype) <= 0)
1166
            {
1167
              /* No parameter type information is recorded with the function's
1168
                 type.  Set that from the type of the parameter symbols. */
1169
              int nparams = top_stack->numargs;
1170
              int iparams;
1171
              struct symbol *sym;
1172
 
1173
              if (nparams > 0)
1174
                {
1175
                  struct dict_iterator iter;
1176
                  TYPE_NFIELDS (ftype) = nparams;
1177
                  TYPE_FIELDS (ftype) = (struct field *)
1178
                    TYPE_ALLOC (ftype, nparams * sizeof (struct field));
1179
 
1180
                  iparams = 0;
1181
                  ALL_BLOCK_SYMBOLS (b, iter, sym)
1182
                    {
1183
                      if (iparams == nparams)
1184
                        break;
1185
 
1186
                      if (SYMBOL_IS_ARGUMENT (sym))
1187
                        {
1188
                          TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
1189
                          TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
1190
                          iparams++;
1191
                        }
1192
                    }
1193
                }
1194
            }
1195
        }
1196
      else if (sh->sc == scText && top_stack->blocktype == stBlock)
1197
        {
1198
          /* End of (code) block. The value of the symbol is the
1199
             displacement from the procedure`s start address of the
1200
             end of this block. */
1201
          BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr;
1202
        }
1203
      else if (sh->sc == scText && top_stack->blocktype == stNil)
1204
        {
1205
          /* End of outermost block.  Pop parse stack and ignore.  The
1206
             following stEnd of stProc will take care of the block.  */
1207
          ;
1208
        }
1209
      else if (sh->sc == scText && top_stack->blocktype == stFile)
1210
        {
1211
          /* End of file.  Pop parse stack and ignore.  Higher
1212
             level code deals with this.  */
1213
          ;
1214
        }
1215
      else
1216
        complaint (&symfile_complaints,
1217
                   _("stEnd with storage class %d not handled"), sh->sc);
1218
 
1219
      pop_parse_stack ();       /* restore previous lexical context */
1220
      break;
1221
 
1222
    case stMember:              /* member of struct or union */
1223
      f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++];
1224
      FIELD_NAME (*f) = name;
1225
      SET_FIELD_BITPOS (*f, sh->value);
1226
      bitsize = 0;
1227
      FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index, &bitsize, bigend, name);
1228
      FIELD_BITSIZE (*f) = bitsize;
1229
      break;
1230
 
1231
    case stIndirect:            /* forward declaration on Irix5 */
1232
      /* Forward declarations from Irix5 cc are handled by cross_ref,
1233
         skip them.  */
1234
      break;
1235
 
1236
    case stTypedef:             /* type definition */
1237
      found_ecoff_debugging_info = 1;
1238
 
1239
      /* Typedefs for forward declarations and opaque structs from alpha cc
1240
         are handled by cross_ref, skip them.  */
1241
      if (sh->iss == 0)
1242
        break;
1243
 
1244
      /* Parse the type or use the pending type.  */
1245
      pend = is_pending_symbol (cur_fdr, ext_sh);
1246
      if (pend == (struct mdebug_pending *) NULL)
1247
        {
1248
          t = parse_type (cur_fd, ax, sh->index, (int *) NULL, bigend, name);
1249
          add_pending (cur_fdr, ext_sh, t);
1250
        }
1251
      else
1252
        t = pend->t;
1253
 
1254
      /* mips cc puts out a typedef with the name of the struct for forward
1255
         declarations. These should not go into the symbol table and
1256
         TYPE_NAME should not be set for them.
1257
         They can't be distinguished from an intentional typedef to
1258
         the same name however:
1259
         x.h:
1260
         struct x { int ix; int jx; };
1261
         struct xx;
1262
         x.c:
1263
         typedef struct x x;
1264
         struct xx {int ixx; int jxx; };
1265
         generates a cross referencing stTypedef for x and xx.
1266
         The user visible effect of this is that the type of a pointer
1267
         to struct foo sometimes is given as `foo *' instead of `struct foo *'.
1268
         The problem is fixed with alpha cc and Irix5 cc.  */
1269
 
1270
      /* However if the typedef cross references to an opaque aggregate, it
1271
         is safe to omit it from the symbol table.  */
1272
 
1273
      if (has_opaque_xref (cur_fdr, sh))
1274
        break;
1275
      s = new_symbol (name);
1276
      SYMBOL_DOMAIN (s) = VAR_DOMAIN;
1277
      SYMBOL_CLASS (s) = LOC_TYPEDEF;
1278
      SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
1279
      SYMBOL_TYPE (s) = t;
1280
      add_symbol (s, top_stack->cur_st, top_stack->cur_block);
1281
 
1282
      /* Incomplete definitions of structs should not get a name.  */
1283
      if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL
1284
          && (TYPE_NFIELDS (SYMBOL_TYPE (s)) != 0
1285
              || (TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_STRUCT
1286
                  && TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_UNION)))
1287
        {
1288
          if (TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_PTR
1289
              || TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_FUNC)
1290
            {
1291
              /* If we are giving a name to a type such as "pointer to
1292
                 foo" or "function returning foo", we better not set
1293
                 the TYPE_NAME.  If the program contains "typedef char
1294
                 *caddr_t;", we don't want all variables of type char
1295
                 * to print as caddr_t.  This is not just a
1296
                 consequence of GDB's type management; CC and GCC (at
1297
                 least through version 2.4) both output variables of
1298
                 either type char * or caddr_t with the type
1299
                 refering to the stTypedef symbol for caddr_t.  If a future
1300
                 compiler cleans this up it GDB is not ready for it
1301
                 yet, but if it becomes ready we somehow need to
1302
                 disable this check (without breaking the PCC/GCC2.4
1303
                 case).
1304
 
1305
                 Sigh.
1306
 
1307
                 Fortunately, this check seems not to be necessary
1308
                 for anything except pointers or functions.  */
1309
            }
1310
          else
1311
            TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_LINKAGE_NAME (s);
1312
        }
1313
      break;
1314
 
1315
    case stFile:                /* file name */
1316
      push_parse_stack ();
1317
      top_stack->blocktype = sh->st;
1318
      break;
1319
 
1320
      /* I`ve never seen these for C */
1321
    case stRegReloc:
1322
      break;                    /* register relocation */
1323
    case stForward:
1324
      break;                    /* forwarding address */
1325
    case stConstant:
1326
      break;                    /* constant */
1327
    default:
1328
      complaint (&symfile_complaints, _("unknown symbol type 0x%x"), sh->st);
1329
      break;
1330
    }
1331
 
1332
  return count;
1333
}
1334
 
1335
/* Basic types.  */
1336
 
1337
static const struct objfile_data *basic_type_data;
1338
 
1339
static struct type *
1340
basic_type (int bt, struct objfile *objfile)
1341
{
1342
  struct gdbarch *gdbarch = get_objfile_arch (objfile);
1343
  struct type **map_bt = objfile_data (objfile, basic_type_data);
1344
  struct type *tp;
1345
 
1346
  if (bt >= btMax)
1347
    return NULL;
1348
 
1349
  if (!map_bt)
1350
    {
1351
      map_bt = OBSTACK_CALLOC (&objfile->objfile_obstack,
1352
                               btMax, struct type *);
1353
      set_objfile_data (objfile, basic_type_data, map_bt);
1354
    }
1355
 
1356
  if (map_bt[bt])
1357
    return map_bt[bt];
1358
 
1359
  switch (bt)
1360
    {
1361
    case btNil:
1362
      tp = objfile_type (objfile)->builtin_void;
1363
      break;
1364
 
1365
    case btAdr:
1366
      tp = init_type (TYPE_CODE_PTR, 4, TYPE_FLAG_UNSIGNED,
1367
                      "adr_32", objfile);
1368
      TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
1369
      break;
1370
 
1371
    case btChar:
1372
      tp = init_type (TYPE_CODE_INT, 1, 0,
1373
                      "char", objfile);
1374
      break;
1375
 
1376
    case btUChar:
1377
      tp = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
1378
                      "unsigned char", objfile);
1379
      break;
1380
 
1381
    case btShort:
1382
      tp = init_type (TYPE_CODE_INT, 2, 0,
1383
                      "short", objfile);
1384
      break;
1385
 
1386
    case btUShort:
1387
      tp = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
1388
                      "unsigned short", objfile);
1389
      break;
1390
 
1391
    case btInt:
1392
      tp = init_type (TYPE_CODE_INT, 4, 0,
1393
                      "int", objfile);
1394
      break;
1395
 
1396
   case btUInt:
1397
      tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1398
                      "unsigned int", objfile);
1399
      break;
1400
 
1401
    case btLong:
1402
      tp = init_type (TYPE_CODE_INT, 4, 0,
1403
                      "long", objfile);
1404
      break;
1405
 
1406
    case btULong:
1407
      tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
1408
                      "unsigned long", objfile);
1409
      break;
1410
 
1411
    case btFloat:
1412
      tp = init_type (TYPE_CODE_FLT,
1413
                      gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1414
                      "float", objfile);
1415
      break;
1416
 
1417
    case btDouble:
1418
      tp = init_type (TYPE_CODE_FLT,
1419
                      gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1420
                      "double", objfile);
1421
      break;
1422
 
1423
    case btComplex:
1424
      tp = init_type (TYPE_CODE_COMPLEX,
1425
                      2 * gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1426
                      "complex", objfile);
1427
      TYPE_TARGET_TYPE (tp) = basic_type (btFloat, objfile);
1428
      break;
1429
 
1430
    case btDComplex:
1431
      tp = init_type (TYPE_CODE_COMPLEX,
1432
                      2 * gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1433
                      "double complex", objfile);
1434
      TYPE_TARGET_TYPE (tp) = basic_type (btDouble, objfile);
1435
      break;
1436
 
1437
    case btFixedDec:
1438
      /* We use TYPE_CODE_INT to print these as integers.  Does this do any
1439
         good?  Would we be better off with TYPE_CODE_ERROR?  Should
1440
         TYPE_CODE_ERROR print things in hex if it knows the size?  */
1441
      tp = init_type (TYPE_CODE_INT,
1442
                      gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1443
                      "fixed decimal", objfile);
1444
      break;
1445
 
1446
    case btFloatDec:
1447
      tp = init_type (TYPE_CODE_ERROR,
1448
                      gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
1449
                      "floating decimal", objfile);
1450
      break;
1451
 
1452
    case btString:
1453
      /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
1454
         FIXME.  */
1455
      tp = init_type (TYPE_CODE_STRING, 1, 0,
1456
                      "string", objfile);
1457
      break;
1458
 
1459
    case btVoid:
1460
      tp = objfile_type (objfile)->builtin_void;
1461
      break;
1462
 
1463
    case btLong64:
1464
      tp = init_type (TYPE_CODE_INT, 8, 0,
1465
                      "long", objfile);
1466
      break;
1467
 
1468
    case btULong64:
1469
      tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1470
                      "unsigned long", objfile);
1471
      break;
1472
 
1473
    case btLongLong64:
1474
      tp = init_type (TYPE_CODE_INT, 8, 0,
1475
                      "long long", objfile);
1476
      break;
1477
 
1478
    case btULongLong64:
1479
      tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1480
                      "unsigned long long", objfile);
1481
      break;
1482
 
1483
    case btAdr64:
1484
      tp = init_type (TYPE_CODE_PTR, 8, TYPE_FLAG_UNSIGNED,
1485
                      "adr_64", objfile);
1486
      TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void;
1487
      break;
1488
 
1489
    case btInt64:
1490
      tp = init_type (TYPE_CODE_INT, 8, 0,
1491
                      "int", objfile);
1492
      break;
1493
 
1494
    case btUInt64:
1495
      tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
1496
                      "unsigned int", objfile);
1497
      break;
1498
 
1499
    default:
1500
      tp = NULL;
1501
      break;
1502
    }
1503
 
1504
  map_bt[bt] = tp;
1505
  return tp;
1506
}
1507
 
1508
/* Parse the type information provided in the raw AX entries for
1509
   the symbol SH. Return the bitfield size in BS, in case.
1510
   We must byte-swap the AX entries before we use them; BIGEND says whether
1511
   they are big-endian or little-endian (from fh->fBigendian).  */
1512
 
1513
static struct type *
1514
parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
1515
            int bigend, char *sym_name)
1516
{
1517
  TIR t[1];
1518
  struct type *tp = 0;
1519
  enum type_code type_code = TYPE_CODE_UNDEF;
1520
 
1521
  /* Handle undefined types, they have indexNil. */
1522
  if (aux_index == indexNil)
1523
    return basic_type (btInt, current_objfile);
1524
 
1525
  /* Handle corrupt aux indices.  */
1526
  if (aux_index >= (debug_info->fdr + fd)->caux)
1527
    {
1528
      index_complaint (sym_name);
1529
      return basic_type (btInt, current_objfile);
1530
    }
1531
  ax += aux_index;
1532
 
1533
  /* Use aux as a type information record, map its basic type.  */
1534
  (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1535
  tp = basic_type (t->bt, current_objfile);
1536
  if (tp == NULL)
1537
    {
1538
      /* Cannot use builtin types -- build our own */
1539
      switch (t->bt)
1540
        {
1541
        case btStruct:
1542
          type_code = TYPE_CODE_STRUCT;
1543
          break;
1544
        case btUnion:
1545
          type_code = TYPE_CODE_UNION;
1546
          break;
1547
        case btEnum:
1548
          type_code = TYPE_CODE_ENUM;
1549
          break;
1550
        case btRange:
1551
          type_code = TYPE_CODE_RANGE;
1552
          break;
1553
        case btSet:
1554
          type_code = TYPE_CODE_SET;
1555
          break;
1556
        case btIndirect:
1557
          /* alpha cc -migrate uses this for typedefs. The true type will
1558
             be obtained by crossreferencing below.  */
1559
          type_code = TYPE_CODE_ERROR;
1560
          break;
1561
        case btTypedef:
1562
          /* alpha cc uses this for typedefs. The true type will be
1563
             obtained by crossreferencing below.  */
1564
          type_code = TYPE_CODE_ERROR;
1565
          break;
1566
        default:
1567
          basic_type_complaint (t->bt, sym_name);
1568
          return basic_type (btInt, current_objfile);
1569
        }
1570
    }
1571
 
1572
  /* Move on to next aux */
1573
  ax++;
1574
 
1575
  if (t->fBitfield)
1576
    {
1577
      int width = AUX_GET_WIDTH (bigend, ax);
1578
      /* Inhibit core dumps if TIR is corrupted.  */
1579
      if (bs == (int *) NULL)
1580
        {
1581
          /* Alpha cc -migrate encodes char and unsigned char types
1582
             as short and unsigned short types with a field width of 8.
1583
             Enum types also have a field width which we ignore for now.  */
1584
          if (t->bt == btShort && width == 8)
1585
            tp = basic_type (btChar, current_objfile);
1586
          else if (t->bt == btUShort && width == 8)
1587
            tp = basic_type (btUChar, current_objfile);
1588
          else if (t->bt == btEnum)
1589
            ;
1590
          else
1591
            complaint (&symfile_complaints, _("can't handle TIR fBitfield for %s"),
1592
                       sym_name);
1593
        }
1594
      else
1595
        *bs = width;
1596
      ax++;
1597
    }
1598
 
1599
  /* A btIndirect entry cross references to an aux entry containing
1600
     the type.  */
1601
  if (t->bt == btIndirect)
1602
    {
1603
      RNDXR rn[1];
1604
      int rf;
1605
      FDR *xref_fh;
1606
      int xref_fd;
1607
 
1608
      (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
1609
      ax++;
1610
      if (rn->rfd == 0xfff)
1611
        {
1612
          rf = AUX_GET_ISYM (bigend, ax);
1613
          ax++;
1614
        }
1615
      else
1616
        rf = rn->rfd;
1617
 
1618
      if (rf == -1)
1619
        {
1620
          complaint (&symfile_complaints,
1621
                     _("unable to cross ref btIndirect for %s"), sym_name);
1622
          return basic_type (btInt, current_objfile);
1623
        }
1624
      xref_fh = get_rfd (fd, rf);
1625
      xref_fd = xref_fh - debug_info->fdr;
1626
      tp = parse_type (xref_fd, debug_info->external_aux + xref_fh->iauxBase,
1627
                    rn->index, (int *) NULL, xref_fh->fBigendian, sym_name);
1628
    }
1629
 
1630
  /* All these types really point to some (common) MIPS type
1631
     definition, and only the type-qualifiers fully identify
1632
     them.  We'll make the same effort at sharing. */
1633
  if (t->bt == btStruct ||
1634
      t->bt == btUnion ||
1635
      t->bt == btEnum ||
1636
 
1637
  /* btSet (I think) implies that the name is a tag name, not a typedef
1638
     name.  This apparently is a MIPS extension for C sets.  */
1639
      t->bt == btSet)
1640
    {
1641
      char *name;
1642
 
1643
      /* Try to cross reference this type, build new type on failure.  */
1644
      ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1645
      if (tp == (struct type *) NULL)
1646
        tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
1647
 
1648
      /* DEC c89 produces cross references to qualified aggregate types,
1649
         dereference them.  */
1650
      while (TYPE_CODE (tp) == TYPE_CODE_PTR
1651
             || TYPE_CODE (tp) == TYPE_CODE_ARRAY)
1652
        tp = TYPE_TARGET_TYPE (tp);
1653
 
1654
      /* Make sure that TYPE_CODE(tp) has an expected type code.
1655
         Any type may be returned from cross_ref if file indirect entries
1656
         are corrupted.  */
1657
      if (TYPE_CODE (tp) != TYPE_CODE_STRUCT
1658
          && TYPE_CODE (tp) != TYPE_CODE_UNION
1659
          && TYPE_CODE (tp) != TYPE_CODE_ENUM)
1660
        {
1661
          unexpected_type_code_complaint (sym_name);
1662
        }
1663
      else
1664
        {
1665
 
1666
          /* Usually, TYPE_CODE(tp) is already type_code.  The main
1667
             exception is if we guessed wrong re struct/union/enum.
1668
             But for struct vs. union a wrong guess is harmless, so
1669
             don't complain().  */
1670
          if ((TYPE_CODE (tp) == TYPE_CODE_ENUM
1671
               && type_code != TYPE_CODE_ENUM)
1672
              || (TYPE_CODE (tp) != TYPE_CODE_ENUM
1673
                  && type_code == TYPE_CODE_ENUM))
1674
            {
1675
              bad_tag_guess_complaint (sym_name);
1676
            }
1677
 
1678
          if (TYPE_CODE (tp) != type_code)
1679
            {
1680
              TYPE_CODE (tp) = type_code;
1681
            }
1682
 
1683
          /* Do not set the tag name if it is a compiler generated tag name
1684
             (.Fxx or .xxfake or empty) for unnamed struct/union/enums.  */
1685
          if (name[0] == '.' || name[0] == '\0')
1686
            TYPE_TAG_NAME (tp) = NULL;
1687
          else if (TYPE_TAG_NAME (tp) == NULL
1688
                   || strcmp (TYPE_TAG_NAME (tp), name) != 0)
1689
            TYPE_TAG_NAME (tp) = obsavestring (name, strlen (name),
1690
                                            &current_objfile->objfile_obstack);
1691
        }
1692
    }
1693
 
1694
  /* All these types really point to some (common) MIPS type
1695
     definition, and only the type-qualifiers fully identify
1696
     them.  We'll make the same effort at sharing.
1697
     FIXME: We are not doing any guessing on range types.  */
1698
  if (t->bt == btRange)
1699
    {
1700
      char *name;
1701
 
1702
      /* Try to cross reference this type, build new type on failure.  */
1703
      ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1704
      if (tp == (struct type *) NULL)
1705
        tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
1706
 
1707
      /* Make sure that TYPE_CODE(tp) has an expected type code.
1708
         Any type may be returned from cross_ref if file indirect entries
1709
         are corrupted.  */
1710
      if (TYPE_CODE (tp) != TYPE_CODE_RANGE)
1711
        {
1712
          unexpected_type_code_complaint (sym_name);
1713
        }
1714
      else
1715
        {
1716
          /* Usually, TYPE_CODE(tp) is already type_code.  The main
1717
             exception is if we guessed wrong re struct/union/enum. */
1718
          if (TYPE_CODE (tp) != type_code)
1719
            {
1720
              bad_tag_guess_complaint (sym_name);
1721
              TYPE_CODE (tp) = type_code;
1722
            }
1723
          if (TYPE_NAME (tp) == NULL
1724
              || strcmp (TYPE_NAME (tp), name) != 0)
1725
            TYPE_NAME (tp) = obsavestring (name, strlen (name),
1726
                                           &current_objfile->objfile_obstack);
1727
        }
1728
    }
1729
  if (t->bt == btTypedef)
1730
    {
1731
      char *name;
1732
 
1733
      /* Try to cross reference this type, it should succeed.  */
1734
      ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
1735
      if (tp == (struct type *) NULL)
1736
        {
1737
          complaint (&symfile_complaints,
1738
                     _("unable to cross ref btTypedef for %s"), sym_name);
1739
          tp = basic_type (btInt, current_objfile);
1740
        }
1741
    }
1742
 
1743
  /* Deal with range types */
1744
  if (t->bt == btRange)
1745
    {
1746
      TYPE_NFIELDS (tp) = 0;
1747
      TYPE_RANGE_DATA (tp) = ((struct range_bounds *)
1748
                          TYPE_ZALLOC (tp, sizeof (struct range_bounds)));
1749
      TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax);
1750
      ax++;
1751
      TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax);
1752
      ax++;
1753
    }
1754
 
1755
  /* Parse all the type qualifiers now. If there are more
1756
     than 6 the game will continue in the next aux */
1757
 
1758
  while (1)
1759
    {
1760
#define PARSE_TQ(tq) \
1761
      if (t->tq != tqNil) \
1762
        ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \
1763
      else \
1764
        break;
1765
 
1766
      PARSE_TQ (tq0);
1767
      PARSE_TQ (tq1);
1768
      PARSE_TQ (tq2);
1769
      PARSE_TQ (tq3);
1770
      PARSE_TQ (tq4);
1771
      PARSE_TQ (tq5);
1772
#undef  PARSE_TQ
1773
 
1774
      /* mips cc 2.x and gcc never put out continued aux entries.  */
1775
      if (!t->continued)
1776
        break;
1777
 
1778
      (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
1779
      ax++;
1780
    }
1781
 
1782
  /* Complain for illegal continuations due to corrupt aux entries.  */
1783
  if (t->continued)
1784
    complaint (&symfile_complaints, _("illegal TIR continued for %s"), sym_name);
1785
 
1786
  return tp;
1787
}
1788
 
1789
/* Make up a complex type from a basic one.  Type is passed by
1790
   reference in TPP and side-effected as necessary. The type
1791
   qualifier TQ says how to handle the aux symbols at AX for
1792
   the symbol SX we are currently analyzing.  BIGEND says whether
1793
   aux symbols are big-endian or little-endian.
1794
   Returns the number of aux symbols we parsed. */
1795
 
1796
static int
1797
upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
1798
              char *sym_name)
1799
{
1800
  int off;
1801
  struct type *t;
1802
 
1803
  /* Used in array processing */
1804
  int rf, id;
1805
  FDR *fh;
1806
  struct type *range;
1807
  struct type *indx;
1808
  int lower, upper;
1809
  RNDXR rndx;
1810
 
1811
  switch (tq)
1812
    {
1813
    case tqPtr:
1814
      t = lookup_pointer_type (*tpp);
1815
      *tpp = t;
1816
      return 0;
1817
 
1818
    case tqProc:
1819
      t = lookup_function_type (*tpp);
1820
      *tpp = t;
1821
      return 0;
1822
 
1823
    case tqArray:
1824
      off = 0;
1825
 
1826
      /* Determine and record the domain type (type of index) */
1827
      (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, &rndx);
1828
      id = rndx.index;
1829
      rf = rndx.rfd;
1830
      if (rf == 0xfff)
1831
        {
1832
          ax++;
1833
          rf = AUX_GET_ISYM (bigend, ax);
1834
          off++;
1835
        }
1836
      fh = get_rfd (fd, rf);
1837
 
1838
      indx = parse_type (fh - debug_info->fdr,
1839
                         debug_info->external_aux + fh->iauxBase,
1840
                         id, (int *) NULL, bigend, sym_name);
1841
 
1842
      /* The bounds type should be an integer type, but might be anything
1843
         else due to corrupt aux entries.  */
1844
      if (TYPE_CODE (indx) != TYPE_CODE_INT)
1845
        {
1846
          complaint (&symfile_complaints,
1847
                     _("illegal array index type for %s, assuming int"), sym_name);
1848
          indx = objfile_type (current_objfile)->builtin_int;
1849
        }
1850
 
1851
      /* Get the bounds, and create the array type.  */
1852
      ax++;
1853
      lower = AUX_GET_DNLOW (bigend, ax);
1854
      ax++;
1855
      upper = AUX_GET_DNHIGH (bigend, ax);
1856
      ax++;
1857
      rf = AUX_GET_WIDTH (bigend, ax);  /* bit size of array element */
1858
 
1859
      range = create_range_type ((struct type *) NULL, indx,
1860
                                 lower, upper);
1861
 
1862
      t = create_array_type ((struct type *) NULL, *tpp, range);
1863
 
1864
      /* We used to fill in the supplied array element bitsize
1865
         here if the TYPE_LENGTH of the target type was zero.
1866
         This happens for a `pointer to an array of anonymous structs',
1867
         but in this case the array element bitsize is also zero,
1868
         so nothing is gained.
1869
         And we used to check the TYPE_LENGTH of the target type against
1870
         the supplied array element bitsize.
1871
         gcc causes a mismatch for `pointer to array of object',
1872
         since the sdb directives it uses do not have a way of
1873
         specifying the bitsize, but it does no harm (the
1874
         TYPE_LENGTH should be correct) and we should be able to
1875
         ignore the erroneous bitsize from the auxiliary entry safely.
1876
         dbx seems to ignore it too.  */
1877
 
1878
      /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem.  */
1879
      if (TYPE_LENGTH (*tpp) == 0)
1880
        TYPE_TARGET_STUB (t) = 1;
1881
 
1882
      *tpp = t;
1883
      return 4 + off;
1884
 
1885
    case tqVol:
1886
      /* Volatile -- currently ignored */
1887
      return 0;
1888
 
1889
    case tqConst:
1890
      /* Const -- currently ignored */
1891
      return 0;
1892
 
1893
    default:
1894
      complaint (&symfile_complaints, _("unknown type qualifier 0x%x"), tq);
1895
      return 0;
1896
    }
1897
}
1898
 
1899
 
1900
/* Parse a procedure descriptor record PR.  Note that the procedure is
1901
   parsed _after_ the local symbols, now we just insert the extra
1902
   information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has
1903
   already been placed in the procedure's main block.  Note also that
1904
   images that have been partially stripped (ld -x) have been deprived
1905
   of local symbols, and we have to cope with them here.  FIRST_OFF is
1906
   the offset of the first procedure for this FDR; we adjust the
1907
   address by this amount, but I don't know why.  SEARCH_SYMTAB is the symtab
1908
   to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
1909
   in question, or NULL to use top_stack->cur_block.  */
1910
 
1911
static void parse_procedure (PDR *, struct symtab *, struct partial_symtab *);
1912
 
1913
static void
1914
parse_procedure (PDR *pr, struct symtab *search_symtab,
1915
                 struct partial_symtab *pst)
1916
{
1917
  struct symbol *s, *i;
1918
  struct block *b;
1919
  char *sh_name;
1920
 
1921
  /* Simple rule to find files linked "-x" */
1922
  if (cur_fdr->rss == -1)
1923
    {
1924
      if (pr->isym == -1)
1925
        {
1926
          /* Static procedure at address pr->adr.  Sigh. */
1927
          /* FIXME-32x64.  assuming pr->adr fits in long.  */
1928
          complaint (&symfile_complaints,
1929
                     _("can't handle PDR for static proc at 0x%lx"),
1930
                     (unsigned long) pr->adr);
1931
          return;
1932
        }
1933
      else
1934
        {
1935
          /* external */
1936
          EXTR she;
1937
 
1938
          (*debug_swap->swap_ext_in) (cur_bfd,
1939
                                      ((char *) debug_info->external_ext
1940
                                       + (pr->isym
1941
                                          * debug_swap->external_ext_size)),
1942
                                      &she);
1943
          sh_name = debug_info->ssext + she.asym.iss;
1944
        }
1945
    }
1946
  else
1947
    {
1948
      /* Full symbols */
1949
      SYMR sh;
1950
 
1951
      (*debug_swap->swap_sym_in) (cur_bfd,
1952
                                  ((char *) debug_info->external_sym
1953
                                   + ((cur_fdr->isymBase + pr->isym)
1954
                                      * debug_swap->external_sym_size)),
1955
                                  &sh);
1956
      sh_name = debug_info->ss + cur_fdr->issBase + sh.iss;
1957
    }
1958
 
1959
  if (search_symtab != NULL)
1960
    {
1961
#if 0
1962
      /* This loses both in the case mentioned (want a static, find a global),
1963
         but also if we are looking up a non-mangled name which happens to
1964
         match the name of a mangled function.  */
1965
      /* We have to save the cur_fdr across the call to lookup_symbol.
1966
         If the pdr is for a static function and if a global function with
1967
         the same name exists, lookup_symbol will eventually read in the symtab
1968
         for the global function and clobber cur_fdr.  */
1969
      FDR *save_cur_fdr = cur_fdr;
1970
      s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0);
1971
      cur_fdr = save_cur_fdr;
1972
#else
1973
      s = mylookup_symbol
1974
        (sh_name,
1975
         BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK),
1976
         VAR_DOMAIN,
1977
         LOC_BLOCK);
1978
#endif
1979
    }
1980
  else
1981
    s = mylookup_symbol (sh_name, top_stack->cur_block,
1982
                         VAR_DOMAIN, LOC_BLOCK);
1983
 
1984
  if (s != 0)
1985
    {
1986
      b = SYMBOL_BLOCK_VALUE (s);
1987
    }
1988
  else
1989
    {
1990
      complaint (&symfile_complaints, _("PDR for %s, but no symbol"), sh_name);
1991
#if 1
1992
      return;
1993
#else
1994
/* FIXME -- delete.  We can't do symbol allocation now; it's all done.  */
1995
      s = new_symbol (sh_name);
1996
      SYMBOL_DOMAIN (s) = VAR_DOMAIN;
1997
      SYMBOL_CLASS (s) = LOC_BLOCK;
1998
      /* Donno its type, hope int is ok */
1999
      SYMBOL_TYPE (s)
2000
        = lookup_function_type (objfile_type (pst->objfile)->builtin_int);
2001
      add_symbol (s, top_stack->cur_st, top_stack->cur_block);
2002
      /* Wont have symbols for this one */
2003
      b = new_block (2);
2004
      SYMBOL_BLOCK_VALUE (s) = b;
2005
      BLOCK_FUNCTION (b) = s;
2006
      BLOCK_START (b) = pr->adr;
2007
      /* BOUND used to be the end of procedure's text, but the
2008
         argument is no longer passed in.  */
2009
      BLOCK_END (b) = bound;
2010
      BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
2011
      add_block (b, top_stack->cur_st);
2012
#endif
2013
    }
2014
 
2015
  i = mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, LOC_CONST);
2016
 
2017
  if (i)
2018
    {
2019
      struct mdebug_extra_func_info *e;
2020
 
2021
      e = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (i);
2022
      e->pdr = *pr;
2023
 
2024
      /* GDB expects the absolute function start address for the
2025
         procedure descriptor in e->pdr.adr.
2026
         As the address in the procedure descriptor is usually relative,
2027
         we would have to relocate e->pdr.adr with cur_fdr->adr and
2028
         ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
2029
         Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
2030
         in shared libraries on some systems, and on other systems
2031
         e->pdr.adr is sometimes offset by a bogus value.
2032
         To work around these problems, we replace e->pdr.adr with
2033
         the start address of the function.  */
2034
      e->pdr.adr = BLOCK_START (b);
2035
    }
2036
 
2037
  /* It would be reasonable that functions that have been compiled
2038
     without debugging info have a btNil type for their return value,
2039
     and functions that are void and are compiled with debugging info
2040
     have btVoid.
2041
     gcc and DEC f77 put out btNil types for both cases, so btNil is mapped
2042
     to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info'
2043
     case right.
2044
     The glevel field in cur_fdr could be used to determine the presence
2045
     of debugging info, but GCC doesn't always pass the -g switch settings
2046
     to the assembler and GAS doesn't set the glevel field from the -g switch
2047
     settings.
2048
     To work around these problems, the return value type of a TYPE_CODE_VOID
2049
     function is adjusted accordingly if no debugging info was found in the
2050
     compilation unit.  */
2051
 
2052
  if (processing_gcc_compilation == 0
2053
      && found_ecoff_debugging_info == 0
2054
      && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
2055
    SYMBOL_TYPE (s) = objfile_type (pst->objfile)->nodebug_text_symbol;
2056
}
2057
 
2058
/* Parse the external symbol ES. Just call parse_symbol() after
2059
   making sure we know where the aux are for it.
2060
   BIGEND says whether aux entries are big-endian or little-endian.
2061
 
2062
   This routine clobbers top_stack->cur_block and ->cur_st. */
2063
 
2064
static void parse_external (EXTR *, int, struct section_offsets *,
2065
                            struct objfile *);
2066
 
2067
static void
2068
parse_external (EXTR *es, int bigend, struct section_offsets *section_offsets,
2069
                struct objfile *objfile)
2070
{
2071
  union aux_ext *ax;
2072
 
2073
  if (es->ifd != ifdNil)
2074
    {
2075
      cur_fd = es->ifd;
2076
      cur_fdr = debug_info->fdr + cur_fd;
2077
      ax = debug_info->external_aux + cur_fdr->iauxBase;
2078
    }
2079
  else
2080
    {
2081
      cur_fdr = debug_info->fdr;
2082
      ax = 0;
2083
    }
2084
 
2085
  /* Reading .o files */
2086
  if (SC_IS_UNDEF (es->asym.sc) || es->asym.sc == scNil)
2087
    {
2088
      char *what;
2089
      switch (es->asym.st)
2090
        {
2091
        case stNil:
2092
          /* These are generated for static symbols in .o files,
2093
             ignore them.  */
2094
          return;
2095
        case stStaticProc:
2096
        case stProc:
2097
          what = "procedure";
2098
          n_undef_procs++;
2099
          break;
2100
        case stGlobal:
2101
          what = "variable";
2102
          n_undef_vars++;
2103
          break;
2104
        case stLabel:
2105
          what = "label";
2106
          n_undef_labels++;
2107
          break;
2108
        default:
2109
          what = "symbol";
2110
          break;
2111
        }
2112
      n_undef_symbols++;
2113
      /* FIXME:  Turn this into a complaint? */
2114
      if (info_verbose)
2115
        printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"),
2116
                         what, debug_info->ssext + es->asym.iss,
2117
                         fdr_name (cur_fdr));
2118
      return;
2119
    }
2120
 
2121
  switch (es->asym.st)
2122
    {
2123
    case stProc:
2124
    case stStaticProc:
2125
      /* There is no need to parse the external procedure symbols.
2126
         If they are from objects compiled without -g, their index will
2127
         be indexNil, and the symbol definition from the minimal symbol
2128
         is preferrable (yielding a function returning int instead of int).
2129
         If the index points to a local procedure symbol, the local
2130
         symbol already provides the correct type.
2131
         Note that the index of the external procedure symbol points
2132
         to the local procedure symbol in the local symbol table, and
2133
         _not_ to the auxiliary symbol info.  */
2134
      break;
2135
    case stGlobal:
2136
    case stLabel:
2137
      /* Global common symbols are resolved by the runtime loader,
2138
         ignore them.  */
2139
      if (SC_IS_COMMON (es->asym.sc))
2140
        break;
2141
 
2142
      /* Note that the case of a symbol with indexNil must be handled
2143
         anyways by parse_symbol().  */
2144
      parse_symbol (&es->asym, ax, (char *) NULL, bigend, section_offsets, objfile);
2145
      break;
2146
    default:
2147
      break;
2148
    }
2149
}
2150
 
2151
/* Parse the line number info for file descriptor FH into
2152
   GDB's linetable LT.  MIPS' encoding requires a little bit
2153
   of magic to get things out.  Note also that MIPS' line
2154
   numbers can go back and forth, apparently we can live
2155
   with that and do not need to reorder our linetables */
2156
 
2157
static void parse_lines (FDR *, PDR *, struct linetable *, int,
2158
                         struct partial_symtab *, CORE_ADDR);
2159
 
2160
static void
2161
parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines,
2162
             struct partial_symtab *pst, CORE_ADDR lowest_pdr_addr)
2163
{
2164
  unsigned char *base;
2165
  int j, k;
2166
  int delta, count, lineno = 0;
2167
 
2168
  if (fh->cbLine == 0)
2169
    return;
2170
 
2171
  /* Scan by procedure descriptors */
2172
  k = 0;
2173
  for (j = 0; j < fh->cpd; j++, pr++)
2174
    {
2175
      CORE_ADDR l;
2176
      CORE_ADDR adr;
2177
      unsigned char *halt;
2178
 
2179
      /* No code for this one */
2180
      if (pr->iline == ilineNil ||
2181
          pr->lnLow == -1 || pr->lnHigh == -1)
2182
        continue;
2183
 
2184
      /* Determine start and end address of compressed line bytes for
2185
         this procedure.  */
2186
      base = debug_info->line + fh->cbLineOffset;
2187
      if (j != (fh->cpd - 1))
2188
        halt = base + pr[1].cbLineOffset;
2189
      else
2190
        halt = base + fh->cbLine;
2191
      base += pr->cbLineOffset;
2192
 
2193
      adr = pst->textlow + pr->adr - lowest_pdr_addr;
2194
 
2195
      l = adr >> 2;             /* in words */
2196
      for (lineno = pr->lnLow; base < halt;)
2197
        {
2198
          count = *base & 0x0f;
2199
          delta = *base++ >> 4;
2200
          if (delta >= 8)
2201
            delta -= 16;
2202
          if (delta == -8)
2203
            {
2204
              delta = (base[0] << 8) | base[1];
2205
              if (delta >= 0x8000)
2206
                delta -= 0x10000;
2207
              base += 2;
2208
            }
2209
          lineno += delta;      /* first delta is 0 */
2210
 
2211
          /* Complain if the line table overflows. Could happen
2212
             with corrupt binaries.  */
2213
          if (lt->nitems >= maxlines)
2214
            {
2215
              complaint (&symfile_complaints,
2216
                         _("guessed size of linetable for %s incorrectly"),
2217
                         fdr_name (fh));
2218
              break;
2219
            }
2220
          k = add_line (lt, lineno, l, k);
2221
          l += count + 1;
2222
        }
2223
    }
2224
}
2225
 
2226
static void
2227
function_outside_compilation_unit_complaint (const char *arg1)
2228
{
2229
  complaint (&symfile_complaints,
2230
             _("function `%s' appears to be defined outside of all compilation units"),
2231
             arg1);
2232
}
2233
 
2234
/* Use the STORAGE_CLASS to compute which section the given symbol
2235
   belongs to, and then records this new minimal symbol.  */
2236
 
2237
static void
2238
record_minimal_symbol (const char *name, const CORE_ADDR address,
2239
                       enum minimal_symbol_type ms_type, int storage_class,
2240
                       struct objfile *objfile)
2241
{
2242
  int section;
2243
  asection *bfd_section;
2244
 
2245
  switch (storage_class)
2246
    {
2247
      case scText:
2248
        section = SECT_OFF_TEXT (objfile);
2249
        bfd_section = bfd_get_section_by_name (cur_bfd, ".text");
2250
        break;
2251
      case scData:
2252
        section = SECT_OFF_DATA (objfile);
2253
        bfd_section = bfd_get_section_by_name (cur_bfd, ".data");
2254
        break;
2255
      case scBss:
2256
        section = SECT_OFF_BSS (objfile);
2257
        bfd_section = bfd_get_section_by_name (cur_bfd, ".bss");
2258
        break;
2259
      case scSData:
2260
        section = get_section_index (objfile, ".sdata");
2261
        bfd_section = bfd_get_section_by_name (cur_bfd, ".sdata");
2262
        break;
2263
      case scSBss:
2264
        section = get_section_index (objfile, ".sbss");
2265
        bfd_section = bfd_get_section_by_name (cur_bfd, ".sbss");
2266
        break;
2267
      case scRData:
2268
        section = get_section_index (objfile, ".rdata");
2269
        bfd_section = bfd_get_section_by_name (cur_bfd, ".rdata");
2270
        break;
2271
      case scInit:
2272
        section = get_section_index (objfile, ".init");
2273
        bfd_section = bfd_get_section_by_name (cur_bfd, ".init");
2274
        break;
2275
      case scXData:
2276
        section = get_section_index (objfile, ".xdata");
2277
        bfd_section = bfd_get_section_by_name (cur_bfd, ".xdata");
2278
        break;
2279
      case scPData:
2280
        section = get_section_index (objfile, ".pdata");
2281
        bfd_section = bfd_get_section_by_name (cur_bfd, ".pdata");
2282
        break;
2283
      case scFini:
2284
        section = get_section_index (objfile, ".fini");
2285
        bfd_section = bfd_get_section_by_name (cur_bfd, ".fini");
2286
        break;
2287
      case scRConst:
2288
        section = get_section_index (objfile, ".rconst");
2289
        bfd_section = bfd_get_section_by_name (cur_bfd, ".rconst");
2290
        break;
2291
#ifdef scTlsData
2292
      case scTlsData:
2293
        section = get_section_index (objfile, ".tlsdata");
2294
        bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsdata");
2295
        break;
2296
#endif
2297
#ifdef scTlsBss
2298
      case scTlsBss:
2299
        section = get_section_index (objfile, ".tlsbss");
2300
        bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsbss");
2301
        break;
2302
#endif
2303
      default:
2304
        /* This kind of symbol is not associated to a section.  */
2305
        section = -1;
2306
        bfd_section = NULL;
2307
    }
2308
 
2309
  prim_record_minimal_symbol_and_info (name, address, ms_type,
2310
                                       section, bfd_section, objfile);
2311
}
2312
 
2313
/* Master parsing procedure for first-pass reading of file symbols
2314
   into a partial_symtab.  */
2315
 
2316
static void
2317
parse_partial_symbols (struct objfile *objfile)
2318
{
2319
  struct gdbarch *gdbarch = get_objfile_arch (objfile);
2320
  const bfd_size_type external_sym_size = debug_swap->external_sym_size;
2321
  const bfd_size_type external_rfd_size = debug_swap->external_rfd_size;
2322
  const bfd_size_type external_ext_size = debug_swap->external_ext_size;
2323
  void (*const swap_ext_in) (bfd *, void *, EXTR *) = debug_swap->swap_ext_in;
2324
  void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
2325
  void (*const swap_rfd_in) (bfd *, void *, RFDT *) = debug_swap->swap_rfd_in;
2326
  int f_idx, s_idx;
2327
  HDRR *hdr = &debug_info->symbolic_header;
2328
  /* Running pointers */
2329
  FDR *fh;
2330
  char *ext_out;
2331
  char *ext_out_end;
2332
  EXTR *ext_block;
2333
  EXTR *ext_in;
2334
  EXTR *ext_in_end;
2335
  SYMR sh;
2336
  struct partial_symtab *pst;
2337
  int textlow_not_set = 1;
2338
  int past_first_source_file = 0;
2339
 
2340
  /* List of current psymtab's include files */
2341
  char **psymtab_include_list;
2342
  int includes_allocated;
2343
  int includes_used;
2344
  EXTR *extern_tab;
2345
  struct pst_map *fdr_to_pst;
2346
  /* Index within current psymtab dependency list */
2347
  struct partial_symtab **dependency_list;
2348
  int dependencies_used, dependencies_allocated;
2349
  struct cleanup *old_chain;
2350
  char *name;
2351
  enum language prev_language;
2352
  asection *text_sect;
2353
  int relocatable = 0;
2354
 
2355
  /* Irix 5.2 shared libraries have a fh->adr field of zero, but
2356
     the shared libraries are prelinked at a high memory address.
2357
     We have to adjust the start address of the object file for this case,
2358
     by setting it to the start address of the first procedure in the file.
2359
     But we should do no adjustments if we are debugging a .o file, where
2360
     the text section (and fh->adr) really starts at zero.  */
2361
  text_sect = bfd_get_section_by_name (cur_bfd, ".text");
2362
  if (text_sect != NULL
2363
      && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC))
2364
    relocatable = 1;
2365
 
2366
  extern_tab = (EXTR *) obstack_alloc (&objfile->objfile_obstack,
2367
                                       sizeof (EXTR) * hdr->iextMax);
2368
 
2369
  includes_allocated = 30;
2370
  includes_used = 0;
2371
  psymtab_include_list = (char **) alloca (includes_allocated *
2372
                                           sizeof (char *));
2373
  next_symbol_text_func = mdebug_next_symbol_text;
2374
 
2375
  dependencies_allocated = 30;
2376
  dependencies_used = 0;
2377
  dependency_list =
2378
    (struct partial_symtab **) alloca (dependencies_allocated *
2379
                                       sizeof (struct partial_symtab *));
2380
 
2381
  last_source_file = NULL;
2382
 
2383
  /*
2384
   * Big plan:
2385
   *
2386
   * Only parse the Local and External symbols, and the Relative FDR.
2387
   * Fixup enough of the loader symtab to be able to use it.
2388
   * Allocate space only for the file's portions we need to
2389
   * look at. (XXX)
2390
   */
2391
 
2392
  max_gdbinfo = 0;
2393
  max_glevel = MIN_GLEVEL;
2394
 
2395
  /* Allocate the map FDR -> PST.
2396
     Minor hack: -O3 images might claim some global data belongs
2397
     to FDR -1. We`ll go along with that */
2398
  fdr_to_pst = (struct pst_map *) xzalloc ((hdr->ifdMax + 1) * sizeof *fdr_to_pst);
2399
  old_chain = make_cleanup (xfree, fdr_to_pst);
2400
  fdr_to_pst++;
2401
  {
2402
    struct partial_symtab *pst = new_psymtab ("", objfile);
2403
    fdr_to_pst[-1].pst = pst;
2404
    FDR_IDX (pst) = -1;
2405
  }
2406
 
2407
  /* Allocate the global pending list.  */
2408
  pending_list =
2409
    ((struct mdebug_pending **)
2410
     obstack_alloc (&objfile->objfile_obstack,
2411
                    hdr->ifdMax * sizeof (struct mdebug_pending *)));
2412
  memset (pending_list, 0,
2413
          hdr->ifdMax * sizeof (struct mdebug_pending *));
2414
 
2415
  /* Pass 0 over external syms: swap them in.  */
2416
  ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR));
2417
  make_cleanup (xfree, ext_block);
2418
 
2419
  ext_out = (char *) debug_info->external_ext;
2420
  ext_out_end = ext_out + hdr->iextMax * external_ext_size;
2421
  ext_in = ext_block;
2422
  for (; ext_out < ext_out_end; ext_out += external_ext_size, ext_in++)
2423
    (*swap_ext_in) (cur_bfd, ext_out, ext_in);
2424
 
2425
  /* Pass 1 over external syms: Presize and partition the list */
2426
  ext_in = ext_block;
2427
  ext_in_end = ext_in + hdr->iextMax;
2428
  for (; ext_in < ext_in_end; ext_in++)
2429
    {
2430
      /* See calls to complain below.  */
2431
      if (ext_in->ifd >= -1
2432
          && ext_in->ifd < hdr->ifdMax
2433
          && ext_in->asym.iss >= 0
2434
          && ext_in->asym.iss < hdr->issExtMax)
2435
        fdr_to_pst[ext_in->ifd].n_globals++;
2436
    }
2437
 
2438
  /* Pass 1.5 over files:  partition out global symbol space */
2439
  s_idx = 0;
2440
  for (f_idx = -1; f_idx < hdr->ifdMax; f_idx++)
2441
    {
2442
      fdr_to_pst[f_idx].globals_offset = s_idx;
2443
      s_idx += fdr_to_pst[f_idx].n_globals;
2444
      fdr_to_pst[f_idx].n_globals = 0;
2445
    }
2446
 
2447
  /* ECOFF in ELF:
2448
 
2449
     For ECOFF in ELF, we skip the creation of the minimal symbols.
2450
     The ECOFF symbols should be a subset of the Elf symbols, and the
2451
     section information of the elf symbols will be more accurate.
2452
     FIXME!  What about Irix 5's native linker?
2453
 
2454
     By default, Elf sections which don't exist in ECOFF
2455
     get put in ECOFF's absolute section by the gnu linker.
2456
     Since absolute sections don't get relocated, we
2457
     end up calculating an address different from that of
2458
     the symbol's minimal symbol (created earlier from the
2459
     Elf symtab).
2460
 
2461
     To fix this, either :
2462
     1) don't create the duplicate symbol
2463
     (assumes ECOFF symtab is a subset of the ELF symtab;
2464
     assumes no side-effects result from ignoring ECOFF symbol)
2465
     2) create it, only if lookup for existing symbol in ELF's minimal
2466
     symbols fails
2467
     (inefficient;
2468
     assumes no side-effects result from ignoring ECOFF symbol)
2469
     3) create it, but lookup ELF's minimal symbol and use it's section
2470
     during relocation, then modify "uniqify" phase to merge and
2471
     eliminate the duplicate symbol
2472
     (highly inefficient)
2473
 
2474
     I've implemented #1 here...
2475
     Skip the creation of the minimal symbols based on the ECOFF
2476
     symbol table. */
2477
 
2478
  /* Pass 2 over external syms: fill in external symbols */
2479
  ext_in = ext_block;
2480
  ext_in_end = ext_in + hdr->iextMax;
2481
  for (; ext_in < ext_in_end; ext_in++)
2482
    {
2483
      enum minimal_symbol_type ms_type = mst_text;
2484
      CORE_ADDR svalue = ext_in->asym.value;
2485
 
2486
      /* The Irix 5 native tools seem to sometimes generate bogus
2487
         external symbols.  */
2488
      if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
2489
        {
2490
          complaint (&symfile_complaints,
2491
                     _("bad ifd for external symbol: %d (max %ld)"), ext_in->ifd,
2492
                     hdr->ifdMax);
2493
          continue;
2494
        }
2495
      if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
2496
        {
2497
          complaint (&symfile_complaints,
2498
                     _("bad iss for external symbol: %ld (max %ld)"),
2499
                     ext_in->asym.iss, hdr->issExtMax);
2500
          continue;
2501
        }
2502
 
2503
      extern_tab[fdr_to_pst[ext_in->ifd].globals_offset
2504
                 + fdr_to_pst[ext_in->ifd].n_globals++] = *ext_in;
2505
 
2506
 
2507
      if (SC_IS_UNDEF (ext_in->asym.sc) || ext_in->asym.sc == scNil)
2508
        continue;
2509
 
2510
 
2511
      /* Pass 3 over files, over local syms: fill in static symbols */
2512
      name = debug_info->ssext + ext_in->asym.iss;
2513
 
2514
      /* Process ECOFF Symbol Types and Storage Classes */
2515
      switch (ext_in->asym.st)
2516
        {
2517
        case stProc:
2518
          /* Beginnning of Procedure */
2519
          svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2520
          break;
2521
        case stStaticProc:
2522
          /* Load time only static procs */
2523
          ms_type = mst_file_text;
2524
          svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2525
          break;
2526
        case stGlobal:
2527
          /* External symbol */
2528
          if (SC_IS_COMMON (ext_in->asym.sc))
2529
            {
2530
              /* The value of a common symbol is its size, not its address.
2531
                 Ignore it.  */
2532
              continue;
2533
            }
2534
          else if (SC_IS_DATA (ext_in->asym.sc))
2535
            {
2536
              ms_type = mst_data;
2537
              svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2538
            }
2539
          else if (SC_IS_BSS (ext_in->asym.sc))
2540
            {
2541
              ms_type = mst_bss;
2542
              svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2543
            }
2544
          else if (SC_IS_SBSS (ext_in->asym.sc))
2545
            {
2546
              ms_type = mst_bss;
2547
              svalue += ANOFFSET (objfile->section_offsets,
2548
                                  get_section_index (objfile, ".sbss"));
2549
            }
2550
          else
2551
            ms_type = mst_abs;
2552
          break;
2553
        case stLabel:
2554
          /* Label */
2555
 
2556
          /* On certain platforms, some extra label symbols can be
2557
             generated by the linker. One possible usage for this kind
2558
             of symbols is to represent the address of the begining of a
2559
             given section. For instance, on Tru64 5.1, the address of
2560
             the _ftext label is the start address of the .text section.
2561
 
2562
             The storage class of these symbols is usually directly
2563
             related to the section to which the symbol refers. For
2564
             instance, on Tru64 5.1, the storage class for the _fdata
2565
             label is scData, refering to the .data section.
2566
 
2567
             It is actually possible that the section associated to the
2568
             storage class of the label does not exist. On True64 5.1
2569
             for instance, the libm.so shared library does not contain
2570
             any .data section, although it contains a _fpdata label
2571
             which storage class is scData... Since these symbols are
2572
             usually useless for the debugger user anyway, we just
2573
             discard these symbols.
2574
           */
2575
 
2576
          if (SC_IS_TEXT (ext_in->asym.sc))
2577
            {
2578
              if (objfile->sect_index_text == -1)
2579
                continue;
2580
 
2581
              ms_type = mst_file_text;
2582
              svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2583
            }
2584
          else if (SC_IS_DATA (ext_in->asym.sc))
2585
            {
2586
              if (objfile->sect_index_data == -1)
2587
                continue;
2588
 
2589
              ms_type = mst_file_data;
2590
              svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2591
            }
2592
          else if (SC_IS_BSS (ext_in->asym.sc))
2593
            {
2594
              if (objfile->sect_index_bss == -1)
2595
                continue;
2596
 
2597
              ms_type = mst_file_bss;
2598
              svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2599
            }
2600
          else if (SC_IS_SBSS (ext_in->asym.sc))
2601
            {
2602
              const int sbss_sect_index = get_section_index (objfile, ".sbss");
2603
 
2604
              if (sbss_sect_index == -1)
2605
                continue;
2606
 
2607
              ms_type = mst_file_bss;
2608
              svalue += ANOFFSET (objfile->section_offsets, sbss_sect_index);
2609
            }
2610
          else
2611
            ms_type = mst_abs;
2612
          break;
2613
        case stLocal:
2614
        case stNil:
2615
          /* The alpha has the section start addresses in stLocal symbols
2616
             whose name starts with a `.'. Skip those but complain for all
2617
             other stLocal symbols.
2618
             Irix6 puts the section start addresses in stNil symbols, skip
2619
             those too. */
2620
          if (name[0] == '.')
2621
            continue;
2622
          /* Fall through.  */
2623
        default:
2624
          ms_type = mst_unknown;
2625
          unknown_ext_complaint (name);
2626
        }
2627
      if (!ECOFF_IN_ELF (cur_bfd))
2628
        record_minimal_symbol (name, svalue, ms_type, ext_in->asym.sc,
2629
                               objfile);
2630
    }
2631
 
2632
  /* Pass 3 over files, over local syms: fill in static symbols */
2633
  for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
2634
    {
2635
      struct partial_symtab *save_pst;
2636
      EXTR *ext_ptr;
2637
      CORE_ADDR textlow;
2638
 
2639
      cur_fdr = fh = debug_info->fdr + f_idx;
2640
 
2641
      if (fh->csym == 0)
2642
        {
2643
          fdr_to_pst[f_idx].pst = NULL;
2644
          continue;
2645
        }
2646
 
2647
      /* Determine the start address for this object file from the
2648
         file header and relocate it, except for Irix 5.2 zero fh->adr.  */
2649
      if (fh->cpd)
2650
        {
2651
          textlow = fh->adr;
2652
          if (relocatable || textlow != 0)
2653
            textlow += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2654
        }
2655
      else
2656
        textlow = 0;
2657
      pst = start_psymtab_common (objfile, objfile->section_offsets,
2658
                                  fdr_name (fh),
2659
                                  textlow,
2660
                                  objfile->global_psymbols.next,
2661
                                  objfile->static_psymbols.next);
2662
      pst->read_symtab_private = ((char *)
2663
                                  obstack_alloc (&objfile->objfile_obstack,
2664
                                                 sizeof (struct symloc)));
2665
      memset (pst->read_symtab_private, 0, sizeof (struct symloc));
2666
 
2667
      save_pst = pst;
2668
      FDR_IDX (pst) = f_idx;
2669
      CUR_BFD (pst) = cur_bfd;
2670
      DEBUG_SWAP (pst) = debug_swap;
2671
      DEBUG_INFO (pst) = debug_info;
2672
      PENDING_LIST (pst) = pending_list;
2673
 
2674
      /* The way to turn this into a symtab is to call... */
2675
      pst->read_symtab = mdebug_psymtab_to_symtab;
2676
 
2677
      /* Set up language for the pst.
2678
         The language from the FDR is used if it is unambigious (e.g. cfront
2679
         with native cc and g++ will set the language to C).
2680
         Otherwise we have to deduce the language from the filename.
2681
         Native ecoff has every header file in a separate FDR, so
2682
         deduce_language_from_filename will return language_unknown for
2683
         a header file, which is not what we want.
2684
         But the FDRs for the header files are after the FDR for the source
2685
         file, so we can assign the language of the source file to the
2686
         following header files. Then we save the language in the private
2687
         pst data so that we can reuse it when building symtabs.  */
2688
      prev_language = psymtab_language;
2689
 
2690
      switch (fh->lang)
2691
        {
2692
        case langCplusplusV2:
2693
          psymtab_language = language_cplus;
2694
          break;
2695
        default:
2696
          psymtab_language = deduce_language_from_filename (fdr_name (fh));
2697
          break;
2698
        }
2699
      if (psymtab_language == language_unknown)
2700
        psymtab_language = prev_language;
2701
      PST_PRIVATE (pst)->pst_language = psymtab_language;
2702
 
2703
      pst->texthigh = pst->textlow;
2704
 
2705
      /* For stabs-in-ecoff files, the second symbol must be @stab.
2706
         This symbol is emitted by mips-tfile to signal that the
2707
         current object file uses encapsulated stabs instead of mips
2708
         ecoff for local symbols.  (It is the second symbol because
2709
         the first symbol is the stFile used to signal the start of a
2710
         file). */
2711
      processing_gcc_compilation = 0;
2712
      if (fh->csym >= 2)
2713
        {
2714
          (*swap_sym_in) (cur_bfd,
2715
                          ((char *) debug_info->external_sym
2716
                           + (fh->isymBase + 1) * external_sym_size),
2717
                          &sh);
2718
          if (strcmp (debug_info->ss + fh->issBase + sh.iss,
2719
                      stabs_symbol) == 0)
2720
            processing_gcc_compilation = 2;
2721
        }
2722
 
2723
      if (processing_gcc_compilation != 0)
2724
        {
2725
          for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
2726
            {
2727
              int type_code;
2728
              char *namestring;
2729
 
2730
              (*swap_sym_in) (cur_bfd,
2731
                              (((char *) debug_info->external_sym)
2732
                            + (fh->isymBase + cur_sdx) * external_sym_size),
2733
                              &sh);
2734
              type_code = ECOFF_UNMARK_STAB (sh.index);
2735
              if (!ECOFF_IS_STAB (&sh))
2736
                {
2737
                  if (sh.st == stProc || sh.st == stStaticProc)
2738
                    {
2739
                      CORE_ADDR procaddr;
2740
                      long isym;
2741
 
2742
                      sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2743
                      if (sh.st == stStaticProc)
2744
                        {
2745
                          namestring = debug_info->ss + fh->issBase + sh.iss;
2746
                          record_minimal_symbol (namestring, sh.value,
2747
                                                 mst_file_text, sh.sc,
2748
                                                 objfile);
2749
                        }
2750
                      procaddr = sh.value;
2751
 
2752
                      isym = AUX_GET_ISYM (fh->fBigendian,
2753
                                           (debug_info->external_aux
2754
                                            + fh->iauxBase
2755
                                            + sh.index));
2756
                      (*swap_sym_in) (cur_bfd,
2757
                                      ((char *) debug_info->external_sym
2758
                                       + ((fh->isymBase + isym - 1)
2759
                                          * external_sym_size)),
2760
                                      &sh);
2761
                      if (sh.st == stEnd)
2762
                        {
2763
                          CORE_ADDR high = procaddr + sh.value;
2764
 
2765
                          /* Kludge for Irix 5.2 zero fh->adr.  */
2766
                          if (!relocatable
2767
                          && (pst->textlow == 0 || procaddr < pst->textlow))
2768
                            pst->textlow = procaddr;
2769
                          if (high > pst->texthigh)
2770
                            pst->texthigh = high;
2771
                        }
2772
                    }
2773
                  else if (sh.st == stStatic)
2774
                    {
2775
                      switch (sh.sc)
2776
                        {
2777
                        case scUndefined:
2778
                        case scSUndefined:
2779
                        case scNil:
2780
                        case scAbs:
2781
                          break;
2782
 
2783
                        case scData:
2784
                        case scSData:
2785
                        case scRData:
2786
                        case scPData:
2787
                        case scXData:
2788
                          namestring = debug_info->ss + fh->issBase + sh.iss;
2789
                          sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2790
                          record_minimal_symbol (namestring, sh.value,
2791
                                                 mst_file_data, sh.sc,
2792
                                                 objfile);
2793
                          break;
2794
 
2795
                        default:
2796
                          /* FIXME!  Shouldn't this use cases for bss,
2797
                             then have the default be abs? */
2798
                          namestring = debug_info->ss + fh->issBase + sh.iss;
2799
                          sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2800
                          record_minimal_symbol (namestring, sh.value,
2801
                                                 mst_file_bss, sh.sc,
2802
                                                 objfile);
2803
                          break;
2804
                        }
2805
                    }
2806
                  continue;
2807
                }
2808
              /* Handle stabs continuation */
2809
              {
2810
                char *stabstring = debug_info->ss + fh->issBase + sh.iss;
2811
                int len = strlen (stabstring);
2812
                while (stabstring[len - 1] == '\\')
2813
                  {
2814
                    SYMR sh2;
2815
                    char *stabstring1 = stabstring;
2816
                    char *stabstring2;
2817
                    int len2;
2818
 
2819
                    /* Ignore continuation char from 1st string */
2820
                    len--;
2821
 
2822
                    /* Read next stabstring */
2823
                    cur_sdx++;
2824
                    (*swap_sym_in) (cur_bfd,
2825
                                    (((char *) debug_info->external_sym)
2826
                                     + (fh->isymBase + cur_sdx)
2827
                                     * external_sym_size),
2828
                                    &sh2);
2829
                    stabstring2 = debug_info->ss + fh->issBase + sh2.iss;
2830
                    len2 = strlen (stabstring2);
2831
 
2832
                    /* Concatinate stabstring2 with stabstring1 */
2833
                    if (stabstring
2834
                     && stabstring != debug_info->ss + fh->issBase + sh.iss)
2835
                      stabstring = xrealloc (stabstring, len + len2 + 1);
2836
                    else
2837
                      {
2838
                        stabstring = xmalloc (len + len2 + 1);
2839
                        strcpy (stabstring, stabstring1);
2840
                      }
2841
                    strcpy (stabstring + len, stabstring2);
2842
                    len += len2;
2843
                  }
2844
 
2845
                switch (type_code)
2846
                  {
2847
                    char *p;
2848
                    /*
2849
                     * Standard, external, non-debugger, symbols
2850
                     */
2851
 
2852
                  case N_TEXT | N_EXT:
2853
                  case N_NBTEXT | N_EXT:
2854
                    sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2855
                    goto record_it;
2856
 
2857
                  case N_DATA | N_EXT:
2858
                  case N_NBDATA | N_EXT:
2859
                    sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2860
                    goto record_it;
2861
 
2862
                  case N_BSS:
2863
                  case N_BSS | N_EXT:
2864
                  case N_NBBSS | N_EXT:
2865
                  case N_SETV | N_EXT:          /* FIXME, is this in BSS? */
2866
                    sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
2867
                    goto record_it;
2868
 
2869
                  case N_ABS | N_EXT:
2870
                  record_it:
2871
                  continue;
2872
 
2873
                  /* Standard, local, non-debugger, symbols */
2874
 
2875
                  case N_NBTEXT:
2876
 
2877
                    /* We need to be able to deal with both N_FN or N_TEXT,
2878
                       because we have no way of knowing whether the sys-supplied ld
2879
                       or GNU ld was used to make the executable.  Sequents throw
2880
                       in another wrinkle -- they renumbered N_FN.  */
2881
 
2882
                  case N_FN:
2883
                  case N_FN_SEQ:
2884
                  case N_TEXT:
2885
                    continue;
2886
 
2887
                  case N_DATA:
2888
                    sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2889
                    goto record_it;
2890
 
2891
                  case N_UNDF | N_EXT:
2892
                    continue;                   /* Just undefined, not COMMON */
2893
 
2894
                  case N_UNDF:
2895
                    continue;
2896
 
2897
                    /* Lots of symbol types we can just ignore.  */
2898
 
2899
                  case N_ABS:
2900
                  case N_NBDATA:
2901
                  case N_NBBSS:
2902
                    continue;
2903
 
2904
                    /* Keep going . . . */
2905
 
2906
                    /*
2907
                     * Special symbol types for GNU
2908
                     */
2909
                  case N_INDR:
2910
                  case N_INDR | N_EXT:
2911
                  case N_SETA:
2912
                  case N_SETA | N_EXT:
2913
                  case N_SETT:
2914
                  case N_SETT | N_EXT:
2915
                  case N_SETD:
2916
                  case N_SETD | N_EXT:
2917
                  case N_SETB:
2918
                  case N_SETB | N_EXT:
2919
                  case N_SETV:
2920
                    continue;
2921
 
2922
                    /*
2923
                     * Debugger symbols
2924
                     */
2925
 
2926
                  case N_SO:
2927
                    {
2928
                      CORE_ADDR valu;
2929
                      static int prev_so_symnum = -10;
2930
                      static int first_so_symnum;
2931
                      char *p;
2932
                      int prev_textlow_not_set;
2933
 
2934
                      valu = sh.value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2935
 
2936
                      prev_textlow_not_set = textlow_not_set;
2937
 
2938
                      /* A zero value is probably an indication for the SunPRO 3.0
2939
                         compiler. end_psymtab explicitly tests for zero, so
2940
                         don't relocate it.  */
2941
 
2942
                      if (sh.value == 0
2943
                          && gdbarch_sofun_address_maybe_missing (gdbarch))
2944
                        {
2945
                          textlow_not_set = 1;
2946
                          valu = 0;
2947
                        }
2948
                      else
2949
                        textlow_not_set = 0;
2950
 
2951
                      past_first_source_file = 1;
2952
 
2953
                      if (prev_so_symnum != symnum - 1)
2954
                        {                       /* Here if prev stab wasn't N_SO */
2955
                          first_so_symnum = symnum;
2956
 
2957
                          if (pst)
2958
                            {
2959
                              pst = (struct partial_symtab *) 0;
2960
                              includes_used = 0;
2961
                              dependencies_used = 0;
2962
                            }
2963
                        }
2964
 
2965
                      prev_so_symnum = symnum;
2966
 
2967
                      /* End the current partial symtab and start a new one */
2968
 
2969
                      /* SET_NAMESTRING ();*/
2970
                      namestring = stabstring;
2971
 
2972
                      /* Null name means end of .o file.  Don't start a new one. */
2973
                      if (*namestring == '\000')
2974
                        continue;
2975
 
2976
                      /* Some compilers (including gcc) emit a pair of initial N_SOs.
2977
                         The first one is a directory name; the second the file name.
2978
                         If pst exists, is empty, and has a filename ending in '/',
2979
                         we assume the previous N_SO was a directory name. */
2980
 
2981
                      p = strrchr (namestring, '/');
2982
                      if (p && *(p + 1) == '\000')
2983
                        continue;               /* Simply ignore directory name SOs */
2984
 
2985
                      /* Some other compilers (C++ ones in particular) emit useless
2986
                         SOs for non-existant .c files.  We ignore all subsequent SOs that
2987
                         immediately follow the first.  */
2988
 
2989
                      if (!pst)
2990
                        pst = save_pst;
2991
                      continue;
2992
                    }
2993
 
2994
                  case N_BINCL:
2995
                    continue;
2996
 
2997
                  case N_SOL:
2998
                    {
2999
                      enum language tmp_language;
3000
                      /* Mark down an include file in the current psymtab */
3001
 
3002
                      /* SET_NAMESTRING ();*/
3003
                      namestring = stabstring;
3004
 
3005
                      tmp_language = deduce_language_from_filename (namestring);
3006
 
3007
                      /* Only change the psymtab's language if we've learned
3008
                         something useful (eg. tmp_language is not language_unknown).
3009
                         In addition, to match what start_subfile does, never change
3010
                         from C++ to C.  */
3011
                      if (tmp_language != language_unknown
3012
                          && (tmp_language != language_c
3013
                              || psymtab_language != language_cplus))
3014
                        psymtab_language = tmp_language;
3015
 
3016
                      /* In C++, one may expect the same filename to come round many
3017
                         times, when code is coming alternately from the main file
3018
                         and from inline functions in other files. So I check to see
3019
                         if this is a file we've seen before -- either the main
3020
                         source file, or a previously included file.
3021
 
3022
                         This seems to be a lot of time to be spending on N_SOL, but
3023
                         things like "break c-exp.y:435" need to work (I
3024
                         suppose the psymtab_include_list could be hashed or put
3025
                         in a binary tree, if profiling shows this is a major hog).  */
3026
                      if (pst && strcmp (namestring, pst->filename) == 0)
3027
                        continue;
3028
                      {
3029
                        int i;
3030
                        for (i = 0; i < includes_used; i++)
3031
                          if (strcmp (namestring,
3032
                                      psymtab_include_list[i]) == 0)
3033
                            {
3034
                              i = -1;
3035
                              break;
3036
                            }
3037
                        if (i == -1)
3038
                          continue;
3039
                      }
3040
 
3041
                      psymtab_include_list[includes_used++] = namestring;
3042
                      if (includes_used >= includes_allocated)
3043
                        {
3044
                          char **orig = psymtab_include_list;
3045
 
3046
                          psymtab_include_list = (char **)
3047
                            alloca ((includes_allocated *= 2) *
3048
                                    sizeof (char *));
3049
                          memcpy (psymtab_include_list, orig,
3050
                                  includes_used * sizeof (char *));
3051
                        }
3052
                      continue;
3053
                    }
3054
                  case N_LSYM:                  /* Typedef or automatic variable. */
3055
                  case N_STSYM:         /* Data seg var -- static  */
3056
                  case N_LCSYM:         /* BSS      "  */
3057
                  case N_ROSYM:         /* Read-only data seg var -- static.  */
3058
                  case N_NBSTS:         /* Gould nobase.  */
3059
                  case N_NBLCS:         /* symbols.  */
3060
                  case N_FUN:
3061
                  case N_GSYM:                  /* Global (extern) variable; can be
3062
                                                   data or bss (sigh FIXME).  */
3063
 
3064
                    /* Following may probably be ignored; I'll leave them here
3065
                       for now (until I do Pascal and Modula 2 extensions).  */
3066
 
3067
                  case N_PC:                    /* I may or may not need this; I
3068
                                                   suspect not.  */
3069
                  case N_M2C:                   /* I suspect that I can ignore this here. */
3070
                  case N_SCOPE:         /* Same.   */
3071
 
3072
                    /*    SET_NAMESTRING ();*/
3073
                    namestring = stabstring;
3074
                    p = (char *) strchr (namestring, ':');
3075
                    if (!p)
3076
                      continue;                 /* Not a debugging symbol.   */
3077
 
3078
 
3079
 
3080
                    /* Main processing section for debugging symbols which
3081
                       the initial read through the symbol tables needs to worry
3082
                       about.  If we reach this point, the symbol which we are
3083
                       considering is definitely one we are interested in.
3084
                       p must also contain the (valid) index into the namestring
3085
                       which indicates the debugging type symbol.  */
3086
 
3087
                    switch (p[1])
3088
                      {
3089
                      case 'S':
3090
                        sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
3091
 
3092
                        if (gdbarch_static_transform_name_p (gdbarch))
3093
                          namestring = gdbarch_static_transform_name
3094
                                         (gdbarch, namestring);
3095
 
3096
                        add_psymbol_to_list (namestring, p - namestring, 1,
3097
                                             VAR_DOMAIN, LOC_STATIC,
3098
                                             &objfile->static_psymbols,
3099
                                             0, sh.value,
3100
                                             psymtab_language, objfile);
3101
                        continue;
3102
                      case 'G':
3103
                        sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
3104
                        /* The addresses in these entries are reported to be
3105
                           wrong.  See the code that reads 'G's for symtabs. */
3106
                        add_psymbol_to_list (namestring, p - namestring, 1,
3107
                                             VAR_DOMAIN, LOC_STATIC,
3108
                                             &objfile->global_psymbols,
3109
                                             0, sh.value,
3110
                                             psymtab_language, objfile);
3111
                        continue;
3112
 
3113
                      case 'T':
3114
                        /* When a 'T' entry is defining an anonymous enum, it
3115
                           may have a name which is the empty string, or a
3116
                           single space.  Since they're not really defining a
3117
                           symbol, those shouldn't go in the partial symbol
3118
                           table.  We do pick up the elements of such enums at
3119
                           'check_enum:', below.  */
3120
                        if (p >= namestring + 2
3121
                            || (p == namestring + 1
3122
                                && namestring[0] != ' '))
3123
                          {
3124
                            add_psymbol_to_list (namestring, p - namestring, 1,
3125
                                                 STRUCT_DOMAIN, LOC_TYPEDEF,
3126
                                                 &objfile->static_psymbols,
3127
                                                 sh.value, 0,
3128
                                                 psymtab_language, objfile);
3129
                            if (p[2] == 't')
3130
                              {
3131
                                /* Also a typedef with the same name.  */
3132
                                add_psymbol_to_list (namestring, p - namestring,
3133
                                                     1,
3134
                                                     VAR_DOMAIN, LOC_TYPEDEF,
3135
                                                     &objfile->static_psymbols,
3136
                                                     sh.value, 0,
3137
                                                     psymtab_language, objfile);
3138
                                p += 1;
3139
                              }
3140
                          }
3141
                        goto check_enum;
3142
                      case 't':
3143
                        if (p != namestring)    /* a name is there, not just :T... */
3144
                          {
3145
                            add_psymbol_to_list (namestring, p - namestring, 1,
3146
                                                 VAR_DOMAIN, LOC_TYPEDEF,
3147
                                                 &objfile->static_psymbols,
3148
                                                 sh.value, 0,
3149
                                                 psymtab_language, objfile);
3150
                          }
3151
                      check_enum:
3152
                        /* If this is an enumerated type, we need to
3153
                           add all the enum constants to the partial symbol
3154
                           table.  This does not cover enums without names, e.g.
3155
                           "enum {a, b} c;" in C, but fortunately those are
3156
                           rare.  There is no way for GDB to find those from the
3157
                           enum type without spending too much time on it.  Thus
3158
                           to solve this problem, the compiler needs to put out the
3159
                           enum in a nameless type.  GCC2 does this.  */
3160
 
3161
                        /* We are looking for something of the form
3162
                           <name> ":" ("t" | "T") [<number> "="] "e"
3163
                           {<constant> ":" <value> ","} ";".  */
3164
 
3165
                        /* Skip over the colon and the 't' or 'T'.  */
3166
                        p += 2;
3167
                        /* This type may be given a number.  Also, numbers can come
3168
                           in pairs like (0,26).  Skip over it.  */
3169
                        while ((*p >= '0' && *p <= '9')
3170
                               || *p == '(' || *p == ',' || *p == ')'
3171
                               || *p == '=')
3172
                          p++;
3173
 
3174
                        if (*p++ == 'e')
3175
                          {
3176
                            /* The aix4 compiler emits extra crud before the members.  */
3177
                            if (*p == '-')
3178
                              {
3179
                                /* Skip over the type (?).  */
3180
                                while (*p != ':')
3181
                                  p++;
3182
 
3183
                                /* Skip over the colon.  */
3184
                                p++;
3185
                              }
3186
 
3187
                            /* We have found an enumerated type.  */
3188
                            /* According to comments in read_enum_type
3189
                               a comma could end it instead of a semicolon.
3190
                               I don't know where that happens.
3191
                               Accept either.  */
3192
                            while (*p && *p != ';' && *p != ',')
3193
                              {
3194
                                char *q;
3195
 
3196
                                /* Check for and handle cretinous dbx symbol name
3197
                                   continuation!  */
3198
                                if (*p == '\\' || (*p == '?' && p[1] == '\0'))
3199
                                  p = next_symbol_text (objfile);
3200
 
3201
                                /* Point to the character after the name
3202
                                   of the enum constant.  */
3203
                                for (q = p; *q && *q != ':'; q++)
3204
                                  ;
3205
                                /* Note that the value doesn't matter for
3206
                                   enum constants in psymtabs, just in symtabs.  */
3207
                                add_psymbol_to_list (p, q - p, 1,
3208
                                                     VAR_DOMAIN, LOC_CONST,
3209
                                                     &objfile->static_psymbols, 0,
3210
                                                     0, psymtab_language, objfile);
3211
                                /* Point past the name.  */
3212
                                p = q;
3213
                                /* Skip over the value.  */
3214
                                while (*p && *p != ',')
3215
                                  p++;
3216
                                /* Advance past the comma.  */
3217
                                if (*p)
3218
                                  p++;
3219
                              }
3220
                          }
3221
                        continue;
3222
                      case 'c':
3223
                        /* Constant, e.g. from "const" in Pascal.  */
3224
                        add_psymbol_to_list (namestring, p - namestring, 1,
3225
                                             VAR_DOMAIN, LOC_CONST,
3226
                                             &objfile->static_psymbols, sh.value,
3227
                                             0, psymtab_language, objfile);
3228
                        continue;
3229
 
3230
                      case 'f':
3231
                        if (! pst)
3232
                          {
3233
                            int name_len = p - namestring;
3234
                            char *name = xmalloc (name_len + 1);
3235
                            memcpy (name, namestring, name_len);
3236
                            name[name_len] = '\0';
3237
                            function_outside_compilation_unit_complaint (name);
3238
                            xfree (name);
3239
                          }
3240
                        sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3241
                        add_psymbol_to_list (namestring, p - namestring, 1,
3242
                                             VAR_DOMAIN, LOC_BLOCK,
3243
                                             &objfile->static_psymbols,
3244
                                             0, sh.value,
3245
                                             psymtab_language, objfile);
3246
                        continue;
3247
 
3248
                        /* Global functions were ignored here, but now they
3249
                           are put into the global psymtab like one would expect.
3250
                           They're also in the minimal symbol table.  */
3251
                      case 'F':
3252
                        if (! pst)
3253
                          {
3254
                            int name_len = p - namestring;
3255
                            char *name = xmalloc (name_len + 1);
3256
                            memcpy (name, namestring, name_len);
3257
                            name[name_len] = '\0';
3258
                            function_outside_compilation_unit_complaint (name);
3259
                            xfree (name);
3260
                          }
3261
                        sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3262
                        add_psymbol_to_list (namestring, p - namestring, 1,
3263
                                             VAR_DOMAIN, LOC_BLOCK,
3264
                                             &objfile->global_psymbols,
3265
                                             0, sh.value,
3266
                                             psymtab_language, objfile);
3267
                        continue;
3268
 
3269
                        /* Two things show up here (hopefully); static symbols of
3270
                           local scope (static used inside braces) or extensions
3271
                           of structure symbols.  We can ignore both.  */
3272
                      case 'V':
3273
                      case '(':
3274
                      case '0':
3275
                      case '1':
3276
                      case '2':
3277
                      case '3':
3278
                      case '4':
3279
                      case '5':
3280
                      case '6':
3281
                      case '7':
3282
                      case '8':
3283
                      case '9':
3284
                      case '-':
3285
                      case '#':         /* for symbol identification (used in live ranges) */
3286
                        continue;
3287
 
3288
                      case ':':
3289
                        /* It is a C++ nested symbol.  We don't need to record it
3290
                           (I don't think); if we try to look up foo::bar::baz,
3291
                           then symbols for the symtab containing foo should get
3292
                           read in, I think.  */
3293
                        /* Someone says sun cc puts out symbols like
3294
                           /foo/baz/maclib::/usr/local/bin/maclib,
3295
                           which would get here with a symbol type of ':'.  */
3296
                        continue;
3297
 
3298
                      default:
3299
                        /* Unexpected symbol descriptor.  The second and subsequent stabs
3300
                           of a continued stab can show up here.  The question is
3301
                           whether they ever can mimic a normal stab--it would be
3302
                           nice if not, since we certainly don't want to spend the
3303
                           time searching to the end of every string looking for
3304
                           a backslash.  */
3305
 
3306
                        complaint (&symfile_complaints,
3307
                                   _("unknown symbol descriptor `%c'"), p[1]);
3308
 
3309
                        /* Ignore it; perhaps it is an extension that we don't
3310
                           know about.  */
3311
                        continue;
3312
                      }
3313
 
3314
                  case N_EXCL:
3315
                    continue;
3316
 
3317
                  case N_ENDM:
3318
                    /* Solaris 2 end of module, finish current partial
3319
                       symbol table.  END_PSYMTAB will set
3320
                       pst->texthigh to the proper value, which is
3321
                       necessary if a module compiled without
3322
                       debugging info follows this module.  */
3323
                    if (pst
3324
                        && gdbarch_sofun_address_maybe_missing (gdbarch))
3325
                      {
3326
                        pst = (struct partial_symtab *) 0;
3327
                        includes_used = 0;
3328
                        dependencies_used = 0;
3329
                      }
3330
                    continue;
3331
 
3332
                  case N_RBRAC:
3333
                    if (sh.value > save_pst->texthigh)
3334
                      save_pst->texthigh = sh.value;
3335
                    continue;
3336
                  case N_EINCL:
3337
                  case N_DSLINE:
3338
                  case N_BSLINE:
3339
                  case N_SSYM:                  /* Claim: Structure or union element.
3340
                                                   Hopefully, I can ignore this.  */
3341
                  case N_ENTRY:         /* Alternate entry point; can ignore. */
3342
                  case N_MAIN:                  /* Can definitely ignore this.   */
3343
                  case N_CATCH:         /* These are GNU C++ extensions */
3344
                  case N_EHDECL:                /* that can safely be ignored here. */
3345
                  case N_LENG:
3346
                  case N_BCOMM:
3347
                  case N_ECOMM:
3348
                  case N_ECOML:
3349
                  case N_FNAME:
3350
                  case N_SLINE:
3351
                  case N_RSYM:
3352
                  case N_PSYM:
3353
                  case N_LBRAC:
3354
                  case N_NSYMS:         /* Ultrix 4.0: symbol count */
3355
                  case N_DEFD:                  /* GNU Modula-2 */
3356
                  case N_ALIAS:         /* SunPro F77: alias name, ignore for now.  */
3357
 
3358
                  case N_OBJ:                   /* useless types from Solaris */
3359
                  case N_OPT:
3360
                    /* These symbols aren't interesting; don't worry about them */
3361
 
3362
                    continue;
3363
 
3364
                  default:
3365
                    /* If we haven't found it yet, ignore it.  It's probably some
3366
                       new type we don't know about yet.  */
3367
                    complaint (&symfile_complaints, _("unknown symbol type %s"),
3368
                               hex_string (type_code)); /*CUR_SYMBOL_TYPE*/
3369
                    continue;
3370
                  }
3371
                if (stabstring
3372
                    && stabstring != debug_info->ss + fh->issBase + sh.iss)
3373
                  xfree (stabstring);
3374
              }
3375
              /* end - Handle continuation */
3376
            }
3377
        }
3378
      else
3379
        {
3380
          for (cur_sdx = 0; cur_sdx < fh->csym;)
3381
            {
3382
              char *name;
3383
              enum address_class class;
3384
 
3385
              (*swap_sym_in) (cur_bfd,
3386
                              ((char *) debug_info->external_sym
3387
                               + ((fh->isymBase + cur_sdx)
3388
                                  * external_sym_size)),
3389
                              &sh);
3390
 
3391
              if (ECOFF_IS_STAB (&sh))
3392
                {
3393
                  cur_sdx++;
3394
                  continue;
3395
                }
3396
 
3397
              /* Non absolute static symbols go into the minimal table.  */
3398
              if (SC_IS_UNDEF (sh.sc) || sh.sc == scNil
3399
                  || (sh.index == indexNil
3400
                      && (sh.st != stStatic || sh.sc == scAbs)))
3401
                {
3402
                  /* FIXME, premature? */
3403
                  cur_sdx++;
3404
                  continue;
3405
                }
3406
 
3407
              name = debug_info->ss + fh->issBase + sh.iss;
3408
 
3409
              switch (sh.sc)
3410
                {
3411
                case scText:
3412
                case scRConst:
3413
                  /* The value of a stEnd symbol is the displacement from the
3414
                     corresponding start symbol value, do not relocate it.  */
3415
                  if (sh.st != stEnd)
3416
                    sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3417
                  break;
3418
                case scData:
3419
                case scSData:
3420
                case scRData:
3421
                case scPData:
3422
                case scXData:
3423
                  sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
3424
                  break;
3425
                case scBss:
3426
                case scSBss:
3427
                  sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
3428
                  break;
3429
                }
3430
 
3431
              switch (sh.st)
3432
                {
3433
                  CORE_ADDR high;
3434
                  CORE_ADDR procaddr;
3435
                  int new_sdx;
3436
 
3437
                case stStaticProc:
3438
                  prim_record_minimal_symbol_and_info (name, sh.value,
3439
                                                       mst_file_text,
3440
                                                       SECT_OFF_TEXT (objfile), NULL,
3441
                                                       objfile);
3442
 
3443
                  /* FALLTHROUGH */
3444
 
3445
                case stProc:
3446
                  /* Ignore all parameter symbol records.  */
3447
                  if (sh.index >= hdr->iauxMax)
3448
                    {
3449
                      /* Should not happen, but does when cross-compiling
3450
                         with the MIPS compiler.  FIXME -- pull later.  */
3451
                      index_complaint (name);
3452
                      new_sdx = cur_sdx + 1;    /* Don't skip at all */
3453
                    }
3454
                  else
3455
                    new_sdx = AUX_GET_ISYM (fh->fBigendian,
3456
                                            (debug_info->external_aux
3457
                                             + fh->iauxBase
3458
                                             + sh.index));
3459
 
3460
                  if (new_sdx <= cur_sdx)
3461
                    {
3462
                      /* This should not happen either... FIXME.  */
3463
                      complaint (&symfile_complaints,
3464
                                 _("bad proc end in aux found from symbol %s"),
3465
                                 name);
3466
                      new_sdx = cur_sdx + 1;    /* Don't skip backward */
3467
                    }
3468
 
3469
                  /* For stProc symbol records, we need to check the
3470
                     storage class as well, as only (stProc, scText)
3471
                     entries represent "real" procedures - See the
3472
                     Compaq document titled "Object File / Symbol Table
3473
                     Format Specification" for more information.  If the
3474
                     storage class is not scText, we discard the whole
3475
                     block of symbol records for this stProc.  */
3476
                  if (sh.st == stProc && sh.sc != scText)
3477
                    goto skip;
3478
 
3479
                  /* Usually there is a local and a global stProc symbol
3480
                     for a function. This means that the function name
3481
                     has already been entered into the mimimal symbol table
3482
                     while processing the global symbols in pass 2 above.
3483
                     One notable exception is the PROGRAM name from
3484
                     f77 compiled executables, it is only put out as
3485
                     local stProc symbol, and a global MAIN__ stProc symbol
3486
                     points to it.  It doesn't matter though, as gdb is
3487
                     still able to find the PROGRAM name via the partial
3488
                     symbol table, and the MAIN__ symbol via the minimal
3489
                     symbol table.  */
3490
                  if (sh.st == stProc)
3491
                    add_psymbol_to_list (name, strlen (name), 1,
3492
                                         VAR_DOMAIN, LOC_BLOCK,
3493
                                         &objfile->global_psymbols,
3494
                                    0, sh.value, psymtab_language, objfile);
3495
                  else
3496
                    add_psymbol_to_list (name, strlen (name), 1,
3497
                                         VAR_DOMAIN, LOC_BLOCK,
3498
                                         &objfile->static_psymbols,
3499
                                    0, sh.value, psymtab_language, objfile);
3500
 
3501
                  procaddr = sh.value;
3502
 
3503
                  cur_sdx = new_sdx;
3504
                  (*swap_sym_in) (cur_bfd,
3505
                                  ((char *) debug_info->external_sym
3506
                                   + ((fh->isymBase + cur_sdx - 1)
3507
                                      * external_sym_size)),
3508
                                  &sh);
3509
                  if (sh.st != stEnd)
3510
                    continue;
3511
 
3512
                  /* Kludge for Irix 5.2 zero fh->adr.  */
3513
                  if (!relocatable
3514
                      && (pst->textlow == 0 || procaddr < pst->textlow))
3515
                    pst->textlow = procaddr;
3516
 
3517
                  high = procaddr + sh.value;
3518
                  if (high > pst->texthigh)
3519
                    pst->texthigh = high;
3520
                  continue;
3521
 
3522
                case stStatic:  /* Variable */
3523
                  if (SC_IS_DATA (sh.sc))
3524
                    prim_record_minimal_symbol_and_info (name, sh.value,
3525
                                                         mst_file_data,
3526
                                                         SECT_OFF_DATA (objfile),
3527
                                                         NULL,
3528
                                                         objfile);
3529
                  else
3530
                    prim_record_minimal_symbol_and_info (name, sh.value,
3531
                                                         mst_file_bss,
3532
                                                         SECT_OFF_BSS (objfile),
3533
                                                         NULL,
3534
                                                         objfile);
3535
                  class = LOC_STATIC;
3536
                  break;
3537
 
3538
                case stIndirect:        /* Irix5 forward declaration */
3539
                  /* Skip forward declarations from Irix5 cc */
3540
                  goto skip;
3541
 
3542
                case stTypedef: /* Typedef */
3543
                  /* Skip typedefs for forward declarations and opaque
3544
                     structs from alpha and mips cc.  */
3545
                  if (sh.iss == 0 || has_opaque_xref (fh, &sh))
3546
                    goto skip;
3547
                  class = LOC_TYPEDEF;
3548
                  break;
3549
 
3550
                case stConstant:        /* Constant decl */
3551
                  class = LOC_CONST;
3552
                  break;
3553
 
3554
                case stUnion:
3555
                case stStruct:
3556
                case stEnum:
3557
                case stBlock:   /* { }, str, un, enum */
3558
                  /* Do not create a partial symbol for cc unnamed aggregates
3559
                     and gcc empty aggregates. */
3560
                  if ((sh.sc == scInfo
3561
                       || SC_IS_COMMON (sh.sc))
3562
                      && sh.iss != 0
3563
                      && sh.index != cur_sdx + 2)
3564
                    {
3565
                      add_psymbol_to_list (name, strlen (name), 1,
3566
                                           STRUCT_DOMAIN, LOC_TYPEDEF,
3567
                                           &objfile->static_psymbols,
3568
                                           0, (CORE_ADDR) 0,
3569
                                           psymtab_language, objfile);
3570
                    }
3571
                  handle_psymbol_enumerators (objfile, fh, sh.st, sh.value);
3572
 
3573
                  /* Skip over the block */
3574
                  new_sdx = sh.index;
3575
                  if (new_sdx <= cur_sdx)
3576
                    {
3577
                      /* This happens with the Ultrix kernel. */
3578
                      complaint (&symfile_complaints,
3579
                                 _("bad aux index at block symbol %s"), name);
3580
                      new_sdx = cur_sdx + 1;    /* Don't skip backward */
3581
                    }
3582
                  cur_sdx = new_sdx;
3583
                  continue;
3584
 
3585
                case stFile:    /* File headers */
3586
                case stLabel:   /* Labels */
3587
                case stEnd:     /* Ends of files */
3588
                  goto skip;
3589
 
3590
                case stLocal:   /* Local variables */
3591
                  /* Normally these are skipped because we skip over
3592
                     all blocks we see.  However, these can occur
3593
                     as visible symbols in a .h file that contains code. */
3594
                  goto skip;
3595
 
3596
                default:
3597
                  /* Both complaints are valid:  one gives symbol name,
3598
                     the other the offending symbol type.  */
3599
                  complaint (&symfile_complaints, _("unknown local symbol %s"),
3600
                             name);
3601
                  complaint (&symfile_complaints, _("with type %d"), sh.st);
3602
                  cur_sdx++;
3603
                  continue;
3604
                }
3605
              /* Use this gdb symbol */
3606
              add_psymbol_to_list (name, strlen (name), 1,
3607
                                   VAR_DOMAIN, class,
3608
                                   &objfile->static_psymbols,
3609
                                   0, sh.value, psymtab_language, objfile);
3610
            skip:
3611
              cur_sdx++;        /* Go to next file symbol */
3612
            }
3613
 
3614
          /* Now do enter the external symbols. */
3615
          ext_ptr = &extern_tab[fdr_to_pst[f_idx].globals_offset];
3616
          cur_sdx = fdr_to_pst[f_idx].n_globals;
3617
          PST_PRIVATE (save_pst)->extern_count = cur_sdx;
3618
          PST_PRIVATE (save_pst)->extern_tab = ext_ptr;
3619
          for (; --cur_sdx >= 0; ext_ptr++)
3620
            {
3621
              enum address_class class;
3622
              SYMR *psh;
3623
              char *name;
3624
              CORE_ADDR svalue;
3625
 
3626
              if (ext_ptr->ifd != f_idx)
3627
                internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
3628
              psh = &ext_ptr->asym;
3629
 
3630
              /* Do not add undefined symbols to the partial symbol table.  */
3631
              if (SC_IS_UNDEF (psh->sc) || psh->sc == scNil)
3632
                continue;
3633
 
3634
              svalue = psh->value;
3635
              switch (psh->sc)
3636
                {
3637
                case scText:
3638
                case scRConst:
3639
                  svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3640
                  break;
3641
                case scData:
3642
                case scSData:
3643
                case scRData:
3644
                case scPData:
3645
                case scXData:
3646
                  svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
3647
                  break;
3648
                case scBss:
3649
                case scSBss:
3650
                  svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
3651
                  break;
3652
                }
3653
 
3654
              switch (psh->st)
3655
                {
3656
                case stNil:
3657
                  /* These are generated for static symbols in .o files,
3658
                     ignore them.  */
3659
                  continue;
3660
                case stProc:
3661
                case stStaticProc:
3662
                  /* External procedure symbols have been entered
3663
                     into the minimal symbol table in pass 2 above.
3664
                     Ignore them, as parse_external will ignore them too.  */
3665
                  continue;
3666
                case stLabel:
3667
                  class = LOC_LABEL;
3668
                  break;
3669
                default:
3670
                  unknown_ext_complaint (debug_info->ssext + psh->iss);
3671
                  /* Fall through, pretend it's global.  */
3672
                case stGlobal:
3673
                  /* Global common symbols are resolved by the runtime loader,
3674
                     ignore them.  */
3675
                  if (SC_IS_COMMON (psh->sc))
3676
                    continue;
3677
 
3678
                  class = LOC_STATIC;
3679
                  break;
3680
                }
3681
              name = debug_info->ssext + psh->iss;
3682
              add_psymbol_to_list (name, strlen (name), 1,
3683
                                   VAR_DOMAIN, class,
3684
                                   &objfile->global_psymbols,
3685
                                   0, svalue,
3686
                                   psymtab_language, objfile);
3687
            }
3688
        }
3689
 
3690
      /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
3691
         empty and put on the free list.  */
3692
      fdr_to_pst[f_idx].pst = end_psymtab (save_pst,
3693
                                        psymtab_include_list, includes_used,
3694
                                           -1, save_pst->texthigh,
3695
                       dependency_list, dependencies_used, textlow_not_set);
3696
      includes_used = 0;
3697
      dependencies_used = 0;
3698
 
3699
      /* The objfile has its functions reordered if this partial symbol
3700
         table overlaps any other partial symbol table.
3701
         We cannot assume a reordered objfile if a partial symbol table
3702
         is contained within another partial symbol table, as partial symbol
3703
         tables for include files with executable code are contained
3704
         within the partial symbol table for the including source file,
3705
         and we do not want to flag the objfile reordered for these cases.
3706
 
3707
         This strategy works well for Irix-5.2 shared libraries, but we
3708
         might have to use a more elaborate (and slower) algorithm for
3709
         other cases.  */
3710
      save_pst = fdr_to_pst[f_idx].pst;
3711
      if (save_pst != NULL
3712
          && save_pst->textlow != 0
3713
          && !(objfile->flags & OBJF_REORDERED))
3714
        {
3715
          ALL_OBJFILE_PSYMTABS (objfile, pst)
3716
          {
3717
            if (save_pst != pst
3718
                && save_pst->textlow >= pst->textlow
3719
                && save_pst->textlow < pst->texthigh
3720
                && save_pst->texthigh > pst->texthigh)
3721
              {
3722
                objfile->flags |= OBJF_REORDERED;
3723
                break;
3724
              }
3725
          }
3726
        }
3727
    }
3728
 
3729
  /* Now scan the FDRs for dependencies */
3730
  for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
3731
    {
3732
      fh = f_idx + debug_info->fdr;
3733
      pst = fdr_to_pst[f_idx].pst;
3734
 
3735
      if (pst == (struct partial_symtab *) NULL)
3736
        continue;
3737
 
3738
      /* This should catch stabs-in-ecoff. */
3739
      if (fh->crfd <= 1)
3740
        continue;
3741
 
3742
      /* Skip the first file indirect entry as it is a self dependency
3743
         for source files or a reverse .h -> .c dependency for header files.  */
3744
      pst->number_of_dependencies = 0;
3745
      pst->dependencies =
3746
        ((struct partial_symtab **)
3747
         obstack_alloc (&objfile->objfile_obstack,
3748
                        ((fh->crfd - 1)
3749
                         * sizeof (struct partial_symtab *))));
3750
      for (s_idx = 1; s_idx < fh->crfd; s_idx++)
3751
        {
3752
          RFDT rh;
3753
 
3754
          (*swap_rfd_in) (cur_bfd,
3755
                          ((char *) debug_info->external_rfd
3756
                           + (fh->rfdBase + s_idx) * external_rfd_size),
3757
                          &rh);
3758
          if (rh < 0 || rh >= hdr->ifdMax)
3759
            {
3760
              complaint (&symfile_complaints, _("bad file number %ld"), rh);
3761
              continue;
3762
            }
3763
 
3764
          /* Skip self dependencies of header files.  */
3765
          if (rh == f_idx)
3766
            continue;
3767
 
3768
          /* Do not add to dependeny list if psymtab was empty.  */
3769
          if (fdr_to_pst[rh].pst == (struct partial_symtab *) NULL)
3770
            continue;
3771
          pst->dependencies[pst->number_of_dependencies++] = fdr_to_pst[rh].pst;
3772
        }
3773
    }
3774
 
3775
  /* Remove the dummy psymtab created for -O3 images above, if it is
3776
     still empty, to enable the detection of stripped executables.  */
3777
  if (objfile->psymtabs->next == NULL
3778
      && objfile->psymtabs->number_of_dependencies == 0
3779
      && objfile->psymtabs->n_global_syms == 0
3780
      && objfile->psymtabs->n_static_syms == 0)
3781
    objfile->psymtabs = NULL;
3782
  do_cleanups (old_chain);
3783
}
3784
 
3785
/* If the current psymbol has an enumerated type, we need to add
3786
   all the the enum constants to the partial symbol table.  */
3787
 
3788
static void
3789
handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype,
3790
                            CORE_ADDR svalue)
3791
{
3792
  const bfd_size_type external_sym_size = debug_swap->external_sym_size;
3793
  void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
3794
  char *ext_sym = ((char *) debug_info->external_sym
3795
                   + ((fh->isymBase + cur_sdx + 1) * external_sym_size));
3796
  SYMR sh;
3797
  TIR tir;
3798
 
3799
  switch (stype)
3800
    {
3801
    case stEnum:
3802
      break;
3803
 
3804
    case stBlock:
3805
      /* It is an enumerated type if the next symbol entry is a stMember
3806
         and its auxiliary index is indexNil or its auxiliary entry
3807
         is a plain btNil or btVoid.
3808
         Alpha cc -migrate enums are recognized by a zero index and
3809
         a zero symbol value.
3810
         DU 4.0 cc enums are recognized by a member type of btEnum without
3811
         qualifiers and a zero symbol value.  */
3812
      (*swap_sym_in) (cur_bfd, ext_sym, &sh);
3813
      if (sh.st != stMember)
3814
        return;
3815
 
3816
      if (sh.index == indexNil
3817
          || (sh.index == 0 && svalue == 0))
3818
        break;
3819
      (*debug_swap->swap_tir_in) (fh->fBigendian,
3820
                                  &(debug_info->external_aux
3821
                                    + fh->iauxBase + sh.index)->a_ti,
3822
                                  &tir);
3823
      if ((tir.bt != btNil
3824
           && tir.bt != btVoid
3825
           && (tir.bt != btEnum || svalue != 0))
3826
          || tir.tq0 != tqNil)
3827
        return;
3828
      break;
3829
 
3830
    default:
3831
      return;
3832
    }
3833
 
3834
  for (;;)
3835
    {
3836
      char *name;
3837
 
3838
      (*swap_sym_in) (cur_bfd, ext_sym, &sh);
3839
      if (sh.st != stMember)
3840
        break;
3841
      name = debug_info->ss + cur_fdr->issBase + sh.iss;
3842
 
3843
      /* Note that the value doesn't matter for enum constants
3844
         in psymtabs, just in symtabs.  */
3845
      add_psymbol_to_list (name, strlen (name), 1,
3846
                           VAR_DOMAIN, LOC_CONST,
3847
                           &objfile->static_psymbols, 0,
3848
                           (CORE_ADDR) 0, psymtab_language, objfile);
3849
      ext_sym += external_sym_size;
3850
    }
3851
}
3852
 
3853
/* Get the next symbol.  OBJFILE is unused. */
3854
 
3855
static char *
3856
mdebug_next_symbol_text (struct objfile *objfile)
3857
{
3858
  SYMR sh;
3859
 
3860
  cur_sdx++;
3861
  (*debug_swap->swap_sym_in) (cur_bfd,
3862
                              ((char *) debug_info->external_sym
3863
                               + ((cur_fdr->isymBase + cur_sdx)
3864
                                  * debug_swap->external_sym_size)),
3865
                              &sh);
3866
  return debug_info->ss + cur_fdr->issBase + sh.iss;
3867
}
3868
 
3869
/* Ancillary function to psymtab_to_symtab().  Does all the work
3870
   for turning the partial symtab PST into a symtab, recurring
3871
   first on all dependent psymtabs.  The argument FILENAME is
3872
   only passed so we can see in debug stack traces what file
3873
   is being read.
3874
 
3875
   This function has a split personality, based on whether the
3876
   symbol table contains ordinary ecoff symbols, or stabs-in-ecoff.
3877
   The flow of control and even the memory allocation differs.  FIXME.  */
3878
 
3879
static void
3880
psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
3881
{
3882
  bfd_size_type external_sym_size;
3883
  bfd_size_type external_pdr_size;
3884
  void (*swap_sym_in) (bfd *, void *, SYMR *);
3885
  void (*swap_pdr_in) (bfd *, void *, PDR *);
3886
  int i;
3887
  struct symtab *st = NULL;
3888
  FDR *fh;
3889
  struct linetable *lines;
3890
  CORE_ADDR lowest_pdr_addr = 0;
3891
  int last_symtab_ended = 0;
3892
 
3893
  if (pst->readin)
3894
    return;
3895
  pst->readin = 1;
3896
 
3897
  /* Read in all partial symbtabs on which this one is dependent.
3898
     NOTE that we do have circular dependencies, sigh.  We solved
3899
     that by setting pst->readin before this point.  */
3900
 
3901
  for (i = 0; i < pst->number_of_dependencies; i++)
3902
    if (!pst->dependencies[i]->readin)
3903
      {
3904
        /* Inform about additional files to be read in.  */
3905
        if (info_verbose)
3906
          {
3907
            fputs_filtered (" ", gdb_stdout);
3908
            wrap_here ("");
3909
            fputs_filtered ("and ", gdb_stdout);
3910
            wrap_here ("");
3911
            printf_filtered ("%s...",
3912
                             pst->dependencies[i]->filename);
3913
            wrap_here ("");     /* Flush output */
3914
            gdb_flush (gdb_stdout);
3915
          }
3916
        /* We only pass the filename for debug purposes */
3917
        psymtab_to_symtab_1 (pst->dependencies[i],
3918
                             pst->dependencies[i]->filename);
3919
      }
3920
 
3921
  /* Do nothing if this is a dummy psymtab.  */
3922
 
3923
  if (pst->n_global_syms == 0 && pst->n_static_syms == 0
3924
      && pst->textlow == 0 && pst->texthigh == 0)
3925
    return;
3926
 
3927
  /* Now read the symbols for this symtab */
3928
 
3929
  cur_bfd = CUR_BFD (pst);
3930
  debug_swap = DEBUG_SWAP (pst);
3931
  debug_info = DEBUG_INFO (pst);
3932
  pending_list = PENDING_LIST (pst);
3933
  external_sym_size = debug_swap->external_sym_size;
3934
  external_pdr_size = debug_swap->external_pdr_size;
3935
  swap_sym_in = debug_swap->swap_sym_in;
3936
  swap_pdr_in = debug_swap->swap_pdr_in;
3937
  current_objfile = pst->objfile;
3938
  cur_fd = FDR_IDX (pst);
3939
  fh = ((cur_fd == -1)
3940
        ? (FDR *) NULL
3941
        : debug_info->fdr + cur_fd);
3942
  cur_fdr = fh;
3943
 
3944
  /* See comment in parse_partial_symbols about the @stabs sentinel. */
3945
  processing_gcc_compilation = 0;
3946
  if (fh != (FDR *) NULL && fh->csym >= 2)
3947
    {
3948
      SYMR sh;
3949
 
3950
      (*swap_sym_in) (cur_bfd,
3951
                      ((char *) debug_info->external_sym
3952
                       + (fh->isymBase + 1) * external_sym_size),
3953
                      &sh);
3954
      if (strcmp (debug_info->ss + fh->issBase + sh.iss,
3955
                  stabs_symbol) == 0)
3956
        {
3957
          /* We indicate that this is a GCC compilation so that certain
3958
             features will be enabled in stabsread/dbxread.  */
3959
          processing_gcc_compilation = 2;
3960
        }
3961
    }
3962
 
3963
  if (processing_gcc_compilation != 0)
3964
    {
3965
      struct gdbarch *gdbarch = get_objfile_arch (pst->objfile);
3966
 
3967
      /* This symbol table contains stabs-in-ecoff entries.  */
3968
 
3969
      /* Parse local symbols first */
3970
 
3971
      if (fh->csym <= 2)        /* FIXME, this blows psymtab->symtab ptr */
3972
        {
3973
          current_objfile = NULL;
3974
          return;
3975
        }
3976
      for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
3977
        {
3978
          SYMR sh;
3979
          char *name;
3980
          CORE_ADDR valu;
3981
 
3982
          (*swap_sym_in) (cur_bfd,
3983
                          (((char *) debug_info->external_sym)
3984
                           + (fh->isymBase + cur_sdx) * external_sym_size),
3985
                          &sh);
3986
          name = debug_info->ss + fh->issBase + sh.iss;
3987
          valu = sh.value;
3988
          /* XXX This is a hack.  It will go away!  */
3989
          if (ECOFF_IS_STAB (&sh) || (name[0] == '#'))
3990
            {
3991
              int type_code = ECOFF_UNMARK_STAB (sh.index);
3992
 
3993
              /* We should never get non N_STAB symbols here, but they
3994
                 should be harmless, so keep process_one_symbol from
3995
                 complaining about them.  */
3996
              if (type_code & N_STAB)
3997
                {
3998
                  /* If we found a trailing N_SO with no name, process
3999
                     it here instead of in process_one_symbol, so we
4000
                     can keep a handle to its symtab.  The symtab
4001
                     would otherwise be ended twice, once in
4002
                     process_one_symbol, and once after this loop. */
4003
                  if (type_code == N_SO
4004
                      && last_source_file
4005
                      && previous_stab_code != (unsigned char) N_SO
4006
                      && *name == '\000')
4007
                    {
4008
                      valu += ANOFFSET (pst->section_offsets,
4009
                                        SECT_OFF_TEXT (pst->objfile));
4010
                      previous_stab_code = N_SO;
4011
                      st = end_symtab (valu, pst->objfile,
4012
                                       SECT_OFF_TEXT (pst->objfile));
4013
                      end_stabs ();
4014
                      last_symtab_ended = 1;
4015
                    }
4016
                  else
4017
                    {
4018
                      last_symtab_ended = 0;
4019
                      process_one_symbol (type_code, 0, valu, name,
4020
                                          pst->section_offsets, pst->objfile);
4021
                    }
4022
                }
4023
              /* Similarly a hack.  */
4024
              else if (name[0] == '#')
4025
                {
4026
                  process_one_symbol (N_SLINE, 0, valu, name,
4027
                                      pst->section_offsets, pst->objfile);
4028
                }
4029
              if (type_code == N_FUN)
4030
                {
4031
                  /* Make up special symbol to contain
4032
                     procedure specific info */
4033
                  struct mdebug_extra_func_info *e =
4034
                  ((struct mdebug_extra_func_info *)
4035
                   obstack_alloc (&current_objfile->objfile_obstack,
4036
                                  sizeof (struct mdebug_extra_func_info)));
4037
                  struct symbol *s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
4038
 
4039
                  memset (e, 0, sizeof (struct mdebug_extra_func_info));
4040
                  SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
4041
                  SYMBOL_CLASS (s) = LOC_CONST;
4042
                  SYMBOL_TYPE (s) = objfile_type (pst->objfile)->builtin_void;
4043
                  SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
4044
                  e->pdr.framereg = -1;
4045
                  add_symbol_to_list (s, &local_symbols);
4046
                }
4047
            }
4048
          else if (sh.st == stLabel)
4049
            {
4050
              if (sh.index == indexNil)
4051
                {
4052
                  /* This is what the gcc2_compiled and __gnu_compiled_*
4053
                     show up as.  So don't complain.  */
4054
                  ;
4055
                }
4056
              else
4057
                {
4058
                  /* Handle encoded stab line number. */
4059
                  valu += ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile));
4060
                  record_line (current_subfile, sh.index,
4061
                               gdbarch_addr_bits_remove (gdbarch, valu));
4062
                }
4063
            }
4064
          else if (sh.st == stProc || sh.st == stStaticProc
4065
                   || sh.st == stStatic || sh.st == stEnd)
4066
            /* These are generated by gcc-2.x, do not complain */
4067
            ;
4068
          else
4069
            complaint (&symfile_complaints, _("unknown stabs symbol %s"), name);
4070
        }
4071
 
4072
      if (! last_symtab_ended)
4073
        {
4074
          st = end_symtab (pst->texthigh, pst->objfile, SECT_OFF_TEXT (pst->objfile));
4075
          end_stabs ();
4076
        }
4077
 
4078
      /* There used to be a call to sort_blocks here, but this should not
4079
         be necessary for stabs symtabs.  And as sort_blocks modifies the
4080
         start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
4081
         it did the wrong thing if the first procedure in a file was
4082
         generated via asm statements.  */
4083
 
4084
      /* Fill in procedure info next.  */
4085
      if (fh->cpd > 0)
4086
        {
4087
          PDR *pr_block;
4088
          struct cleanup *old_chain;
4089
          char *pdr_ptr;
4090
          char *pdr_end;
4091
          PDR *pdr_in;
4092
          PDR *pdr_in_end;
4093
 
4094
          pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
4095
          old_chain = make_cleanup (xfree, pr_block);
4096
 
4097
          pdr_ptr = ((char *) debug_info->external_pdr
4098
                     + fh->ipdFirst * external_pdr_size);
4099
          pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
4100
          pdr_in = pr_block;
4101
          for (;
4102
               pdr_ptr < pdr_end;
4103
               pdr_ptr += external_pdr_size, pdr_in++)
4104
            {
4105
              (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
4106
 
4107
              /* Determine lowest PDR address, the PDRs are not always
4108
                 sorted.  */
4109
              if (pdr_in == pr_block)
4110
                lowest_pdr_addr = pdr_in->adr;
4111
              else if (pdr_in->adr < lowest_pdr_addr)
4112
                lowest_pdr_addr = pdr_in->adr;
4113
            }
4114
 
4115
          pdr_in = pr_block;
4116
          pdr_in_end = pdr_in + fh->cpd;
4117
          for (; pdr_in < pdr_in_end; pdr_in++)
4118
            parse_procedure (pdr_in, st, pst);
4119
 
4120
          do_cleanups (old_chain);
4121
        }
4122
    }
4123
  else
4124
    {
4125
      /* This symbol table contains ordinary ecoff entries.  */
4126
 
4127
      int f_max;
4128
      int maxlines;
4129
      EXTR *ext_ptr;
4130
 
4131
      if (fh == 0)
4132
        {
4133
          maxlines = 0;
4134
          st = new_symtab ("unknown", 0, pst->objfile);
4135
        }
4136
      else
4137
        {
4138
          maxlines = 2 * fh->cline;
4139
          st = new_symtab (pst->filename, maxlines, pst->objfile);
4140
 
4141
          /* The proper language was already determined when building
4142
             the psymtab, use it.  */
4143
          st->language = PST_PRIVATE (pst)->pst_language;
4144
        }
4145
 
4146
      psymtab_language = st->language;
4147
 
4148
      lines = LINETABLE (st);
4149
 
4150
      /* Get a new lexical context */
4151
 
4152
      push_parse_stack ();
4153
      top_stack->cur_st = st;
4154
      top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (st),
4155
                                                STATIC_BLOCK);
4156
      BLOCK_START (top_stack->cur_block) = pst->textlow;
4157
      BLOCK_END (top_stack->cur_block) = 0;
4158
      top_stack->blocktype = stFile;
4159
      top_stack->cur_type = 0;
4160
      top_stack->procadr = 0;
4161
      top_stack->numargs = 0;
4162
      found_ecoff_debugging_info = 0;
4163
 
4164
      if (fh)
4165
        {
4166
          char *sym_ptr;
4167
          char *sym_end;
4168
 
4169
          /* Parse local symbols first */
4170
          sym_ptr = ((char *) debug_info->external_sym
4171
                     + fh->isymBase * external_sym_size);
4172
          sym_end = sym_ptr + fh->csym * external_sym_size;
4173
          while (sym_ptr < sym_end)
4174
            {
4175
              SYMR sh;
4176
              int c;
4177
 
4178
              (*swap_sym_in) (cur_bfd, sym_ptr, &sh);
4179
              c = parse_symbol (&sh,
4180
                                debug_info->external_aux + fh->iauxBase,
4181
                                sym_ptr, fh->fBigendian, pst->section_offsets, pst->objfile);
4182
              sym_ptr += c * external_sym_size;
4183
            }
4184
 
4185
          /* Linenumbers.  At the end, check if we can save memory.
4186
             parse_lines has to look ahead an arbitrary number of PDR
4187
             structures, so we swap them all first.  */
4188
          if (fh->cpd > 0)
4189
            {
4190
              PDR *pr_block;
4191
              struct cleanup *old_chain;
4192
              char *pdr_ptr;
4193
              char *pdr_end;
4194
              PDR *pdr_in;
4195
              PDR *pdr_in_end;
4196
 
4197
              pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
4198
 
4199
              old_chain = make_cleanup (xfree, pr_block);
4200
 
4201
              pdr_ptr = ((char *) debug_info->external_pdr
4202
                         + fh->ipdFirst * external_pdr_size);
4203
              pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
4204
              pdr_in = pr_block;
4205
              for (;
4206
                   pdr_ptr < pdr_end;
4207
                   pdr_ptr += external_pdr_size, pdr_in++)
4208
                {
4209
                  (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
4210
 
4211
                  /* Determine lowest PDR address, the PDRs are not always
4212
                     sorted.  */
4213
                  if (pdr_in == pr_block)
4214
                    lowest_pdr_addr = pdr_in->adr;
4215
                  else if (pdr_in->adr < lowest_pdr_addr)
4216
                    lowest_pdr_addr = pdr_in->adr;
4217
                }
4218
 
4219
              parse_lines (fh, pr_block, lines, maxlines, pst, lowest_pdr_addr);
4220
              if (lines->nitems < fh->cline)
4221
                lines = shrink_linetable (lines);
4222
 
4223
              /* Fill in procedure info next.  */
4224
              pdr_in = pr_block;
4225
              pdr_in_end = pdr_in + fh->cpd;
4226
              for (; pdr_in < pdr_in_end; pdr_in++)
4227
                parse_procedure (pdr_in, 0, pst);
4228
 
4229
              do_cleanups (old_chain);
4230
            }
4231
        }
4232
 
4233
      LINETABLE (st) = lines;
4234
 
4235
      /* .. and our share of externals.
4236
         XXX use the global list to speed up things here. how?
4237
         FIXME, Maybe quit once we have found the right number of ext's? */
4238
      top_stack->cur_st = st;
4239
      top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
4240
                                                GLOBAL_BLOCK);
4241
      top_stack->blocktype = stFile;
4242
 
4243
      ext_ptr = PST_PRIVATE (pst)->extern_tab;
4244
      for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
4245
        parse_external (ext_ptr, fh->fBigendian, pst->section_offsets, pst->objfile);
4246
 
4247
      /* If there are undefined symbols, tell the user.
4248
         The alpha has an undefined symbol for every symbol that is
4249
         from a shared library, so tell the user only if verbose is on.  */
4250
      if (info_verbose && n_undef_symbols)
4251
        {
4252
          printf_filtered (_("File %s contains %d unresolved references:"),
4253
                           st->filename, n_undef_symbols);
4254
          printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
4255
                           n_undef_vars, n_undef_procs, n_undef_labels);
4256
          n_undef_symbols = n_undef_labels = n_undef_vars = n_undef_procs = 0;
4257
 
4258
        }
4259
      pop_parse_stack ();
4260
 
4261
      st->primary = 1;
4262
 
4263
      sort_blocks (st);
4264
    }
4265
 
4266
  /* Now link the psymtab and the symtab.  */
4267
  pst->symtab = st;
4268
 
4269
  current_objfile = NULL;
4270
}
4271
 
4272
/* Ancillary parsing procedures. */
4273
 
4274
/* Return 1 if the symbol pointed to by SH has a cross reference
4275
   to an opaque aggregate type, else 0.  */
4276
 
4277
static int
4278
has_opaque_xref (FDR *fh, SYMR *sh)
4279
{
4280
  TIR tir;
4281
  union aux_ext *ax;
4282
  RNDXR rn[1];
4283
  unsigned int rf;
4284
 
4285
  if (sh->index == indexNil)
4286
    return 0;
4287
 
4288
  ax = debug_info->external_aux + fh->iauxBase + sh->index;
4289
  (*debug_swap->swap_tir_in) (fh->fBigendian, &ax->a_ti, &tir);
4290
  if (tir.bt != btStruct && tir.bt != btUnion && tir.bt != btEnum)
4291
    return 0;
4292
 
4293
  ax++;
4294
  (*debug_swap->swap_rndx_in) (fh->fBigendian, &ax->a_rndx, rn);
4295
  if (rn->rfd == 0xfff)
4296
    rf = AUX_GET_ISYM (fh->fBigendian, ax + 1);
4297
  else
4298
    rf = rn->rfd;
4299
  if (rf != -1)
4300
    return 0;
4301
  return 1;
4302
}
4303
 
4304
/* Lookup the type at relative index RN.  Return it in TPP
4305
   if found and in any event come up with its name PNAME.
4306
   BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
4307
   Return value says how many aux symbols we ate. */
4308
 
4309
static int
4310
cross_ref (int fd, union aux_ext *ax, struct type **tpp, enum type_code type_code,      /* Use to alloc new type if none is found. */
4311
           char **pname, int bigend, char *sym_name)
4312
{
4313
  RNDXR rn[1];
4314
  unsigned int rf;
4315
  int result = 1;
4316
  FDR *fh;
4317
  char *esh;
4318
  SYMR sh;
4319
  int xref_fd;
4320
  struct mdebug_pending *pend;
4321
 
4322
  *tpp = (struct type *) NULL;
4323
 
4324
  (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
4325
 
4326
  /* Escape index means 'the next one' */
4327
  if (rn->rfd == 0xfff)
4328
    {
4329
      result++;
4330
      rf = AUX_GET_ISYM (bigend, ax + 1);
4331
    }
4332
  else
4333
    {
4334
      rf = rn->rfd;
4335
    }
4336
 
4337
  /* mips cc uses a rf of -1 for opaque struct definitions.
4338
     Set TYPE_FLAG_STUB for these types so that check_typedef will
4339
     resolve them if the struct gets defined in another compilation unit.  */
4340
  if (rf == -1)
4341
    {
4342
      *pname = "<undefined>";
4343
      *tpp = init_type (type_code, 0, TYPE_FLAG_STUB, (char *) NULL, current_objfile);
4344
      return result;
4345
    }
4346
 
4347
  /* mips cc uses an escaped rn->index of 0 for struct return types
4348
     of procedures that were compiled without -g. These will always remain
4349
     undefined.  */
4350
  if (rn->rfd == 0xfff && rn->index == 0)
4351
    {
4352
      *pname = "<undefined>";
4353
      return result;
4354
    }
4355
 
4356
  /* Find the relative file descriptor and the symbol in it.  */
4357
  fh = get_rfd (fd, rf);
4358
  xref_fd = fh - debug_info->fdr;
4359
 
4360
  if (rn->index >= fh->csym)
4361
    {
4362
      /* File indirect entry is corrupt.  */
4363
      *pname = "<illegal>";
4364
      bad_rfd_entry_complaint (sym_name, xref_fd, rn->index);
4365
      return result;
4366
    }
4367
 
4368
  /* If we have processed this symbol then we left a forwarding
4369
     pointer to the type in the pending list.  If not, we`ll put
4370
     it in a list of pending types, to be processed later when
4371
     the file will be.  In any event, we collect the name for the
4372
     type here.  */
4373
 
4374
  esh = ((char *) debug_info->external_sym
4375
         + ((fh->isymBase + rn->index)
4376
            * debug_swap->external_sym_size));
4377
  (*debug_swap->swap_sym_in) (cur_bfd, esh, &sh);
4378
 
4379
  /* Make sure that this type of cross reference can be handled.  */
4380
  if ((sh.sc != scInfo
4381
       || (sh.st != stBlock && sh.st != stTypedef && sh.st != stIndirect
4382
           && sh.st != stStruct && sh.st != stUnion
4383
           && sh.st != stEnum))
4384
      && (sh.st != stBlock || !SC_IS_COMMON (sh.sc)))
4385
    {
4386
      /* File indirect entry is corrupt.  */
4387
      *pname = "<illegal>";
4388
      bad_rfd_entry_complaint (sym_name, xref_fd, rn->index);
4389
      return result;
4390
    }
4391
 
4392
  *pname = debug_info->ss + fh->issBase + sh.iss;
4393
 
4394
  pend = is_pending_symbol (fh, esh);
4395
  if (pend)
4396
    *tpp = pend->t;
4397
  else
4398
    {
4399
      /* We have not yet seen this type.  */
4400
 
4401
      if ((sh.iss == 0 && sh.st == stTypedef) || sh.st == stIndirect)
4402
        {
4403
          TIR tir;
4404
 
4405
          /* alpha cc puts out a stTypedef with a sh.iss of zero for
4406
             two cases:
4407
             a) forward declarations of structs/unions/enums which are not
4408
             defined in this compilation unit.
4409
             For these the type will be void. This is a bad design decision
4410
             as cross referencing across compilation units is impossible
4411
             due to the missing name.
4412
             b) forward declarations of structs/unions/enums/typedefs which
4413
             are defined later in this file or in another file in the same
4414
             compilation unit. Irix5 cc uses a stIndirect symbol for this.
4415
             Simply cross reference those again to get the true type.
4416
             The forward references are not entered in the pending list and
4417
             in the symbol table.  */
4418
 
4419
          (*debug_swap->swap_tir_in) (bigend,
4420
                                      &(debug_info->external_aux
4421
                                        + fh->iauxBase + sh.index)->a_ti,
4422
                                      &tir);
4423
          if (tir.tq0 != tqNil)
4424
            complaint (&symfile_complaints,
4425
                       _("illegal tq0 in forward typedef for %s"), sym_name);
4426
          switch (tir.bt)
4427
            {
4428
            case btVoid:
4429
              *tpp = init_type (type_code, 0, 0, (char *) NULL,
4430
                                current_objfile);
4431
              *pname = "<undefined>";
4432
              break;
4433
 
4434
            case btStruct:
4435
            case btUnion:
4436
            case btEnum:
4437
              cross_ref (xref_fd,
4438
                         (debug_info->external_aux
4439
                          + fh->iauxBase + sh.index + 1),
4440
                         tpp, type_code, pname,
4441
                         fh->fBigendian, sym_name);
4442
              break;
4443
 
4444
            case btTypedef:
4445
              /* Follow a forward typedef. This might recursively
4446
                 call cross_ref till we get a non typedef'ed type.
4447
                 FIXME: This is not correct behaviour, but gdb currently
4448
                 cannot handle typedefs without type copying. Type
4449
                 copying is impossible as we might have mutual forward
4450
                 references between two files and the copied type would not
4451
                 get filled in when we later parse its definition.  */
4452
              *tpp = parse_type (xref_fd,
4453
                                 debug_info->external_aux + fh->iauxBase,
4454
                                 sh.index,
4455
                                 (int *) NULL,
4456
                                 fh->fBigendian,
4457
                                 debug_info->ss + fh->issBase + sh.iss);
4458
              add_pending (fh, esh, *tpp);
4459
              break;
4460
 
4461
            default:
4462
              complaint (&symfile_complaints,
4463
                         _("illegal bt %d in forward typedef for %s"), tir.bt,
4464
                         sym_name);
4465
              *tpp = init_type (type_code, 0, 0, (char *) NULL,
4466
                                current_objfile);
4467
              break;
4468
            }
4469
          return result;
4470
        }
4471
      else if (sh.st == stTypedef)
4472
        {
4473
          /* Parse the type for a normal typedef. This might recursively call
4474
             cross_ref till we get a non typedef'ed type.
4475
             FIXME: This is not correct behaviour, but gdb currently
4476
             cannot handle typedefs without type copying. But type copying is
4477
             impossible as we might have mutual forward references between
4478
             two files and the copied type would not get filled in when
4479
             we later parse its definition.   */
4480
          *tpp = parse_type (xref_fd,
4481
                             debug_info->external_aux + fh->iauxBase,
4482
                             sh.index,
4483
                             (int *) NULL,
4484
                             fh->fBigendian,
4485
                             debug_info->ss + fh->issBase + sh.iss);
4486
        }
4487
      else
4488
        {
4489
          /* Cross reference to a struct/union/enum which is defined
4490
             in another file in the same compilation unit but that file
4491
             has not been parsed yet.
4492
             Initialize the type only, it will be filled in when
4493
             it's definition is parsed.  */
4494
          *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
4495
        }
4496
      add_pending (fh, esh, *tpp);
4497
    }
4498
 
4499
  /* We used one auxent normally, two if we got a "next one" rf. */
4500
  return result;
4501
}
4502
 
4503
 
4504
/* Quick&dirty lookup procedure, to avoid the MI ones that require
4505
   keeping the symtab sorted */
4506
 
4507
static struct symbol *
4508
mylookup_symbol (char *name, struct block *block,
4509
                 domain_enum domain, enum address_class class)
4510
{
4511
  struct dict_iterator iter;
4512
  int inc;
4513
  struct symbol *sym;
4514
 
4515
  inc = name[0];
4516
  ALL_BLOCK_SYMBOLS (block, iter, sym)
4517
    {
4518
      if (SYMBOL_LINKAGE_NAME (sym)[0] == inc
4519
          && SYMBOL_DOMAIN (sym) == domain
4520
          && SYMBOL_CLASS (sym) == class
4521
          && strcmp (SYMBOL_LINKAGE_NAME (sym), name) == 0)
4522
        return sym;
4523
    }
4524
 
4525
  block = BLOCK_SUPERBLOCK (block);
4526
  if (block)
4527
    return mylookup_symbol (name, block, domain, class);
4528
  return 0;
4529
}
4530
 
4531
 
4532
/* Add a new symbol S to a block B.  */
4533
 
4534
static void
4535
add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
4536
{
4537
  SYMBOL_SYMTAB (s) = symtab;
4538
  dict_add_symbol (BLOCK_DICT (b), s);
4539
}
4540
 
4541
/* Add a new block B to a symtab S */
4542
 
4543
static void
4544
add_block (struct block *b, struct symtab *s)
4545
{
4546
  struct blockvector *bv = BLOCKVECTOR (s);
4547
 
4548
  bv = (struct blockvector *) xrealloc ((void *) bv,
4549
                                        (sizeof (struct blockvector)
4550
                                         + BLOCKVECTOR_NBLOCKS (bv)
4551
                                         * sizeof (bv->block)));
4552
  if (bv != BLOCKVECTOR (s))
4553
    BLOCKVECTOR (s) = bv;
4554
 
4555
  BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)++) = b;
4556
}
4557
 
4558
/* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
4559
   MIPS' linenumber encoding might need more than one byte
4560
   to describe it, LAST is used to detect these continuation lines.
4561
 
4562
   Combining lines with the same line number seems like a bad idea.
4563
   E.g: There could be a line number entry with the same line number after the
4564
   prologue and GDB should not ignore it (this is a better way to find
4565
   a prologue than mips_skip_prologue).
4566
   But due to the compressed line table format there are line number entries
4567
   for the same line which are needed to bridge the gap to the next
4568
   line number entry. These entries have a bogus address info with them
4569
   and we are unable to tell them from intended duplicate line number
4570
   entries.
4571
   This is another reason why -ggdb debugging format is preferable.  */
4572
 
4573
static int
4574
add_line (struct linetable *lt, int lineno, CORE_ADDR adr, int last)
4575
{
4576
  /* DEC c89 sometimes produces zero linenos which confuse gdb.
4577
     Change them to something sensible. */
4578
  if (lineno == 0)
4579
    lineno = 1;
4580
  if (last == 0)
4581
    last = -2;                  /* make sure we record first line */
4582
 
4583
  if (last == lineno)           /* skip continuation lines */
4584
    return lineno;
4585
 
4586
  lt->item[lt->nitems].line = lineno;
4587
  lt->item[lt->nitems++].pc = adr << 2;
4588
  return lineno;
4589
}
4590
 
4591
/* Sorting and reordering procedures */
4592
 
4593
/* Blocks with a smaller low bound should come first */
4594
 
4595
static int
4596
compare_blocks (const void *arg1, const void *arg2)
4597
{
4598
  LONGEST addr_diff;
4599
  struct block **b1 = (struct block **) arg1;
4600
  struct block **b2 = (struct block **) arg2;
4601
 
4602
  addr_diff = (BLOCK_START ((*b1))) - (BLOCK_START ((*b2)));
4603
  if (addr_diff == 0)
4604
    return (BLOCK_END ((*b2))) - (BLOCK_END ((*b1)));
4605
  return addr_diff;
4606
}
4607
 
4608
/* Sort the blocks of a symtab S.
4609
   Reorder the blocks in the blockvector by code-address,
4610
   as required by some MI search routines */
4611
 
4612
static void
4613
sort_blocks (struct symtab *s)
4614
{
4615
  struct blockvector *bv = BLOCKVECTOR (s);
4616
 
4617
  if (BLOCKVECTOR_NBLOCKS (bv) <= 2)
4618
    {
4619
      /* Cosmetic */
4620
      if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) == 0)
4621
        BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = 0;
4622
      if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) == 0)
4623
        BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 0;
4624
      return;
4625
    }
4626
  /*
4627
   * This is very unfortunate: normally all functions are compiled in
4628
   * the order they are found, but if the file is compiled -O3 things
4629
   * are very different.  It would be nice to find a reliable test
4630
   * to detect -O3 images in advance.
4631
   */
4632
  if (BLOCKVECTOR_NBLOCKS (bv) > 3)
4633
    qsort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK),
4634
           BLOCKVECTOR_NBLOCKS (bv) - FIRST_LOCAL_BLOCK,
4635
           sizeof (struct block *),
4636
           compare_blocks);
4637
 
4638
  {
4639
    CORE_ADDR high = 0;
4640
    int i, j = BLOCKVECTOR_NBLOCKS (bv);
4641
 
4642
    for (i = FIRST_LOCAL_BLOCK; i < j; i++)
4643
      if (high < BLOCK_END (BLOCKVECTOR_BLOCK (bv, i)))
4644
        high = BLOCK_END (BLOCKVECTOR_BLOCK (bv, i));
4645
    BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = high;
4646
  }
4647
 
4648
  BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) =
4649
    BLOCK_START (BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK));
4650
 
4651
  BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
4652
    BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
4653
  BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
4654
    BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
4655
}
4656
 
4657
 
4658
/* Constructor/restructor/destructor procedures */
4659
 
4660
/* Allocate a new symtab for NAME.  Needs an estimate of how many
4661
   linenumbers MAXLINES we'll put in it */
4662
 
4663
static struct symtab *
4664
new_symtab (char *name, int maxlines, struct objfile *objfile)
4665
{
4666
  struct symtab *s = allocate_symtab (name, objfile);
4667
 
4668
  LINETABLE (s) = new_linetable (maxlines);
4669
 
4670
  /* All symtabs must have at least two blocks */
4671
  BLOCKVECTOR (s) = new_bvect (2);
4672
  BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK)
4673
    = new_block (NON_FUNCTION_BLOCK);
4674
  BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)
4675
    = new_block (NON_FUNCTION_BLOCK);
4676
  BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) =
4677
    BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
4678
 
4679
  s->free_code = free_linetable;
4680
  s->debugformat = "ECOFF";
4681
  return (s);
4682
}
4683
 
4684
/* Allocate a new partial_symtab NAME */
4685
 
4686
static struct partial_symtab *
4687
new_psymtab (char *name, struct objfile *objfile)
4688
{
4689
  struct partial_symtab *psymtab;
4690
 
4691
  psymtab = allocate_psymtab (name, objfile);
4692
  psymtab->section_offsets = objfile->section_offsets;
4693
 
4694
  /* Keep a backpointer to the file's symbols */
4695
 
4696
  psymtab->read_symtab_private = ((char *)
4697
                                  obstack_alloc (&objfile->objfile_obstack,
4698
                                                 sizeof (struct symloc)));
4699
  memset (psymtab->read_symtab_private, 0, sizeof (struct symloc));
4700
  CUR_BFD (psymtab) = cur_bfd;
4701
  DEBUG_SWAP (psymtab) = debug_swap;
4702
  DEBUG_INFO (psymtab) = debug_info;
4703
  PENDING_LIST (psymtab) = pending_list;
4704
 
4705
  /* The way to turn this into a symtab is to call... */
4706
  psymtab->read_symtab = mdebug_psymtab_to_symtab;
4707
  return (psymtab);
4708
}
4709
 
4710
 
4711
/* Allocate a linetable array of the given SIZE.  Since the struct
4712
   already includes one item, we subtract one when calculating the
4713
   proper size to allocate.  */
4714
 
4715
static struct linetable *
4716
new_linetable (int size)
4717
{
4718
  struct linetable *l;
4719
 
4720
  size = (size - 1) * sizeof (l->item) + sizeof (struct linetable);
4721
  l = (struct linetable *) xmalloc (size);
4722
  l->nitems = 0;
4723
  return l;
4724
}
4725
 
4726
/* Oops, too big. Shrink it.  This was important with the 2.4 linetables,
4727
   I am not so sure about the 3.4 ones.
4728
 
4729
   Since the struct linetable already includes one item, we subtract one when
4730
   calculating the proper size to allocate.  */
4731
 
4732
static struct linetable *
4733
shrink_linetable (struct linetable *lt)
4734
{
4735
 
4736
  return (struct linetable *) xrealloc ((void *) lt,
4737
                                        (sizeof (struct linetable)
4738
                                         + ((lt->nitems - 1)
4739
                                            * sizeof (lt->item))));
4740
}
4741
 
4742
/* Allocate and zero a new blockvector of NBLOCKS blocks. */
4743
 
4744
static struct blockvector *
4745
new_bvect (int nblocks)
4746
{
4747
  struct blockvector *bv;
4748
  int size;
4749
 
4750
  size = sizeof (struct blockvector) + nblocks * sizeof (struct block *);
4751
  bv = (struct blockvector *) xzalloc (size);
4752
 
4753
  BLOCKVECTOR_NBLOCKS (bv) = nblocks;
4754
 
4755
  return bv;
4756
}
4757
 
4758
/* Allocate and zero a new block, and set its BLOCK_DICT.  If function
4759
   is non-zero, assume the block is associated to a function, and make
4760
   sure that the symbols are stored linearly; otherwise, store them
4761
   hashed.  */
4762
 
4763
static struct block *
4764
new_block (enum block_type type)
4765
{
4766
  /* FIXME: carlton/2003-09-11: This should use allocate_block to
4767
     allocate the block.  Which, in turn, suggests that the block
4768
     should be allocated on an obstack.  */
4769
  struct block *retval = xzalloc (sizeof (struct block));
4770
 
4771
  if (type == FUNCTION_BLOCK)
4772
    BLOCK_DICT (retval) = dict_create_linear_expandable ();
4773
  else
4774
    BLOCK_DICT (retval) = dict_create_hashed_expandable ();
4775
 
4776
  return retval;
4777
}
4778
 
4779
/* Create a new symbol with printname NAME */
4780
 
4781
static struct symbol *
4782
new_symbol (char *name)
4783
{
4784
  struct symbol *s = ((struct symbol *)
4785
                      obstack_alloc (&current_objfile->objfile_obstack,
4786
                                     sizeof (struct symbol)));
4787
 
4788
  memset (s, 0, sizeof (*s));
4789
  SYMBOL_LANGUAGE (s) = psymtab_language;
4790
  SYMBOL_SET_NAMES (s, name, strlen (name), 1, current_objfile);
4791
  return s;
4792
}
4793
 
4794
/* Create a new type with printname NAME */
4795
 
4796
static struct type *
4797
new_type (char *name)
4798
{
4799
  struct type *t;
4800
 
4801
  t = alloc_type (current_objfile);
4802
  TYPE_NAME (t) = name;
4803
  INIT_CPLUS_SPECIFIC (t);
4804
  return t;
4805
}
4806
 
4807
/* Read ECOFF debugging information from a BFD section.  This is
4808
   called from elfread.c.  It parses the section into a
4809
   ecoff_debug_info struct, and then lets the rest of the file handle
4810
   it as normal.  */
4811
 
4812
void
4813
elfmdebug_build_psymtabs (struct objfile *objfile,
4814
                          const struct ecoff_debug_swap *swap, asection *sec)
4815
{
4816
  bfd *abfd = objfile->obfd;
4817
  struct ecoff_debug_info *info;
4818
  struct cleanup *back_to;
4819
 
4820
  /* FIXME: It's not clear whether we should be getting minimal symbol
4821
     information from .mdebug in an ELF file, or whether we will.
4822
     Re-initialize the minimal symbol reader in case we do.  */
4823
 
4824
  init_minimal_symbol_collection ();
4825
  back_to = make_cleanup_discard_minimal_symbols ();
4826
 
4827
  info = ((struct ecoff_debug_info *)
4828
          obstack_alloc (&objfile->objfile_obstack,
4829
                         sizeof (struct ecoff_debug_info)));
4830
 
4831
  if (!(*swap->read_debug_info) (abfd, sec, info))
4832
    error (_("Error reading ECOFF debugging information: %s"),
4833
           bfd_errmsg (bfd_get_error ()));
4834
 
4835
  mdebug_build_psymtabs (objfile, swap, info);
4836
 
4837
  install_minimal_symbols (objfile);
4838
  do_cleanups (back_to);
4839
}
4840
 
4841
void
4842
_initialize_mdebugread (void)
4843
{
4844
  basic_type_data = register_objfile_data ();
4845
}

powered by: WebSVN 2.1.0

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