gdb/symtab.h

   1 /* Symbol table definitions for GDB.
   2
   3    Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
   4    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
   5    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 2 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, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 #if !defined (SYMTAB_H)
  25 #define SYMTAB_H 1
  26
  27 /* Opaque declarations.  */
  28 struct ui_file;
  29 struct frame_info;
  30 struct symbol;
  31 struct obstack;
  32 struct objfile;
  33 struct block;
  34 struct blockvector;
  35 struct axs_value;
  36 struct agent_expr;
  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 layed 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
  80
  81 /* Define a structure for the information that is common to all symbol types,
  82    including minimal symbols, partial symbols, and full symbols.  In a
  83    multilanguage environment, some language specific information may need to
  84    be recorded along with each symbol. */
  85
  86 /* This structure is space critical.  See space comments at the top. */
  87
  88 struct general_symbol_info
  89 {
  90   /* Name of the symbol.  This is a required field.  Storage for the
  91      name is allocated on the psymbol_obstack or symbol_obstack for
  92      the associated objfile.  For languages like C++ that make a
  93      distinction between the mangled name and demangled name, this is
  94      the mangled name.  */
  95
  96   char *name;
  97
  98   /* Value of the symbol.  Which member of this union to use, and what
  99      it means, depends on what kind of symbol this is and its
 100      SYMBOL_CLASS.  See comments there for more details.  All of these
 101      are in host byte order (though what they point to might be in
 102      target byte order, e.g. LOC_CONST_BYTES).  */
 103
 104   union
 105   {
 106     /* The fact that this is a long not a LONGEST mainly limits the
 107        range of a LOC_CONST.  Since LOC_CONST_BYTES exists, I'm not
 108        sure that is a big deal.  */
 109     long ivalue;
 110
 111     struct block *block;
 112
 113     char *bytes;
 114
 115     CORE_ADDR address;
 116
 117     /* for opaque typedef struct chain */
 118
 119     struct symbol *chain;
 120   }
 121   value;
 122
 123   /* Since one and only one language can apply, wrap the language specific
 124      information inside a union. */
 125
 126   union
 127   {
 128     struct cplus_specific
 129     {
 130       /* This is in fact used for C++, Java, and Objective C.  */
 131       char *demangled_name;
 132     }
 133     cplus_specific;
 134   }
 135   language_specific;
 136
 137   /* Record the source code language that applies to this symbol.
 138      This is used to select one of the fields from the language specific
 139      union above. */
 140
 141   ENUM_BITFIELD(language) language : 8;
 142
 143   /* Which section is this symbol in?  This is an index into
 144      section_offsets for this objfile.  Negative means that the symbol
 145      does not get relocated relative to a section.
 146      Disclaimer: currently this is just used for xcoff, so don't
 147      expect all symbol-reading code to set it correctly (the ELF code
 148      also tries to set it correctly).  */
 149
 150   short section;
 151
 152   /* The bfd section associated with this symbol. */
 153
 154   asection *bfd_section;
 155 };
 156
 157 extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, asection *);
 158
 159 /* Note that all the following SYMBOL_* macros are used with the
 160    SYMBOL argument being either a partial symbol, a minimal symbol or
 161    a full symbol.  All three types have a ginfo field.  In particular
 162    the SYMBOL_INIT_LANGUAGE_SPECIFIC, SYMBOL_INIT_DEMANGLED_NAME,
 163    SYMBOL_DEMANGLED_NAME macros cannot be entirely substituted by
 164    functions, unless the callers are changed to pass in the ginfo
 165    field only, instead of the SYMBOL parameter.  */
 166
 167 #define DEPRECATED_SYMBOL_NAME(symbol)  (symbol)->ginfo.name
 168 #define SYMBOL_VALUE(symbol)            (symbol)->ginfo.value.ivalue
 169 #define SYMBOL_VALUE_ADDRESS(symbol)    (symbol)->ginfo.value.address
 170 #define SYMBOL_VALUE_BYTES(symbol)      (symbol)->ginfo.value.bytes
 171 #define SYMBOL_BLOCK_VALUE(symbol)      (symbol)->ginfo.value.block
 172 #define SYMBOL_VALUE_CHAIN(symbol)      (symbol)->ginfo.value.chain
 173 #define SYMBOL_LANGUAGE(symbol)         (symbol)->ginfo.language
 174 #define SYMBOL_SECTION(symbol)          (symbol)->ginfo.section
 175 #define SYMBOL_BFD_SECTION(symbol)      (symbol)->ginfo.bfd_section
 176
 177 #define SYMBOL_CPLUS_DEMANGLED_NAME(symbol)     \
 178   (symbol)->ginfo.language_specific.cplus_specific.demangled_name
 179
 180 /* Initializes the language dependent portion of a symbol
 181    depending upon the language for the symbol. */
 182 #define SYMBOL_INIT_LANGUAGE_SPECIFIC(symbol,language) \
 183   (symbol_init_language_specific (&(symbol)->ginfo, (language)))
 184 extern void symbol_init_language_specific (struct general_symbol_info *symbol,
 185                                            enum language language);
 186
 187 #define SYMBOL_INIT_DEMANGLED_NAME(symbol,obstack) \
 188   (symbol_init_demangled_name (&(symbol)->ginfo, (obstack)))
 189 extern void symbol_init_demangled_name (struct general_symbol_info *symbol,
 190                                         struct obstack *obstack);
 191
 192 #define SYMBOL_SET_NAMES(symbol,linkage_name,len,objfile) \
 193   symbol_set_names (&(symbol)->ginfo, linkage_name, len, objfile)
 194 extern void symbol_set_names (struct general_symbol_info *symbol,
 195                               const char *linkage_name, int len,
 196                               struct objfile *objfile);
 197
 198 /* Now come lots of name accessor macros.  Short version as to when to
 199    use which: Use SYMBOL_NATURAL_NAME to refer to the name of the
 200    symbol in the original source code.  Use SYMBOL_LINKAGE_NAME if you
 201    want to know what the linker thinks the symbol's name is.  Use
 202    SYMBOL_PRINT_NAME for output.  Use SYMBOL_DEMANGLED_NAME if you
 203    specifically need to know whether SYMBOL_NATURAL_NAME and
 204    SYMBOL_LINKAGE_NAME are different.  Don't use
 205    DEPRECATED_SYMBOL_NAME at all: instances of that macro should be
 206    replaced by SYMBOL_NATURAL_NAME, SYMBOL_LINKAGE_NAME, or perhaps
 207    SYMBOL_PRINT_NAME.  */
 208
 209 /* Return SYMBOL's "natural" name, i.e. the name that it was called in
 210    the original source code.  In languages like C++ where symbols may
 211    be mangled for ease of manipulation by the linker, this is the
 212    demangled name.  */
 213
 214 #define SYMBOL_NATURAL_NAME(symbol) \
 215   (symbol_natural_name (&(symbol)->ginfo))
 216 extern char *symbol_natural_name (const struct general_symbol_info *symbol);
 217
 218 /* Return SYMBOL's name from the point of view of the linker.  In
 219    languages like C++ where symbols may be mangled for ease of
 220    manipulation by the linker, this is the mangled name; otherwise,
 221    it's the same as SYMBOL_NATURAL_NAME.  This is currently identical
 222    to DEPRECATED_SYMBOL_NAME, but please use SYMBOL_LINKAGE_NAME when
 223    appropriate: it conveys the additional semantic information that
 224    you really have thought about the issue and decided that you mean
 225    SYMBOL_LINKAGE_NAME instead of SYMBOL_NATURAL_NAME.  */
 226
 227 #define SYMBOL_LINKAGE_NAME(symbol)     (symbol)->ginfo.name
 228
 229 /* Return the demangled name for a symbol based on the language for
 230    that symbol.  If no demangled name exists, return NULL. */
 231 #define SYMBOL_DEMANGLED_NAME(symbol) \
 232   (symbol_demangled_name (&(symbol)->ginfo))
 233 extern char *symbol_demangled_name (struct general_symbol_info *symbol);
 234
 235 /* Macro that returns a version of the name of a symbol that is
 236    suitable for output.  In C++ this is the "demangled" form of the
 237    name if demangle is on and the "mangled" form of the name if
 238    demangle is off.  In other languages this is just the symbol name.
 239    The result should never be NULL.  Don't use this for internal
 240    purposes (e.g. storing in a hashtable): it's only suitable for
 241    output.  */
 242
 243 #define SYMBOL_PRINT_NAME(symbol)                                       \
 244   (demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
 245
 246 /* Macro that tests a symbol for a match against a specified name string.
 247    First test the unencoded name, then looks for and test a C++ encoded
 248    name if it exists.  Note that whitespace is ignored while attempting to
 249    match a C++ encoded name, so that "foo::bar(int,long)" is the same as
 250    "foo :: bar (int, long)".
 251    Evaluates to zero if the match fails, or nonzero if it succeeds. */
 252
 253 /* Macro that tests a symbol for a match against a specified name
 254    string.  It tests against SYMBOL_NATURAL_NAME, and it ignores
 255    whitespace and trailing parentheses.  (See strcmp_iw for details
 256    about its behavior.)  */
 257
 258 #define SYMBOL_MATCHES_NATURAL_NAME(symbol, name)                       \
 259   (strcmp_iw (SYMBOL_NATURAL_NAME (symbol), (name)) == 0)
 260
 261 /* Classification types for a minimal symbol.  These should be taken as
 262    "advisory only", since if gdb can't easily figure out a
 263    classification it simply selects mst_unknown.  It may also have to
 264    guess when it can't figure out which is a better match between two
 265    types (mst_data versus mst_bss) for example.  Since the minimal
 266    symbol info is sometimes derived from the BFD library's view of a
 267    file, we need to live with what information bfd supplies. */
 268
 269 enum minimal_symbol_type
 270 {
 271   mst_unknown = 0,              /* Unknown type, the default */
 272   mst_text,                     /* Generally executable instructions */
 273   mst_data,                     /* Generally initialized data */
 274   mst_bss,                      /* Generally uninitialized data */
 275   mst_abs,                      /* Generally absolute (nonrelocatable) */
 276   /* GDB uses mst_solib_trampoline for the start address of a shared
 277      library trampoline entry.  Breakpoints for shared library functions
 278      are put there if the shared library is not yet loaded.
 279      After the shared library is loaded, lookup_minimal_symbol will
 280      prefer the minimal symbol from the shared library (usually
 281      a mst_text symbol) over the mst_solib_trampoline symbol, and the
 282      breakpoints will be moved to their true address in the shared
 283      library via breakpoint_re_set.  */
 284   mst_solib_trampoline,         /* Shared library trampoline code */
 285   /* For the mst_file* types, the names are only guaranteed to be unique
 286      within a given .o file.  */
 287   mst_file_text,                /* Static version of mst_text */
 288   mst_file_data,                /* Static version of mst_data */
 289   mst_file_bss                  /* Static version of mst_bss */
 290 };
 291
 292 /* Define a simple structure used to hold some very basic information about
 293    all defined global symbols (text, data, bss, abs, etc).  The only required
 294    information is the general_symbol_info.
 295
 296    In many cases, even if a file was compiled with no special options for
 297    debugging at all, as long as was not stripped it will contain sufficient
 298    information to build a useful minimal symbol table using this structure.
 299    Even when a file contains enough debugging information to build a full
 300    symbol table, these minimal symbols are still useful for quickly mapping
 301    between names and addresses, and vice versa.  They are also sometimes
 302    used to figure out what full symbol table entries need to be read in. */
 303
 304 struct minimal_symbol
 305 {
 306
 307   /* The general symbol info required for all types of symbols.
 308
 309      The SYMBOL_VALUE_ADDRESS contains the address that this symbol
 310      corresponds to.  */
 311
 312   struct general_symbol_info ginfo;
 313
 314   /* The info field is available for caching machine-specific information
 315      so it doesn't have to rederive the info constantly (over a serial line).
 316      It is initialized to zero and stays that way until target-dependent code
 317      sets it.  Storage for any data pointed to by this field should be allo-
 318      cated on the symbol_obstack for the associated objfile.
 319      The type would be "void *" except for reasons of compatibility with older
 320      compilers.  This field is optional.
 321
 322      Currently, the AMD 29000 tdep.c uses it to remember things it has decoded
 323      from the instructions in the function header, and the MIPS-16 code uses
 324      it to identify 16-bit procedures.  */
 325
 326   char *info;
 327
 328 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 329   /* Which source file is this symbol in?  Only relevant for mst_file_*.  */
 330   char *filename;
 331 #endif
 332
 333   /* Classification type for this minimal symbol.  */
 334
 335   ENUM_BITFIELD(minimal_symbol_type) type : 8;
 336
 337   /* Minimal symbols with the same hash key are kept on a linked
 338      list.  This is the link.  */
 339
 340   struct minimal_symbol *hash_next;
 341
 342   /* Minimal symbols are stored in two different hash tables.  This is
 343      the `next' pointer for the demangled hash table.  */
 344
 345   struct minimal_symbol *demangled_hash_next;
 346 };
 347
 348 #define MSYMBOL_INFO(msymbol)           (msymbol)->info
 349 #define MSYMBOL_TYPE(msymbol)           (msymbol)->type
 350
 351 \f
 352
 353 /* Represent one symbol name; a variable, constant, function or typedef.  */
 354
 355 /* Different name domains for symbols.  Looking up a symbol specifies a
 356    domain and ignores symbol definitions in other name domains. */
 357
 358 typedef enum domain_enum_tag
 359 {
 360   /* UNDEF_DOMAIN is used when a domain has not been discovered or
 361      none of the following apply.  This usually indicates an error either
 362      in the symbol information or in gdb's handling of symbols. */
 363
 364   UNDEF_DOMAIN,
 365
 366   /* VAR_DOMAIN is the usual domain.  In C, this contains variables,
 367      function names, typedef names and enum type values. */
 368
 369   VAR_DOMAIN,
 370
 371   /* STRUCT_DOMAIN is used in C to hold struct, union and enum type names.
 372      Thus, if `struct foo' is used in a C program, it produces a symbol named
 373      `foo' in the STRUCT_DOMAIN. */
 374
 375   STRUCT_DOMAIN,
 376
 377   /* LABEL_DOMAIN may be used for names of labels (for gotos);
 378      currently it is not used and labels are not recorded at all.  */
 379
 380   LABEL_DOMAIN,
 381
 382   /* Searching domains. These overlap with VAR_DOMAIN, providing
 383      some granularity with the search_symbols function. */
 384
 385   /* Everything in VAR_DOMAIN minus FUNCTIONS_-, TYPES_-, and
 386      METHODS_DOMAIN */
 387   VARIABLES_DOMAIN,
 388
 389   /* All functions -- for some reason not methods, though. */
 390   FUNCTIONS_DOMAIN,
 391
 392   /* All defined types */
 393   TYPES_DOMAIN,
 394
 395   /* All class methods -- why is this separated out? */
 396   METHODS_DOMAIN
 397 }
 398 domain_enum;
 399
 400 /* An address-class says where to find the value of a symbol.  */
 401
 402 enum address_class
 403 {
 404   /* Not used; catches errors */
 405
 406   LOC_UNDEF,
 407
 408   /* Value is constant int SYMBOL_VALUE, host byteorder */
 409
 410   LOC_CONST,
 411
 412   /* Value is at fixed address SYMBOL_VALUE_ADDRESS */
 413
 414   LOC_STATIC,
 415
 416   /* Value is in register.  SYMBOL_VALUE is the register number.  */
 417
 418   LOC_REGISTER,
 419
 420   /* It's an argument; the value is at SYMBOL_VALUE offset in arglist.  */
 421
 422   LOC_ARG,
 423
 424   /* Value address is at SYMBOL_VALUE offset in arglist.  */
 425
 426   LOC_REF_ARG,
 427
 428   /* Value is in register number SYMBOL_VALUE.  Just like LOC_REGISTER
 429      except this is an argument.  Probably the cleaner way to handle
 430      this would be to separate address_class (which would include
 431      separate ARG and LOCAL to deal with the frame's arguments
 432      (get_frame_args_address) versus the frame's locals
 433      (get_frame_locals_address), and an is_argument flag.
 434
 435      For some symbol formats (stabs, for some compilers at least),
 436      the compiler generates two symbols, an argument and a register.
 437      In some cases we combine them to a single LOC_REGPARM in symbol
 438      reading, but currently not for all cases (e.g. it's passed on the
 439      stack and then loaded into a register).  */
 440
 441   LOC_REGPARM,
 442
 443   /* Value is in specified register.  Just like LOC_REGPARM except the
 444      register holds the address of the argument instead of the argument
 445      itself. This is currently used for the passing of structs and unions
 446      on sparc and hppa.  It is also used for call by reference where the
 447      address is in a register, at least by mipsread.c.  */
 448
 449   LOC_REGPARM_ADDR,
 450
 451   /* Value is a local variable at SYMBOL_VALUE offset in stack frame.  */
 452
 453   LOC_LOCAL,
 454
 455   /* Value not used; definition in SYMBOL_TYPE.  Symbols in the domain
 456      STRUCT_DOMAIN all have this class.  */
 457
 458   LOC_TYPEDEF,
 459
 460   /* Value is address SYMBOL_VALUE_ADDRESS in the code */
 461
 462   LOC_LABEL,
 463
 464   /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
 465      In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
 466      of the block.  Function names have this class. */
 467
 468   LOC_BLOCK,
 469
 470   /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
 471      target byte order.  */
 472
 473   LOC_CONST_BYTES,
 474
 475   /* Value is arg at SYMBOL_VALUE offset in stack frame. Differs from
 476      LOC_LOCAL in that symbol is an argument; differs from LOC_ARG in
 477      that we find it in the frame (get_frame_locals_address), not in
 478      the arglist (get_frame_args_address).  Added for i960, which
 479      passes args in regs then copies to frame.  */
 480
 481   LOC_LOCAL_ARG,
 482
 483   /* Value is at SYMBOL_VALUE offset from the current value of
 484      register number SYMBOL_BASEREG.  This exists mainly for the same
 485      things that LOC_LOCAL and LOC_ARG do; but we need to do this
 486      instead because on 88k DWARF gives us the offset from the
 487      frame/stack pointer, rather than the offset from the "canonical
 488      frame address" used by COFF, stabs, etc., and we don't know how
 489      to convert between these until we start examining prologues.
 490
 491      Note that LOC_BASEREG is much less general than a DWARF expression.
 492      We don't need the generality (at least not yet), and storing a general
 493      DWARF expression would presumably take up more space than the existing
 494      scheme.  */
 495
 496   LOC_BASEREG,
 497
 498   /* Same as LOC_BASEREG but it is an argument.  */
 499
 500   LOC_BASEREG_ARG,
 501
 502   /* Value is at fixed address, but the address of the variable has
 503      to be determined from the minimal symbol table whenever the
 504      variable is referenced.
 505      This happens if debugging information for a global symbol is
 506      emitted and the corresponding minimal symbol is defined
 507      in another object file or runtime common storage.
 508      The linker might even remove the minimal symbol if the global
 509      symbol is never referenced, in which case the symbol remains
 510      unresolved.  */
 511
 512   LOC_UNRESOLVED,
 513
 514   /* Value is at a thread-specific location calculated by a
 515      target-specific method. This is used only by hppa.  */
 516
 517   LOC_HP_THREAD_LOCAL_STATIC,
 518
 519   /* The variable does not actually exist in the program.
 520      The value is ignored.  */
 521
 522   LOC_OPTIMIZED_OUT,
 523
 524   /* The variable is static, but actually lives at * (address).
 525    * I.e. do an extra indirection to get to it.
 526    * This is used on HP-UX to get at globals that are allocated
 527    * in shared libraries, where references from images other
 528    * than the one where the global was allocated are done
 529    * with a level of indirection.
 530    */
 531
 532   LOC_INDIRECT,
 533
 534   /* The variable's address is computed by a set of location
 535      functions (see "struct location_funcs" below).  */
 536   LOC_COMPUTED,
 537
 538   /* Same as LOC_COMPUTED, but for function arguments.  */
 539   LOC_COMPUTED_ARG
 540 };
 541
 542 /* A structure of function pointers describing the location of a
 543    variable, structure member, or structure base class.
 544
 545    These functions' BATON arguments are generic data pointers, holding
 546    whatever data the functions need --- the code which provides this
 547    structure also provides the actual contents of the baton, and
 548    decides its form.  However, there may be other rules about where
 549    the baton data must be allocated; whoever is pointing to this
 550    `struct location_funcs' object will know the rules.  For example,
 551    when a symbol S's location is LOC_COMPUTED, then
 552    SYMBOL_LOCATION_FUNCS(S) is pointing to a location_funcs structure,
 553    and SYMBOL_LOCATION_BATON(S) is the baton, which must be allocated
 554    on the same obstack as the symbol itself.  */
 555
 556 struct location_funcs
 557 {
 558
 559   /* Return the value of the variable SYMBOL, relative to the stack
 560      frame FRAME.  If the variable has been optimized out, return
 561      zero.
 562
 563      Iff `read_needs_frame (SYMBOL)' is zero, then FRAME may be zero.  */
 564
 565   struct value *(*read_variable) (struct symbol * symbol,
 566                                   struct frame_info * frame);
 567
 568   /* Return non-zero if we need a frame to find the value of the SYMBOL.  */
 569   int (*read_needs_frame) (struct symbol * symbol);
 570
 571   /* Write to STREAM a natural-language description of the location of
 572      SYMBOL.  */
 573   int (*describe_location) (struct symbol * symbol, struct ui_file * stream);
 574
 575   /* Tracepoint support.  Append bytecodes to the tracepoint agent
 576      expression AX that push the address of the object SYMBOL.  Set
 577      VALUE appropriately.  Note --- for objects in registers, this
 578      needn't emit any code; as long as it sets VALUE properly, then
 579      the caller will generate the right code in the process of
 580      treating this as an lvalue or rvalue.  */
 581
 582   void (*tracepoint_var_ref) (struct symbol * symbol, struct agent_expr * ax,
 583                               struct axs_value * value);
 584 };
 585
 586 /* Linked list of symbol's live ranges. */
 587
 588 struct range_list
 589 {
 590   CORE_ADDR start;
 591   CORE_ADDR end;
 592   struct range_list *next;
 593 };
 594
 595 /* Linked list of aliases for a particular main/primary symbol.  */
 596 struct alias_list
 597 {
 598   struct symbol *sym;
 599   struct alias_list *next;
 600 };
 601
 602 /* This structure is space critical.  See space comments at the top. */
 603
 604 struct symbol
 605 {
 606
 607   /* The general symbol info required for all types of symbols. */
 608
 609   struct general_symbol_info ginfo;
 610
 611   /* Data type of value */
 612
 613   struct type *type;
 614
 615   /* Domain code.  */
 616
 617   ENUM_BITFIELD(domain_enum_tag) domain : 6;
 618
 619   /* Address class */
 620
 621   ENUM_BITFIELD(address_class) aclass : 6;
 622
 623   /* Line number of definition.  FIXME:  Should we really make the assumption
 624      that nobody will try to debug files longer than 64K lines?  What about
 625      machine generated programs? */
 626
 627   unsigned short line;
 628
 629   /* Some symbols require an additional value to be recorded on a per-
 630      symbol basis.  Stash those values here. */
 631
 632   union
 633   {
 634     /* Used by LOC_BASEREG and LOC_BASEREG_ARG.  */
 635     short basereg;
 636
 637     /* For a LOC_COMPUTED or LOC_COMPUTED_ARG symbol, this is the
 638        baton and location_funcs structure to find its location.  For a
 639        LOC_BLOCK symbol for a function in a compilation unit compiled
 640        with DWARF 2 information, this is information used internally
 641        by the DWARF 2 code --- specifically, the location expression
 642        for the frame base for this function.  */
 643     /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
 644        to add a magic symbol to the block containing this information,
 645        or to have a generic debug info annotation slot for symbols.  */
 646     struct
 647     {
 648       void *baton;
 649       struct location_funcs *funcs;
 650     } loc;
 651   }
 652   aux_value;
 653
 654
 655   /* Link to a list of aliases for this symbol.
 656      Only a "primary/main symbol may have aliases.  */
 657   struct alias_list *aliases;
 658
 659   /* List of ranges where this symbol is active.  This is only
 660      used by alias symbols at the current time.  */
 661   struct range_list *ranges;
 662
 663   struct symbol *hash_next;
 664 };
 665
 666
 667 #define SYMBOL_DOMAIN(symbol)   (symbol)->domain
 668 #define SYMBOL_CLASS(symbol)            (symbol)->aclass
 669 #define SYMBOL_TYPE(symbol)             (symbol)->type
 670 #define SYMBOL_LINE(symbol)             (symbol)->line
 671 #define SYMBOL_BASEREG(symbol)          (symbol)->aux_value.basereg
 672 #define SYMBOL_OBJFILE(symbol)          (symbol)->aux_value.objfile
 673 #define SYMBOL_ALIASES(symbol)          (symbol)->aliases
 674 #define SYMBOL_RANGES(symbol)           (symbol)->ranges
 675 #define SYMBOL_LOCATION_BATON(symbol)   (symbol)->aux_value.loc.baton
 676 #define SYMBOL_LOCATION_FUNCS(symbol)   (symbol)->aux_value.loc.funcs
 677 \f
 678 /* A partial_symbol records the name, domain, and address class of
 679    symbols whose types we have not parsed yet.  For functions, it also
 680    contains their memory address, so we can find them from a PC value.
 681    Each partial_symbol sits in a partial_symtab, all of which are chained
 682    on a  partial symtab list and which points to the corresponding
 683    normal symtab once the partial_symtab has been referenced.  */
 684
 685 /* This structure is space critical.  See space comments at the top. */
 686
 687 struct partial_symbol
 688 {
 689
 690   /* The general symbol info required for all types of symbols. */
 691
 692   struct general_symbol_info ginfo;
 693
 694   /* Name space code.  */
 695
 696   ENUM_BITFIELD(domain_enum_tag) domain : 6;
 697
 698   /* Address class (for info_symbols) */
 699
 700   ENUM_BITFIELD(address_class) aclass : 6;
 701
 702 };
 703
 704 #define PSYMBOL_DOMAIN(psymbol) (psymbol)->domain
 705 #define PSYMBOL_CLASS(psymbol)          (psymbol)->aclass
 706 \f
 707
 708 /* Each item represents a line-->pc (or the reverse) mapping.  This is
 709    somewhat more wasteful of space than one might wish, but since only
 710    the files which are actually debugged are read in to core, we don't
 711    waste much space.  */
 712
 713 struct linetable_entry
 714 {
 715   int line;
 716   CORE_ADDR pc;
 717 };
 718
 719 /* The order of entries in the linetable is significant.  They should
 720    be sorted by increasing values of the pc field.  If there is more than
 721    one entry for a given pc, then I'm not sure what should happen (and
 722    I not sure whether we currently handle it the best way).
 723
 724    Example: a C for statement generally looks like this
 725
 726    10   0x100   - for the init/test part of a for stmt.
 727    20   0x200
 728    30   0x300
 729    10   0x400   - for the increment part of a for stmt.
 730
 731    If an entry has a line number of zero, it marks the start of a PC
 732    range for which no line number information is available.  It is
 733    acceptable, though wasteful of table space, for such a range to be
 734    zero length.  */
 735
 736 struct linetable
 737 {
 738   int nitems;
 739
 740   /* Actually NITEMS elements.  If you don't like this use of the
 741      `struct hack', you can shove it up your ANSI (seriously, if the
 742      committee tells us how to do it, we can probably go along).  */
 743   struct linetable_entry item[1];
 744 };
 745
 746 /* How to relocate the symbols from each section in a symbol file.
 747    Each struct contains an array of offsets.
 748    The ordering and meaning of the offsets is file-type-dependent;
 749    typically it is indexed by section numbers or symbol types or
 750    something like that.
 751
 752    To give us flexibility in changing the internal representation
 753    of these offsets, the ANOFFSET macro must be used to insert and
 754    extract offset values in the struct.  */
 755
 756 struct section_offsets
 757 {
 758   CORE_ADDR offsets[1];         /* As many as needed. */
 759 };
 760
 761 #define ANOFFSET(secoff, whichone) \
 762    ((whichone == -1) \
 763     ? (internal_error (__FILE__, __LINE__, "Section index is uninitialized"), -1) \
 764     : secoff->offsets[whichone])
 765
 766 /* The size of a section_offsets table for N sections.  */
 767 #define SIZEOF_N_SECTION_OFFSETS(n) \
 768   (sizeof (struct section_offsets) \
 769    + sizeof (((struct section_offsets *) 0)->offsets) * ((n)-1))
 770
 771 /* Each source file or header is represented by a struct symtab.
 772    These objects are chained through the `next' field.  */
 773
 774 struct symtab
 775 {
 776
 777   /* Chain of all existing symtabs.  */
 778
 779   struct symtab *next;
 780
 781   /* List of all symbol scope blocks for this symtab.  May be shared
 782      between different symtabs (and normally is for all the symtabs
 783      in a given compilation unit).  */
 784
 785   struct blockvector *blockvector;
 786
 787   /* Table mapping core addresses to line numbers for this file.
 788      Can be NULL if none.  Never shared between different symtabs.  */
 789
 790   struct linetable *linetable;
 791
 792   /* Section in objfile->section_offsets for the blockvector and
 793      the linetable.  Probably always SECT_OFF_TEXT.  */
 794
 795   int block_line_section;
 796
 797   /* If several symtabs share a blockvector, exactly one of them
 798      should be designated the primary, so that the blockvector
 799      is relocated exactly once by objfile_relocate.  */
 800
 801   int primary;
 802
 803   /* The macro table for this symtab.  Like the blockvector, this
 804      may be shared between different symtabs --- and normally is for
 805      all the symtabs in a given compilation unit.  */
 806   struct macro_table *macro_table;
 807
 808   /* Name of this source file.  */
 809
 810   char *filename;
 811
 812   /* Directory in which it was compiled, or NULL if we don't know.  */
 813
 814   char *dirname;
 815
 816   /* This component says how to free the data we point to:
 817      free_contents => do a tree walk and free each object.
 818      free_nothing => do nothing; some other symtab will free
 819      the data this one uses.
 820      free_linetable => free just the linetable.  FIXME: Is this redundant
 821      with the primary field?  */
 822
 823   enum free_code
 824   {
 825     free_nothing, free_contents, free_linetable
 826   }
 827   free_code;
 828
 829   /* A function to call to free space, if necessary.  This is IN
 830      ADDITION to the action indicated by free_code.  */
 831
 832   void (*free_func)(struct symtab *symtab);
 833
 834   /* Total number of lines found in source file.  */
 835
 836   int nlines;
 837
 838   /* line_charpos[N] is the position of the (N-1)th line of the
 839      source file.  "position" means something we can lseek() to; it
 840      is not guaranteed to be useful any other way.  */
 841
 842   int *line_charpos;
 843
 844   /* Language of this source file.  */
 845
 846   enum language language;
 847
 848   /* String that identifies the format of the debugging information, such
 849      as "stabs", "dwarf 1", "dwarf 2", "coff", etc.  This is mostly useful
 850      for automated testing of gdb but may also be information that is
 851      useful to the user. */
 852
 853   char *debugformat;
 854
 855   /* String of version information.  May be zero.  */
 856
 857   char *version;
 858
 859   /* Full name of file as found by searching the source path.
 860      NULL if not yet known.  */
 861
 862   char *fullname;
 863
 864   /* Object file from which this symbol information was read.  */
 865
 866   struct objfile *objfile;
 867
 868 };
 869
 870 #define BLOCKVECTOR(symtab)     (symtab)->blockvector
 871 #define LINETABLE(symtab)       (symtab)->linetable
 872 \f
 873
 874 /* Each source file that has not been fully read in is represented by
 875    a partial_symtab.  This contains the information on where in the
 876    executable the debugging symbols for a specific file are, and a
 877    list of names of global symbols which are located in this file.
 878    They are all chained on partial symtab lists.
 879
 880    Even after the source file has been read into a symtab, the
 881    partial_symtab remains around.  They are allocated on an obstack,
 882    psymbol_obstack.  FIXME, this is bad for dynamic linking or VxWorks-
 883    style execution of a bunch of .o's.  */
 884
 885 struct partial_symtab
 886 {
 887
 888   /* Chain of all existing partial symtabs.  */
 889
 890   struct partial_symtab *next;
 891
 892   /* Name of the source file which this partial_symtab defines */
 893
 894   char *filename;
 895
 896   /* Full path of the source file.  NULL if not known.  */
 897
 898   char *fullname;
 899
 900   /* Information about the object file from which symbols should be read.  */
 901
 902   struct objfile *objfile;
 903
 904   /* Set of relocation offsets to apply to each section.  */
 905
 906   struct section_offsets *section_offsets;
 907
 908   /* Range of text addresses covered by this file; texthigh is the
 909      beginning of the next section. */
 910
 911   CORE_ADDR textlow;
 912   CORE_ADDR texthigh;
 913
 914   /* Array of pointers to all of the partial_symtab's which this one
 915      depends on.  Since this array can only be set to previous or
 916      the current (?) psymtab, this dependency tree is guaranteed not
 917      to have any loops.  "depends on" means that symbols must be read
 918      for the dependencies before being read for this psymtab; this is
 919      for type references in stabs, where if foo.c includes foo.h, declarations
 920      in foo.h may use type numbers defined in foo.c.  For other debugging
 921      formats there may be no need to use dependencies.  */
 922
 923   struct partial_symtab **dependencies;
 924
 925   int number_of_dependencies;
 926
 927   /* Global symbol list.  This list will be sorted after readin to
 928      improve access.  Binary search will be the usual method of
 929      finding a symbol within it. globals_offset is an integer offset
 930      within global_psymbols[].  */
 931
 932   int globals_offset;
 933   int n_global_syms;
 934
 935   /* Static symbol list.  This list will *not* be sorted after readin;
 936      to find a symbol in it, exhaustive search must be used.  This is
 937      reasonable because searches through this list will eventually
 938      lead to either the read in of a files symbols for real (assumed
 939      to take a *lot* of time; check) or an error (and we don't care
 940      how long errors take).  This is an offset and size within
 941      static_psymbols[].  */
 942
 943   int statics_offset;
 944   int n_static_syms;
 945
 946   /* Pointer to symtab eventually allocated for this source file, 0 if
 947      !readin or if we haven't looked for the symtab after it was readin.  */
 948
 949   struct symtab *symtab;
 950
 951   /* Pointer to function which will read in the symtab corresponding to
 952      this psymtab.  */
 953
 954   void (*read_symtab) (struct partial_symtab *);
 955
 956   /* Information that lets read_symtab() locate the part of the symbol table
 957      that this psymtab corresponds to.  This information is private to the
 958      format-dependent symbol reading routines.  For further detail examine
 959      the various symbol reading modules.  Should really be (void *) but is
 960      (char *) as with other such gdb variables.  (FIXME) */
 961
 962   char *read_symtab_private;
 963
 964   /* Non-zero if the symtab corresponding to this psymtab has been readin */
 965
 966   unsigned char readin;
 967 };
 968
 969 /* A fast way to get from a psymtab to its symtab (after the first time).  */
 970 #define PSYMTAB_TO_SYMTAB(pst)  \
 971     ((pst) -> symtab != NULL ? (pst) -> symtab : psymtab_to_symtab (pst))
 972 \f
 973
 974 /* The virtual function table is now an array of structures which have the
 975    form { int16 offset, delta; void *pfn; }.
 976
 977    In normal virtual function tables, OFFSET is unused.
 978    DELTA is the amount which is added to the apparent object's base
 979    address in order to point to the actual object to which the
 980    virtual function should be applied.
 981    PFN is a pointer to the virtual function.
 982
 983    Note that this macro is g++ specific (FIXME). */
 984
 985 #define VTBL_FNADDR_OFFSET 2
 986
 987 /* External variables and functions for the objects described above. */
 988
 989 /* See the comment in symfile.c about how current_objfile is used. */
 990
 991 extern struct objfile *current_objfile;
 992
 993 /* True if we are nested inside psymtab_to_symtab. */
 994
 995 extern int currently_reading_symtab;
 996
 997 /* From utils.c.  */
 998 extern int demangle;
 999 extern int asm_demangle;
1000
1001 /* symtab.c lookup functions */
1002
1003 /* lookup a symbol table by source file name */
1004
1005 extern struct symtab *lookup_symtab (const char *);
1006
1007 /* lookup a symbol by name (optional block, optional symtab) */
1008
1009 extern struct symbol *lookup_symbol (const char *, const struct block *,
1010                                      const domain_enum, int *,
1011                                      struct symtab **);
1012
1013 /* A default version of lookup_symbol_nonlocal for use by languages
1014    that can't think of anything better to do.  */
1015
1016 extern struct symbol *basic_lookup_symbol_nonlocal (const char *,
1017                                                     const char *,
1018                                                     const struct block *,
1019                                                     const domain_enum,
1020                                                     struct symtab **);
1021
1022 /* Some helper functions for languages that need to write their own
1023    lookup_symbol_nonlocal functions.  */
1024
1025 /* Lookup a symbol in the static block associated to BLOCK, if there
1026    is one; do nothing if BLOCK is NULL or a global block.  */
1027
1028 extern struct symbol *lookup_symbol_static (const char *name,
1029                                             const char *linkage_name,
1030                                             const struct block *block,
1031                                             const domain_enum domain,
1032                                             struct symtab **symtab);
1033
1034 /* Lookup a symbol in all files' global blocks (searching psymtabs if
1035    necessary).  */
1036
1037 extern struct symbol *lookup_symbol_global (const char *name,
1038                                             const char *linkage_name,
1039                                             const domain_enum domain,
1040                                             struct symtab **symtab);
1041
1042 /* Lookup a symbol within the block BLOCK.  This, unlike
1043    lookup_symbol_block, will set SYMTAB and BLOCK_FOUND correctly, and
1044    will fix up the symbol if necessary.  */
1045
1046 extern struct symbol *lookup_symbol_aux_block (const char *name,
1047                                                const char *linkage_name,
1048                                                const struct block *block,
1049                                                const domain_enum domain,
1050                                                struct symtab **symtab);
1051
1052 /* Lookup a partial symbol.  */
1053
1054 extern struct partial_symbol *lookup_partial_symbol (struct partial_symtab *,
1055                                                      const char *,
1056                                                      const char *, int,
1057                                                      domain_enum);
1058
1059 /* lookup a symbol by name, within a specified block */
1060
1061 extern struct symbol *lookup_block_symbol (const struct block *, const char *,
1062                                            const char *,
1063                                            const domain_enum);
1064
1065 /* lookup a [struct, union, enum] by name, within a specified block */
1066
1067 extern struct type *lookup_struct (char *, struct block *);
1068
1069 extern struct type *lookup_union (char *, struct block *);
1070
1071 extern struct type *lookup_enum (char *, struct block *);
1072
1073 /* from blockframe.c: */
1074
1075 /* lookup the function symbol corresponding to the address */
1076
1077 extern struct symbol *find_pc_function (CORE_ADDR);
1078
1079 /* lookup the function corresponding to the address and section */
1080
1081 extern struct symbol *find_pc_sect_function (CORE_ADDR, asection *);
1082
1083 /* lookup function from address, return name, start addr and end addr */
1084
1085 extern int find_pc_partial_function (CORE_ADDR, char **, CORE_ADDR *,
1086                                      CORE_ADDR *);
1087
1088 extern void clear_pc_function_cache (void);
1089
1090 extern int find_pc_sect_partial_function (CORE_ADDR, asection *,
1091                                           char **, CORE_ADDR *, CORE_ADDR *);
1092
1093 /* from symtab.c: */
1094
1095 /* lookup partial symbol table by filename */
1096
1097 extern struct partial_symtab *lookup_partial_symtab (const char *);
1098
1099 /* lookup partial symbol table by address */
1100
1101 extern struct partial_symtab *find_pc_psymtab (CORE_ADDR);
1102
1103 /* lookup partial symbol table by address and section */
1104
1105 extern struct partial_symtab *find_pc_sect_psymtab (CORE_ADDR, asection *);
1106
1107 /* lookup full symbol table by address */
1108
1109 extern struct symtab *find_pc_symtab (CORE_ADDR);
1110
1111 /* lookup full symbol table by address and section */
1112
1113 extern struct symtab *find_pc_sect_symtab (CORE_ADDR, asection *);
1114
1115 /* lookup partial symbol by address */
1116
1117 extern struct partial_symbol *find_pc_psymbol (struct partial_symtab *,
1118                                                CORE_ADDR);
1119
1120 /* lookup partial symbol by address and section */
1121
1122 extern struct partial_symbol *find_pc_sect_psymbol (struct partial_symtab *,
1123                                                     CORE_ADDR, asection *);
1124
1125 extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
1126
1127 extern void reread_symbols (void);
1128
1129 extern struct type *lookup_transparent_type (const char *);
1130
1131
1132 /* Macro for name of symbol to indicate a file compiled with gcc. */
1133 #ifndef GCC_COMPILED_FLAG_SYMBOL
1134 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
1135 #endif
1136
1137 /* Macro for name of symbol to indicate a file compiled with gcc2. */
1138 #ifndef GCC2_COMPILED_FLAG_SYMBOL
1139 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
1140 #endif
1141
1142 /* Functions for dealing with the minimal symbol table, really a misc
1143    address<->symbol mapping for things we don't have debug symbols for.  */
1144
1145 extern void prim_record_minimal_symbol (const char *, CORE_ADDR,
1146                                         enum minimal_symbol_type,
1147                                         struct objfile *);
1148
1149 extern struct minimal_symbol *prim_record_minimal_symbol_and_info
1150   (const char *, CORE_ADDR,
1151    enum minimal_symbol_type,
1152    char *info, int section, asection * bfd_section, struct objfile *);
1153
1154 extern unsigned int msymbol_hash_iw (const char *);
1155
1156 extern unsigned int msymbol_hash (const char *);
1157
1158 extern void
1159 add_minsym_to_hash_table (struct minimal_symbol *sym,
1160                           struct minimal_symbol **table);
1161
1162 extern struct minimal_symbol *lookup_minimal_symbol (const char *,
1163                                                      const char *,
1164                                                      struct objfile *);
1165
1166 extern struct minimal_symbol *lookup_minimal_symbol_text (const char *,
1167                                                           const char *,
1168                                                           struct objfile *);
1169
1170 struct minimal_symbol *lookup_minimal_symbol_solib_trampoline (const char *,
1171                                                                const char *,
1172                                                                struct objfile
1173                                                                *);
1174
1175 extern struct minimal_symbol *lookup_minimal_symbol_by_pc (CORE_ADDR);
1176
1177 extern struct minimal_symbol *lookup_minimal_symbol_by_pc_section (CORE_ADDR,
1178                                                                    asection
1179                                                                    *);
1180
1181 extern struct minimal_symbol
1182   *lookup_solib_trampoline_symbol_by_pc (CORE_ADDR);
1183
1184 extern CORE_ADDR find_solib_trampoline_target (CORE_ADDR);
1185
1186 extern void init_minimal_symbol_collection (void);
1187
1188 extern struct cleanup *make_cleanup_discard_minimal_symbols (void);
1189
1190 extern void install_minimal_symbols (struct objfile *);
1191
1192 /* Sort all the minimal symbols in OBJFILE.  */
1193
1194 extern void msymbols_sort (struct objfile *objfile);
1195
1196 struct symtab_and_line
1197 {
1198   struct symtab *symtab;
1199   asection *section;
1200   /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
1201      0 is never a valid line number; it is used to indicate that line number
1202      information is not available.  */
1203   int line;
1204
1205   CORE_ADDR pc;
1206   CORE_ADDR end;
1207 };
1208
1209 extern void init_sal (struct symtab_and_line *sal);
1210
1211 struct symtabs_and_lines
1212 {
1213   struct symtab_and_line *sals;
1214   int nelts;
1215 };
1216 \f
1217
1218
1219 /* Some types and macros needed for exception catchpoints.
1220    Can't put these in target.h because symtab_and_line isn't
1221    known there. This file will be included by breakpoint.c,
1222    hppa-tdep.c, etc. */
1223
1224 /* Enums for exception-handling support */
1225 enum exception_event_kind
1226 {
1227   EX_EVENT_THROW,
1228   EX_EVENT_CATCH
1229 };
1230
1231 /* Type for returning info about an exception */
1232 struct exception_event_record
1233 {
1234   enum exception_event_kind kind;
1235   struct symtab_and_line throw_sal;
1236   struct symtab_and_line catch_sal;
1237   /* This may need to be extended in the future, if
1238      some platforms allow reporting more information,
1239      such as point of rethrow, type of exception object,
1240      type expected by catch clause, etc. */
1241 };
1242
1243 #define CURRENT_EXCEPTION_KIND       (current_exception_event->kind)
1244 #define CURRENT_EXCEPTION_CATCH_SAL  (current_exception_event->catch_sal)
1245 #define CURRENT_EXCEPTION_CATCH_LINE (current_exception_event->catch_sal.line)
1246 #define CURRENT_EXCEPTION_CATCH_FILE (current_exception_event->catch_sal.symtab->filename)
1247 #define CURRENT_EXCEPTION_CATCH_PC   (current_exception_event->catch_sal.pc)
1248 #define CURRENT_EXCEPTION_THROW_SAL  (current_exception_event->throw_sal)
1249 #define CURRENT_EXCEPTION_THROW_LINE (current_exception_event->throw_sal.line)
1250 #define CURRENT_EXCEPTION_THROW_FILE (current_exception_event->throw_sal.symtab->filename)
1251 #define CURRENT_EXCEPTION_THROW_PC   (current_exception_event->throw_sal.pc)
1252 \f
1253
1254 /* Given a pc value, return line number it is in.  Second arg nonzero means
1255    if pc is on the boundary use the previous statement's line number.  */
1256
1257 extern struct symtab_and_line find_pc_line (CORE_ADDR, int);
1258
1259 /* Same function, but specify a section as well as an address */
1260
1261 extern struct symtab_and_line find_pc_sect_line (CORE_ADDR, asection *, int);
1262
1263 /* Given a symtab and line number, return the pc there.  */
1264
1265 extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
1266
1267 extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
1268                                CORE_ADDR *);
1269
1270 extern void resolve_sal_pc (struct symtab_and_line *);
1271
1272 /* Given a string, return the line specified by it.  For commands like "list"
1273    and "breakpoint".  */
1274
1275 extern struct symtabs_and_lines decode_line_spec (char *, int);
1276
1277 extern struct symtabs_and_lines decode_line_spec_1 (char *, int);
1278
1279 /* Symmisc.c */
1280
1281 void maintenance_print_symbols (char *, int);
1282
1283 void maintenance_print_psymbols (char *, int);
1284
1285 void maintenance_print_msymbols (char *, int);
1286
1287 void maintenance_print_objfiles (char *, int);
1288
1289 void maintenance_info_symtabs (char *, int);
1290
1291 void maintenance_info_psymtabs (char *, int);
1292
1293 void maintenance_check_symtabs (char *, int);
1294
1295 /* maint.c */
1296
1297 void maintenance_print_statistics (char *, int);
1298
1299 extern void free_symtab (struct symtab *);
1300
1301 /* Symbol-reading stuff in symfile.c and solib.c.  */
1302
1303 extern struct symtab *psymtab_to_symtab (struct partial_symtab *);
1304
1305 extern void clear_solib (void);
1306
1307 /* source.c */
1308
1309 extern int identify_source_line (struct symtab *, int, int, CORE_ADDR);
1310
1311 extern void print_source_lines (struct symtab *, int, int, int);
1312
1313 extern void forget_cached_source_info (void);
1314
1315 extern void select_source_symtab (struct symtab *);
1316
1317 extern char **make_symbol_completion_list (char *, char *);
1318
1319 extern char **make_file_symbol_completion_list (char *, char *, char *);
1320
1321 extern char **make_source_files_completion_list (char *, char *);
1322
1323 /* symtab.c */
1324
1325 extern struct partial_symtab *find_main_psymtab (void);
1326
1327 extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
1328
1329 extern struct symtab_and_line find_function_start_sal (struct symbol *sym,
1330                                                        int);
1331
1332 /* symfile.c */
1333
1334 extern void clear_symtab_users (void);
1335
1336 extern enum language deduce_language_from_filename (char *);
1337
1338 /* symtab.c */
1339
1340 extern int in_prologue (CORE_ADDR pc, CORE_ADDR func_start);
1341
1342 extern struct symbol *fixup_symbol_section (struct symbol *,
1343                                             struct objfile *);
1344
1345 extern struct partial_symbol *fixup_psymbol_section (struct partial_symbol
1346                                                      *psym,
1347                                                      struct objfile *objfile);
1348
1349 /* Symbol searching */
1350
1351 /* When using search_symbols, a list of the following structs is returned.
1352    Callers must free the search list using free_search_symbols! */
1353 struct symbol_search
1354 {
1355   /* The block in which the match was found. Could be, for example,
1356      STATIC_BLOCK or GLOBAL_BLOCK. */
1357   int block;
1358
1359   /* Information describing what was found.
1360
1361      If symtab abd symbol are NOT NULL, then information was found
1362      for this match. */
1363   struct symtab *symtab;
1364   struct symbol *symbol;
1365
1366   /* If msymbol is non-null, then a match was made on something for
1367      which only minimal_symbols exist. */
1368   struct minimal_symbol *msymbol;
1369
1370   /* A link to the next match, or NULL for the end. */
1371   struct symbol_search *next;
1372 };
1373
1374 extern void search_symbols (char *, domain_enum, int, char **,
1375                             struct symbol_search **);
1376 extern void free_search_symbols (struct symbol_search *);
1377 extern struct cleanup *make_cleanup_free_search_symbols (struct symbol_search
1378                                                          *);
1379
1380 /* The name of the ``main'' function.
1381    FIXME: cagney/2001-03-20: Can't make main_name() const since some
1382    of the calling code currently assumes that the string isn't
1383    const. */
1384 extern void set_main_name (const char *name);
1385 extern /*const */ char *main_name (void);
1386
1387 #endif /* !defined(SYMTAB_H) */