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   /* Return non-zero if we need a frame to find the value of the SYMBOL.  */
 537   int (*read_needs_frame) (struct symbol * symbol);
 538
 539   /* Write to STREAM a natural-language description of the location of
 540      SYMBOL, in the context of ADDR.  */
 541   void (*describe_location) (struct symbol * symbol, CORE_ADDR addr,
 542                              struct ui_file * stream);
 543
 544   /* Tracepoint support.  Append bytecodes to the tracepoint agent
 545      expression AX that push the address of the object SYMBOL.  Set
 546      VALUE appropriately.  Note --- for objects in registers, this
 547      needn't emit any code; as long as it sets VALUE properly, then
 548      the caller will generate the right code in the process of
 549      treating this as an lvalue or rvalue.  */
 550
 551   void (*tracepoint_var_ref) (struct symbol *symbol, struct gdbarch *gdbarch,
 552                               struct agent_expr *ax, struct axs_value *value);
 553 };
 554
 555 /* Functions used with LOC_REGISTER and LOC_REGPARM_ADDR.  */
 556
 557 struct symbol_register_ops
 558 {
 559   int (*register_number) (struct symbol *symbol, struct gdbarch *gdbarch);
 560 };
 561
 562 /* This structure is space critical.  See space comments at the top.  */
 563
 564 struct symbol
 565 {
 566
 567   /* The general symbol info required for all types of symbols.  */
 568
 569   struct general_symbol_info ginfo;
 570
 571   /* Data type of value */
 572
 573   struct type *type;
 574
 575   /* The symbol table containing this symbol.  This is the file
 576      associated with LINE.  It can be NULL during symbols read-in but it is
 577      never NULL during normal operation.  */
 578   struct symtab *symtab;
 579
 580   /* Domain code.  */
 581
 582   ENUM_BITFIELD(domain_enum_tag) domain : 6;
 583
 584   /* Address class */
 585   /* NOTE: cagney/2003-11-02: The fields "aclass" and "ops" contain
 586      overlapping information.  By creating a per-aclass ops vector, or
 587      using the aclass as an index into an ops table, the aclass and
 588      ops fields can be merged.  The latter, for instance, would shave
 589      32-bits from each symbol (relative to a symbol lookup, any table
 590      index overhead would be in the noise).  */
 591
 592   ENUM_BITFIELD(address_class) aclass : 6;
 593
 594   /* Whether this is an argument.  */
 595
 596   unsigned is_argument : 1;
 597
 598   /* Whether this is an inlined function (class LOC_BLOCK only).  */
 599   unsigned is_inlined : 1;
 600
 601   /* True if this is a C++ function symbol with template arguments.
 602      In this case the symbol is really a "struct template_symbol".  */
 603   unsigned is_cplus_template_function : 1;
 604
 605   /* Line number of this symbol's definition, except for inlined
 606      functions.  For an inlined function (class LOC_BLOCK and
 607      SYMBOL_INLINED set) this is the line number of the function's call
 608      site.  Inlined function symbols are not definitions, and they are
 609      never found by symbol table lookup.
 610
 611      FIXME: Should we really make the assumption that nobody will try
 612      to debug files longer than 64K lines?  What about machine
 613      generated programs?  */
 614
 615   unsigned short line;
 616
 617   /* Method's for symbol's of this class.  */
 618   /* NOTE: cagney/2003-11-02: See comment above attached to "aclass".  */
 619
 620   union
 621     {
 622       /* Used with LOC_COMPUTED.  */
 623       const struct symbol_computed_ops *ops_computed;
 624
 625       /* Used with LOC_REGISTER and LOC_REGPARM_ADDR.  */
 626       const struct symbol_register_ops *ops_register;
 627     } ops;
 628
 629   /* An arbitrary data pointer, allowing symbol readers to record
 630      additional information on a per-symbol basis.  Note that this data
 631      must be allocated using the same obstack as the symbol itself.  */
 632   /* So far it is only used by LOC_COMPUTED to
 633      find the location information.  For a LOC_BLOCK symbol
 634      for a function in a compilation unit compiled with DWARF 2
 635      information, this is information used internally by the DWARF 2
 636      code --- specifically, the location expression for the frame
 637      base for this function.  */
 638   /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
 639      to add a magic symbol to the block containing this information,
 640      or to have a generic debug info annotation slot for symbols.  */
 641
 642   void *aux_value;
 643
 644   struct symbol *hash_next;
 645 };
 646
 647
 648 #define SYMBOL_DOMAIN(symbol)   (symbol)->domain
 649 #define SYMBOL_CLASS(symbol)            (symbol)->aclass
 650 #define SYMBOL_IS_ARGUMENT(symbol)      (symbol)->is_argument
 651 #define SYMBOL_INLINED(symbol)          (symbol)->is_inlined
 652 #define SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION(symbol) \
 653   (symbol)->is_cplus_template_function
 654 #define SYMBOL_TYPE(symbol)             (symbol)->type
 655 #define SYMBOL_LINE(symbol)             (symbol)->line
 656 #define SYMBOL_SYMTAB(symbol)           (symbol)->symtab
 657 #define SYMBOL_COMPUTED_OPS(symbol)     (symbol)->ops.ops_computed
 658 #define SYMBOL_REGISTER_OPS(symbol)     (symbol)->ops.ops_register
 659 #define SYMBOL_LOCATION_BATON(symbol)   (symbol)->aux_value
 660
 661 /* An instance of this type is used to represent a C++ template
 662    function.  It includes a "struct symbol" as a kind of base class;
 663    users downcast to "struct template_symbol *" when needed.  A symbol
 664    is really of this type iff SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION is
 665    true.  */
 666
 667 struct template_symbol
 668 {
 669   /* The base class.  */
 670   struct symbol base;
 671
 672   /* The number of template arguments.  */
 673   int n_template_arguments;
 674
 675   /* The template arguments.  This is an array with
 676      N_TEMPLATE_ARGUMENTS elements.  */
 677   struct symbol **template_arguments;
 678 };
 679
 680 \f
 681 /* Each item represents a line-->pc (or the reverse) mapping.  This is
 682    somewhat more wasteful of space than one might wish, but since only
 683    the files which are actually debugged are read in to core, we don't
 684    waste much space.  */
 685
 686 struct linetable_entry
 687 {
 688   int line;
 689   CORE_ADDR pc;
 690 };
 691
 692 /* The order of entries in the linetable is significant.  They should
 693    be sorted by increasing values of the pc field.  If there is more than
 694    one entry for a given pc, then I'm not sure what should happen (and
 695    I not sure whether we currently handle it the best way).
 696
 697    Example: a C for statement generally looks like this
 698
 699    10   0x100   - for the init/test part of a for stmt.
 700    20   0x200
 701    30   0x300
 702    10   0x400   - for the increment part of a for stmt.
 703
 704    If an entry has a line number of zero, it marks the start of a PC
 705    range for which no line number information is available.  It is
 706    acceptable, though wasteful of table space, for such a range to be
 707    zero length.  */
 708
 709 struct linetable
 710 {
 711   int nitems;
 712
 713   /* Actually NITEMS elements.  If you don't like this use of the
 714      `struct hack', you can shove it up your ANSI (seriously, if the
 715      committee tells us how to do it, we can probably go along).  */
 716   struct linetable_entry item[1];
 717 };
 718
 719 /* How to relocate the symbols from each section in a symbol file.
 720    Each struct contains an array of offsets.
 721    The ordering and meaning of the offsets is file-type-dependent;
 722    typically it is indexed by section numbers or symbol types or
 723    something like that.
 724
 725    To give us flexibility in changing the internal representation
 726    of these offsets, the ANOFFSET macro must be used to insert and
 727    extract offset values in the struct.  */
 728
 729 struct section_offsets
 730 {
 731   CORE_ADDR offsets[1];         /* As many as needed.  */
 732 };
 733
 734 #define ANOFFSET(secoff, whichone) \
 735   ((whichone == -1)                       \
 736    ? (internal_error (__FILE__, __LINE__, \
 737                       _("Section index is uninitialized")), -1) \
 738    : secoff->offsets[whichone])
 739
 740 /* The size of a section_offsets table for N sections.  */
 741 #define SIZEOF_N_SECTION_OFFSETS(n) \
 742   (sizeof (struct section_offsets) \
 743    + sizeof (((struct section_offsets *) 0)->offsets) * ((n)-1))
 744
 745 /* Each source file or header is represented by a struct symtab.
 746    These objects are chained through the `next' field.  */
 747
 748 struct symtab
 749 {
 750   /* Unordered chain of all existing symtabs of this objfile.  */
 751
 752   struct symtab *next;
 753
 754   /* List of all symbol scope blocks for this symtab.  May be shared
 755      between different symtabs (and normally is for all the symtabs
 756      in a given compilation unit).  */
 757
 758   struct blockvector *blockvector;
 759
 760   /* Table mapping core addresses to line numbers for this file.
 761      Can be NULL if none.  Never shared between different symtabs.  */
 762
 763   struct linetable *linetable;
 764
 765   /* Section in objfile->section_offsets for the blockvector and
 766      the linetable.  Probably always SECT_OFF_TEXT.  */
 767
 768   int block_line_section;
 769
 770   /* If several symtabs share a blockvector, exactly one of them
 771      should be designated the primary, so that the blockvector
 772      is relocated exactly once by objfile_relocate.  */
 773
 774   unsigned int primary : 1;
 775
 776   /* Symtab has been compiled with both optimizations and debug info so that
 777      GDB may stop skipping prologues as variables locations are valid already
 778      at function entry points.  */
 779
 780   unsigned int locations_valid : 1;
 781
 782   /* DWARF unwinder for this CU is valid even for epilogues (PC at the return
 783      instruction).  This is supported by GCC since 4.5.0.  */
 784
 785   unsigned int epilogue_unwind_valid : 1;
 786
 787   /* The macro table for this symtab.  Like the blockvector, this
 788      may be shared between different symtabs --- and normally is for
 789      all the symtabs in a given compilation unit.  */
 790   struct macro_table *macro_table;
 791
 792   /* Name of this source file.  */
 793
 794   char *filename;
 795
 796   /* Directory in which it was compiled, or NULL if we don't know.  */
 797
 798   char *dirname;
 799
 800   /* Total number of lines found in source file.  */
 801
 802   int nlines;
 803
 804   /* line_charpos[N] is the position of the (N-1)th line of the
 805      source file.  "position" means something we can lseek() to; it
 806      is not guaranteed to be useful any other way.  */
 807
 808   int *line_charpos;
 809
 810   /* Language of this source file.  */
 811
 812   enum language language;
 813
 814   /* String that identifies the format of the debugging information, such
 815      as "stabs", "dwarf 1", "dwarf 2", "coff", etc.  This is mostly useful
 816      for automated testing of gdb but may also be information that is
 817      useful to the user.  */
 818
 819   const char *debugformat;
 820
 821   /* String of producer version information.  May be zero.  */
 822
 823   const char *producer;
 824
 825   /* Full name of file as found by searching the source path.
 826      NULL if not yet known.  */
 827
 828   char *fullname;
 829
 830   /* Object file from which this symbol information was read.  */
 831
 832   struct objfile *objfile;
 833
 834 };
 835
 836 #define BLOCKVECTOR(symtab)     (symtab)->blockvector
 837 #define LINETABLE(symtab)       (symtab)->linetable
 838 #define SYMTAB_PSPACE(symtab)   (symtab)->objfile->pspace
 839 \f
 840
 841 /* The virtual function table is now an array of structures which have the
 842    form { int16 offset, delta; void *pfn; }.
 843
 844    In normal virtual function tables, OFFSET is unused.
 845    DELTA is the amount which is added to the apparent object's base
 846    address in order to point to the actual object to which the
 847    virtual function should be applied.
 848    PFN is a pointer to the virtual function.
 849
 850    Note that this macro is g++ specific (FIXME).  */
 851
 852 #define VTBL_FNADDR_OFFSET 2
 853
 854 /* External variables and functions for the objects described above.  */
 855
 856 /* True if we are nested inside psymtab_to_symtab.  */
 857
 858 extern int currently_reading_symtab;
 859
 860 /* From utils.c.  */
 861 extern int demangle;
 862 extern int asm_demangle;
 863
 864 /* symtab.c lookup functions */
 865
 866 extern const char multiple_symbols_ask[];
 867 extern const char multiple_symbols_all[];
 868 extern const char multiple_symbols_cancel[];
 869
 870 const char *multiple_symbols_select_mode (void);
 871
 872 int symbol_matches_domain (enum language symbol_language,
 873                            domain_enum symbol_domain,
 874                            domain_enum domain);
 875
 876 /* lookup a symbol table by source file name.  */
 877
 878 extern struct symtab *lookup_symtab (const char *);
 879
 880 /* lookup a symbol by name (optional block) in language.  */
 881
 882 extern struct symbol *lookup_symbol_in_language (const char *,
 883                                                  const struct block *,
 884                                                  const domain_enum,
 885                                                  enum language,
 886                                                  int *);
 887
 888 /* lookup a symbol by name (optional block, optional symtab)
 889    in the current language.  */
 890
 891 extern struct symbol *lookup_symbol (const char *, const struct block *,
 892                                      const domain_enum, int *);
 893
 894 /* A default version of lookup_symbol_nonlocal for use by languages
 895    that can't think of anything better to do.  */
 896
 897 extern struct symbol *basic_lookup_symbol_nonlocal (const char *,
 898                                                     const struct block *,
 899                                                     const domain_enum);
 900
 901 /* Some helper functions for languages that need to write their own
 902    lookup_symbol_nonlocal functions.  */
 903
 904 /* Lookup a symbol in the static block associated to BLOCK, if there
 905    is one; do nothing if BLOCK is NULL or a global block.  */
 906
 907 extern struct symbol *lookup_symbol_static (const char *name,
 908                                             const struct block *block,
 909                                             const domain_enum domain);
 910
 911 /* Lookup a symbol in all files' global blocks (searching psymtabs if
 912    necessary).  */
 913
 914 extern struct symbol *lookup_symbol_global (const char *name,
 915                                             const struct block *block,
 916                                             const domain_enum domain);
 917
 918 /* Lookup a symbol within the block BLOCK.  This, unlike
 919    lookup_symbol_block, will set SYMTAB and BLOCK_FOUND correctly, and
 920    will fix up the symbol if necessary.  */
 921
 922 extern struct symbol *lookup_symbol_aux_block (const char *name,
 923                                                const struct block *block,
 924                                                const domain_enum domain);
 925
 926 extern struct symbol *lookup_language_this (const struct language_defn *lang,
 927                                             const struct block *block);
 928
 929 /* Lookup a symbol only in the file static scope of all the objfiles.  */
 930
 931 struct symbol *lookup_static_symbol_aux (const char *name,
 932                                          const domain_enum domain);
 933
 934
 935 /* lookup a symbol by name, within a specified block.  */
 936
 937 extern struct symbol *lookup_block_symbol (const struct block *, const char *,
 938                                            const domain_enum);
 939
 940 /* lookup a [struct, union, enum] by name, within a specified block.  */
 941
 942 extern struct type *lookup_struct (const char *, struct block *);
 943
 944 extern struct type *lookup_union (const char *, struct block *);
 945
 946 extern struct type *lookup_enum (const char *, struct block *);
 947
 948 /* from blockframe.c: */
 949
 950 /* lookup the function symbol corresponding to the address.  */
 951
 952 extern struct symbol *find_pc_function (CORE_ADDR);
 953
 954 /* lookup the function corresponding to the address and section.  */
 955
 956 extern struct symbol *find_pc_sect_function (CORE_ADDR, struct obj_section *);
 957
 958 extern int find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, char **name,
 959                                                CORE_ADDR *address,
 960                                                CORE_ADDR *endaddr,
 961                                                int *is_gnu_ifunc_p);
 962
 963 /* lookup function from address, return name, start addr and end addr.  */
 964
 965 extern int find_pc_partial_function (CORE_ADDR, char **, CORE_ADDR *,
 966                                      CORE_ADDR *);
 967
 968 extern void clear_pc_function_cache (void);
 969
 970 /* lookup partial symbol table by address and section.  */
 971
 972 extern struct symtab *find_pc_sect_symtab_via_partial (CORE_ADDR,
 973                                                        struct obj_section *);
 974
 975 /* lookup full symbol table by address.  */
 976
 977 extern struct symtab *find_pc_symtab (CORE_ADDR);
 978
 979 /* lookup full symbol table by address and section.  */
 980
 981 extern struct symtab *find_pc_sect_symtab (CORE_ADDR, struct obj_section *);
 982
 983 extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
 984
 985 extern void reread_symbols (void);
 986
 987 extern struct type *lookup_transparent_type (const char *);
 988 extern struct type *basic_lookup_transparent_type (const char *);
 989
 990
 991 /* Macro for name of symbol to indicate a file compiled with gcc.  */
 992 #ifndef GCC_COMPILED_FLAG_SYMBOL
 993 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
 994 #endif
 995
 996 /* Macro for name of symbol to indicate a file compiled with gcc2.  */
 997 #ifndef GCC2_COMPILED_FLAG_SYMBOL
 998 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
 999 #endif
