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