gdb: Handle missing domain types in: maintenance print psymbols
[external/binutils.git] / gdb / symtab.h
1 /* Symbol table definitions for GDB.
2
3    Copyright (C) 1986-2019 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 <array>
24 #include <vector>
25 #include <string>
26 #include "gdbsupport/gdb_vecs.h"
27 #include "gdbtypes.h"
28 #include "gdb_regex.h"
29 #include "gdbsupport/enum-flags.h"
30 #include "gdbsupport/function-view.h"
31 #include "gdbsupport/gdb_optional.h"
32 #include "gdbsupport/next-iterator.h"
33 #include "completer.h"
34
35 /* Opaque declarations.  */
36 struct ui_file;
37 struct frame_info;
38 struct symbol;
39 struct obstack;
40 struct objfile;
41 struct block;
42 struct blockvector;
43 struct axs_value;
44 struct agent_expr;
45 struct program_space;
46 struct language_defn;
47 struct common_block;
48 struct obj_section;
49 struct cmd_list_element;
50 class probe;
51 struct lookup_name_info;
52
53 /* How to match a lookup name against a symbol search name.  */
54 enum class symbol_name_match_type
55 {
56   /* Wild matching.  Matches unqualified symbol names in all
57      namespace/module/packages, etc.  */
58   WILD,
59
60   /* Full matching.  The lookup name indicates a fully-qualified name,
61      and only matches symbol search names in the specified
62      namespace/module/package.  */
63   FULL,
64
65   /* Search name matching.  This is like FULL, but the search name did
66      not come from the user; instead it is already a search name
67      retrieved from a SYMBOL_SEARCH_NAME/MSYMBOL_SEARCH_NAME call.
68      For Ada, this avoids re-encoding an already-encoded search name
69      (which would potentially incorrectly lowercase letters in the
70      linkage/search name that should remain uppercase).  For C++, it
71      avoids trying to demangle a name we already know is
72      demangled.  */
73   SEARCH_NAME,
74
75   /* Expression matching.  The same as FULL matching in most
76      languages.  The same as WILD matching in Ada.  */
77   EXPRESSION,
78 };
79
80 /* Hash the given symbol search name according to LANGUAGE's
81    rules.  */
82 extern unsigned int search_name_hash (enum language language,
83                                       const char *search_name);
84
85 /* Ada-specific bits of a lookup_name_info object.  This is lazily
86    constructed on demand.  */
87
88 class ada_lookup_name_info final
89 {
90  public:
91   /* Construct.  */
92   explicit ada_lookup_name_info (const lookup_name_info &lookup_name);
93
94   /* Compare SYMBOL_SEARCH_NAME with our lookup name, using MATCH_TYPE
95      as name match type.  Returns true if there's a match, false
96      otherwise.  If non-NULL, store the matching results in MATCH.  */
97   bool matches (const char *symbol_search_name,
98                 symbol_name_match_type match_type,
99                 completion_match_result *comp_match_res) const;
100
101   /* The Ada-encoded lookup name.  */
102   const std::string &lookup_name () const
103   { return m_encoded_name; }
104
105   /* Return true if we're supposed to be doing a wild match look
106      up.  */
107   bool wild_match_p () const
108   { return m_wild_match_p; }
109
110   /* Return true if we're looking up a name inside package
111      Standard.  */
112   bool standard_p () const
113   { return m_standard_p; }
114
115   /* Return true if doing a verbatim match.  */
116   bool verbatim_p () const
117   { return m_verbatim_p; }
118
119 private:
120   /* The Ada-encoded lookup name.  */
121   std::string m_encoded_name;
122
123   /* Whether the user-provided lookup name was Ada encoded.  If so,
124      then return encoded names in the 'matches' method's 'completion
125      match result' output.  */
126   bool m_encoded_p : 1;
127
128   /* True if really doing wild matching.  Even if the user requests
129      wild matching, some cases require full matching.  */
130   bool m_wild_match_p : 1;
131
132   /* True if doing a verbatim match.  This is true if the decoded
133      version of the symbol name is wrapped in '<'/'>'.  This is an
134      escape hatch users can use to look up symbols the Ada encoding
135      does not understand.  */
136   bool m_verbatim_p : 1;
137
138    /* True if the user specified a symbol name that is inside package
139       Standard.  Symbol names inside package Standard are handled
140       specially.  We always do a non-wild match of the symbol name
141       without the "standard__" prefix, and only search static and
142       global symbols.  This was primarily introduced in order to allow
143       the user to specifically access the standard exceptions using,
144       for instance, Standard.Constraint_Error when Constraint_Error is
145       ambiguous (due to the user defining its own Constraint_Error
146       entity inside its program).  */
147   bool m_standard_p : 1;
148 };
149
150 /* Language-specific bits of a lookup_name_info object, for languages
151    that do name searching using demangled names (C++/D/Go).  This is
152    lazily constructed on demand.  */
153
154 struct demangle_for_lookup_info final
155 {
156 public:
157   demangle_for_lookup_info (const lookup_name_info &lookup_name,
158                             language lang);
159
160   /* The demangled lookup name.  */
161   const std::string &lookup_name () const
162   { return m_demangled_name; }
163
164 private:
165   /* The demangled lookup name.  */
166   std::string m_demangled_name;
167 };
168
169 /* Object that aggregates all information related to a symbol lookup
170    name.  I.e., the name that is matched against the symbol's search
171    name.  Caches per-language information so that it doesn't require
172    recomputing it for every symbol comparison, like for example the
173    Ada encoded name and the symbol's name hash for a given language.
174    The object is conceptually immutable once constructed, and thus has
175    no setters.  This is to prevent some code path from tweaking some
176    property of the lookup name for some local reason and accidentally
177    altering the results of any continuing search(es).
178    lookup_name_info objects are generally passed around as a const
179    reference to reinforce that.  (They're not passed around by value
180    because they're not small.)  */
181 class lookup_name_info final
182 {
183  public:
184   /* Create a new object.  */
185   lookup_name_info (std::string name,
186                     symbol_name_match_type match_type,
187                     bool completion_mode = false,
188                     bool ignore_parameters = false)
189     : m_match_type (match_type),
190       m_completion_mode (completion_mode),
191       m_ignore_parameters (ignore_parameters),
192       m_name (std::move (name))
193   {}
194
195   /* Getters.  See description of each corresponding field.  */
196   symbol_name_match_type match_type () const { return m_match_type; }
197   bool completion_mode () const { return m_completion_mode; }
198   const std::string &name () const { return m_name; }
199   const bool ignore_parameters () const { return m_ignore_parameters; }
200
201   /* Return a version of this lookup name that is usable with
202      comparisons against symbols have no parameter info, such as
203      psymbols and GDB index symbols.  */
204   lookup_name_info make_ignore_params () const
205   {
206     return lookup_name_info (m_name, m_match_type, m_completion_mode,
207                              true /* ignore params */);
208   }
209
210   /* Get the search name hash for searches in language LANG.  */
211   unsigned int search_name_hash (language lang) const
212   {
213     /* Only compute each language's hash once.  */
214     if (!m_demangled_hashes_p[lang])
215       {
216         m_demangled_hashes[lang]
217           = ::search_name_hash (lang, language_lookup_name (lang).c_str ());
218         m_demangled_hashes_p[lang] = true;
219       }
220     return m_demangled_hashes[lang];
221   }
222
223   /* Get the search name for searches in language LANG.  */
224   const std::string &language_lookup_name (language lang) const
225   {
226     switch (lang)
227       {
228       case language_ada:
229         return ada ().lookup_name ();
230       case language_cplus:
231         return cplus ().lookup_name ();
232       case language_d:
233         return d ().lookup_name ();
234       case language_go:
235         return go ().lookup_name ();
236       default:
237         return m_name;
238       }
239   }
240
241   /* Get the Ada-specific lookup info.  */
242   const ada_lookup_name_info &ada () const
243   {
244     maybe_init (m_ada);
245     return *m_ada;
246   }
247
248   /* Get the C++-specific lookup info.  */
249   const demangle_for_lookup_info &cplus () const
250   {
251     maybe_init (m_cplus, language_cplus);
252     return *m_cplus;
253   }
254
255   /* Get the D-specific lookup info.  */
256   const demangle_for_lookup_info &d () const
257   {
258     maybe_init (m_d, language_d);
259     return *m_d;
260   }
261
262   /* Get the Go-specific lookup info.  */
263   const demangle_for_lookup_info &go () const
264   {
265     maybe_init (m_go, language_go);
266     return *m_go;
267   }
268
269   /* Get a reference to a lookup_name_info object that matches any
270      symbol name.  */
271   static const lookup_name_info &match_any ();
272
273 private:
274   /* Initialize FIELD, if not initialized yet.  */
275   template<typename Field, typename... Args>
276   void maybe_init (Field &field, Args&&... args) const
277   {
278     if (!field)
279       field.emplace (*this, std::forward<Args> (args)...);
280   }
281
282   /* The lookup info as passed to the ctor.  */
283   symbol_name_match_type m_match_type;
284   bool m_completion_mode;
285   bool m_ignore_parameters;
286   std::string m_name;
287
288   /* Language-specific info.  These fields are filled lazily the first
289      time a lookup is done in the corresponding language.  They're
290      mutable because lookup_name_info objects are typically passed
291      around by const reference (see intro), and they're conceptually
292      "cache" that can always be reconstructed from the non-mutable
293      fields.  */
294   mutable gdb::optional<ada_lookup_name_info> m_ada;
295   mutable gdb::optional<demangle_for_lookup_info> m_cplus;
296   mutable gdb::optional<demangle_for_lookup_info> m_d;
297   mutable gdb::optional<demangle_for_lookup_info> m_go;
298
299   /* The demangled hashes.  Stored in an array with one entry for each
300      possible language.  The second array records whether we've
301      already computed the each language's hash.  (These are separate
302      arrays instead of a single array of optional<unsigned> to avoid
303      alignment padding).  */
304   mutable std::array<unsigned int, nr_languages> m_demangled_hashes;
305   mutable std::array<bool, nr_languages> m_demangled_hashes_p {};
306 };
307
308 /* Comparison function for completion symbol lookup.
309
310    Returns true if the symbol name matches against LOOKUP_NAME.
311
312    SYMBOL_SEARCH_NAME should be a symbol's "search" name.
313
314    On success and if non-NULL, COMP_MATCH_RES->match is set to point
315    to the symbol name as should be presented to the user as a
316    completion match list element.  In most languages, this is the same
317    as the symbol's search name, but in some, like Ada, the display
318    name is dynamically computed within the comparison routine.
319
320    Also, on success and if non-NULL, COMP_MATCH_RES->match_for_lcd
321    points the part of SYMBOL_SEARCH_NAME that was considered to match
322    LOOKUP_NAME.  E.g., in C++, in linespec/wild mode, if the symbol is
323    "foo::function()" and LOOKUP_NAME is "function(", MATCH_FOR_LCD
324    points to "function()" inside SYMBOL_SEARCH_NAME.  */
325 typedef bool (symbol_name_matcher_ftype)
326   (const char *symbol_search_name,
327    const lookup_name_info &lookup_name,
328    completion_match_result *comp_match_res);
329
330 /* Some of the structures in this file are space critical.
331    The space-critical structures are:
332
333      struct general_symbol_info
334      struct symbol
335      struct partial_symbol
336
337    These structures are laid out to encourage good packing.
338    They use ENUM_BITFIELD and short int fields, and they order the
339    structure members so that fields less than a word are next
340    to each other so they can be packed together.  */
341
342 /* Rearranged: used ENUM_BITFIELD and rearranged field order in
343    all the space critical structures (plus struct minimal_symbol).
344    Memory usage dropped from 99360768 bytes to 90001408 bytes.
345    I measured this with before-and-after tests of
346    "HEAD-old-gdb -readnow HEAD-old-gdb" and
347    "HEAD-new-gdb -readnow HEAD-old-gdb" on native i686-pc-linux-gnu,
348    red hat linux 8, with LD_LIBRARY_PATH=/usr/lib/debug,
349    typing "maint space 1" at the first command prompt.
350
351    Here is another measurement (from andrew c):
352      # no /usr/lib/debug, just plain glibc, like a normal user
353      gdb HEAD-old-gdb
354      (gdb) break internal_error
355      (gdb) run
356      (gdb) maint internal-error
357      (gdb) backtrace
358      (gdb) maint space 1
359
360    gdb gdb_6_0_branch  2003-08-19  space used: 8896512
361    gdb HEAD            2003-08-19  space used: 8904704
362    gdb HEAD            2003-08-21  space used: 8396800 (+symtab.h)
363    gdb HEAD            2003-08-21  space used: 8265728 (+gdbtypes.h)
364
365    The third line shows the savings from the optimizations in symtab.h.
366    The fourth line shows the savings from the optimizations in
367    gdbtypes.h.  Both optimizations are in gdb HEAD now.
368
369    --chastain 2003-08-21  */
370
371 /* Define a structure for the information that is common to all symbol types,
372    including minimal symbols, partial symbols, and full symbols.  In a
373    multilanguage environment, some language specific information may need to
374    be recorded along with each symbol.  */
375
376 /* This structure is space critical.  See space comments at the top.  */
377
378 struct general_symbol_info
379 {
380   /* Name of the symbol.  This is a required field.  Storage for the
381      name is allocated on the objfile_obstack for the associated
382      objfile.  For languages like C++ that make a distinction between
383      the mangled name and demangled name, this is the mangled
384      name.  */
385
386   const char *name;
387
388   /* Value of the symbol.  Which member of this union to use, and what
389      it means, depends on what kind of symbol this is and its
390      SYMBOL_CLASS.  See comments there for more details.  All of these
391      are in host byte order (though what they point to might be in
392      target byte order, e.g. LOC_CONST_BYTES).  */
393
394   union
395   {
396     LONGEST ivalue;
397
398     const struct block *block;
399
400     const gdb_byte *bytes;
401
402     CORE_ADDR address;
403
404     /* A common block.  Used with LOC_COMMON_BLOCK.  */
405
406     const struct common_block *common_block;
407
408     /* For opaque typedef struct chain.  */
409
410     struct symbol *chain;
411   }
412   value;
413
414   /* Since one and only one language can apply, wrap the language specific
415      information inside a union.  */
416
417   union
418   {
419     /* A pointer to an obstack that can be used for storage associated
420        with this symbol.  This is only used by Ada, and only when the
421        'ada_mangled' field is zero.  */
422     struct obstack *obstack;
423
424     /* This is used by languages which wish to store a demangled name.
425        currently used by Ada, C++, and Objective C.  */
426     const char *demangled_name;
427   }
428   language_specific;
429
430   /* Record the source code language that applies to this symbol.
431      This is used to select one of the fields from the language specific
432      union above.  */
433
434   ENUM_BITFIELD(language) language : LANGUAGE_BITS;
435
436   /* This is only used by Ada.  If set, then the 'demangled_name' field
437      of language_specific is valid.  Otherwise, the 'obstack' field is
438      valid.  */
439   unsigned int ada_mangled : 1;
440
441   /* Which section is this symbol in?  This is an index into
442      section_offsets for this objfile.  Negative means that the symbol
443      does not get relocated relative to a section.  */
444
445   short section;
446 };
447
448 extern void symbol_set_demangled_name (struct general_symbol_info *,
449                                        const char *,
450                                        struct obstack *);
451
452 extern const char *symbol_get_demangled_name
453   (const struct general_symbol_info *);
454
455 extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
456
457 /* Note that all the following SYMBOL_* macros are used with the
458    SYMBOL argument being either a partial symbol or
459    a full symbol.  Both types have a ginfo field.  In particular
460    the SYMBOL_SET_LANGUAGE, SYMBOL_DEMANGLED_NAME, etc.
461    macros cannot be entirely substituted by
462    functions, unless the callers are changed to pass in the ginfo
463    field only, instead of the SYMBOL parameter.  */
464
465 #define SYMBOL_VALUE(symbol)            (symbol)->ginfo.value.ivalue
466 #define SYMBOL_VALUE_ADDRESS(symbol)    (symbol)->ginfo.value.address
467 #define SYMBOL_VALUE_BYTES(symbol)      (symbol)->ginfo.value.bytes
468 #define SYMBOL_VALUE_COMMON_BLOCK(symbol) (symbol)->ginfo.value.common_block
469 #define SYMBOL_BLOCK_VALUE(symbol)      (symbol)->ginfo.value.block
470 #define SYMBOL_VALUE_CHAIN(symbol)      (symbol)->ginfo.value.chain
471 #define SYMBOL_LANGUAGE(symbol)         (symbol)->ginfo.language
472 #define SYMBOL_SECTION(symbol)          (symbol)->ginfo.section
473 #define SYMBOL_OBJ_SECTION(objfile, symbol)                     \
474   (((symbol)->ginfo.section >= 0)                               \
475    ? (&(((objfile)->sections)[(symbol)->ginfo.section]))        \
476    : NULL)
477
478 /* Initializes the language dependent portion of a symbol
479    depending upon the language for the symbol.  */
480 #define SYMBOL_SET_LANGUAGE(symbol,language,obstack)    \
481   (symbol_set_language (&(symbol)->ginfo, (language), (obstack)))
482 extern void symbol_set_language (struct general_symbol_info *symbol,
483                                  enum language language,
484                                  struct obstack *obstack);
485
486 /* Set just the linkage name of a symbol; do not try to demangle
487    it.  Used for constructs which do not have a mangled name,
488    e.g. struct tags.  Unlike SYMBOL_SET_NAMES, linkage_name must
489    be terminated and either already on the objfile's obstack or
490    permanently allocated.  */
491 #define SYMBOL_SET_LINKAGE_NAME(symbol,linkage_name) \
492   (symbol)->ginfo.name = (linkage_name)
493
494 /* Set the linkage and natural names of a symbol, by demangling
495    the linkage name.  */
496 #define SYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile)     \
497   symbol_set_names (&(symbol)->ginfo, linkage_name, len, copy_name, \
498                     (objfile)->per_bfd)
499 extern void symbol_set_names (struct general_symbol_info *symbol,
500                               const char *linkage_name, int len, int copy_name,
501                               struct objfile_per_bfd_storage *per_bfd);
502
503 /* Now come lots of name accessor macros.  Short version as to when to
504    use which: Use SYMBOL_NATURAL_NAME to refer to the name of the
505    symbol in the original source code.  Use SYMBOL_LINKAGE_NAME if you
506    want to know what the linker thinks the symbol's name is.  Use
507    SYMBOL_PRINT_NAME for output.  Use SYMBOL_DEMANGLED_NAME if you
508    specifically need to know whether SYMBOL_NATURAL_NAME and
509    SYMBOL_LINKAGE_NAME are different.  */
510
511 /* Return SYMBOL's "natural" name, i.e. the name that it was called in
512    the original source code.  In languages like C++ where symbols may
513    be mangled for ease of manipulation by the linker, this is the
514    demangled name.  */
515
516 #define SYMBOL_NATURAL_NAME(symbol) \
517   (symbol_natural_name (&(symbol)->ginfo))
518 extern const char *symbol_natural_name
519   (const struct general_symbol_info *symbol);
520
521 /* Return SYMBOL's name from the point of view of the linker.  In
522    languages like C++ where symbols may be mangled for ease of
523    manipulation by the linker, this is the mangled name; otherwise,
524    it's the same as SYMBOL_NATURAL_NAME.  */
525
526 #define SYMBOL_LINKAGE_NAME(symbol)     (symbol)->ginfo.name
527
528 /* Return the demangled name for a symbol based on the language for
529    that symbol.  If no demangled name exists, return NULL.  */
530 #define SYMBOL_DEMANGLED_NAME(symbol) \
531   (symbol_demangled_name (&(symbol)->ginfo))
532 extern const char *symbol_demangled_name
533   (const struct general_symbol_info *symbol);
534
535 /* Macro that returns a version of the name of a symbol that is
536    suitable for output.  In C++ this is the "demangled" form of the
537    name if demangle is on and the "mangled" form of the name if
538    demangle is off.  In other languages this is just the symbol name.
539    The result should never be NULL.  Don't use this for internal
540    purposes (e.g. storing in a hashtable): it's only suitable for output.
541
542    N.B. symbol may be anything with a ginfo member,
543    e.g., struct symbol or struct minimal_symbol.  */
544
545 #define SYMBOL_PRINT_NAME(symbol)                                       \
546   (demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
547 extern int demangle;
548
549 /* Macro that returns the name to be used when sorting and searching symbols.
550    In C++, we search for the demangled form of a name,
551    and so sort symbols accordingly.  In Ada, however, we search by mangled
552    name.  If there is no distinct demangled name, then SYMBOL_SEARCH_NAME
553    returns the same value (same pointer) as SYMBOL_LINKAGE_NAME.  */
554 #define SYMBOL_SEARCH_NAME(symbol)                                       \
555    (symbol_search_name (&(symbol)->ginfo))
556 extern const char *symbol_search_name (const struct general_symbol_info *ginfo);
557
558 /* Return true if NAME matches the "search" name of SYMBOL, according
559    to the symbol's language.  */
560 #define SYMBOL_MATCHES_SEARCH_NAME(symbol, name)                       \
561   symbol_matches_search_name (&(symbol)->ginfo, (name))
562
563 /* Helper for SYMBOL_MATCHES_SEARCH_NAME that works with both symbols
564    and psymbols.  */
565 extern bool symbol_matches_search_name
566   (const struct general_symbol_info *gsymbol,
567    const lookup_name_info &name);
568
569 /* Compute the hash of the given symbol search name of a symbol of
570    language LANGUAGE.  */
571 extern unsigned int search_name_hash (enum language language,
572                                       const char *search_name);
573
574 /* Classification types for a minimal symbol.  These should be taken as
575    "advisory only", since if gdb can't easily figure out a
576    classification it simply selects mst_unknown.  It may also have to
577    guess when it can't figure out which is a better match between two
578    types (mst_data versus mst_bss) for example.  Since the minimal
579    symbol info is sometimes derived from the BFD library's view of a
580    file, we need to live with what information bfd supplies.  */
581
582 enum minimal_symbol_type
583 {
584   mst_unknown = 0,              /* Unknown type, the default */
585   mst_text,                     /* Generally executable instructions */
586
587   /* A GNU ifunc symbol, in the .text section.  GDB uses to know
588      whether the user is setting a breakpoint on a GNU ifunc function,
589      and thus GDB needs to actually set the breakpoint on the target
590      function.  It is also used to know whether the program stepped
591      into an ifunc resolver -- the resolver may get a separate
592      symbol/alias under a different name, but it'll have the same
593      address as the ifunc symbol.  */
594   mst_text_gnu_ifunc,           /* Executable code returning address
595                                    of executable code */
596
597   /* A GNU ifunc function descriptor symbol, in a data section
598      (typically ".opd").  Seen on architectures that use function
599      descriptors, like PPC64/ELFv1.  In this case, this symbol's value
600      is the address of the descriptor.  There'll be a corresponding
601      mst_text_gnu_ifunc synthetic symbol for the text/entry
602      address.  */
603   mst_data_gnu_ifunc,           /* Executable code returning address
604                                    of executable code */
605
606   mst_slot_got_plt,             /* GOT entries for .plt sections */
607   mst_data,                     /* Generally initialized data */
608   mst_bss,                      /* Generally uninitialized data */
609   mst_abs,                      /* Generally absolute (nonrelocatable) */
610   /* GDB uses mst_solib_trampoline for the start address of a shared
611      library trampoline entry.  Breakpoints for shared library functions
612      are put there if the shared library is not yet loaded.
613      After the shared library is loaded, lookup_minimal_symbol will
614      prefer the minimal symbol from the shared library (usually
615      a mst_text symbol) over the mst_solib_trampoline symbol, and the
616      breakpoints will be moved to their true address in the shared
617      library via breakpoint_re_set.  */
618   mst_solib_trampoline,         /* Shared library trampoline code */
619   /* For the mst_file* types, the names are only guaranteed to be unique
620      within a given .o file.  */
621   mst_file_text,                /* Static version of mst_text */
622   mst_file_data,                /* Static version of mst_data */
623   mst_file_bss,                 /* Static version of mst_bss */
624   nr_minsym_types
625 };
626
627 /* The number of enum minimal_symbol_type values, with some padding for
628    reasonable growth.  */
629 #define MINSYM_TYPE_BITS 4
630 gdb_static_assert (nr_minsym_types <= (1 << MINSYM_TYPE_BITS));
631
632 /* Define a simple structure used to hold some very basic information about
633    all defined global symbols (text, data, bss, abs, etc).  The only required
634    information is the general_symbol_info.
635
636    In many cases, even if a file was compiled with no special options for
637    debugging at all, as long as was not stripped it will contain sufficient
638    information to build a useful minimal symbol table using this structure.
639    Even when a file contains enough debugging information to build a full
640    symbol table, these minimal symbols are still useful for quickly mapping
641    between names and addresses, and vice versa.  They are also sometimes
642    used to figure out what full symbol table entries need to be read in.  */
643
644 struct minimal_symbol : public general_symbol_info
645 {
646   /* Size of this symbol.  dbx_end_psymtab in dbxread.c uses this
647      information to calculate the end of the partial symtab based on the
648      address of the last symbol plus the size of the last symbol.  */
649
650   unsigned long size;
651
652   /* Which source file is this symbol in?  Only relevant for mst_file_*.  */
653   const char *filename;
654
655   /* Classification type for this minimal symbol.  */
656
657   ENUM_BITFIELD(minimal_symbol_type) type : MINSYM_TYPE_BITS;
658
659   /* Non-zero if this symbol was created by gdb.
660      Such symbols do not appear in the output of "info var|fun".  */
661   unsigned int created_by_gdb : 1;
662
663   /* Two flag bits provided for the use of the target.  */
664   unsigned int target_flag_1 : 1;
665   unsigned int target_flag_2 : 1;
666
667   /* Nonzero iff the size of the minimal symbol has been set.
668      Symbol size information can sometimes not be determined, because
669      the object file format may not carry that piece of information.  */
670   unsigned int has_size : 1;
671
672   /* Minimal symbols with the same hash key are kept on a linked
673      list.  This is the link.  */
674
675   struct minimal_symbol *hash_next;
676
677   /* Minimal symbols are stored in two different hash tables.  This is
678      the `next' pointer for the demangled hash table.  */
679
680   struct minimal_symbol *demangled_hash_next;
681
682   /* True if this symbol is of some data type.  */
683
684   bool data_p () const;
685
686   /* True if MSYMBOL is of some text type.  */
687
688   bool text_p () const;
689 };
690
691 #define MSYMBOL_TARGET_FLAG_1(msymbol)  (msymbol)->target_flag_1
692 #define MSYMBOL_TARGET_FLAG_2(msymbol)  (msymbol)->target_flag_2
693 #define MSYMBOL_SIZE(msymbol)           ((msymbol)->size + 0)
694 #define SET_MSYMBOL_SIZE(msymbol, sz)           \
695   do                                            \
696     {                                           \
697       (msymbol)->size = sz;                     \
698       (msymbol)->has_size = 1;                  \
699     } while (0)
700 #define MSYMBOL_HAS_SIZE(msymbol)       ((msymbol)->has_size + 0)
701 #define MSYMBOL_TYPE(msymbol)           (msymbol)->type
702
703 #define MSYMBOL_VALUE(symbol)           (symbol)->value.ivalue
704 /* The unrelocated address of the minimal symbol.  */
705 #define MSYMBOL_VALUE_RAW_ADDRESS(symbol) ((symbol)->value.address + 0)
706 /* The relocated address of the minimal symbol, using the section
707    offsets from OBJFILE.  */
708 #define MSYMBOL_VALUE_ADDRESS(objfile, symbol)                          \
709   ((symbol)->value.address                                      \
710    + ANOFFSET ((objfile)->section_offsets, ((symbol)->section)))
711 /* For a bound minsym, we can easily compute the address directly.  */
712 #define BMSYMBOL_VALUE_ADDRESS(symbol) \
713   MSYMBOL_VALUE_ADDRESS ((symbol).objfile, (symbol).minsym)
714 #define SET_MSYMBOL_VALUE_ADDRESS(symbol, new_value)    \
715   ((symbol)->value.address = (new_value))
716 #define MSYMBOL_VALUE_BYTES(symbol)     (symbol)->value.bytes
717 #define MSYMBOL_BLOCK_VALUE(symbol)     (symbol)->value.block
718 #define MSYMBOL_VALUE_CHAIN(symbol)     (symbol)->value.chain
719 #define MSYMBOL_LANGUAGE(symbol)        (symbol)->language
720 #define MSYMBOL_SECTION(symbol)         (symbol)->section
721 #define MSYMBOL_OBJ_SECTION(objfile, symbol)                    \
722   (((symbol)->section >= 0)                             \
723    ? (&(((objfile)->sections)[(symbol)->section]))      \
724    : NULL)
725
726 #define MSYMBOL_NATURAL_NAME(symbol) \
727   (symbol_natural_name (symbol))
728 #define MSYMBOL_LINKAGE_NAME(symbol)    (symbol)->name
729 #define MSYMBOL_PRINT_NAME(symbol)                                      \
730   (demangle ? MSYMBOL_NATURAL_NAME (symbol) : MSYMBOL_LINKAGE_NAME (symbol))
731 #define MSYMBOL_DEMANGLED_NAME(symbol) \
732   (symbol_demangled_name (symbol))
733 #define MSYMBOL_SEARCH_NAME(symbol)                                      \
734    (symbol_search_name (symbol))
735
736 #include "minsyms.h"
737
738 \f
739
740 /* Represent one symbol name; a variable, constant, function or typedef.  */
741
742 /* Different name domains for symbols.  Looking up a symbol specifies a
743    domain and ignores symbol definitions in other name domains.  */
744
745 typedef enum domain_enum_tag
746 {
747   /* UNDEF_DOMAIN is used when a domain has not been discovered or
748      none of the following apply.  This usually indicates an error either
749      in the symbol information or in gdb's handling of symbols.  */
750
751   UNDEF_DOMAIN,
752
753   /* VAR_DOMAIN is the usual domain.  In C, this contains variables,
754      function names, typedef names and enum type values.  */
755
756   VAR_DOMAIN,
757
758   /* STRUCT_DOMAIN is used in C to hold struct, union and enum type names.
759      Thus, if `struct foo' is used in a C program, it produces a symbol named
760      `foo' in the STRUCT_DOMAIN.  */
761
762   STRUCT_DOMAIN,
763
764   /* MODULE_DOMAIN is used in Fortran to hold module type names.  */
765
766   MODULE_DOMAIN,
767
768   /* LABEL_DOMAIN may be used for names of labels (for gotos).  */
769
770   LABEL_DOMAIN,
771
772   /* Fortran common blocks.  Their naming must be separate from VAR_DOMAIN.
773      They also always use LOC_COMMON_BLOCK.  */
774   COMMON_BLOCK_DOMAIN,
775
776   /* This must remain last.  */
777   NR_DOMAINS
778 } domain_enum;
779
780 /* The number of bits in a symbol used to represent the domain.  */
781
782 #define SYMBOL_DOMAIN_BITS 3
783 gdb_static_assert (NR_DOMAINS <= (1 << SYMBOL_DOMAIN_BITS));
784
785 extern const char *domain_name (domain_enum);
786
787 /* Searching domains, used for `search_symbols'.  Element numbers are
788    hardcoded in GDB, check all enum uses before changing it.  */
789
790 enum search_domain
791 {
792   /* Everything in VAR_DOMAIN minus FUNCTIONS_DOMAIN and
793      TYPES_DOMAIN.  */
794   VARIABLES_DOMAIN = 0,
795
796   /* All functions -- for some reason not methods, though.  */
797   FUNCTIONS_DOMAIN = 1,
798
799   /* All defined types */
800   TYPES_DOMAIN = 2,
801
802   /* Any type.  */
803   ALL_DOMAIN = 3
804 };
805
806 extern const char *search_domain_name (enum search_domain);
807
808 /* An address-class says where to find the value of a symbol.  */
809
810 enum address_class
811 {
812   /* Not used; catches errors.  */
813
814   LOC_UNDEF,
815
816   /* Value is constant int SYMBOL_VALUE, host byteorder.  */
817
818   LOC_CONST,
819
820   /* Value is at fixed address SYMBOL_VALUE_ADDRESS.  */
821
822   LOC_STATIC,
823
824   /* Value is in register.  SYMBOL_VALUE is the register number
825      in the original debug format.  SYMBOL_REGISTER_OPS holds a
826      function that can be called to transform this into the
827      actual register number this represents in a specific target
828      architecture (gdbarch).
829
830      For some symbol formats (stabs, for some compilers at least),
831      the compiler generates two symbols, an argument and a register.
832      In some cases we combine them to a single LOC_REGISTER in symbol
833      reading, but currently not for all cases (e.g. it's passed on the
834      stack and then loaded into a register).  */
835
836   LOC_REGISTER,
837
838   /* It's an argument; the value is at SYMBOL_VALUE offset in arglist.  */
839
840   LOC_ARG,
841
842   /* Value address is at SYMBOL_VALUE offset in arglist.  */
843
844   LOC_REF_ARG,
845
846   /* Value is in specified register.  Just like LOC_REGISTER except the
847      register holds the address of the argument instead of the argument
848      itself.  This is currently used for the passing of structs and unions
849      on sparc and hppa.  It is also used for call by reference where the
850      address is in a register, at least by mipsread.c.  */
851
852   LOC_REGPARM_ADDR,
853
854   /* Value is a local variable at SYMBOL_VALUE offset in stack frame.  */
855
856   LOC_LOCAL,
857
858   /* Value not used; definition in SYMBOL_TYPE.  Symbols in the domain
859      STRUCT_DOMAIN all have this class.  */
860
861   LOC_TYPEDEF,
862
863   /* Value is address SYMBOL_VALUE_ADDRESS in the code.  */
864
865   LOC_LABEL,
866
867   /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
868      In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
869      of the block.  Function names have this class.  */
870
871   LOC_BLOCK,
872
873   /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
874      target byte order.  */
875
876   LOC_CONST_BYTES,
877
878   /* Value is at fixed address, but the address of the variable has
879      to be determined from the minimal symbol table whenever the
880      variable is referenced.
881      This happens if debugging information for a global symbol is
882      emitted and the corresponding minimal symbol is defined
883      in another object file or runtime common storage.
884      The linker might even remove the minimal symbol if the global
885      symbol is never referenced, in which case the symbol remains
886      unresolved.
887      
888      GDB would normally find the symbol in the minimal symbol table if it will
889      not find it in the full symbol table.  But a reference to an external
890      symbol in a local block shadowing other definition requires full symbol
891      without possibly having its address available for LOC_STATIC.  Testcase
892      is provided as `gdb.dwarf2/dw2-unresolved.exp'.
893
894      This is also used for thread local storage (TLS) variables.  In this case,
895      the address of the TLS variable must be determined when the variable is
896      referenced, from the MSYMBOL_VALUE_RAW_ADDRESS, which is the offset
897      of the TLS variable in the thread local storage of the shared
898      library/object.  */
899
900   LOC_UNRESOLVED,
901
902   /* The variable does not actually exist in the program.
903      The value is ignored.  */
904
905   LOC_OPTIMIZED_OUT,
906
907   /* The variable's address is computed by a set of location
908      functions (see "struct symbol_computed_ops" below).  */
909   LOC_COMPUTED,
910
911   /* The variable uses general_symbol_info->value->common_block field.
912      It also always uses COMMON_BLOCK_DOMAIN.  */
913   LOC_COMMON_BLOCK,
914
915   /* Not used, just notes the boundary of the enum.  */
916   LOC_FINAL_VALUE
917 };
918
919 /* The number of bits needed for values in enum address_class, with some
920    padding for reasonable growth, and room for run-time registered address
921    classes. See symtab.c:MAX_SYMBOL_IMPLS.
922    This is a #define so that we can have a assertion elsewhere to
923    verify that we have reserved enough space for synthetic address
924    classes.  */
925 #define SYMBOL_ACLASS_BITS 5
926 gdb_static_assert (LOC_FINAL_VALUE <= (1 << SYMBOL_ACLASS_BITS));
927
928 /* The methods needed to implement LOC_COMPUTED.  These methods can
929    use the symbol's .aux_value for additional per-symbol information.
930
931    At present this is only used to implement location expressions.  */
932
933 struct symbol_computed_ops
934 {
935
936   /* Return the value of the variable SYMBOL, relative to the stack
937      frame FRAME.  If the variable has been optimized out, return
938      zero.
939
940      Iff `read_needs_frame (SYMBOL)' is not SYMBOL_NEEDS_FRAME, then
941      FRAME may be zero.  */
942
943   struct value *(*read_variable) (struct symbol * symbol,
944                                   struct frame_info * frame);
945
946   /* Read variable SYMBOL like read_variable at (callee) FRAME's function
947      entry.  SYMBOL should be a function parameter, otherwise
948      NO_ENTRY_VALUE_ERROR will be thrown.  */
949   struct value *(*read_variable_at_entry) (struct symbol *symbol,
950                                            struct frame_info *frame);
951
952   /* Find the "symbol_needs_kind" value for the given symbol.  This
953      value determines whether reading the symbol needs memory (e.g., a
954      global variable), just registers (a thread-local), or a frame (a
955      local variable).  */
956   enum symbol_needs_kind (*get_symbol_read_needs) (struct symbol * symbol);
957
958   /* Write to STREAM a natural-language description of the location of
959      SYMBOL, in the context of ADDR.  */
960   void (*describe_location) (struct symbol * symbol, CORE_ADDR addr,
961                              struct ui_file * stream);
962
963   /* Non-zero if this symbol's address computation is dependent on PC.  */
964   unsigned char location_has_loclist;
965
966   /* Tracepoint support.  Append bytecodes to the tracepoint agent
967      expression AX that push the address of the object SYMBOL.  Set
968      VALUE appropriately.  Note --- for objects in registers, this
969      needn't emit any code; as long as it sets VALUE properly, then
970      the caller will generate the right code in the process of
971      treating this as an lvalue or rvalue.  */
972
973   void (*tracepoint_var_ref) (struct symbol *symbol, struct agent_expr *ax,
974                               struct axs_value *value);
975
976   /* Generate C code to compute the location of SYMBOL.  The C code is
977      emitted to STREAM.  GDBARCH is the current architecture and PC is
978      the PC at which SYMBOL's location should be evaluated.
979      REGISTERS_USED is a vector indexed by register number; the
980      generator function should set an element in this vector if the
981      corresponding register is needed by the location computation.
982      The generated C code must assign the location to a local
983      variable; this variable's name is RESULT_NAME.  */
984
985   void (*generate_c_location) (struct symbol *symbol, string_file *stream,
986                                struct gdbarch *gdbarch,
987                                unsigned char *registers_used,
988                                CORE_ADDR pc, const char *result_name);
989
990 };
991
992 /* The methods needed to implement LOC_BLOCK for inferior functions.
993    These methods can use the symbol's .aux_value for additional
994    per-symbol information.  */
995
996 struct symbol_block_ops
997 {
998   /* Fill in *START and *LENGTH with DWARF block data of function
999      FRAMEFUNC valid for inferior context address PC.  Set *LENGTH to
1000      zero if such location is not valid for PC; *START is left
1001      uninitialized in such case.  */
1002   void (*find_frame_base_location) (struct symbol *framefunc, CORE_ADDR pc,
1003                                     const gdb_byte **start, size_t *length);
1004
1005   /* Return the frame base address.  FRAME is the frame for which we want to
1006      compute the base address while FRAMEFUNC is the symbol for the
1007      corresponding function.  Return 0 on failure (FRAMEFUNC may not hold the
1008      information we need).
1009
1010      This method is designed to work with static links (nested functions
1011      handling).  Static links are function properties whose evaluation returns
1012      the frame base address for the enclosing frame.  However, there are
1013      multiple definitions for "frame base": the content of the frame base
1014      register, the CFA as defined by DWARF unwinding information, ...
1015
1016      So this specific method is supposed to compute the frame base address such
1017      as for nested fuctions, the static link computes the same address.  For
1018      instance, considering DWARF debugging information, the static link is
1019      computed with DW_AT_static_link and this method must be used to compute
1020      the corresponding DW_AT_frame_base attribute.  */
1021   CORE_ADDR (*get_frame_base) (struct symbol *framefunc,
1022                                struct frame_info *frame);
1023 };
1024
1025 /* Functions used with LOC_REGISTER and LOC_REGPARM_ADDR.  */
1026
1027 struct symbol_register_ops
1028 {
1029   int (*register_number) (struct symbol *symbol, struct gdbarch *gdbarch);
1030 };
1031
1032 /* Objects of this type are used to find the address class and the
1033    various computed ops vectors of a symbol.  */
1034
1035 struct symbol_impl
1036 {
1037   enum address_class aclass;
1038
1039   /* Used with LOC_COMPUTED.  */
1040   const struct symbol_computed_ops *ops_computed;
1041
1042   /* Used with LOC_BLOCK.  */
1043   const struct symbol_block_ops *ops_block;
1044
1045   /* Used with LOC_REGISTER and LOC_REGPARM_ADDR.  */
1046   const struct symbol_register_ops *ops_register;
1047 };
1048
1049 /* struct symbol has some subclasses.  This enum is used to
1050    differentiate between them.  */
1051
1052 enum symbol_subclass_kind
1053 {
1054   /* Plain struct symbol.  */
1055   SYMBOL_NONE,
1056
1057   /* struct template_symbol.  */
1058   SYMBOL_TEMPLATE,
1059
1060   /* struct rust_vtable_symbol.  */
1061   SYMBOL_RUST_VTABLE
1062 };
1063
1064 /* This structure is space critical.  See space comments at the top.  */
1065
1066 struct symbol
1067 {
1068
1069   /* The general symbol info required for all types of symbols.  */
1070
1071   struct general_symbol_info ginfo;
1072
1073   /* Data type of value */
1074
1075   struct type *type;
1076
1077   /* The owner of this symbol.
1078      Which one to use is defined by symbol.is_objfile_owned.  */
1079
1080   union
1081   {
1082     /* The symbol table containing this symbol.  This is the file associated
1083        with LINE.  It can be NULL during symbols read-in but it is never NULL
1084        during normal operation.  */
1085     struct symtab *symtab;
1086
1087     /* For types defined by the architecture.  */
1088     struct gdbarch *arch;
1089   } owner;
1090
1091   /* Domain code.  */
1092
1093   ENUM_BITFIELD(domain_enum_tag) domain : SYMBOL_DOMAIN_BITS;
1094
1095   /* Address class.  This holds an index into the 'symbol_impls'
1096      table.  The actual enum address_class value is stored there,
1097      alongside any per-class ops vectors.  */
1098
1099   unsigned int aclass_index : SYMBOL_ACLASS_BITS;
1100
1101   /* If non-zero then symbol is objfile-owned, use owner.symtab.
1102      Otherwise symbol is arch-owned, use owner.arch.  */
1103
1104   unsigned int is_objfile_owned : 1;
1105
1106   /* Whether this is an argument.  */
1107
1108   unsigned is_argument : 1;
1109
1110   /* Whether this is an inlined function (class LOC_BLOCK only).  */
1111   unsigned is_inlined : 1;
1112
1113   /* The concrete type of this symbol.  */
1114
1115   ENUM_BITFIELD (symbol_subclass_kind) subclass : 2;
1116
1117   /* Line number of this symbol's definition, except for inlined
1118      functions.  For an inlined function (class LOC_BLOCK and
1119      SYMBOL_INLINED set) this is the line number of the function's call
1120      site.  Inlined function symbols are not definitions, and they are
1121      never found by symbol table lookup.
1122      If this symbol is arch-owned, LINE shall be zero.
1123
1124      FIXME: Should we really make the assumption that nobody will try
1125      to debug files longer than 64K lines?  What about machine
1126      generated programs?  */
1127
1128   unsigned short line;
1129
1130   /* An arbitrary data pointer, allowing symbol readers to record
1131      additional information on a per-symbol basis.  Note that this data
1132      must be allocated using the same obstack as the symbol itself.  */
1133   /* So far it is only used by:
1134      LOC_COMPUTED: to find the location information
1135      LOC_BLOCK (DWARF2 function): information used internally by the
1136      DWARF 2 code --- specifically, the location expression for the frame
1137      base for this function.  */
1138   /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
1139      to add a magic symbol to the block containing this information,
1140      or to have a generic debug info annotation slot for symbols.  */
1141
1142   void *aux_value;
1143
1144   struct symbol *hash_next;
1145 };
1146
1147 /* Several lookup functions return both a symbol and the block in which the
1148    symbol is found.  This structure is used in these cases.  */
1149
1150 struct block_symbol
1151 {
1152   /* The symbol that was found, or NULL if no symbol was found.  */
1153   struct symbol *symbol;
1154
1155   /* If SYMBOL is not NULL, then this is the block in which the symbol is
1156      defined.  */
1157   const struct block *block;
1158 };
1159
1160 extern const struct symbol_impl *symbol_impls;
1161
1162 /* Note: There is no accessor macro for symbol.owner because it is
1163    "private".  */
1164
1165 #define SYMBOL_DOMAIN(symbol)   (symbol)->domain
1166 #define SYMBOL_IMPL(symbol)             (symbol_impls[(symbol)->aclass_index])
1167 #define SYMBOL_ACLASS_INDEX(symbol)     (symbol)->aclass_index
1168 #define SYMBOL_CLASS(symbol)            (SYMBOL_IMPL (symbol).aclass)
1169 #define SYMBOL_OBJFILE_OWNED(symbol)    ((symbol)->is_objfile_owned)
1170 #define SYMBOL_IS_ARGUMENT(symbol)      (symbol)->is_argument
1171 #define SYMBOL_INLINED(symbol)          (symbol)->is_inlined
1172 #define SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION(symbol) \
1173   (((symbol)->subclass) == SYMBOL_TEMPLATE)
1174 #define SYMBOL_TYPE(symbol)             (symbol)->type
1175 #define SYMBOL_LINE(symbol)             (symbol)->line
1176 #define SYMBOL_COMPUTED_OPS(symbol)     (SYMBOL_IMPL (symbol).ops_computed)
1177 #define SYMBOL_BLOCK_OPS(symbol)        (SYMBOL_IMPL (symbol).ops_block)
1178 #define SYMBOL_REGISTER_OPS(symbol)     (SYMBOL_IMPL (symbol).ops_register)
1179 #define SYMBOL_LOCATION_BATON(symbol)   (symbol)->aux_value
1180
1181 extern int register_symbol_computed_impl (enum address_class,
1182                                           const struct symbol_computed_ops *);
1183
1184 extern int register_symbol_block_impl (enum address_class aclass,
1185                                        const struct symbol_block_ops *ops);
1186
1187 extern int register_symbol_register_impl (enum address_class,
1188                                           const struct symbol_register_ops *);
1189
1190 /* Return the OBJFILE of SYMBOL.
1191    It is an error to call this if symbol.is_objfile_owned is false, which
1192    only happens for architecture-provided types.  */
1193
1194 extern struct objfile *symbol_objfile (const struct symbol *symbol);
1195
1196 /* Return the ARCH of SYMBOL.  */
1197
1198 extern struct gdbarch *symbol_arch (const struct symbol *symbol);
1199
1200 /* Return the SYMTAB of SYMBOL.
1201    It is an error to call this if symbol.is_objfile_owned is false, which
1202    only happens for architecture-provided types.  */
1203
1204 extern struct symtab *symbol_symtab (const struct symbol *symbol);
1205
1206 /* Set the symtab of SYMBOL to SYMTAB.
1207    It is an error to call this if symbol.is_objfile_owned is false, which
1208    only happens for architecture-provided types.  */
1209
1210 extern void symbol_set_symtab (struct symbol *symbol, struct symtab *symtab);
1211
1212 /* An instance of this type is used to represent a C++ template
1213    function.  A symbol is really of this type iff
1214    SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION is true.  */
1215
1216 struct template_symbol : public symbol
1217 {
1218   /* The number of template arguments.  */
1219   int n_template_arguments;
1220
1221   /* The template arguments.  This is an array with
1222      N_TEMPLATE_ARGUMENTS elements.  */
1223   struct symbol **template_arguments;
1224 };
1225
1226 /* A symbol that represents a Rust virtual table object.  */
1227
1228 struct rust_vtable_symbol : public symbol
1229 {
1230   /* The concrete type for which this vtable was created; that is, in
1231      "impl Trait for Type", this is "Type".  */
1232   struct type *concrete_type;
1233 };
1234
1235 \f
1236 /* Each item represents a line-->pc (or the reverse) mapping.  This is
1237    somewhat more wasteful of space than one might wish, but since only
1238    the files which are actually debugged are read in to core, we don't
1239    waste much space.  */
1240
1241 struct linetable_entry
1242 {
1243   int line;
1244   CORE_ADDR pc;
1245 };
1246
1247 /* The order of entries in the linetable is significant.  They should
1248    be sorted by increasing values of the pc field.  If there is more than
1249    one entry for a given pc, then I'm not sure what should happen (and
1250    I not sure whether we currently handle it the best way).
1251
1252    Example: a C for statement generally looks like this
1253
1254    10   0x100   - for the init/test part of a for stmt.
1255    20   0x200
1256    30   0x300
1257    10   0x400   - for the increment part of a for stmt.
1258
1259    If an entry has a line number of zero, it marks the start of a PC
1260    range for which no line number information is available.  It is
1261    acceptable, though wasteful of table space, for such a range to be
1262    zero length.  */
1263
1264 struct linetable
1265 {
1266   int nitems;
1267
1268   /* Actually NITEMS elements.  If you don't like this use of the
1269      `struct hack', you can shove it up your ANSI (seriously, if the
1270      committee tells us how to do it, we can probably go along).  */
1271   struct linetable_entry item[1];
1272 };
1273
1274 /* How to relocate the symbols from each section in a symbol file.
1275    Each struct contains an array of offsets.
1276    The ordering and meaning of the offsets is file-type-dependent;
1277    typically it is indexed by section numbers or symbol types or
1278    something like that.
1279
1280    To give us flexibility in changing the internal representation
1281    of these offsets, the ANOFFSET macro must be used to insert and
1282    extract offset values in the struct.  */
1283
1284 struct section_offsets
1285 {
1286   CORE_ADDR offsets[1];         /* As many as needed.  */
1287 };
1288
1289 #define ANOFFSET(secoff, whichone) \
1290   ((whichone == -1)                       \
1291    ? (internal_error (__FILE__, __LINE__, \
1292                       _("Section index is uninitialized")), -1) \
1293    : secoff->offsets[whichone])
1294
1295 /* The size of a section_offsets table for N sections.  */
1296 #define SIZEOF_N_SECTION_OFFSETS(n) \
1297   (sizeof (struct section_offsets) \
1298    + sizeof (((struct section_offsets *) 0)->offsets) * ((n)-1))
1299
1300 /* Each source file or header is represented by a struct symtab.
1301    The name "symtab" is historical, another name for it is "filetab".
1302    These objects are chained through the `next' field.  */
1303
1304 struct symtab
1305 {
1306   /* Unordered chain of all filetabs in the compunit,  with the exception
1307      that the "main" source file is the first entry in the list.  */
1308
1309   struct symtab *next;
1310
1311   /* Backlink to containing compunit symtab.  */
1312
1313   struct compunit_symtab *compunit_symtab;
1314
1315   /* Table mapping core addresses to line numbers for this file.
1316      Can be NULL if none.  Never shared between different symtabs.  */
1317
1318   struct linetable *linetable;
1319
1320   /* Name of this source file.  This pointer is never NULL.  */
1321
1322   const char *filename;
1323
1324   /* Language of this source file.  */
1325
1326   enum language language;
1327
1328   /* Full name of file as found by searching the source path.
1329      NULL if not yet known.  */
1330
1331   char *fullname;
1332 };
1333
1334 #define SYMTAB_COMPUNIT(symtab) ((symtab)->compunit_symtab)
1335 #define SYMTAB_LINETABLE(symtab) ((symtab)->linetable)
1336 #define SYMTAB_LANGUAGE(symtab) ((symtab)->language)
1337 #define SYMTAB_BLOCKVECTOR(symtab) \
1338   COMPUNIT_BLOCKVECTOR (SYMTAB_COMPUNIT (symtab))
1339 #define SYMTAB_OBJFILE(symtab) \
1340   COMPUNIT_OBJFILE (SYMTAB_COMPUNIT (symtab))
1341 #define SYMTAB_PSPACE(symtab) (SYMTAB_OBJFILE (symtab)->pspace)
1342 #define SYMTAB_DIRNAME(symtab) \
1343   COMPUNIT_DIRNAME (SYMTAB_COMPUNIT (symtab))
1344
1345 /* Compunit symtabs contain the actual "symbol table", aka blockvector, as well
1346    as the list of all source files (what gdb has historically associated with
1347    the term "symtab").
1348    Additional information is recorded here that is common to all symtabs in a
1349    compilation unit (DWARF or otherwise).
1350
1351    Example:
1352    For the case of a program built out of these files:
1353
1354    foo.c
1355      foo1.h
1356      foo2.h
1357    bar.c
1358      foo1.h
1359      bar.h
1360
1361    This is recorded as:
1362
1363    objfile -> foo.c(cu) -> bar.c(cu) -> NULL
1364                 |            |
1365                 v            v
1366               foo.c        bar.c
1367                 |            |
1368                 v            v
1369               foo1.h       foo1.h
1370                 |            |
1371                 v            v
1372               foo2.h       bar.h
1373                 |            |
1374                 v            v
1375                NULL         NULL
1376
1377    where "foo.c(cu)" and "bar.c(cu)" are struct compunit_symtab objects,
1378    and the files foo.c, etc. are struct symtab objects.  */
1379
1380 struct compunit_symtab
1381 {
1382   /* Unordered chain of all compunit symtabs of this objfile.  */
1383   struct compunit_symtab *next;
1384
1385   /* Object file from which this symtab information was read.  */
1386   struct objfile *objfile;
1387
1388   /* Name of the symtab.
1389      This is *not* intended to be a usable filename, and is
1390      for debugging purposes only.  */
1391   const char *name;
1392
1393   /* Unordered list of file symtabs, except that by convention the "main"
1394      source file (e.g., .c, .cc) is guaranteed to be first.
1395      Each symtab is a file, either the "main" source file (e.g., .c, .cc)
1396      or header (e.g., .h).  */
1397   struct symtab *filetabs;
1398
1399   /* Last entry in FILETABS list.
1400      Subfiles are added to the end of the list so they accumulate in order,
1401      with the main source subfile living at the front.
1402      The main reason is so that the main source file symtab is at the head
1403      of the list, and the rest appear in order for debugging convenience.  */
1404   struct symtab *last_filetab;
1405
1406   /* Non-NULL string that identifies the format of the debugging information,
1407      such as "stabs", "dwarf 1", "dwarf 2", "coff", etc.  This is mostly useful
1408      for automated testing of gdb but may also be information that is
1409      useful to the user.  */
1410   const char *debugformat;
1411
1412   /* String of producer version information, or NULL if we don't know.  */
1413   const char *producer;
1414
1415   /* Directory in which it was compiled, or NULL if we don't know.  */
1416   const char *dirname;
1417
1418   /* List of all symbol scope blocks for this symtab.  It is shared among
1419      all symtabs in a given compilation unit.  */
1420   const struct blockvector *blockvector;
1421
1422   /* Section in objfile->section_offsets for the blockvector and
1423      the linetable.  Probably always SECT_OFF_TEXT.  */
1424   int block_line_section;
1425
1426   /* Symtab has been compiled with both optimizations and debug info so that
1427      GDB may stop skipping prologues as variables locations are valid already
1428      at function entry points.  */
1429   unsigned int locations_valid : 1;
1430
1431   /* DWARF unwinder for this CU is valid even for epilogues (PC at the return
1432      instruction).  This is supported by GCC since 4.5.0.  */
1433   unsigned int epilogue_unwind_valid : 1;
1434
1435   /* struct call_site entries for this compilation unit or NULL.  */
1436   htab_t call_site_htab;
1437
1438   /* The macro table for this symtab.  Like the blockvector, this
1439      is shared between different symtabs in a given compilation unit.
1440      It's debatable whether it *should* be shared among all the symtabs in
1441      the given compilation unit, but it currently is.  */
1442   struct macro_table *macro_table;
1443
1444   /* If non-NULL, then this points to a NULL-terminated vector of
1445      included compunits.  When searching the static or global
1446      block of this compunit, the corresponding block of all
1447      included compunits will also be searched.  Note that this
1448      list must be flattened -- the symbol reader is responsible for
1449      ensuring that this vector contains the transitive closure of all
1450      included compunits.  */
1451   struct compunit_symtab **includes;
1452
1453   /* If this is an included compunit, this points to one includer
1454      of the table.  This user is considered the canonical compunit
1455      containing this one.  An included compunit may itself be
1456      included by another.  */
1457   struct compunit_symtab *user;
1458 };
1459
1460 #define COMPUNIT_OBJFILE(cust) ((cust)->objfile)
1461 #define COMPUNIT_FILETABS(cust) ((cust)->filetabs)
1462 #define COMPUNIT_DEBUGFORMAT(cust) ((cust)->debugformat)
1463 #define COMPUNIT_PRODUCER(cust) ((cust)->producer)
1464 #define COMPUNIT_DIRNAME(cust) ((cust)->dirname)
1465 #define COMPUNIT_BLOCKVECTOR(cust) ((cust)->blockvector)
1466 #define COMPUNIT_BLOCK_LINE_SECTION(cust) ((cust)->block_line_section)
1467 #define COMPUNIT_LOCATIONS_VALID(cust) ((cust)->locations_valid)
1468 #define COMPUNIT_EPILOGUE_UNWIND_VALID(cust) ((cust)->epilogue_unwind_valid)
1469 #define COMPUNIT_CALL_SITE_HTAB(cust) ((cust)->call_site_htab)
1470 #define COMPUNIT_MACRO_TABLE(cust) ((cust)->macro_table)
1471
1472 /* A range adapter to allowing iterating over all the file tables
1473    within a compunit.  */
1474
1475 struct compunit_filetabs : public next_adapter<struct symtab>
1476 {
1477   compunit_filetabs (struct compunit_symtab *cu)
1478     : next_adapter<struct symtab> (cu->filetabs)
1479   {
1480   }
1481 };
1482
1483 /* Return the primary symtab of CUST.  */
1484
1485 extern struct symtab *
1486   compunit_primary_filetab (const struct compunit_symtab *cust);
1487
1488 /* Return the language of CUST.  */
1489
1490 extern enum language compunit_language (const struct compunit_symtab *cust);
1491
1492 \f
1493
1494 /* The virtual function table is now an array of structures which have the
1495    form { int16 offset, delta; void *pfn; }. 
1496
1497    In normal virtual function tables, OFFSET is unused.
1498    DELTA is the amount which is added to the apparent object's base
1499    address in order to point to the actual object to which the
1500    virtual function should be applied.
1501    PFN is a pointer to the virtual function.
1502
1503    Note that this macro is g++ specific (FIXME).  */
1504
1505 #define VTBL_FNADDR_OFFSET 2
1506
1507 /* External variables and functions for the objects described above.  */
1508
1509 /* True if we are nested inside psymtab_to_symtab.  */
1510
1511 extern int currently_reading_symtab;
1512
1513 /* symtab.c lookup functions */
1514
1515 extern const char multiple_symbols_ask[];
1516 extern const char multiple_symbols_all[];
1517 extern const char multiple_symbols_cancel[];
1518
1519 const char *multiple_symbols_select_mode (void);
1520
1521 int symbol_matches_domain (enum language symbol_language, 
1522                            domain_enum symbol_domain,
1523                            domain_enum domain);
1524
1525 /* lookup a symbol table by source file name.  */
1526
1527 extern struct symtab *lookup_symtab (const char *);
1528
1529 /* An object of this type is passed as the 'is_a_field_of_this'
1530    argument to lookup_symbol and lookup_symbol_in_language.  */
1531
1532 struct field_of_this_result
1533 {
1534   /* The type in which the field was found.  If this is NULL then the
1535      symbol was not found in 'this'.  If non-NULL, then one of the
1536      other fields will be non-NULL as well.  */
1537
1538   struct type *type;
1539
1540   /* If the symbol was found as an ordinary field of 'this', then this
1541      is non-NULL and points to the particular field.  */
1542
1543   struct field *field;
1544
1545   /* If the symbol was found as a function field of 'this', then this
1546      is non-NULL and points to the particular field.  */
1547
1548   struct fn_fieldlist *fn_field;
1549 };
1550
1551 /* Find the definition for a specified symbol name NAME
1552    in domain DOMAIN in language LANGUAGE, visible from lexical block BLOCK
1553    if non-NULL or from global/static blocks if BLOCK is NULL.
1554    Returns the struct symbol pointer, or NULL if no symbol is found.
1555    C++: if IS_A_FIELD_OF_THIS is non-NULL on entry, check to see if
1556    NAME is a field of the current implied argument `this'.  If so fill in the
1557    fields of IS_A_FIELD_OF_THIS, otherwise the fields are set to NULL.
1558    The symbol's section is fixed up if necessary.  */
1559
1560 extern struct block_symbol
1561   lookup_symbol_in_language (const char *,
1562                              const struct block *,
1563                              const domain_enum,
1564                              enum language,
1565                              struct field_of_this_result *);
1566
1567 /* Same as lookup_symbol_in_language, but using the current language.  */
1568
1569 extern struct block_symbol lookup_symbol (const char *,
1570                                           const struct block *,
1571                                           const domain_enum,
1572                                           struct field_of_this_result *);
1573
1574 /* Find the definition for a specified symbol search name in domain
1575    DOMAIN, visible from lexical block BLOCK if non-NULL or from
1576    global/static blocks if BLOCK is NULL.  The passed-in search name
1577    should not come from the user; instead it should already be a
1578    search name as retrieved from a
1579    SYMBOL_SEARCH_NAME/MSYMBOL_SEARCH_NAME call.  See definition of
1580    symbol_name_match_type::SEARCH_NAME.  Returns the struct symbol
1581    pointer, or NULL if no symbol is found.  The symbol's section is
1582    fixed up if necessary.  */
1583
1584 extern struct block_symbol lookup_symbol_search_name (const char *search_name,
1585                                                       const struct block *block,
1586                                                       domain_enum domain);
1587
1588 /* A default version of lookup_symbol_nonlocal for use by languages
1589    that can't think of anything better to do.
1590    This implements the C lookup rules.  */
1591
1592 extern struct block_symbol
1593   basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
1594                                 const char *,
1595                                 const struct block *,
1596                                 const domain_enum);
1597
1598 /* Some helper functions for languages that need to write their own
1599    lookup_symbol_nonlocal functions.  */
1600
1601 /* Lookup a symbol in the static block associated to BLOCK, if there
1602    is one; do nothing if BLOCK is NULL or a global block.
1603    Upon success fixes up the symbol's section if necessary.  */
1604
1605 extern struct block_symbol
1606   lookup_symbol_in_static_block (const char *name,
1607                                  const struct block *block,
1608                                  const domain_enum domain);
1609
1610 /* Search all static file-level symbols for NAME from DOMAIN.
1611    Upon success fixes up the symbol's section if necessary.  */
1612
1613 extern struct block_symbol lookup_static_symbol (const char *name,
1614                                                  const domain_enum domain);
1615
1616 /* Lookup a symbol in all files' global blocks.
1617
1618    If BLOCK is non-NULL then it is used for two things:
1619    1) If a target-specific lookup routine for libraries exists, then use the
1620       routine for the objfile of BLOCK, and
1621    2) The objfile of BLOCK is used to assist in determining the search order
1622       if the target requires it.
1623       See gdbarch_iterate_over_objfiles_in_search_order.
1624
1625    Upon success fixes up the symbol's section if necessary.  */
1626
1627 extern struct block_symbol
1628   lookup_global_symbol (const char *name,
1629                         const struct block *block,
1630                         const domain_enum domain);
1631
1632 /* Lookup a symbol in block BLOCK.
1633    Upon success fixes up the symbol's section if necessary.  */
1634
1635 extern struct symbol *
1636   lookup_symbol_in_block (const char *name,
1637                           symbol_name_match_type match_type,
1638                           const struct block *block,
1639                           const domain_enum domain);
1640
1641 /* Look up the `this' symbol for LANG in BLOCK.  Return the symbol if
1642    found, or NULL if not found.  */
1643
1644 extern struct block_symbol
1645   lookup_language_this (const struct language_defn *lang,
1646                         const struct block *block);
1647
1648 /* Lookup a [struct, union, enum] by name, within a specified block.  */
1649
1650 extern struct type *lookup_struct (const char *, const struct block *);
1651
1652 extern struct type *lookup_union (const char *, const struct block *);
1653
1654 extern struct type *lookup_enum (const char *, const struct block *);
1655
1656 /* from blockframe.c: */
1657
1658 /* lookup the function symbol corresponding to the address.  The
1659    return value will not be an inlined function; the containing
1660    function will be returned instead.  */
1661
1662 extern struct symbol *find_pc_function (CORE_ADDR);
1663
1664 /* lookup the function corresponding to the address and section.  The
1665    return value will not be an inlined function; the containing
1666    function will be returned instead.  */
1667
1668 extern struct symbol *find_pc_sect_function (CORE_ADDR, struct obj_section *);
1669
1670 /* lookup the function symbol corresponding to the address and
1671    section.  The return value will be the closest enclosing function,
1672    which might be an inline function.  */
1673
1674 extern struct symbol *find_pc_sect_containing_function
1675   (CORE_ADDR pc, struct obj_section *section);
1676
1677 /* Find the symbol at the given address.  Returns NULL if no symbol
1678    found.  Only exact matches for ADDRESS are considered.  */
1679
1680 extern struct symbol *find_symbol_at_address (CORE_ADDR);
1681
1682 /* Finds the "function" (text symbol) that is smaller than PC but
1683    greatest of all of the potential text symbols in SECTION.  Sets
1684    *NAME and/or *ADDRESS conditionally if that pointer is non-null.
1685    If ENDADDR is non-null, then set *ENDADDR to be the end of the
1686    function (exclusive).  If the optional parameter BLOCK is non-null,
1687    then set *BLOCK to the address of the block corresponding to the
1688    function symbol, if such a symbol could be found during the lookup;
1689    nullptr is used as a return value for *BLOCK if no block is found. 
1690    This function either succeeds or fails (not halfway succeeds).  If
1691    it succeeds, it sets *NAME, *ADDRESS, and *ENDADDR to real
1692    information and returns 1.  If it fails, it sets *NAME, *ADDRESS
1693    and *ENDADDR to zero and returns 0.
1694    
1695    If the function in question occupies non-contiguous ranges,
1696    *ADDRESS and *ENDADDR are (subject to the conditions noted above) set
1697    to the start and end of the range in which PC is found.  Thus
1698    *ADDRESS <= PC < *ENDADDR with no intervening gaps (in which ranges
1699    from other functions might be found).
1700    
1701    This property allows find_pc_partial_function to be used (as it had
1702    been prior to the introduction of non-contiguous range support) by
1703    various tdep files for finding a start address and limit address
1704    for prologue analysis.  This still isn't ideal, however, because we
1705    probably shouldn't be doing prologue analysis (in which
1706    instructions are scanned to determine frame size and stack layout)
1707    for any range that doesn't contain the entry pc.  Moreover, a good
1708    argument can be made that prologue analysis ought to be performed
1709    starting from the entry pc even when PC is within some other range.
1710    This might suggest that *ADDRESS and *ENDADDR ought to be set to the
1711    limits of the entry pc range, but that will cause the 
1712    *ADDRESS <= PC < *ENDADDR condition to be violated; many of the
1713    callers of find_pc_partial_function expect this condition to hold. 
1714
1715    Callers which require the start and/or end addresses for the range
1716    containing the entry pc should instead call
1717    find_function_entry_range_from_pc.  */
1718
1719 extern int find_pc_partial_function (CORE_ADDR pc, const char **name,
1720                                      CORE_ADDR *address, CORE_ADDR *endaddr,
1721                                      const struct block **block = nullptr);
1722
1723 /* Like find_pc_partial_function, above, but *ADDRESS and *ENDADDR are
1724    set to start and end addresses of the range containing the entry pc.
1725
1726    Note that it is not necessarily the case that (for non-NULL ADDRESS
1727    and ENDADDR arguments) the *ADDRESS <= PC < *ENDADDR condition will
1728    hold.
1729
1730    See comment for find_pc_partial_function, above, for further
1731    explanation.  */
1732
1733 extern bool find_function_entry_range_from_pc (CORE_ADDR pc,
1734                                                const char **name,
1735                                                CORE_ADDR *address,
1736                                                CORE_ADDR *endaddr);
1737
1738 /* Return the type of a function with its first instruction exactly at
1739    the PC address.  Return NULL otherwise.  */
1740
1741 extern struct type *find_function_type (CORE_ADDR pc);
1742
1743 /* See if we can figure out the function's actual type from the type
1744    that the resolver returns.  RESOLVER_FUNADDR is the address of the
1745    ifunc resolver.  */
1746
1747 extern struct type *find_gnu_ifunc_target_type (CORE_ADDR resolver_funaddr);
1748
1749 /* Find the GNU ifunc minimal symbol that matches SYM.  */
1750 extern bound_minimal_symbol find_gnu_ifunc (const symbol *sym);
1751
1752 extern void clear_pc_function_cache (void);
1753
1754 /* Expand symtab containing PC, SECTION if not already expanded.  */
1755
1756 extern void expand_symtab_containing_pc (CORE_ADDR, struct obj_section *);
1757
1758 /* lookup full symbol table by address.  */
1759
1760 extern struct compunit_symtab *find_pc_compunit_symtab (CORE_ADDR);
1761
1762 /* lookup full symbol table by address and section.  */
1763
1764 extern struct compunit_symtab *
1765   find_pc_sect_compunit_symtab (CORE_ADDR, struct obj_section *);
1766
1767 extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
1768
1769 extern void reread_symbols (void);
1770
1771 /* Look up a type named NAME in STRUCT_DOMAIN in the current language.
1772    The type returned must not be opaque -- i.e., must have at least one field
1773    defined.  */
1774
1775 extern struct type *lookup_transparent_type (const char *);
1776
1777 extern struct type *basic_lookup_transparent_type (const char *);
1778
1779 /* Macro for name of symbol to indicate a file compiled with gcc.  */
1780 #ifndef GCC_COMPILED_FLAG_SYMBOL
1781 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
1782 #endif
1783
1784 /* Macro for name of symbol to indicate a file compiled with gcc2.  */
1785 #ifndef GCC2_COMPILED_FLAG_SYMBOL
1786 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
1787 #endif
1788
1789 extern int in_gnu_ifunc_stub (CORE_ADDR pc);
1790
1791 /* Functions for resolving STT_GNU_IFUNC symbols which are implemented only
1792    for ELF symbol files.  */
1793
1794 struct gnu_ifunc_fns
1795 {
1796   /* See elf_gnu_ifunc_resolve_addr for its real implementation.  */
1797   CORE_ADDR (*gnu_ifunc_resolve_addr) (struct gdbarch *gdbarch, CORE_ADDR pc);
1798
1799   /* See elf_gnu_ifunc_resolve_name for its real implementation.  */
1800   int (*gnu_ifunc_resolve_name) (const char *function_name,
1801                                  CORE_ADDR *function_address_p);
1802
1803   /* See elf_gnu_ifunc_resolver_stop for its real implementation.  */
1804   void (*gnu_ifunc_resolver_stop) (struct breakpoint *b);
1805
1806   /* See elf_gnu_ifunc_resolver_return_stop for its real implementation.  */
1807   void (*gnu_ifunc_resolver_return_stop) (struct breakpoint *b);
1808 };
1809
1810 #define gnu_ifunc_resolve_addr gnu_ifunc_fns_p->gnu_ifunc_resolve_addr
1811 #define gnu_ifunc_resolve_name gnu_ifunc_fns_p->gnu_ifunc_resolve_name
1812 #define gnu_ifunc_resolver_stop gnu_ifunc_fns_p->gnu_ifunc_resolver_stop
1813 #define gnu_ifunc_resolver_return_stop \
1814   gnu_ifunc_fns_p->gnu_ifunc_resolver_return_stop
1815
1816 extern const struct gnu_ifunc_fns *gnu_ifunc_fns_p;
1817
1818 extern CORE_ADDR find_solib_trampoline_target (struct frame_info *, CORE_ADDR);
1819
1820 struct symtab_and_line
1821 {
1822   /* The program space of this sal.  */
1823   struct program_space *pspace = NULL;
1824
1825   struct symtab *symtab = NULL;
1826   struct symbol *symbol = NULL;
1827   struct obj_section *section = NULL;
1828   struct minimal_symbol *msymbol = NULL;
1829   /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
1830      0 is never a valid line number; it is used to indicate that line number
1831      information is not available.  */
1832   int line = 0;
1833
1834   CORE_ADDR pc = 0;
1835   CORE_ADDR end = 0;
1836   bool explicit_pc = false;
1837   bool explicit_line = false;
1838
1839   /* The probe associated with this symtab_and_line.  */
1840   probe *prob = NULL;
1841   /* If PROBE is not NULL, then this is the objfile in which the probe
1842      originated.  */
1843   struct objfile *objfile = NULL;
1844 };
1845
1846 \f
1847
1848 /* Given a pc value, return line number it is in.  Second arg nonzero means
1849    if pc is on the boundary use the previous statement's line number.  */
1850
1851 extern struct symtab_and_line find_pc_line (CORE_ADDR, int);
1852
1853 /* Same function, but specify a section as well as an address.  */
1854
1855 extern struct symtab_and_line find_pc_sect_line (CORE_ADDR,
1856                                                  struct obj_section *, int);
1857
1858 /* Wrapper around find_pc_line to just return the symtab.  */
1859
1860 extern struct symtab *find_pc_line_symtab (CORE_ADDR);
1861
1862 /* Given a symtab and line number, return the pc there.  */
1863
1864 extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
1865
1866 extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
1867                                CORE_ADDR *);
1868
1869 extern void resolve_sal_pc (struct symtab_and_line *);
1870
1871 /* solib.c */
1872
1873 extern void clear_solib (void);
1874
1875 /* The reason we're calling into a completion match list collector
1876    function.  */
1877 enum class complete_symbol_mode
1878   {
1879     /* Completing an expression.  */
1880     EXPRESSION,
1881
1882     /* Completing a linespec.  */
1883     LINESPEC,
1884   };
1885
1886 extern void default_collect_symbol_completion_matches_break_on
1887   (completion_tracker &tracker,
1888    complete_symbol_mode mode,
1889    symbol_name_match_type name_match_type,
1890    const char *text, const char *word, const char *break_on,
1891    enum type_code code);
1892 extern void default_collect_symbol_completion_matches
1893   (completion_tracker &tracker,
1894    complete_symbol_mode,
1895    symbol_name_match_type name_match_type,
1896    const char *,
1897    const char *,
1898    enum type_code);
1899 extern void collect_symbol_completion_matches
1900   (completion_tracker &tracker,
1901    complete_symbol_mode mode,
1902    symbol_name_match_type name_match_type,
1903    const char *, const char *);
1904 extern void collect_symbol_completion_matches_type (completion_tracker &tracker,
1905                                                     const char *, const char *,
1906                                                     enum type_code);
1907
1908 extern void collect_file_symbol_completion_matches
1909   (completion_tracker &tracker,
1910    complete_symbol_mode,
1911    symbol_name_match_type name_match_type,
1912    const char *, const char *, const char *);
1913
1914 extern completion_list
1915   make_source_files_completion_list (const char *, const char *);
1916
1917 /* Return whether SYM is a function/method, as opposed to a data symbol.  */
1918
1919 extern bool symbol_is_function_or_method (symbol *sym);
1920
1921 /* Return whether MSYMBOL is a function/method, as opposed to a data
1922    symbol */
1923
1924 extern bool symbol_is_function_or_method (minimal_symbol *msymbol);
1925
1926 /* Return whether SYM should be skipped in completion mode MODE.  In
1927    linespec mode, we're only interested in functions/methods.  */
1928
1929 template<typename Symbol>
1930 static bool
1931 completion_skip_symbol (complete_symbol_mode mode, Symbol *sym)
1932 {
1933   return (mode == complete_symbol_mode::LINESPEC
1934           && !symbol_is_function_or_method (sym));
1935 }
1936
1937 /* symtab.c */
1938
1939 int matching_obj_sections (struct obj_section *, struct obj_section *);
1940
1941 extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
1942
1943 /* Given a function symbol SYM, find the symtab and line for the start
1944    of the function.  If FUNFIRSTLINE is true, we want the first line
1945    of real code inside the function.  */
1946 extern symtab_and_line find_function_start_sal (symbol *sym, bool
1947                                                 funfirstline);
1948
1949 /* Same, but start with a function address/section instead of a
1950    symbol.  */
1951 extern symtab_and_line find_function_start_sal (CORE_ADDR func_addr,
1952                                                 obj_section *section,
1953                                                 bool funfirstline);
1954
1955 extern void skip_prologue_sal (struct symtab_and_line *);
1956
1957 /* symtab.c */
1958
1959 extern CORE_ADDR skip_prologue_using_sal (struct gdbarch *gdbarch,
1960                                           CORE_ADDR func_addr);
1961
1962 extern struct symbol *fixup_symbol_section (struct symbol *,
1963                                             struct objfile *);
1964
1965 /* If MSYMBOL is an text symbol, look for a function debug symbol with
1966    the same address.  Returns NULL if not found.  This is necessary in
1967    case a function is an alias to some other function, because debug
1968    information is only emitted for the alias target function's
1969    definition, not for the alias.  */
1970 extern symbol *find_function_alias_target (bound_minimal_symbol msymbol);
1971
1972 /* Symbol searching */
1973 /* Note: struct symbol_search, search_symbols, et.al. are declared here,
1974    instead of making them local to symtab.c, for gdbtk's sake.  */
1975
1976 /* When using search_symbols, a vector of the following structs is
1977    returned.  */
1978 struct symbol_search
1979 {
1980   symbol_search (int block_, struct symbol *symbol_)
1981     : block (block_),
1982       symbol (symbol_)
1983   {
1984     msymbol.minsym = nullptr;
1985     msymbol.objfile = nullptr;
1986   }
1987
1988   symbol_search (int block_, struct minimal_symbol *minsym,
1989                  struct objfile *objfile)
1990     : block (block_),
1991       symbol (nullptr)
1992   {
1993     msymbol.minsym = minsym;
1994     msymbol.objfile = objfile;
1995   }
1996
1997   bool operator< (const symbol_search &other) const
1998   {
1999     return compare_search_syms (*this, other) < 0;
2000   }
2001
2002   bool operator== (const symbol_search &other) const
2003   {
2004     return compare_search_syms (*this, other) == 0;
2005   }
2006
2007   /* The block in which the match was found.  Could be, for example,
2008      STATIC_BLOCK or GLOBAL_BLOCK.  */
2009   int block;
2010
2011   /* Information describing what was found.
2012
2013      If symbol is NOT NULL, then information was found for this match.  */
2014   struct symbol *symbol;
2015
2016   /* If msymbol is non-null, then a match was made on something for
2017      which only minimal_symbols exist.  */
2018   struct bound_minimal_symbol msymbol;
2019
2020 private:
2021
2022   static int compare_search_syms (const symbol_search &sym_a,
2023                                   const symbol_search &sym_b);
2024 };
2025
2026 extern std::vector<symbol_search> search_symbols (const char *,
2027                                                   enum search_domain,
2028                                                   const char *,
2029                                                   int,
2030                                                   const char **,
2031                                                   bool);
2032 extern bool treg_matches_sym_type_name (const compiled_regex &treg,
2033                                         const struct symbol *sym);
2034
2035 /* The name of the ``main'' function.  */
2036 extern const char *main_name ();
2037 extern enum language main_language (void);
2038
2039 /* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global or static blocks,
2040    as specified by BLOCK_INDEX.
2041    This searches MAIN_OBJFILE as well as any associated separate debug info
2042    objfiles of MAIN_OBJFILE.
2043    BLOCK_INDEX can be GLOBAL_BLOCK or STATIC_BLOCK.
2044    Upon success fixes up the symbol's section if necessary.  */
2045
2046 extern struct block_symbol
2047   lookup_global_symbol_from_objfile (struct objfile *main_objfile,
2048                                      enum block_enum block_index,
2049                                      const char *name,
2050                                      const domain_enum domain);
2051
2052 /* Return 1 if the supplied producer string matches the ARM RealView
2053    compiler (armcc).  */
2054 int producer_is_realview (const char *producer);
2055
2056 void fixup_section (struct general_symbol_info *ginfo,
2057                     CORE_ADDR addr, struct objfile *objfile);
2058
2059 /* Look up objfile containing BLOCK.  */
2060
2061 struct objfile *lookup_objfile_from_block (const struct block *block);
2062
2063 extern unsigned int symtab_create_debug;
2064
2065 extern unsigned int symbol_lookup_debug;
2066
2067 extern int basenames_may_differ;
2068
2069 int compare_filenames_for_search (const char *filename,
2070                                   const char *search_name);
2071
2072 int compare_glob_filenames_for_search (const char *filename,
2073                                        const char *search_name);
2074
2075 bool iterate_over_some_symtabs (const char *name,
2076                                 const char *real_path,
2077                                 struct compunit_symtab *first,
2078                                 struct compunit_symtab *after_last,
2079                                 gdb::function_view<bool (symtab *)> callback);
2080
2081 void iterate_over_symtabs (const char *name,
2082                            gdb::function_view<bool (symtab *)> callback);
2083
2084
2085 std::vector<CORE_ADDR> find_pcs_for_symtab_line
2086     (struct symtab *symtab, int line, struct linetable_entry **best_entry);
2087
2088 /* Prototype for callbacks for LA_ITERATE_OVER_SYMBOLS.  The callback
2089    is called once per matching symbol SYM.  The callback should return
2090    true to indicate that LA_ITERATE_OVER_SYMBOLS should continue
2091    iterating, or false to indicate that the iteration should end.  */
2092
2093 typedef bool (symbol_found_callback_ftype) (struct block_symbol *bsym);
2094
2095 void iterate_over_symbols (const struct block *block,
2096                            const lookup_name_info &name,
2097                            const domain_enum domain,
2098                            gdb::function_view<symbol_found_callback_ftype> callback);
2099
2100 /* Storage type used by demangle_for_lookup.  demangle_for_lookup
2101    either returns a const char * pointer that points to either of the
2102    fields of this type, or a pointer to the input NAME.  This is done
2103    this way because the underlying functions that demangle_for_lookup
2104    calls either return a std::string (e.g., cp_canonicalize_string) or
2105    a malloc'ed buffer (libiberty's demangled), and we want to avoid
2106    unnecessary reallocation/string copying.  */
2107 class demangle_result_storage
2108 {
2109 public:
2110
2111   /* Swap the std::string storage with STR, and return a pointer to
2112      the beginning of the new string.  */
2113   const char *swap_string (std::string &str)
2114   {
2115     std::swap (m_string, str);
2116     return m_string.c_str ();
2117   }
2118
2119   /* Set the malloc storage to now point at PTR.  Any previous malloc
2120      storage is released.  */
2121   const char *set_malloc_ptr (char *ptr)
2122   {
2123     m_malloc.reset (ptr);
2124     return ptr;
2125   }
2126
2127 private:
2128
2129   /* The storage.  */
2130   std::string m_string;
2131   gdb::unique_xmalloc_ptr<char> m_malloc;
2132 };
2133
2134 const char *
2135   demangle_for_lookup (const char *name, enum language lang,
2136                        demangle_result_storage &storage);
2137
2138 struct symbol *allocate_symbol (struct objfile *);
2139
2140 void initialize_objfile_symbol (struct symbol *);
2141
2142 struct template_symbol *allocate_template_symbol (struct objfile *);
2143
2144 /* Test to see if the symbol of language SYMBOL_LANGUAGE specified by
2145    SYMNAME (which is already demangled for C++ symbols) matches
2146    SYM_TEXT in the first SYM_TEXT_LEN characters.  If so, add it to
2147    the current completion list.  */
2148 void completion_list_add_name (completion_tracker &tracker,
2149                                language symbol_language,
2150                                const char *symname,
2151                                const lookup_name_info &lookup_name,
2152                                const char *text, const char *word);
2153
2154 /* A simple symbol searching class.  */
2155
2156 class symbol_searcher
2157 {
2158 public:
2159   /* Returns the symbols found for the search.  */
2160   const std::vector<block_symbol> &
2161   matching_symbols () const
2162   {
2163     return m_symbols;
2164   }
2165
2166   /* Returns the minimal symbols found for the search.  */
2167   const std::vector<bound_minimal_symbol> &
2168   matching_msymbols () const
2169   {
2170     return m_minimal_symbols;
2171   }
2172
2173   /* Search for all symbols named NAME in LANGUAGE with DOMAIN, restricting
2174      search to FILE_SYMTABS and SEARCH_PSPACE, both of which may be NULL
2175      to search all symtabs and program spaces.  */
2176   void find_all_symbols (const std::string &name,
2177                          const struct language_defn *language,
2178                          enum search_domain search_domain,
2179                          std::vector<symtab *> *search_symtabs,
2180                          struct program_space *search_pspace);
2181
2182   /* Reset this object to perform another search.  */
2183   void reset ()
2184   {
2185     m_symbols.clear ();
2186     m_minimal_symbols.clear ();
2187   }
2188
2189 private:
2190   /* Matching debug symbols.  */
2191   std::vector<block_symbol>  m_symbols;
2192
2193   /* Matching non-debug symbols.  */
2194   std::vector<bound_minimal_symbol> m_minimal_symbols;
2195 };
2196
2197 #endif /* !defined(SYMTAB_H) */