gdb/buildsym.h

   1 /* Build symbol tables in GDB's internal format.
   2    Copyright (C) 1986-1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /* This module provides definitions used for creating and adding to
  21    the symbol table.  These routines are called from various symbol-
  22    file-reading routines.
  23
  24    They originated in dbxread.c of gdb-4.2, and were split out to
  25    make xcoffread.c more maintainable by sharing code.
  26
  27    Variables declared in this file can be defined by #define-ing
  28    the name EXTERN to null.  It is used to declare variables that
  29    are normally extern, but which get defined in a single module
  30    using this technique.  */
  31
  32 #ifndef EXTERN
  33 #define EXTERN  extern
  34 #endif
  35
  36 extern void add_symbol_to_list ();
  37 extern void process_one_symbol ();
  38 extern struct type *read_type ();
  39 extern struct type *read_range_type ();
  40 extern struct type *read_enum_type ();
  41 extern struct type *read_struct_type ();
  42 extern struct type *read_array_type ();
  43 extern struct type **read_args ();
  44 extern struct type **dbx_lookup_type ();
  45 extern long read_number ();
  46 extern void finish_block ();
  47 extern struct blockvector *make_blockvector ();
  48 extern void add_undefined_type ();
  49 extern void really_free_pendings ();
  50 extern void start_subfile ();
  51 extern struct symtab *end_symtab ();
  52 extern void scan_file_globals ();
  53 extern void buildsym_new_init ();
  54 extern void buildsym_init ();
  55
  56 /* Convert stab register number (from `r' declaration) to a gdb REGNUM.  */
  57
  58 #ifndef STAB_REG_TO_REGNUM
  59 #define STAB_REG_TO_REGNUM(VALUE) (VALUE)
  60 #endif
  61 \f
  62 /* Name of source file whose symbol data we are now processing.
  63    This comes from a symbol of type N_SO.  */
  64
  65 EXTERN char *last_source_file;
  66
  67 /* Core address of start of text of current source file.
  68    This too comes from the N_SO symbol.  */
  69
  70 EXTERN CORE_ADDR last_source_start_addr;
  71
  72 /* The list of sub-source-files within the current individual compilation.
  73    Each file gets its own symtab with its own linetable and associated info,
  74    but they all share one blockvector.  */
  75
  76 struct subfile
  77 {
  78   struct subfile *next;
  79   char *name;
  80   char *dirname;
  81   struct linetable *line_vector;
  82   int line_vector_length;
  83 };
  84
  85 EXTERN struct subfile *subfiles;
  86
  87 EXTERN struct subfile *current_subfile;
  88
  89 /* Global variable which, when set, indicates that we are processing a
  90    .o file compiled with gcc */
  91
  92 EXTERN unsigned char processing_gcc_compilation;
  93
  94 /* Count symbols as they are processed, for error messages.  */
  95
  96 EXTERN unsigned int symnum;
  97
  98 /* Vector of types defined so far, indexed by their dbx type numbers.
  99    (In newer sun systems, dbx uses a pair of numbers in parens,
 100     as in "(SUBFILENUM,NUMWITHINSUBFILE)".  Then these numbers must be
 101     translated through the type_translations hash table to get
 102     the index into the type vector.)  */
 103
 104 EXTERN struct type **type_vector;
 105
 106 /* Number of elements allocated for type_vector currently.  */
 107
 108 EXTERN int type_vector_length;
 109
 110 /* Hash table of global symbols whose values are not known yet.
 111    They are chained thru the SYMBOL_VALUE_CHAIN, since we don't
 112    have the correct data for that slot yet.  */
 113 /* The use of the LOC_BLOCK code in this chain is nonstandard--
 114    it refers to a FORTRAN common block rather than the usual meaning.  */
 115
 116 #define HASHSIZE 127
 117 EXTERN struct symbol *global_sym_chain[HASHSIZE];
 118
 119 /* Record the symbols defined for each context in a list.
 120    We don't create a struct block for the context until we
 121    know how long to make it.  */
 122
 123 #define PENDINGSIZE 100
 124
 125 struct pending
 126 {
 127   struct pending *next;
 128   int nsyms;
 129   struct symbol *symbol[PENDINGSIZE];
 130 };
 131
 132 /* List of free `struct pending' structures for reuse.  */
 133 EXTERN struct pending *free_pendings;
 134
 135 /* Here are the three lists that symbols are put on.  */
 136
 137 EXTERN struct pending *file_symbols;    /* static at top level, and types */
 138
 139 EXTERN struct pending *global_symbols;  /* global functions and variables */
 140
 141 EXTERN struct pending *local_symbols;   /* everything local to lexic context */
 142
 143 /* Kludge for xcoffread.c */
 144 struct pending_stabs {
 145   int   count, length;
 146   char  *stab[1];
 147 };
 148
 149 EXTERN struct pending_stabs *global_stabs;
 150 EXTERN struct pending_stabs *file_stabs;
 151
 152 /* List of symbols declared since the last BCOMM.  This list is a tail
 153    of local_symbols.  When ECOMM is seen, the symbols on the list
 154    are noted so their proper addresses can be filled in later,
 155    using the common block base address gotten from the assembler
 156    stabs.  */
 157
 158 EXTERN struct pending *common_block;
 159 EXTERN int common_block_i;
 160
 161 /* Stack representing unclosed lexical contexts
 162    (that will become blocks, eventually).  */
 163
 164 struct context_stack
 165 {
 166   struct pending *locals;
 167   struct pending_block *old_blocks;
 168   struct symbol *name;
 169   CORE_ADDR start_addr;
 170   CORE_ADDR end_addr;           /* Temp slot for exception handling. */
 171   int depth;
 172 };
 173
 174 EXTERN struct context_stack *context_stack;
 175
 176 /* Index of first unused entry in context stack.  */
 177 EXTERN int context_stack_depth;
 178
 179 /* Currently allocated size of context stack.  */
 180
 181 EXTERN int context_stack_size;
 182
 183 /* Nonzero if within a function (so symbols should be local,
 184    if nothing says specifically).  */
 185
 186 EXTERN int within_function;
 187
 188 /* List of blocks already made (lexical contexts already closed).
 189    This is used at the end to make the blockvector.  */
 190
 191 struct pending_block
 192 {
 193   struct pending_block *next;
 194   struct block *block;
 195 };
 196
 197 EXTERN struct pending_block *pending_blocks;
 198
 199 extern CORE_ADDR startup_file_start;    /* From blockframe.c */
 200 extern CORE_ADDR startup_file_end;      /* From blockframe.c */
 201
 202 /* Global variable which, when set, indicates that we are processing a
 203    .o file compiled with gcc */
 204
 205 EXTERN unsigned char processing_gcc_compilation;
 206
 207 /* Setup a define to deal cleanly with the underscore problem */
 208
 209 #ifdef NAMES_HAVE_UNDERSCORE
 210 #define HASH_OFFSET 1
 211 #else
 212 #define HASH_OFFSET 0
 213 #endif
 214 \f
 215 /* Support for Sun changes to dbx symbol format */
 216
 217 /* For each identified header file, we have a table of types defined
 218    in that header file.
 219
 220    header_files maps header file names to their type tables.
 221    It is a vector of n_header_files elements.
 222    Each element describes one header file.
 223    It contains a vector of types.
 224
 225    Sometimes it can happen that the same header file produces
 226    different results when included in different places.
 227    This can result from conditionals or from different
 228    things done before including the file.
 229    When this happens, there are multiple entries for the file in this table,
 230    one entry for each distinct set of results.
 231    The entries are distinguished by the INSTANCE field.
 232    The INSTANCE field appears in the N_BINCL and N_EXCL symbol table and is
 233    used to match header-file references to their corresponding data.  */
 234
 235 struct header_file
 236 {
 237   char *name;                   /* Name of header file */
 238   int instance;                 /* Numeric code distinguishing instances
 239                                    of one header file that produced
 240                                    different results when included.
 241                                    It comes from the N_BINCL or N_EXCL.  */
 242   struct type **vector;         /* Pointer to vector of types */
 243   int length;                   /* Allocated length (# elts) of that vector */
 244 };
 245
 246 EXTERN struct header_file *header_files;
 247
 248 EXTERN int n_header_files;
 249
 250 EXTERN int n_allocated_header_files;
 251
 252 /* Within each object file, various header files are assigned numbers.
 253    A type is defined or referred to with a pair of numbers
 254    (FILENUM,TYPENUM) where FILENUM is the number of the header file
 255    and TYPENUM is the number within that header file.
 256    TYPENUM is the index within the vector of types for that header file.
 257
 258    FILENUM == 1 is special; it refers to the main source of the object file,
 259    and not to any header file.  FILENUM != 1 is interpreted by looking it up
 260    in the following table, which contains indices in header_files.  */
 261
 262 EXTERN int *this_object_header_files;
 263
 264 EXTERN int n_this_object_header_files;
 265
 266 EXTERN int n_allocated_this_object_header_files;