1000
1001 /* Functions for dealing with the minimal symbol table, really a misc
1002    address<->symbol mapping for things we don't have debug symbols for.  */
1003
1004 extern void prim_record_minimal_symbol (const char *, CORE_ADDR,
1005                                         enum minimal_symbol_type,
1006                                         struct objfile *);
1007
1008 extern struct minimal_symbol *prim_record_minimal_symbol_full
1009   (const char *, int, int, CORE_ADDR,
1010    enum minimal_symbol_type,
1011    int section, asection * bfd_section, struct objfile *);
1012
1013 extern struct minimal_symbol *prim_record_minimal_symbol_and_info
1014   (const char *, CORE_ADDR,
1015    enum minimal_symbol_type,
1016    int section, asection * bfd_section, struct objfile *);
1017
1018 extern unsigned int msymbol_hash_iw (const char *);
1019
1020 extern unsigned int msymbol_hash (const char *);
1021
1022 /* Compute the next hash value from previous HASH and the character C.  This
1023    is only a GDB in-memory computed value with no external files compatibility
1024    requirements.  */
1025
1026 #define SYMBOL_HASH_NEXT(hash, c) \
1027   ((hash) * 67 + tolower ((unsigned char) (c)) - 113)
1028
1029 extern struct objfile * msymbol_objfile (struct minimal_symbol *sym);
1030
1031 extern void
1032 add_minsym_to_hash_table (struct minimal_symbol *sym,
1033                           struct minimal_symbol **table);
1034
1035 extern struct minimal_symbol *lookup_minimal_symbol (const char *,
1036                                                      const char *,
1037                                                      struct objfile *);
1038
1039 extern struct minimal_symbol *lookup_minimal_symbol_text (const char *,
1040                                                           struct objfile *);
1041
1042 struct minimal_symbol *lookup_minimal_symbol_solib_trampoline (const char *,
1043                                                                struct objfile
1044                                                                *);
1045
1046 extern struct minimal_symbol *lookup_minimal_symbol_by_pc_name
1047                                 (CORE_ADDR, const char *, struct objfile *);
1048
1049 extern struct minimal_symbol *lookup_minimal_symbol_by_pc (CORE_ADDR);
1050
1051 extern int in_gnu_ifunc_stub (CORE_ADDR pc);
1052
1053 /* Functions for resolving STT_GNU_IFUNC symbols which are implemented only
1054    for ELF symbol files.  */
1055
1056 struct gnu_ifunc_fns
1057 {
1058   /* See elf_gnu_ifunc_resolve_addr for its real implementation.  */
1059   CORE_ADDR (*gnu_ifunc_resolve_addr) (struct gdbarch *gdbarch, CORE_ADDR pc);
1060
1061   /* See elf_gnu_ifunc_resolve_name for its real implementation.  */
1062   int (*gnu_ifunc_resolve_name) (const char *function_name,
1063                                  CORE_ADDR *function_address_p);
1064
1065   /* See elf_gnu_ifunc_resolver_stop for its real implementation.  */
1066   void (*gnu_ifunc_resolver_stop) (struct breakpoint *b);
1067
1068   /* See elf_gnu_ifunc_resolver_return_stop for its real implementation.  */
1069   void (*gnu_ifunc_resolver_return_stop) (struct breakpoint *b);
1070 };
1071
1072 #define gnu_ifunc_resolve_addr gnu_ifunc_fns_p->gnu_ifunc_resolve_addr
1073 #define gnu_ifunc_resolve_name gnu_ifunc_fns_p->gnu_ifunc_resolve_name
1074 #define gnu_ifunc_resolver_stop gnu_ifunc_fns_p->gnu_ifunc_resolver_stop
1075 #define gnu_ifunc_resolver_return_stop \
1076   gnu_ifunc_fns_p->gnu_ifunc_resolver_return_stop
1077
1078 extern const struct gnu_ifunc_fns *gnu_ifunc_fns_p;
1079
1080 extern struct minimal_symbol *
1081     lookup_minimal_symbol_and_objfile (const char *,
1082                                        struct objfile **);
1083
1084 extern struct minimal_symbol
1085   *lookup_minimal_symbol_by_pc_section (CORE_ADDR, struct obj_section *);
1086
1087 extern struct minimal_symbol
1088   *lookup_solib_trampoline_symbol_by_pc (CORE_ADDR);
1089
1090 extern CORE_ADDR find_solib_trampoline_target (struct frame_info *, CORE_ADDR);
1091
1092 extern void init_minimal_symbol_collection (void);
1093
1094 extern struct cleanup *make_cleanup_discard_minimal_symbols (void);
1095
1096 extern void install_minimal_symbols (struct objfile *);
1097
1098 /* Sort all the minimal symbols in OBJFILE.  */
1099
1100 extern void msymbols_sort (struct objfile *objfile);
1101
1102 struct symtab_and_line
1103 {
1104   /* The program space of this sal.  */
1105   struct program_space *pspace;
1106
1107   struct symtab *symtab;
1108   struct obj_section *section;
1109   /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
1110      0 is never a valid line number; it is used to indicate that line number
1111      information is not available.  */
1112   int line;
1113
1114   CORE_ADDR pc;
1115   CORE_ADDR end;
1116   int explicit_pc;
1117   int explicit_line;
1118 };
1119
1120 extern void init_sal (struct symtab_and_line *sal);
1121
1122 struct symtabs_and_lines
1123 {
1124   struct symtab_and_line *sals;
1125   int nelts;
1126 };
1127 \f
1128
1129
1130 /* Some types and macros needed for exception catchpoints.
1131    Can't put these in target.h because symtab_and_line isn't
1132    known there.  This file will be included by breakpoint.c,
1133    hppa-tdep.c, etc.  */
1134
1135 /* Enums for exception-handling support.  */
1136 enum exception_event_kind
1137 {
1138   EX_EVENT_THROW,
1139   EX_EVENT_CATCH
1140 };
1141
1142 \f
1143
1144 /* Given a pc value, return line number it is in.  Second arg nonzero means
1145    if pc is on the boundary use the previous statement's line number.  */
1146
1147 extern struct symtab_and_line find_pc_line (CORE_ADDR, int);
1148
1149 /* Same function, but specify a section as well as an address.  */
1150
1151 extern struct symtab_and_line find_pc_sect_line (CORE_ADDR,
1152                                                  struct obj_section *, int);
1153
1154 /* Given a symtab and line number, return the pc there.  */
1155
1156 extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
1157
1158 extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
1159                                CORE_ADDR *);
1160
1161 extern void resolve_sal_pc (struct symtab_and_line *);
1162
1163 /* Given a string, return the line specified by it.  For commands like "list"
1164    and "breakpoint".  */
1165
1166 extern struct symtabs_and_lines decode_line_spec (char *, int);
1167
1168 extern struct symtabs_and_lines decode_line_spec_1 (char *, int);
1169
1170 /* Symmisc.c */
1171
1172 void maintenance_print_symbols (char *, int);
1173
1174 void maintenance_print_psymbols (char *, int);
1175
1176 void maintenance_print_msymbols (char *, int);
1177
1178 void maintenance_print_objfiles (char *, int);
1179
1180 void maintenance_info_symtabs (char *, int);
1181
1182 void maintenance_info_psymtabs (char *, int);
1183
1184 void maintenance_check_symtabs (char *, int);
1185
1186 /* maint.c */
1187
1188 void maintenance_print_statistics (char *, int);
1189
1190 /* Symbol-reading stuff in symfile.c and solib.c.  */
1191
1192 extern void clear_solib (void);
1193
1194 /* source.c */
1195
1196 extern int identify_source_line (struct symtab *, int, int, CORE_ADDR);
1197
1198 extern void print_source_lines (struct symtab *, int, int, int);
1199
1200 extern void forget_cached_source_info_for_objfile (struct objfile *);
1201 extern void forget_cached_source_info (void);
1202
1203 extern void select_source_symtab (struct symtab *);
1204
1205 extern char **default_make_symbol_completion_list_break_on
1206   (char *text, char *word, const char *break_on);
1207 extern char **default_make_symbol_completion_list (char *, char *);
1208 extern char **make_symbol_completion_list (char *, char *);
1209 extern char **make_symbol_completion_list_fn (struct cmd_list_element *,
1210                                               char *, char *);
1211
1212 extern char **make_file_symbol_completion_list (char *, char *, char *);
1213
1214 extern char **make_source_files_completion_list (char *, char *);
1215
1216 /* symtab.c */
1217
1218 int matching_obj_sections (struct obj_section *, struct obj_section *);
1219
1220 extern const char *find_main_filename (void);
1221
1222 extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
1223
1224 extern struct symtab_and_line find_function_start_sal (struct symbol *sym,
1225                                                        int);
1226
1227 extern void skip_prologue_sal (struct symtab_and_line *);
1228
1229 /* symfile.c */
1230
1231 extern void clear_symtab_users (int add_flags);
1232
1233 extern enum language deduce_language_from_filename (const char *);
1234
1235 /* symtab.c */
1236
1237 extern int in_prologue (struct gdbarch *gdbarch,
1238                         CORE_ADDR pc, CORE_ADDR func_start);
1239
1240 extern CORE_ADDR skip_prologue_using_sal (struct gdbarch *gdbarch,
1241                                           CORE_ADDR func_addr);
1242
1243 extern struct symbol *fixup_symbol_section (struct symbol *,
1244                                             struct objfile *);
1245
1246 /* Symbol searching */
1247
1248 /* When using search_symbols, a list of the following structs is returned.
1249    Callers must free the search list using free_search_symbols!  */
1250 struct symbol_search
1251 {
1252   /* The block in which the match was found.  Could be, for example,
1253      STATIC_BLOCK or GLOBAL_BLOCK.  */
1254   int block;
1255
1256   /* Information describing what was found.
1257
1258      If symtab abd symbol are NOT NULL, then information was found
1259      for this match.  */
1260   struct symtab *symtab;
1261   struct symbol *symbol;
1262
1263   /* If msymbol is non-null, then a match was made on something for
1264      which only minimal_symbols exist.  */
1265   struct minimal_symbol *msymbol;
1266
1267   /* A link to the next match, or NULL for the end.  */
1268   struct symbol_search *next;
1269 };
1270
1271 extern void search_symbols (char *, enum search_domain, int, char **,
1272                             struct symbol_search **);
1273 extern void free_search_symbols (struct symbol_search *);
1274 extern struct cleanup *make_cleanup_free_search_symbols (struct symbol_search
1275                                                          *);
1276
1277 /* The name of the ``main'' function.
1278    FIXME: cagney/2001-03-20: Can't make main_name() const since some
1279    of the calling code currently assumes that the string isn't
1280    const.  */
1281 extern void set_main_name (const char *name);
1282 extern /*const */ char *main_name (void);
1283 extern enum language language_of_main;
1284
1285 /* Check global symbols in objfile.  */
1286 struct symbol *lookup_global_symbol_from_objfile (const struct objfile *,
1287                                                   const char *name,
1288                                                   const domain_enum domain);
1289
1290 extern struct symtabs_and_lines expand_line_sal (struct symtab_and_line sal);
1291
1292 /* Return 1 if the supplied producer string matches the ARM RealView
1293    compiler (armcc).  */
1294 int producer_is_realview (const char *producer);
1295
1296 void fixup_section (struct general_symbol_info *ginfo,
1297                     CORE_ADDR addr, struct objfile *objfile);
1298
1299 struct objfile *lookup_objfile_from_block (const struct block *block);
1300
1301 #endif /* !defined(SYMTAB_H) */