gdb/symtab.h

   1 /* Symbol table definitions for GDB.
   2
   3    Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   4    1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009, 2010,
   5    2011 Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #if !defined (SYMTAB_H)
  23 #define SYMTAB_H 1
  24
  25 /* Opaque declarations.  */
  26 struct ui_file;
  27 struct frame_info;
  28 struct symbol;
  29 struct obstack;
  30 struct objfile;
  31 struct block;
  32 struct blockvector;
  33 struct axs_value;
  34 struct agent_expr;
  35 struct program_space;
  36 struct language_defn;
  37
  38 /* Some of the structures in this file are space critical.
  39    The space-critical structures are:
  40
  41      struct general_symbol_info
  42      struct symbol
  43      struct partial_symbol
  44
  45    These structures are laid out to encourage good packing.
  46    They use ENUM_BITFIELD and short int fields, and they order the
  47    structure members so that fields less than a word are next
  48    to each other so they can be packed together.  */
  49
  50 /* Rearranged: used ENUM_BITFIELD and rearranged field order in
  51    all the space critical structures (plus struct minimal_symbol).
  52    Memory usage dropped from 99360768 bytes to 90001408 bytes.
  53    I measured this with before-and-after tests of
  54    "HEAD-old-gdb -readnow HEAD-old-gdb" and
  55    "HEAD-new-gdb -readnow HEAD-old-gdb" on native i686-pc-linux-gnu,
  56    red hat linux 8, with LD_LIBRARY_PATH=/usr/lib/debug,
  57    typing "maint space 1" at the first command prompt.
  58
  59    Here is another measurement (from andrew c):
  60      # no /usr/lib/debug, just plain glibc, like a normal user
  61      gdb HEAD-old-gdb
  62      (gdb) break internal_error
  63      (gdb) run
  64      (gdb) maint internal-error
  65      (gdb) backtrace
  66      (gdb) maint space 1
  67
  68    gdb gdb_6_0_branch  2003-08-19  space used: 8896512
  69    gdb HEAD            2003-08-19  space used: 8904704
  70    gdb HEAD            2003-08-21  space used: 8396800 (+symtab.h)
  71    gdb HEAD            2003-08-21  space used: 8265728 (+gdbtypes.h)
  72
  73    The third line shows the savings from the optimizations in symtab.h.
  74    The fourth line shows the savings from the optimizations in
  75    gdbtypes.h.  Both optimizations are in gdb HEAD now.
  76
  77    --chastain 2003-08-21  */
  78
  79 /* Struct for storing C++ specific information.  Allocated when needed.  */
  80
  81 struct cplus_specific
  82 {
  83   char *demangled_name;
  84 };
  85
  86 /* Define a structure for the information that is common to all symbol types,
  87    including minimal symbols, partial symbols, and full symbols.  In a
  88    multilanguage environment, some language specific information may need to
  89    be recorded along with each symbol.  */
  90
  91 /* This structure is space critical.  See space comments at the top.  */
  92
  93 struct general_symbol_info
  94 {
  95   /* Name of the symbol.  This is a required field.  Storage for the
  96      name is allocated on the objfile_obstack for the associated
  97      objfile.  For languages like C++ that make a distinction between
  98      the mangled name and demangled name, this is the mangled
  99      name.  */
 100
 101   char *name;
 102
 103   /* Value of the symbol.  Which member of this union to use, and what
 104      it means, depends on what kind of symbol this is and its
 105      SYMBOL_CLASS.  See comments there for more details.  All of these
 106      are in host byte order (though what they point to might be in
 107      target byte order, e.g. LOC_CONST_BYTES).  */
 108
 109   union
 110   {
 111     /* The fact that this is a long not a LONGEST mainly limits the
 112        range of a LOC_CONST.  Since LOC_CONST_BYTES exists, I'm not
 113        sure that is a big deal.  */
 114     long ivalue;
 115
 116     struct block *block;
 117
 118     gdb_byte *bytes;
 119
 120     CORE_ADDR address;
 121
 122     /* For opaque typedef struct chain.  */
 123
 124     struct symbol *chain;
 125   }
 126   value;
 127
 128   /* Since one and only one language can apply, wrap the language specific
 129      information inside a union.  */
 130
 131   union
 132   {
 133     /* This is used by languages which wish to store a demangled name.
 134        currently used by Ada, Java, and Objective C.  */
 135     struct mangled_lang
 136     {
 137       char *demangled_name;
 138     }
 139     mangled_lang;
 140
 141     struct cplus_specific *cplus_specific;
 142   }
 143   language_specific;
 144
 145   /* Record the source code language that applies to this symbol.
 146      This is used to select one of the fields from the language specific
 147      union above.  */
 148
 149   ENUM_BITFIELD(language) language : 8;
 150
 151   /* Which section is this symbol in?  This is an index into
 152      section_offsets for this objfile.  Negative means that the symbol
 153      does not get relocated relative to a section.
 154      Disclaimer: currently this is just used for xcoff, so don't
 155      expect all symbol-reading code to set it correctly (the ELF code
 156      also tries to set it correctly).  */
 157
 158   short section;
 159
 160   /* The section associated with this symbol.  It can be NULL.  */
 161
 162   struct obj_section *obj_section;
 163 };
 164
 165 extern void symbol_set_demangled_name (struct general_symbol_info *, char *,
 166                                        struct objfile *);
 167
 168 extern char *symbol_get_demangled_name (const struct general_symbol_info *);
 169
 170 extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
 171
 172 /* Note that all the following SYMBOL_* macros are used with the
 173    SYMBOL argument being either a partial symbol, a minimal symbol or
 174    a full symbol.  All three types have a ginfo field.  In particular
 175    the SYMBOL_SET_LANGUAGE, SYMBOL_DEMANGLED_NAME, etc.
 176    macros cannot be entirely substituted by
 177    functions, unless the callers are changed to pass in the ginfo
 178    field only, instead of the SYMBOL parameter.  */
 179
 180 #define SYMBOL_VALUE(symbol)            (symbol)->ginfo.value.ivalue
 181 #define SYMBOL_VALUE_ADDRESS(symbol)    (symbol)->ginfo.value.address
 182 #define SYMBOL_VALUE_BYTES(symbol)      (symbol)->ginfo.value.bytes
 183 #define SYMBOL_BLOCK_VALUE(symbol)      (symbol)->ginfo.value.block
 184 #define SYMBOL_VALUE_CHAIN(symbol)      (symbol)->ginfo.value.chain
 185 #define SYMBOL_LANGUAGE(symbol)         (symbol)->ginfo.language
 186 #define SYMBOL_SECTION(symbol)          (symbol)->ginfo.section
 187 #define SYMBOL_OBJ_SECTION(symbol)      (symbol)->ginfo.obj_section
 188
 189 /* Initializes the language dependent portion of a symbol
 190    depending upon the language for the symbol.  */
 191 #define SYMBOL_SET_LANGUAGE(symbol,language) \
 192   (symbol_set_language (&(symbol)->ginfo, (language)))
 193 extern void symbol_set_language (struct general_symbol_info *symbol,
 194                                  enum language language);
 195
 196 /* Set just the linkage name of a symbol; do not try to demangle
 197    it.  Used for constructs which do not have a mangled name,
 198    e.g. struct tags.  Unlike SYMBOL_SET_NAMES, linkage_name must
 199    be terminated and either already on the objfile's obstack or
 200    permanently allocated.  */
 201 #define SYMBOL_SET_LINKAGE_NAME(symbol,linkage_name) \
 202   (symbol)->ginfo.name = (linkage_name)
 203
 204 /* Set the linkage and natural names of a symbol, by demangling
 205    the linkage name.  */
 206 #define SYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile)     \
 207   symbol_set_names (&(symbol)->ginfo, linkage_name, len, copy_name, objfile)
 208 extern void symbol_set_names (struct general_symbol_info *symbol,
 209                               const char *linkage_name, int len, int copy_name,
 210                               struct objfile *objfile);
 211
 212 /* Now come lots of name accessor macros.  Short version as to when to
 213    use which: Use SYMBOL_NATURAL_NAME to refer to the name of the
 214    symbol in the original source code.  Use SYMBOL_LINKAGE_NAME if you
 215    want to know what the linker thinks the symbol's name is.  Use
 216    SYMBOL_PRINT_NAME for output.  Use SYMBOL_DEMANGLED_NAME if you
 217    specifically need to know whether SYMBOL_NATURAL_NAME and
 218    SYMBOL_LINKAGE_NAME are different.  */
 219
 220 /* Return SYMBOL's "natural" name, i.e. the name that it was called in
 221    the original source code.  In languages like C++ where symbols may
 222    be mangled for ease of manipulation by the linker, this is the
 223    demangled name.  */
 224
 225 #define SYMBOL_NATURAL_NAME(symbol) \
 226   (symbol_natural_name (&(symbol)->ginfo))
 227 extern char *symbol_natural_name (const struct general_symbol_info *symbol);
 228
 229 /* Return SYMBOL's name from the point of view of the linker.  In
 230    languages like C++ where symbols may be mangled for ease of
 231    manipulation by the linker, this is the mangled name; otherwise,
 232    it's the same as SYMBOL_NATURAL_NAME.  */
 233
 234 #define SYMBOL_LINKAGE_NAME(symbol)     (symbol)->ginfo.name
 235
 236 /* Return the demangled name for a symbol based on the language for
 237    that symbol.  If no demangled name exists, return NULL.  */
 238 #define SYMBOL_DEMANGLED_NAME(symbol) \
 239   (symbol_demangled_name (&(symbol)->ginfo))
 240 extern char *symbol_demangled_name (const struct general_symbol_info *symbol);
 241
 242 /* Macro that returns a version of the name of a symbol that is
 243    suitable for output.  In C++ this is the "demangled" form of the
 244    name if demangle is on and the "mangled" form of the name if
 245    demangle is off.  In other languages this is just the symbol name.
 246    The result should never be NULL.  Don't use this for internal
 247    purposes (e.g. storing in a hashtable): it's only suitable for
 248    output.  */
 249
 250 #define SYMBOL_PRINT_NAME(symbol)                                       \
 251   (demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
 252
 253 /* Macro that tests a symbol for a match against a specified name string.
 254    First test the unencoded name, then looks for and test a C++ encoded
 255    name if it exists.  Note that whitespace is ignored while attempting to
 256    match a C++ encoded name, so that "foo::bar(int,long)" is the same as
 257    "foo :: bar (int, long)".
 258    Evaluates to zero if the match fails, or nonzero if it succeeds.  */
 259
 260 /* Macro that tests a symbol for a match against a specified name
 261    string.  It tests against SYMBOL_NATURAL_NAME, and it ignores
 262    whitespace and trailing parentheses.  (See strcmp_iw for details
 263    about its behavior.)  */
 264
 265 #define SYMBOL_MATCHES_NATURAL_NAME(symbol, name)                       \
 266   (strcmp_iw (SYMBOL_NATURAL_NAME (symbol), (name)) == 0)
 267
 268 /* Macro that returns the name to be used when sorting and searching symbols.
 269    In  C++, Chill, and Java, we search for the demangled form of a name,
 270    and so sort symbols accordingly.  In Ada, however, we search by mangled
 271    name.  If there is no distinct demangled name, then SYMBOL_SEARCH_NAME
 272    returns the same value (same pointer) as SYMBOL_LINKAGE_NAME.  */
 273 #define SYMBOL_SEARCH_NAME(symbol)                                       \
 274    (symbol_search_name (&(symbol)->ginfo))
 275 extern char *symbol_search_name (const struct general_symbol_info *);
 276
 277 /* Analogous to SYMBOL_MATCHES_NATURAL_NAME, but uses the search
 278    name.  */
 279 #define SYMBOL_MATCHES_SEARCH_NAME(symbol, name)                        \
 280   (strcmp_iw (SYMBOL_SEARCH_NAME (symbol), (name)) == 0)
 281
 282 /* Classification types for a minimal symbol.  These should be taken as
 283    "advisory only", since if gdb can't easily figure out a
 284    classification it simply selects mst_unknown.  It may also have to
 285    guess when it can't figure out which is a better match between two
 286    types (mst_data versus mst_bss) for example.  Since the minimal
 287    symbol info is sometimes derived from the BFD library's view of a
 288    file, we need to live with what information bfd supplies.  */
 289
 290 enum minimal_symbol_type
 291 {
 292   mst_unknown = 0,              /* Unknown type, the default */
 293   mst_text,                     /* Generally executable instructions */
 294   mst_text_gnu_ifunc,           /* Executable code returning address
 295                                    of executable code */
 296   mst_slot_got_plt,             /* GOT entries for .plt sections */
 297   mst_data,                     /* Generally initialized data */
 298   mst_bss,                      /* Generally uninitialized data */
 299   mst_abs,                      /* Generally absolute (nonrelocatable) */
 300   /* GDB uses mst_solib_trampoline for the start address of a shared
 301      library trampoline entry.  Breakpoints for shared library functions
 302      are put there if the shared library is not yet loaded.
 303      After the shared library is loaded, lookup_minimal_symbol will
 304      prefer the minimal symbol from the shared library (usually
 305      a mst_text symbol) over the mst_solib_trampoline symbol, and the
 306      breakpoints will be moved to their true address in the shared
 307      library via breakpoint_re_set.  */
 308   mst_solib_trampoline,         /* Shared library trampoline code */
 309   /* For the mst_file* types, the names are only guaranteed to be unique
 310      within a given .o file.  */
 311   mst_file_text,                /* Static version of mst_text */
 312   mst_file_data,                /* Static version of mst_data */
 313   mst_file_bss                  /* Static version of mst_bss */
 314 };
 315
 316 /* Define a simple structure used to hold some very basic information about
 317    all defined global symbols (text, data, bss, abs, etc).  The only required
 318    information is the general_symbol_info.
 319
 320    In many cases, even if a file was compiled with no special options for
 321    debugging at all, as long as was not stripped it will contain sufficient
 322    information to build a useful minimal symbol table using this structure.
 323    Even when a file contains enough debugging information to build a full
 324    symbol table, these minimal symbols are still useful for quickly mapping
 325    between names and addresses, and vice versa.  They are also sometimes
 326    used to figure out what full symbol table entries need to be read in.  */
 327
 328 struct minimal_symbol
 329 {
 330
 331   /* The general symbol info required for all types of symbols.
 332
 333      The SYMBOL_VALUE_ADDRESS contains the address that this symbol
 334      corresponds to.  */
 335
 336   struct general_symbol_info ginfo;
 337
 338   /* Size of this symbol.  end_psymtab in dbxread.c uses this
 339      information to calculate the end of the partial symtab based on the
 340      address of the last symbol plus the size of the last symbol.  */
 341
 342   unsigned long size;
 343
 344   /* Which source file is this symbol in?  Only relevant for mst_file_*.  */
 345   char *filename;
 346
 347   /* Classification type for this minimal symbol.  */
 348
 349   ENUM_BITFIELD(minimal_symbol_type) type : 8;
 350
 351   /* Two flag bits provided for the use of the target.  */
 352   unsigned int target_flag_1 : 1;
 353   unsigned int target_flag_2 : 1;
 354
 355   /* Minimal symbols with the same hash key are kept on a linked
 356      list.  This is the link.  */
 357
 358   struct minimal_symbol *hash_next;
 359
 360   /* Minimal symbols are stored in two different hash tables.  This is
 361      the `next' pointer for the demangled hash table.  */
 362
 363   struct minimal_symbol *demangled_hash_next;
 364 };
 365
 366 #define MSYMBOL_TARGET_FLAG_1(msymbol)  (msymbol)->target_flag_1
 367 #define MSYMBOL_TARGET_FLAG_2(msymbol)  (msymbol)->target_flag_2
 368 #define MSYMBOL_SIZE(msymbol)           (msymbol)->size
 369 #define MSYMBOL_TYPE(msymbol)           (msymbol)->type
 370
 371 \f
 372
 373 /* Represent one symbol name; a variable, constant, function or typedef.  */
 374
 375 /* Different name domains for symbols.  Looking up a symbol specifies a
 376    domain and ignores symbol definitions in other name domains.  */
 377
 378 typedef enum domain_enum_tag
 379 {
 380   /* UNDEF_DOMAIN is used when a domain has not been discovered or
 381      none of the following apply.  This usually indicates an error either
 382      in the symbol information or in gdb's handling of symbols.  */
 383
 384   UNDEF_DOMAIN,
 385
 386   /* VAR_DOMAIN is the usual domain.  In C, this contains variables,
 387      function names, typedef names and enum type values.  */
 388
 389   VAR_DOMAIN,
 390
 391   /* STRUCT_DOMAIN is used in C to hold struct, union and enum type names.
 392      Thus, if `struct foo' is used in a C program, it produces a symbol named
 393      `foo' in the STRUCT_DOMAIN.  */
 394
 395   STRUCT_DOMAIN,
 396
 397   /* LABEL_DOMAIN may be used for names of labels (for gotos).  */
 398
 399   LABEL_DOMAIN
 400 } domain_enum;
 401
 402 /* Searching domains, used for `search_symbols'.  Element numbers are
 403    hardcoded in GDB, check all enum uses before changing it.  */
 404
 405 enum search_domain
 406 {
 407   /* Everything in VAR_DOMAIN minus FUNCTIONS_DOMAIN and
 408      TYPES_DOMAIN.  */
 409   VARIABLES_DOMAIN = 0,
 410
 411   /* All functions -- for some reason not methods, though.  */
 412   FUNCTIONS_DOMAIN = 1,
 413
 414   /* All defined types */
 415   TYPES_DOMAIN = 2,
 416
 417   /* Any type.  */
 418   ALL_DOMAIN = 3
 419 };
 420
 421 /* An address-class says where to find the value of a symbol.  */
 422
 423 enum address_class
 424 {
 425   /* Not used; catches errors.  */
 426
 427   LOC_UNDEF,
 428
 429   /* Value is constant int SYMBOL_VALUE, host byteorder.  */
 430
 431   LOC_CONST,
 432
 433   /* Value is at fixed address SYMBOL_VALUE_ADDRESS.  */
 434
 435   LOC_STATIC,
 436
 437   /* Value is in register.  SYMBOL_VALUE is the register number
 438      in the original debug format.  SYMBOL_REGISTER_OPS holds a
 439      function that can be called to transform this into the
 440      actual register number this represents in a specific target
 441      architecture (gdbarch).
 442
 443      For some symbol formats (stabs, for some compilers at least),
 444      the compiler generates two symbols, an argument and a register.
 445      In some cases we combine them to a single LOC_REGISTER in symbol
 446      reading, but currently not for all cases (e.g. it's passed on the
 447      stack and then loaded into a register).  */
 448
 449   LOC_REGISTER,
 450
 451   /* It's an argument; the value is at SYMBOL_VALUE offset in arglist.  */
 452
 453   LOC_ARG,
 454
 455   /* Value address is at SYMBOL_VALUE offset in arglist.  */
 456
 457   LOC_REF_ARG,
 458
 459   /* Value is in specified register.  Just like LOC_REGISTER except the
 460      register holds the address of the argument instead of the argument
 461      itself.  This is currently used for the passing of structs and unions
 462      on sparc and hppa.  It is also used for call by reference where the
 463      address is in a register, at least by mipsread.c.  */
 464
 465   LOC_REGPARM_ADDR,
 466
 467   /* Value is a local variable at SYMBOL_VALUE offset in stack frame.  */
 468
 469   LOC_LOCAL,
 470
 471   /* Value not used; definition in SYMBOL_TYPE.  Symbols in the domain
 472      STRUCT_DOMAIN all have this class.  */
 473
 474   LOC_TYPEDEF,
 475
 476   /* Value is address SYMBOL_VALUE_ADDRESS in the code.  */
 477
 478   LOC_LABEL,
 479
 480   /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
 481      In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
 482      of the block.  Function names have this class.  */
 483
 484   LOC_BLOCK,
 485
 486   /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
 487      target byte order.  */
 488
 489   LOC_CONST_BYTES,
 490
 491   /* Value is at fixed address, but the address of the variable has
 492      to be determined from the minimal symbol table whenever the
 493      variable is referenced.
 494      This happens if debugging information for a global symbol is
 495      emitted and the corresponding minimal symbol is defined
 496      in another object file or runtime common storage.
 497      The linker might even remove the minimal symbol if the global
 498      symbol is never referenced, in which case the symbol remains
 499      unresolved.
 500
 501      GDB would normally find the symbol in the minimal symbol table if it will
 502      not find it in the full symbol table.  But a reference to an external
 503      symbol in a local block shadowing other definition requires full symbol
 504      without possibly having its address available for LOC_STATIC.  Testcase
 505      is provided as `gdb.dwarf2/dw2-unresolved.exp'.  */
 506
 507   LOC_UNRESOLVED,
 508
 509   /* The variable does not actually exist in the program.
 510      The value is ignored.  */
 511
 512   LOC_OPTIMIZED_OUT,
 513
 514   /* The variable's address is computed by a set of location
 515      functions (see "struct symbol_computed_ops" below).  */
 516   LOC_COMPUTED,
 517 };
 518
 519 /* The methods needed to implement LOC_COMPUTED.  These methods can
 520    use the symbol's .aux_value for additional per-symbol information.
 521
 522    At present this is only used to implement location expressions.  */
 523
 524 struct symbol_computed_ops
 525 {
 526
 527   /* Return the value of the variable SYMBOL, relative to the stack
 528      frame FRAME.  If the variable has been optimized out, return
 529      zero.
 530
 531      Iff `read_needs_frame (SYMBOL)' is zero, then FRAME may be zero.  */
 532
 533   struct value *(*read_variable) (struct symbol * symbol,
 534                                   struct frame_info * frame);
 535
 536   /* Read variable SYMBOL like read_variable at (callee) FRAME's function
 537      entry.  SYMBOL should be a function parameter, otherwise
 538      NO_ENTRY_VALUE_ERROR will be thrown.  */
 539   struct value *(*read_variable_at_entry) (struct symbol *symbol,
 540                                            struct frame_info *frame);
 541
 542   /* Return non-zero if we need a frame to find the value of the SYMBOL.  */
 543   int (*read_needs_frame) (struct symbol * symbol);
 544
 545   /* Write to STREAM a natural-language description of the location of
 546      SYMBOL, in the context of ADDR.  */
 547   void (*describe_location) (struct symbol * symbol, CORE_ADDR addr,
 548                              struct ui_file * stream);
 549
 550   /* Tracepoint support.  Append bytecodes to the tracepoint agent
 551      expression AX that push the address of the object SYMBOL.  Set
 552      VALUE appropriately.  Note --- for objects in registers, this
 553      needn't emit any code; as long as it sets VALUE properly, then
 554      the caller will generate the right code in the process of
 555      treating this as an lvalue or rvalue.  */
 556
 557   void (*tracepoint_var_ref) (struct symbol *symbol, struct gdbarch *gdbarch,
 558                               struct agent_expr *ax, struct axs_value *value);
 559 };
 560
 561 /* Functions used with LOC_REGISTER and LOC_REGPARM_ADDR.  */
 562
 563 struct symbol_register_ops
 564 {
 565   int (*register_number) (struct symbol *symbol, struct gdbarch *gdbarch);
 566 };
 567
 568 /* This structure is space critical.  See space comments at the top.  */
 569
 570 struct symbol
 571 {
 572
 573   /* The general symbol info required for all types of symbols.  */
 574
 575   struct general_symbol_info ginfo;
 576
 577   /* Data type of value */
 578
 579   struct type *type;
 580
 581   /* The symbol table containing this symbol.  This is the file
 582      associated with LINE.  It can be NULL during symbols read-in but it is
 583      never NULL during normal operation.  */
 584   struct symtab *symtab;
 585
 586   /* Domain code.  */
 587
 588   ENUM_BITFIELD(domain_enum_tag) domain : 6;
 589
 590   /* Address class */
 591   /* NOTE: cagney/2003-11-02: The fields "aclass" and "ops" contain
 592      overlapping information.  By creating a per-aclass ops vector, or
 593      using the aclass as an index into an ops table, the aclass and
 594      ops fields can be merged.  The latter, for instance, would shave
 595      32-bits from each symbol (relative to a symbol lookup, any table
 596      index overhead would be in the noise).  */
 597
 598   ENUM_BITFIELD(address_class) aclass : 6;
 599
 600   /* Whether this is an argument.  */
 601
 602   unsigned is_argument : 1;
 603
 604   /* Whether this is an inlined function (class LOC_BLOCK only).  */
 605   unsigned is_inlined : 1;
 606
 607   /* True if this is a C++ function symbol with template arguments.
 608      In this case the symbol is really a "struct template_symbol".  */
 609   unsigned is_cplus_template_function : 1;
 610
 611   /* Line number of this symbol's definition, except for inlined
 612      functions.  For an inlined function (class LOC_BLOCK and
 613      SYMBOL_INLINED set) this is the line number of the function's call
 614      site.  Inlined function symbols are not definitions, and they are
 615      never found by symbol table lookup.
 616
 617      FIXME: Should we really make the assumption that nobody will try
 618      to debug files longer than 64K lines?  What about machine
 619      generated programs?  */
 620
 621   unsigned short line;
 622
 623   /* Method's for symbol's of this class.  */
 624   /* NOTE: cagney/2003-11-02: See comment above attached to "aclass".  */
 625
 626   union
 627     {
 628       /* Used with LOC_COMPUTED.  */
 629       const struct symbol_computed_ops *ops_computed;
 630
 631       /* Used with LOC_REGISTER and LOC_REGPARM_ADDR.  */
 632       const struct symbol_register_ops *ops_register;
 633     } ops;
 634
 635   /* An arbitrary data pointer, allowing symbol readers to record
 636      additional information on a per-symbol basis.  Note that this data
 637      must be allocated using the same obstack as the symbol itself.  */
 638   /* So far it is only used by LOC_COMPUTED to
 639      find the location information.  For a LOC_BLOCK symbol
 640      for a function in a compilation unit compiled with DWARF 2
 641      information, this is information used internally by the DWARF 2
 642      code --- specifically, the location expression for the frame
 643      base for this function.  */
 644   /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
 645      to add a magic symbol to the block containing this information,
 646      or to have a generic debug info annotation slot for symbols.  */
 647
 648   void *aux_value;
 649
 650   struct symbol *hash_next;
 651 };
 652
 653
 654 #define SYMBOL_DOMAIN(symbol)   (symbol)->domain
 655 #define SYMBOL_CLASS(symbol)            (symbol)->aclass
 656 #define SYMBOL_IS_ARGUMENT(symbol)      (symbol)->is_argument
 657 #define SYMBOL_INLINED(symbol)          (symbol)->is_inlined
 658 #define SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION(symbol) \
 659   (symbol)->is_cplus_template_function
 660 #define SYMBOL_TYPE(symbol)             (symbol)->type
 661 #define SYMBOL_LINE(symbol)             (symbol)->line
 662 #define SYMBOL_SYMTAB(symbol)           (symbol)->symtab
 663 #define SYMBOL_COMPUTED_OPS(symbol)     (symbol)->ops.ops_computed
 664 #define SYMBOL_REGISTER_OPS(symbol)     (symbol)->ops.ops_register
 665 #define SYMBOL_LOCATION_BATON(symbol)   (symbol)->aux_value
 666
 667 /* An instance of this type is used to represent a C++ template
 668    function.  It includes a "struct symbol" as a kind of base class;
 669    users downcast to "struct template_symbol *" when needed.  A symbol
 670    is really of this type iff SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION is
 671    true.  */
 672
 673 struct template_symbol
 674 {
 675   /* The base class.  */
 676   struct symbol base;
 677
 678   /* The number of template arguments.  */
 679   int n_template_arguments;
 680
 681   /* The template arguments.  This is an array with
 682      N_TEMPLATE_ARGUMENTS elements.  */
 683   struct symbol **template_arguments;
 684 };
 685
 686 \f
 687 /* Each item represents a line-->pc (or the reverse) mapping.  This is
 688    somewhat more wasteful of space than one might wish, but since only
 689    the files which are actually debugged are read in to core, we don't
 690    waste much space.  */
 691
 692 struct linetable_entry
 693 {
 694   int line;
 695   CORE_ADDR pc;
 696 };
 697
 698 /* The order of entries in the linetable is significant.  They should
 699    be sorted by increasing values of the pc field.  If there is more than
 700    one entry for a given pc, then I'm not sure what should happen (and
 701    I not sure whether we currently handle it the best way).
 702
 703    Example: a C for statement generally looks like this
 704
 705    10   0x100   - for the init/test part of a for stmt.
 706    20   0x200
 707    30   0x300
 708    10   0x400   - for the increment part of a for stmt.
 709
 710    If an entry has a line number of zero, it marks the start of a PC
 711    range for which no line number information is available.  It is
 712    acceptable, though wasteful of table space, for such a range to be
 713    zero length.  */
 714
 715 struct linetable
 716 {
 717   int nitems;
 718
 719   /* Actually NITEMS elements.  If you don't like this use of the
 720      `struct hack', you can shove it up your ANSI (seriously, if the
 721      committee tells us how to do it, we can probably go along).  */
 722   struct linetable_entry item[1];
 723 };
 724
 725 /* How to relocate the symbols from each section in a symbol file.
 726    Each struct contains an array of offsets.
 727    The ordering and meaning of the offsets is file-type-dependent;
 728    typically it is indexed by section numbers or symbol types or
 729    something like that.
 730
 731    To give us flexibility in changing the internal representation
 732    of these offsets, the ANOFFSET macro must be used to insert and
 733    extract offset values in the struct.  */
 734
 735 struct section_offsets
 736 {
 737   CORE_ADDR offsets[1];         /* As many as needed.  */
 738 };
 739
 740 #define ANOFFSET(secoff, whichone) \
 741   ((whichone == -1)                       \
 742    ? (internal_error (__FILE__, __LINE__, \
 743                       _("Section index is uninitialized")), -1) \
 744    : secoff->offsets[whichone])
 745
 746 /* The size of a section_offsets table for N sections.  */
 747 #define SIZEOF_N_SECTION_OFFSETS(n) \
 748   (sizeof (struct section_offsets) \
 749    + sizeof (((struct section_offsets *) 0)->offsets) * ((n)-1))
 750
 751 /* Each source file or header is represented by a struct symtab.
 752    These objects are chained through the `next' field.  */
 753
 754 struct symtab
 755 {
 756   /* Unordered chain of all existing symtabs of this objfile.  */
 757
 758   struct symtab *next;
 759
 760   /* List of all symbol scope blocks for this symtab.  May be shared
 761      between different symtabs (and normally is for all the symtabs
 762      in a given compilation unit).  */
 763
 764   struct blockvector *blockvector;
 765
 766   /* Table mapping core addresses to line numbers for this file.
 767      Can be NULL if none.  Never shared between different symtabs.  */
 768
 769   struct linetable *linetable;
 770
 771   /* Section in objfile->section_offsets for the blockvector and
 772      the linetable.  Probably always SECT_OFF_TEXT.  */
 773
 774   int block_line_section;
 775
 776   /* If several symtabs share a blockvector, exactly one of them
 777      should be designated the primary, so that the blockvector
 778      is relocated exactly once by objfile_relocate.  */
 779
 780   unsigned int primary : 1;
 781
 782   /* Symtab has been compiled with both optimizations and debug info so that
 783      GDB may stop skipping prologues as variables locations are valid already
 784      at function entry points.  */
 785
 786   unsigned int locations_valid : 1;
 787
 788   /* DWARF unwinder for this CU is valid even for epilogues (PC at the return
 789      instruction).  This is supported by GCC since 4.5.0.  */
 790
 791   unsigned int epilogue_unwind_valid : 1;
 792
 793   /* The macro table for this symtab.  Like the blockvector, this
 794      may be shared between different symtabs --- and normally is for
 795      all the symtabs in a given compilation unit.  */
 796   struct macro_table *macro_table;
 797
 798   /* Name of this source file.  */
 799
 800   char *filename;
 801
 802   /* Directory in which it was compiled, or NULL if we don't know.  */
 803
 804   char *dirname;
 805
 806   /* Total number of lines found in source file.  */
 807
 808   int nlines;
 809
 810   /* line_charpos[N] is the position of the (N-1)th line of the
 811      source file.  "position" means something we can lseek() to; it
 812      is not guaranteed to be useful any other way.  */
 813
 814   int *line_charpos;
 815
 816   /* Language of this source file.  */
 817
 818   enum language language;
 819
 820   /* String that identifies the format of the debugging information, such
 821      as "stabs", "dwarf 1", "dwarf 2", "coff", etc.  This is mostly useful
 822      for automated testing of gdb but may also be information that is
 823      useful to the user.  */
 824
 825   const char *debugformat;
 826
 827   /* String of producer version information.  May be zero.  */
 828
 829   const char *producer;
 830
 831   /* Full name of file as found by searching the source path.
 832      NULL if not yet known.  */
 833
 834   char *fullname;
 835
 836   /* Object file from which this symbol information was read.  */
 837
 838   struct objfile *objfile;
 839
 840   /* struct call_site entries for this compilation unit or NULL.  */
 841
 842   htab_t call_site_htab;
 843 };
 844
 845 #define BLOCKVECTOR(symtab)     (symtab)->blockvector
 846 #define LINETABLE(symtab)       (symtab)->linetable
 847 #define SYMTAB_PSPACE(symtab)   (symtab)->objfile->pspace
 848 \f
 849
 850 /* The virtual function table is now an array of structures which have the
 851    form { int16 offset, delta; void *pfn; }.
 852
 853    In normal virtual function tables, OFFSET is unused.
 854    DELTA is the amount which is added to the apparent object's base
 855    address in order to point to the actual object to which the
 856    virtual function should be applied.
 857    PFN is a pointer to the virtual function.
 858
 859    Note that this macro is g++ specific (FIXME).  */
 860
 861 #define VTBL_FNADDR_OFFSET 2
 862
 863 /* External variables and functions for the objects described above.  */
 864
 865 /* True if we are nested inside psymtab_to_symtab.  */
 866
 867 extern int currently_reading_symtab;
 868
 869 /* From utils.c.  */
 870 extern int demangle;
 871 extern int asm_demangle;
 872
 873 /* symtab.c lookup functions */
 874
 875 extern const char multiple_symbols_ask[];
 876 extern const char multiple_symbols_all[];
 877 extern const char multiple_symbols_cancel[];
 878
 879 const char *multiple_symbols_select_mode (void);
 880
 881 int symbol_matches_domain (enum language symbol_language,
 882                            domain_enum symbol_domain,
 883                            domain_enum domain);
 884
 885 /* lookup a symbol table by source file name.  */
 886
 887 extern struct symtab *lookup_symtab (const char *);
 888
 889 /* lookup a symbol by name (optional block) in language.  */
 890
 891 extern struct symbol *lookup_symbol_in_language (const char *,
 892                                                  const struct block *,
 893                                                  const domain_enum,
 894                                                  enum language,
 895                                                  int *);
 896
 897 /* lookup a symbol by name (optional block, optional symtab)
 898    in the current language.  */
 899
 900 extern struct symbol *lookup_symbol (const char *, const struct block *,
 901                                      const domain_enum, int *);
 902
 903 /* A default version of lookup_symbol_nonlocal for use by languages
 904    that can't think of anything better to do.  */
 905
 906 extern struct symbol *basic_lookup_symbol_nonlocal (const char *,
 907                                                     const struct block *,
 908                                                     const domain_enum);
 909
 910 /* Some helper functions for languages that need to write their own
 911    lookup_symbol_nonlocal functions.  */
 912
 913 /* Lookup a symbol in the static block associated to BLOCK, if there
 914    is one; do nothing if BLOCK is NULL or a global block.  */
 915
 916 extern struct symbol *lookup_symbol_static (const char *name,
 917                                             const struct block *block,
 918                                             const domain_enum domain);
 919
 920 /* Lookup a symbol in all files' global blocks (searching psymtabs if
 921    necessary).  */
 922
 923 extern struct symbol *lookup_symbol_global (const char *name,
 924                                             const struct block *block,
 925                                             const domain_enum domain);
 926
 927 /* Lookup a symbol within the block BLOCK.  This, unlike
 928    lookup_symbol_block, will set SYMTAB and BLOCK_FOUND correctly, and
 929    will fix up the symbol if necessary.  */
 930
 931 extern struct symbol *lookup_symbol_aux_block (const char *name,
 932                                                const struct block *block,
 933                                                const domain_enum domain);
 934
 935 extern struct symbol *lookup_language_this (const struct language_defn *lang,
 936                                             const struct block *block);
 937
 938 /* Lookup a symbol only in the file static scope of all the objfiles.  */
 939
 940 struct symbol *lookup_static_symbol_aux (const char *name,
 941                                          const domain_enum domain);
 942
 943
 944 /* lookup a symbol by name, within a specified block.  */
 945
 946 extern struct symbol *lookup_block_symbol (const struct block *, const char *,
 947                                            const domain_enum);
 948
 949 /* lookup a [struct, union, enum] by name, within a specified block.  */
 950
 951 extern struct type *lookup_struct (const char *, struct block *);
 952
 953 extern struct type *lookup_union (const char *, struct block *);
 954
 955 extern struct type *lookup_enum (const char *, struct block *);
 956
 957 /* from blockframe.c: */
 958
 959 /* lookup the function symbol corresponding to the address.  */
 960
 961 extern struct symbol *find_pc_function (CORE_ADDR);
 962
 963 /* lookup the function corresponding to the address and section.  */
 964
 965 extern struct symbol *find_pc_sect_function (CORE_ADDR, struct obj_section *);
 966
 967 extern int find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, char **name,
 968                                                CORE_ADDR *address,
 969                                                CORE_ADDR *endaddr,
 970                                                int *is_gnu_ifunc_p);
 971
 972 /* lookup function from address, return name, start addr and end addr.  */
 973
 974 extern int find_pc_partial_function (CORE_ADDR, char **, CORE_ADDR *,
 975                                      CORE_ADDR *);
 976
 977 extern void clear_pc_function_cache (void);
 978
 979 /* lookup partial symbol table by address and section.  */
 980
 981 extern struct symtab *find_pc_sect_symtab_via_partial (CORE_ADDR,
 982                                                        struct obj_section *);
 983
 984 /* lookup full symbol table by address.  */
 985
 986 extern struct symtab *find_pc_symtab (CORE_ADDR);
 987
 988 /* lookup full symbol table by address and section.  */
 989
 990 extern struct symtab *find_pc_sect_symtab (CORE_ADDR, struct obj_section *);
 991
 992 extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
 993
 994 extern void reread_symbols (void);
 995
 996 extern struct type *lookup_transparent_type (const char *);
 997 extern struct type *basic_lookup_transparent_type (const char *);
 998
 999
