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