1000 /* Macro for name of symbol to indicate a file compiled with gcc.  */
1001 #ifndef GCC_COMPILED_FLAG_SYMBOL
1002 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
1003 #endif
1004
1005 /* Macro for name of symbol to indicate a file compiled with gcc2.  */
1006 #ifndef GCC2_COMPILED_FLAG_SYMBOL
1007 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
1008 #endif
1009
1010 /* Functions for dealing with the minimal symbol table, really a misc
1011    address<->symbol mapping for things we don't have debug symbols for.  */
1012
1013 extern void prim_record_minimal_symbol (const char *, CORE_ADDR,
1014                                         enum minimal_symbol_type,
1015                                         struct objfile *);
1016
1017 extern struct minimal_symbol *prim_record_minimal_symbol_full
1018   (const char *, int, int, CORE_ADDR,
1019    enum minimal_symbol_type,
1020    int section, asection * bfd_section, struct objfile *);
1021
1022 extern struct minimal_symbol *prim_record_minimal_symbol_and_info
1023   (const char *, CORE_ADDR,
1024    enum minimal_symbol_type,
1025    int section, asection * bfd_section, struct objfile *);
1026
1027 extern unsigned int msymbol_hash_iw (const char *);
1028
1029 extern unsigned int msymbol_hash (const char *);
1030
1031 /* Compute the next hash value from previous HASH and the character C.  This
1032    is only a GDB in-memory computed value with no external files compatibility
1033    requirements.  */
1034
1035 #define SYMBOL_HASH_NEXT(hash, c) \
1036   ((hash) * 67 + tolower ((unsigned char) (c)) - 113)
1037
1038 extern struct objfile * msymbol_objfile (struct minimal_symbol *sym);
1039
1040 extern void
1041 add_minsym_to_hash_table (struct minimal_symbol *sym,
1042                           struct minimal_symbol **table);
1043
1044 extern struct minimal_symbol *lookup_minimal_symbol (const char *,
1045                                                      const char *,
1046                                                      struct objfile *);
1047
1048 extern struct minimal_symbol *lookup_minimal_symbol_text (const char *,
1049                                                           struct objfile *);
1050
1051 struct minimal_symbol *lookup_minimal_symbol_solib_trampoline (const char *,
1052                                                                struct objfile
1053                                                                *);
1054
1055 extern struct minimal_symbol *lookup_minimal_symbol_by_pc_name
1056                                 (CORE_ADDR, const char *, struct objfile *);
1057
1058 extern struct minimal_symbol *lookup_minimal_symbol_by_pc (CORE_ADDR);
1059
1060 extern int in_gnu_ifunc_stub (CORE_ADDR pc);
1061
1062 /* Functions for resolving STT_GNU_IFUNC symbols which are implemented only
1063    for ELF symbol files.  */
1064
1065 struct gnu_ifunc_fns
1066 {
1067   /* See elf_gnu_ifunc_resolve_addr for its real implementation.  */
1068   CORE_ADDR (*gnu_ifunc_resolve_addr) (struct gdbarch *gdbarch, CORE_ADDR pc);
1069
1070   /* See elf_gnu_ifunc_resolve_name for its real implementation.  */
1071   int (*gnu_ifunc_resolve_name) (const char *function_name,
1072                                  CORE_ADDR *function_address_p);
1073
1074   /* See elf_gnu_ifunc_resolver_stop for its real implementation.  */
1075   void (*gnu_ifunc_resolver_stop) (struct breakpoint *b);
1076
1077   /* See elf_gnu_ifunc_resolver_return_stop for its real implementation.  */
1078   void (*gnu_ifunc_resolver_return_stop) (struct breakpoint *b);
1079 };
1080
1081 #define gnu_ifunc_resolve_addr gnu_ifunc_fns_p->gnu_ifunc_resolve_addr
1082 #define gnu_ifunc_resolve_name gnu_ifunc_fns_p->gnu_ifunc_resolve_name
1083 #define gnu_ifunc_resolver_stop gnu_ifunc_fns_p->gnu_ifunc_resolver_stop
1084 #define gnu_ifunc_resolver_return_stop \
1085   gnu_ifunc_fns_p->gnu_ifunc_resolver_return_stop
1086
1087 extern const struct gnu_ifunc_fns *gnu_ifunc_fns_p;
1088
1089 extern struct minimal_symbol *
1090     lookup_minimal_symbol_and_objfile (const char *,
1091                                        struct objfile **);
1092
1093 extern struct minimal_symbol
1094   *lookup_minimal_symbol_by_pc_section (CORE_ADDR, struct obj_section *);
1095
1096 extern struct minimal_symbol
1097   *lookup_solib_trampoline_symbol_by_pc (CORE_ADDR);
1098
1099 extern CORE_ADDR find_solib_trampoline_target (struct frame_info *, CORE_ADDR);
1100
1101 extern void init_minimal_symbol_collection (void);
1102
1103 extern struct cleanup *make_cleanup_discard_minimal_symbols (void);
1104
1105 extern void install_minimal_symbols (struct objfile *);
1106
1107 /* Sort all the minimal symbols in OBJFILE.  */
1108
1109 extern void msymbols_sort (struct objfile *objfile);
1110
1111 struct symtab_and_line
1112 {
1113   /* The program space of this sal.  */
1114   struct program_space *pspace;
1115
1116   struct symtab *symtab;
1117   struct obj_section *section;
1118   /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
1119      0 is never a valid line number; it is used to indicate that line number
1120      information is not available.  */
1121   int line;
1122
1123   CORE_ADDR pc;
1124   CORE_ADDR end;
1125   int explicit_pc;
1126   int explicit_line;
1127 };
1128
1129 extern void init_sal (struct symtab_and_line *sal);
1130
1131 struct symtabs_and_lines
1132 {
1133   struct symtab_and_line *sals;
1134   int nelts;
1135 };
1136 \f
1137
1138
1139 /* Some types and macros needed for exception catchpoints.
1140    Can't put these in target.h because symtab_and_line isn't
1141    known there.  This file will be included by breakpoint.c,
1142    hppa-tdep.c, etc.  */
1143
1144 /* Enums for exception-handling support.  */
1145 enum exception_event_kind
1146 {
1147   EX_EVENT_THROW,
1148   EX_EVENT_CATCH
1149 };
1150
1151 \f
1152
1153 /* Given a pc value, return line number it is in.  Second arg nonzero means
1154    if pc is on the boundary use the previous statement's line number.  */
1155
1156 extern struct symtab_and_line find_pc_line (CORE_ADDR, int);
1157
1158 /* Same function, but specify a section as well as an address.  */
1159
1160 extern struct symtab_and_line find_pc_sect_line (CORE_ADDR,
1161                                                  struct obj_section *, int);
1162
1163 /* Given a symtab and line number, return the pc there.  */
1164
1165 extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
1166
1167 extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
1168                                CORE_ADDR *);
1169
1170 extern void resolve_sal_pc (struct symtab_and_line *);
1171
1172 /* Given a string, return the line specified by it.  For commands like "list"
1173    and "breakpoint".  */
1174
1175 extern struct symtabs_and_lines decode_line_spec (char *, int);
1176
1177 extern struct symtabs_and_lines decode_line_spec_1 (char *, int);
1178
1179 /* Symmisc.c */
1180
1181 void maintenance_print_symbols (char *, int);
1182
1183 void maintenance_print_psymbols (char *, int);
1184
1185 void maintenance_print_msymbols (char *, int);
1186
1187 void maintenance_print_objfiles (char *, int);
1188
1189 void maintenance_info_symtabs (char *, int);
1190
1191 void maintenance_info_psymtabs (char *, int);
1192
1193 void maintenance_check_symtabs (char *, int);
1194
1195 /* maint.c */
1196
1197 void maintenance_print_statistics (char *, int);
1198
1199 /* Symbol-reading stuff in symfile.c and solib.c.  */
1200
1201 extern void clear_solib (void);
1202
1203 /* source.c */
1204
1205 extern int identify_source_line (struct symtab *, int, int, CORE_ADDR);
1206
1207 extern void print_source_lines (struct symtab *, int, int, int);
1208
1209 extern void forget_cached_source_info_for_objfile (struct objfile *);
1210 extern void forget_cached_source_info (void);
1211
1212 extern void select_source_symtab (struct symtab *);
1213
1214 extern char **default_make_symbol_completion_list_break_on
1215   (char *text, char *word, const char *break_on);
1216 extern char **default_make_symbol_completion_list (char *, char *);
1217 extern char **make_symbol_completion_list (char *, char *);
1218 extern char **make_symbol_completion_list_fn (struct cmd_list_element *,
1219                                               char *, char *);
1220
1221 extern char **make_file_symbol_completion_list (char *, char *, char *);
1222
1223 extern char **make_source_files_completion_list (char *, char *);
1224
1225 /* symtab.c */
1226
1227 int matching_obj_sections (struct obj_section *, struct obj_section *);
1228
1229 extern const char *find_main_filename (void);
1230
1231 extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
1232
1233 extern struct symtab_and_line find_function_start_sal (struct symbol *sym,
1234                                                        int);
1235
1236 extern void skip_prologue_sal (struct symtab_and_line *);
1237
1238 /* symfile.c */
1239
1240 extern void clear_symtab_users (int add_flags);
1241
1242 extern enum language deduce_language_from_filename (const char *);
1243
1244 /* symtab.c */
1245
1246 extern int in_prologue (struct gdbarch *gdbarch,
1247                         CORE_ADDR pc, CORE_ADDR func_start);
1248
1249 extern CORE_ADDR skip_prologue_using_sal (struct gdbarch *gdbarch,
1250                                           CORE_ADDR func_addr);
1251
1252 extern struct symbol *fixup_symbol_section (struct symbol *,
1253                                             struct objfile *);
1254
1255 /* Symbol searching */
1256
1257 /* When using search_symbols, a list of the following structs is returned.
1258    Callers must free the search list using free_search_symbols!  */
1259 struct symbol_search
1260 {
1261   /* The block in which the match was found.  Could be, for example,
1262      STATIC_BLOCK or GLOBAL_BLOCK.  */
1263   int block;
1264
1265   /* Information describing what was found.
1266
1267      If symtab abd symbol are NOT NULL, then information was found
1268      for this match.  */
1269   struct symtab *symtab;
1270   struct symbol *symbol;
1271
1272   /* If msymbol is non-null, then a match was made on something for
1273      which only minimal_symbols exist.  */
1274   struct minimal_symbol *msymbol;
1275
1276   /* A link to the next match, or NULL for the end.  */
1277   struct symbol_search *next;
1278 };
1279
1280 extern void search_symbols (char *, enum search_domain, int, char **,
1281                             struct symbol_search **);
1282 extern void free_search_symbols (struct symbol_search *);
1283 extern struct cleanup *make_cleanup_free_search_symbols (struct symbol_search
1284                                                          *);
1285
1286 /* The name of the ``main'' function.
1287    FIXME: cagney/2001-03-20: Can't make main_name() const since some
1288    of the calling code currently assumes that the string isn't
1289    const.  */
1290 extern void set_main_name (const char *name);
1291 extern /*const */ char *main_name (void);
1292 extern enum language language_of_main;
1293
1294 /* Check global symbols in objfile.  */
1295 struct symbol *lookup_global_symbol_from_objfile (const struct objfile *,
1296                                                   const char *name,
1297                                                   const domain_enum domain);
1298
1299 extern struct symtabs_and_lines expand_line_sal (struct symtab_and_line sal);
1300
1301 /* Return 1 if the supplied producer string matches the ARM RealView
1302    compiler (armcc).  */
1303 int producer_is_realview (const char *producer);
1304
1305 void fixup_section (struct general_symbol_info *ginfo,
1306                     CORE_ADDR addr, struct objfile *objfile);
1307
1308 struct objfile *lookup_objfile_from_block (const struct block *block);
1309
1310 #endif /* !defined(SYMTAB_H) */