Automatic date update in version.in
[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 "common/gdb_vecs.h"
27 #include "gdbtypes.h"
28 #include "gdb_regex.h"
29 #include "common/enum-flags.h"
30 #include "common/function-view.h"
31 #include "common/gdb_optional.h"
32 #include "common/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
645 {
646
647   /* The general symbol info required for all types of symbols.
648
649      The SYMBOL_VALUE_ADDRESS contains the address that this symbol
650      corresponds to.  */
651
652   struct general_symbol_info mginfo;
653
654   /* Size of this symbol.  dbx_end_psymtab in dbxread.c uses this
655      information to calculate the end of the partial symtab based on the
656      address of the last symbol plus the size of the last symbol.  */
657
658   unsigned long size;
659
660   /* Which source file is this symbol in?  Only relevant for mst_file_*.  */
661   const char *filename;
662
663   /* Classification type for this minimal symbol.  */
664
665   ENUM_BITFIELD(minimal_symbol_type) type : MINSYM_TYPE_BITS;
666
667   /* Non-zero if this symbol was created by gdb.
668      Such symbols do not appear in the output of "info var|fun".  */
669   unsigned int created_by_gdb : 1;
670
671   /* Two flag bits provided for the use of the target.  */
672   unsigned int target_flag_1 : 1;
673   unsigned int target_flag_2 : 1;
674
675   /* Nonzero iff the size of the minimal symbol has been set.
676      Symbol size information can sometimes not be determined, because
677      the object file format may not carry that piece of information.  */
678   unsigned int has_size : 1;
679
680   /* Minimal symbols with the same hash key are kept on a linked
681      list.  This is the link.  */
682
683   struct minimal_symbol *hash_next;
684
685   /* Minimal symbols are stored in two different hash tables.  This is
686      the `next' pointer for the demangled hash table.  */
687
688   struct minimal_symbol *demangled_hash_next;
689
690 /* True if this symbol is of some data type.  */
691
692   bool data_p () const;
693
694   /* True if MSYMBOL is of some text type.  */
695
696   bool text_p () const;
697 };
698
699 #define MSYMBOL_TARGET_FLAG_1(msymbol)  (msymbol)->target_flag_1
700 #define MSYMBOL_TARGET_FLAG_2(msymbol)  (msymbol)->target_flag_2
701 #define MSYMBOL_SIZE(msymbol)           ((msymbol)->size + 0)
702 #define SET_MSYMBOL_SIZE(msymbol, sz)           \
703   do                                            \
704     {                                           \
705       (msymbol)->size = sz;                     \
706       (msymbol)->has_size = 1;                  \
707     } while (0)
708 #define MSYMBOL_HAS_SIZE(msymbol)       ((msymbol)->has_size + 0)
709 #define MSYMBOL_TYPE(msymbol)           (msymbol)->type
710
711 #define MSYMBOL_VALUE(symbol)           (symbol)->mginfo.value.ivalue
712 /* The unrelocated address of the minimal symbol.  */
713 #define MSYMBOL_VALUE_RAW_ADDRESS(symbol) ((symbol)->mginfo.value.address + 0)
714 /* The relocated address of the minimal symbol, using the section
715    offsets from OBJFILE.  */
716 #define MSYMBOL_VALUE_ADDRESS(objfile, symbol)                          \
717   ((symbol)->mginfo.value.address                                       \
718    + ANOFFSET ((objfile)->section_offsets, ((symbol)->mginfo.section)))
719 /* For a bound minsym, we can easily compute the address directly.  */
720 #define BMSYMBOL_VALUE_ADDRESS(symbol) \
721   MSYMBOL_VALUE_ADDRESS ((symbol).objfile, (symbol).minsym)
722 #define SET_MSYMBOL_VALUE_ADDRESS(symbol, new_value)    \
723   ((symbol)->mginfo.value.address = (new_value))
724 #define MSYMBOL_VALUE_BYTES(symbol)     (symbol)->mginfo.value.bytes
725 #define MSYMBOL_BLOCK_VALUE(symbol)     (symbol)->mginfo.value.block
726 #define MSYMBOL_VALUE_CHAIN(symbol)     (symbol)->mginfo.value.chain
727 #define MSYMBOL_LANGUAGE(symbol)        (symbol)->mginfo.language
728 #define MSYMBOL_SECTION(symbol)         (symbol)->mginfo.section
729 #define MSYMBOL_OBJ_SECTION(objfile, symbol)                    \
730   (((symbol)->mginfo.section >= 0)                              \
731    ? (&(((objfile)->sections)[(symbol)->mginfo.section]))       \
732    : NULL)
733
734 #define MSYMBOL_NATURAL_NAME(symbol) \
735   (symbol_natural_name (&(symbol)->mginfo))
736 #define MSYMBOL_LINKAGE_NAME(symbol)    (symbol)->mginfo.name
737 #define MSYMBOL_PRINT_NAME(symbol)                                      \
738   (demangle ? MSYMBOL_NATURAL_NAME (symbol) : MSYMBOL_LINKAGE_NAME (symbol))
739 #define MSYMBOL_DEMANGLED_NAME(symbol) \
740   (symbol_demangled_name (&(symbol)->mginfo))
741 #define MSYMBOL_SET_LANGUAGE(symbol,language,obstack)   \
742   (symbol_set_language (&(symbol)->mginfo, (language), (obstack)))
743 #define MSYMBOL_SEARCH_NAME(symbol)                                      \
744    (symbol_search_name (&(symbol)->mginfo))
745 #define MSYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile)    \
746   symbol_set_names (&(symbol)->mginfo, linkage_name, len, copy_name, \
747                     (objfile)->per_bfd)
748
749 #include "minsyms.h"
750
751 \f
752
753 /* Represent one symbol name; a variable, constant, function or typedef.  */
754
755 /* Different name domains for symbols.  Looking up a symbol specifies a
756    domain and ignores symbol definitions in other name domains.  */
757
758 typedef enum domain_enum_tag
759 {
760   /* UNDEF_DOMAIN is used when a domain has not been discovered or
761      none of the following apply.  This usually indicates an error either
762      in the symbol information or in gdb's handling of symbols.  */
763
764   UNDEF_DOMAIN,
765
766   /* VAR_DOMAIN is the usual domain.  In C, this contains variables,
767      function names, typedef names and enum type values.  */
768
769   VAR_DOMAIN,
770
771   /* STRUCT_DOMAIN is used in C to hold struct, union and enum type names.
772      Thus, if `struct foo' is used in a C program, it produces a symbol named
773      `foo' in the STRUCT_DOMAIN.  */
774
775   STRUCT_DOMAIN,
776
777   /* MODULE_DOMAIN is used in Fortran to hold module type names.  */
778
779   MODULE_DOMAIN,
780
781   /* LABEL_DOMAIN may be used for names of labels (for gotos).  */
782
783   LABEL_DOMAIN,
784
785   /* Fortran common blocks.  Their naming must be separate from VAR_DOMAIN.
786      They also always use LOC_COMMON_BLOCK.  */
787   COMMON_BLOCK_DOMAIN,
788
789   /* This must remain last.  */
790   NR_DOMAINS
791 } domain_enum;
792
793 /* The number of bits in a symbol used to represent the domain.  */
794
795 #define SYMBOL_DOMAIN_BITS 3
796 gdb_static_assert (NR_DOMAINS <= (1 << SYMBOL_DOMAIN_BITS));
797
798 extern const char *domain_name (domain_enum);
799
800 /* Searching domains, used for `search_symbols'.  Element numbers are
801    hardcoded in GDB, check all enum uses before changing it.  */
802
803 enum search_domain
804 {
805   /* Everything in VAR_DOMAIN minus FUNCTIONS_DOMAIN and
806      TYPES_DOMAIN.  */
807   VARIABLES_DOMAIN = 0,
808
809   /* All functions -- for some reason not methods, though.  */
810   FUNCTIONS_DOMAIN = 1,
811
812   /* All defined types */
813   TYPES_DOMAIN = 2,
814
815   /* Any type.  */
816   ALL_DOMAIN = 3
817 };
818
819 extern const char *search_domain_name (enum search_domain);
820
821 /* An address-class says where to find the value of a symbol.  */
822
823 enum address_class
824 {
825   /* Not used; catches errors.  */
826
827   LOC_UNDEF,
828
829   /* Value is constant int SYMBOL_VALUE, host byteorder.  */
830
831   LOC_CONST,
832
833   /* Value is at fixed address SYMBOL_VALUE_ADDRESS.  */
834
835   LOC_STATIC,
836
837   /* Value is in register.  SYMBOL_VALUE is the register number
838      in the original debug format.  SYMBOL_REGISTER_OPS holds a
839      function that can be called to transform this into the
840      actual register number this represents in a specific target
841      architecture (gdbarch).
842
843      For some symbol formats (stabs, for some compilers at least),
844      the compiler generates two symbols, an argument and a register.
845      In some cases we combine them to a single LOC_REGISTER in symbol
846      reading, but currently not for all cases (e.g. it's passed on the
847      stack and then loaded into a register).  */
848
849   LOC_REGISTER,
850
851   /* It's an argument; the value is at SYMBOL_VALUE offset in arglist.  */
852
853   LOC_ARG,
854
855   /* Value address is at SYMBOL_VALUE offset in arglist.  */
856
857   LOC_REF_ARG,
858
859   /* Value is in specified register.  Just like LOC_REGISTER except the
860      register holds the address of the argument instead of the argument
861      itself.  This is currently used for the passing of structs and unions
862      on sparc and hppa.  It is also used for call by reference where the
863      address is in a register, at least by mipsread.c.  */
864
865   LOC_REGPARM_ADDR,
866
867   /* Value is a local variable at SYMBOL_VALUE offset in stack frame.  */
868
869   LOC_LOCAL,
870
871   /* Value not used; definition in SYMBOL_TYPE.  Symbols in the domain
872      STRUCT_DOMAIN all have this class.  */
873
874   LOC_TYPEDEF,
875
876   /* Value is address SYMBOL_VALUE_ADDRESS in the code.  */
877
878   LOC_LABEL,
879
880   /* In a symbol table, value is SYMBOL_BLOCK_VALUE of a `struct block'.
881      In a partial symbol table, SYMBOL_VALUE_ADDRESS is the start address
882      of the block.  Function names have this class.  */
883
884   LOC_BLOCK,
885
886   /* Value is a constant byte-sequence pointed to by SYMBOL_VALUE_BYTES, in
887      target byte order.  */
888
889   LOC_CONST_BYTES,
890
891   /* Value is at fixed address, but the address of the variable has
892      to be determined from the minimal symbol table whenever the
893      variable is referenced.
894      This happens if debugging information for a global symbol is
895      emitted and the corresponding minimal symbol is defined
896      in another object file or runtime common storage.
897      The linker might even remove the minimal symbol if the global
898      symbol is never referenced, in which case the symbol remains
899      unresolved.
900      
901      GDB would normally find the symbol in the minimal symbol table if it will
902      not find it in the full symbol table.  But a reference to an external
903      symbol in a local block shadowing other definition requires full symbol
904      without possibly having its address available for LOC_STATIC.  Testcase
905      is provided as `gdb.dwarf2/dw2-unresolved.exp'.
906
907      This is also used for thread local storage (TLS) variables.  In this case,
908      the address of the TLS variable must be determined when the variable is
909      referenced, from the MSYMBOL_VALUE_RAW_ADDRESS, which is the offset
910      of the TLS variable in the thread local storage of the shared
911      library/object.  */
912
913   LOC_UNRESOLVED,
914
915   /* The variable does not actually exist in the program.
916      The value is ignored.  */
917
918   LOC_OPTIMIZED_OUT,
919
920   /* The variable's address is computed by a set of location
921      functions (see "struct symbol_computed_ops" below).  */
922   LOC_COMPUTED,
923
924   /* The variable uses general_symbol_info->value->common_block field.
925      It also always uses COMMON_BLOCK_DOMAIN.  */
926   LOC_COMMON_BLOCK,
927
928   /* Not used, just notes the boundary of the enum.  */
929   LOC_FINAL_VALUE
930 };
931
932 /* The number of bits needed for values in enum address_class, with some
933    padding for reasonable growth, and room for run-time registered address
934    classes. See symtab.c:MAX_SYMBOL_IMPLS.
935    This is a #define so that we can have a assertion elsewhere to
936    verify that we have reserved enough space for synthetic address
937    classes.  */
938 #define SYMBOL_ACLASS_BITS 5
939 gdb_static_assert (LOC_FINAL_VALUE <= (1 << SYMBOL_ACLASS_BITS));
940
941 /* The methods needed to implement LOC_COMPUTED.  These methods can
942    use the symbol's .aux_value for additional per-symbol information.
943
944    At present this is only used to implement location expressions.  */
945
946 struct symbol_computed_ops
947 {
948
949   /* Return the value of the variable SYMBOL, relative to the stack
950      frame FRAME.  If the variable has been optimized out, return
951      zero.
952
953      Iff `read_needs_frame (SYMBOL)' is not SYMBOL_NEEDS_FRAME, then
954      FRAME may be zero.  */
955
956   struct value *(*read_variable) (struct symbol * symbol,
957                                   struct frame_info * frame);
958
959   /* Read variable SYMBOL like read_variable at (callee) FRAME's function
960      entry.  SYMBOL should be a function parameter, otherwise
961      NO_ENTRY_VALUE_ERROR will be thrown.  */
962   struct value *(*read_variable_at_entry) (struct symbol *symbol,
963                                            struct frame_info *frame);
964
965   /* Find the "symbol_needs_kind" value for the given symbol.  This
966      value determines whether reading the symbol needs memory (e.g., a
967      global variable), just registers (a thread-local), or a frame (a
968      local variable).  */
969   enum symbol_needs_kind (*get_symbol_read_needs) (struct symbol * symbol);
970
971   /* Write to STREAM a natural-language description of the location of
972      SYMBOL, in the context of ADDR.  */
973   void (*describe_location) (struct symbol * symbol, CORE_ADDR addr,
974                              struct ui_file * stream);
975
976   /* Non-zero if this symbol's address computation is dependent on PC.  */
977   unsigned char location_has_loclist;
978
979   /* Tracepoint support.  Append bytecodes to the tracepoint agent
980      expression AX that push the address of the object SYMBOL.  Set
981      VALUE appropriately.  Note --- for objects in registers, this
982      needn't emit any code; as long as it sets VALUE properly, then
983      the caller will generate the right code in the process of
984      treating this as an lvalue or rvalue.  */
985
986   void (*tracepoint_var_ref) (struct symbol *symbol, struct agent_expr *ax,
987                               struct axs_value *value);
988
989   /* Generate C code to compute the location of SYMBOL.  The C code is
990      emitted to STREAM.  GDBARCH is the current architecture and PC is
991      the PC at which SYMBOL's location should be evaluated.
992      REGISTERS_USED is a vector indexed by register number; the
993      generator function should set an element in this vector if the
994      corresponding register is needed by the location computation.
995      The generated C code must assign the location to a local
996      variable; this variable's name is RESULT_NAME.  */
997
998   void (*generate_c_location) (struct symbol *symbol, string_file *stream,
999                                struct gdbarch *gdbarch,
1000                                unsigned char *registers_used,
1001                                CORE_ADDR pc, const char *result_name);
1002
1003 };
1004
1005 /* The methods needed to implement LOC_BLOCK for inferior functions.
1006    These methods can use the symbol's .aux_value for additional
1007    per-symbol information.  */
1008
1009 struct symbol_block_ops
1010 {
1011   /* Fill in *START and *LENGTH with DWARF block data of function
1012      FRAMEFUNC valid for inferior context address PC.  Set *LENGTH to
1013      zero if such location is not valid for PC; *START is left
1014      uninitialized in such case.  */
1015   void (*find_frame_base_location) (struct symbol *framefunc, CORE_ADDR pc,
1016                                     const gdb_byte **start, size_t *length);
1017
1018   /* Return the frame base address.  FRAME is the frame for which we want to
1019      compute the base address while FRAMEFUNC is the symbol for the
1020      corresponding function.  Return 0 on failure (FRAMEFUNC may not hold the
1021      information we need).
1022
1023      This method is designed to work with static links (nested functions
1024      handling).  Static links are function properties whose evaluation returns
1025      the frame base address for the enclosing frame.  However, there are
1026      multiple definitions for "frame base": the content of the frame base
1027      register, the CFA as defined by DWARF unwinding information, ...
1028
1029      So this specific method is supposed to compute the frame base address such
1030      as for nested fuctions, the static link computes the same address.  For
1031      instance, considering DWARF debugging information, the static link is
1032      computed with DW_AT_static_link and this method must be used to compute
1033      the corresponding DW_AT_frame_base attribute.  */
1034   CORE_ADDR (*get_frame_base) (struct symbol *framefunc,
1035                                struct frame_info *frame);
1036 };
1037
1038 /* Functions used with LOC_REGISTER and LOC_REGPARM_ADDR.  */
1039
1040 struct symbol_register_ops
1041 {
1042   int (*register_number) (struct symbol *symbol, struct gdbarch *gdbarch);
1043 };
1044
1045 /* Objects of this type are used to find the address class and the
1046    various computed ops vectors of a symbol.  */
1047
1048 struct symbol_impl
1049 {
1050   enum address_class aclass;
1051
1052   /* Used with LOC_COMPUTED.  */
1053   const struct symbol_computed_ops *ops_computed;
1054
1055   /* Used with LOC_BLOCK.  */
1056   const struct symbol_block_ops *ops_block;
1057
1058   /* Used with LOC_REGISTER and LOC_REGPARM_ADDR.  */
1059   const struct symbol_register_ops *ops_register;
1060 };
1061
1062 /* struct symbol has some subclasses.  This enum is used to
1063    differentiate between them.  */
1064
1065 enum symbol_subclass_kind
1066 {
1067   /* Plain struct symbol.  */
1068   SYMBOL_NONE,
1069
1070   /* struct template_symbol.  */
1071   SYMBOL_TEMPLATE,
1072
1073   /* struct rust_vtable_symbol.  */
1074   SYMBOL_RUST_VTABLE
1075 };
1076
1077 /* This structure is space critical.  See space comments at the top.  */
1078
1079 struct symbol
1080 {
1081
1082   /* The general symbol info required for all types of symbols.  */
1083
1084   struct general_symbol_info ginfo;
1085
1086   /* Data type of value */
1087
1088   struct type *type;
1089
1090   /* The owner of this symbol.
1091      Which one to use is defined by symbol.is_objfile_owned.  */
1092
1093   union
1094   {
1095     /* The symbol table containing this symbol.  This is the file associated
1096        with LINE.  It can be NULL during symbols read-in but it is never NULL
1097        during normal operation.  */
1098     struct symtab *symtab;
1099
1100     /* For types defined by the architecture.  */
1101     struct gdbarch *arch;
1102   } owner;
1103
1104   /* Domain code.  */
1105
1106   ENUM_BITFIELD(domain_enum_tag) domain : SYMBOL_DOMAIN_BITS;
1107
1108   /* Address class.  This holds an index into the 'symbol_impls'
1109      table.  The actual enum address_class value is stored there,
1110      alongside any per-class ops vectors.  */
1111
1112   unsigned int aclass_index : SYMBOL_ACLASS_BITS;
1113
1114   /* If non-zero then symbol is objfile-owned, use owner.symtab.
1115      Otherwise symbol is arch-owned, use owner.arch.  */
1116
1117   unsigned int is_objfile_owned : 1;
1118
1119   /* Whether this is an argument.  */
1120
1121   unsigned is_argument : 1;
1122
1123   /* Whether this is an inlined function (class LOC_BLOCK only).  */
1124   unsigned is_inlined : 1;
1125
1126   /* The concrete type of this symbol.  */
1127
1128   ENUM_BITFIELD (symbol_subclass_kind) subclass : 2;
1129
1130   /* Line number of this symbol's definition, except for inlined
1131      functions.  For an inlined function (class LOC_BLOCK and
1132      SYMBOL_INLINED set) this is the line number of the function's call
1133      site.  Inlined function symbols are not definitions, and they are
1134      never found by symbol table lookup.
1135      If this symbol is arch-owned, LINE shall be zero.
1136
1137      FIXME: Should we really make the assumption that nobody will try
1138      to debug files longer than 64K lines?  What about machine
1139      generated programs?  */
1140
1141   unsigned short line;
1142
1143   /* An arbitrary data pointer, allowing symbol readers to record
1144      additional information on a per-symbol basis.  Note that this data
1145      must be allocated using the same obstack as the symbol itself.  */
1146   /* So far it is only used by:
1147      LOC_COMPUTED: to find the location information
1148      LOC_BLOCK (DWARF2 function): information used internally by the
1149      DWARF 2 code --- specifically, the location expression for the frame
1150      base for this function.  */
1151   /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
1152      to add a magic symbol to the block containing this information,
1153      or to have a generic debug info annotation slot for symbols.  */
1154
1155   void *aux_value;
1156
1157   struct symbol *hash_next;
1158 };
1159
1160 /* Several lookup functions return both a symbol and the block in which the
1161    symbol is found.  This structure is used in these cases.  */
1162
1163 struct block_symbol
1164 {
1165   /* The symbol that was found, or NULL if no symbol was found.  */
1166   struct symbol *symbol;
1167
1168   /* If SYMBOL is not NULL, then this is the block in which the symbol is
1169      defined.  */
1170   const struct block *block;
1171 };
1172
1173 extern const struct symbol_impl *symbol_impls;
1174
1175 /* For convenience.  All fields are NULL.  This means "there is no
1176    symbol".  */
1177 extern const struct block_symbol null_block_symbol;
1178
1179 /* Note: There is no accessor macro for symbol.owner because it is
1180    "private".  */
1181
1182 #define SYMBOL_DOMAIN(symbol)   (symbol)->domain
1183 #define SYMBOL_IMPL(symbol)             (symbol_impls[(symbol)->aclass_index])
1184 #define SYMBOL_ACLASS_INDEX(symbol)     (symbol)->aclass_index
1185 #define SYMBOL_CLASS(symbol)            (SYMBOL_IMPL (symbol).aclass)
1186 #define SYMBOL_OBJFILE_OWNED(symbol)    ((symbol)->is_objfile_owned)
1187 #define SYMBOL_IS_ARGUMENT(symbol)      (symbol)->is_argument
1188 #define SYMBOL_INLINED(symbol)          (symbol)->is_inlined
1189 #define SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION(symbol) \
1190   (((symbol)->subclass) == SYMBOL_TEMPLATE)
1191 #define SYMBOL_TYPE(symbol)             (symbol)->type
1192 #define SYMBOL_LINE(symbol)             (symbol)->line
1193 #define SYMBOL_COMPUTED_OPS(symbol)     (SYMBOL_IMPL (symbol).ops_computed)
1194 #define SYMBOL_BLOCK_OPS(symbol)        (SYMBOL_IMPL (symbol).ops_block)
1195 #define SYMBOL_REGISTER_OPS(symbol)     (SYMBOL_IMPL (symbol).ops_register)
1196 #define SYMBOL_LOCATION_BATON(symbol)   (symbol)->aux_value
1197
1198 extern int register_symbol_computed_impl (enum address_class,
1199                                           const struct symbol_computed_ops *);
1200
1201 extern int register_symbol_block_impl (enum address_class aclass,
1202                                        const struct symbol_block_ops *ops);
1203
1204 extern int register_symbol_register_impl (enum address_class,
1205                                           const struct symbol_register_ops *);
1206
1207 /* Return the OBJFILE of SYMBOL.
1208    It is an error to call this if symbol.is_objfile_owned is false, which
1209    only happens for architecture-provided types.  */
1210
1211 extern struct objfile *symbol_objfile (const struct symbol *symbol);
1212
1213 /* Return the ARCH of SYMBOL.  */
1214
1215 extern struct gdbarch *symbol_arch (const struct symbol *symbol);
1216
1217 /* Return the SYMTAB of SYMBOL.
1218    It is an error to call this if symbol.is_objfile_owned is false, which
1219    only happens for architecture-provided types.  */
1220
1221 extern struct symtab *symbol_symtab (const struct symbol *symbol);
1222
1223 /* Set the symtab of SYMBOL to SYMTAB.
1224    It is an error to call this if symbol.is_objfile_owned is false, which
1225    only happens for architecture-provided types.  */
1226
1227 extern void symbol_set_symtab (struct symbol *symbol, struct symtab *symtab);
1228
1229 /* An instance of this type is used to represent a C++ template
1230    function.  A symbol is really of this type iff
1231    SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION is true.  */
1232
1233 struct template_symbol : public symbol
1234 {
1235   /* The number of template arguments.  */
1236   int n_template_arguments;
1237
1238   /* The template arguments.  This is an array with
1239      N_TEMPLATE_ARGUMENTS elements.  */
1240   struct symbol **template_arguments;
1241 };
1242
1243 /* A symbol that represents a Rust virtual table object.  */
1244
1245 struct rust_vtable_symbol : public symbol
1246 {
1247   /* The concrete type for which this vtable was created; that is, in
1248      "impl Trait for Type", this is "Type".  */
1249   struct type *concrete_type;
1250 };
1251
1252 \f
1253 /* Each item represents a line-->pc (or the reverse) mapping.  This is
1254    somewhat more wasteful of space than one might wish, but since only
1255    the files which are actually debugged are read in to core, we don't
1256    waste much space.  */
1257
1258 struct linetable_entry
1259 {
1260   int line;
1261   CORE_ADDR pc;
1262 };
1263
1264 /* The order of entries in the linetable is significant.  They should
1265    be sorted by increasing values of the pc field.  If there is more than
1266    one entry for a given pc, then I'm not sure what should happen (and
1267    I not sure whether we currently handle it the best way).
1268
1269    Example: a C for statement generally looks like this
1270
1271    10   0x100   - for the init/test part of a for stmt.
1272    20   0x200
1273    30   0x300
1274    10   0x400   - for the increment part of a for stmt.
1275
1276    If an entry has a line number of zero, it marks the start of a PC
1277    range for which no line number information is available.  It is
1278    acceptable, though wasteful of table space, for such a range to be
1279    zero length.  */
1280
1281 struct linetable
1282 {
1283   int nitems;
1284
1285   /* Actually NITEMS elements.  If you don't like this use of the
1286      `struct hack', you can shove it up your ANSI (seriously, if the
1287      committee tells us how to do it, we can probably go along).  */
1288   struct linetable_entry item[1];
1289 };
1290
1291 /* How to relocate the symbols from each section in a symbol file.
1292    Each struct contains an array of offsets.
1293    The ordering and meaning of the offsets is file-type-dependent;
1294    typically it is indexed by section numbers or symbol types or
1295    something like that.
1296
1297    To give us flexibility in changing the internal representation
1298    of these offsets, the ANOFFSET macro must be used to insert and
1299    extract offset values in the struct.  */
1300
1301 struct section_offsets
1302 {
1303   CORE_ADDR offsets[1];         /* As many as needed.  */
1304 };
1305
1306 #define ANOFFSET(secoff, whichone) \
1307   ((whichone == -1)                       \
1308    ? (internal_error (__FILE__, __LINE__, \
1309                       _("Section index is uninitialized")), -1) \
1310    : secoff->offsets[whichone])
1311
1312 /* The size of a section_offsets table for N sections.  */
1313 #define SIZEOF_N_SECTION_OFFSETS(n) \
1314   (sizeof (struct section_offsets) \
1315    + sizeof (((struct section_offsets *) 0)->offsets) * ((n)-1))
1316
1317 /* Each source file or header is represented by a struct symtab.
1318    The name "symtab" is historical, another name for it is "filetab".
1319    These objects are chained through the `next' field.  */
1320
1321 struct symtab
1322 {
1323   /* Unordered chain of all filetabs in the compunit,  with the exception
1324      that the "main" source file is the first entry in the list.  */
1325
1326   struct symtab *next;
1327
1328   /* Backlink to containing compunit symtab.  */
1329
1330   struct compunit_symtab *compunit_symtab;
1331
1332   /* Table mapping core addresses to line numbers for this file.
1333      Can be NULL if none.  Never shared between different symtabs.  */
1334
1335   struct linetable *linetable;
1336
1337   /* Name of this source file.  This pointer is never NULL.  */
1338
1339   const char *filename;
1340
1341   /* Total number of lines found in source file.  */
1342
1343   int nlines;
1344
1345   /* line_charpos[N] is the position of the (N-1)th line of the
1346      source file.  "position" means something we can lseek() to; it
1347      is not guaranteed to be useful any other way.  */
1348
1349   int *line_charpos;
1350
1351   /* Language of this source file.  */
1352
1353   enum language language;
1354
1355   /* Full name of file as found by searching the source path.
1356      NULL if not yet known.  */
1357
1358   char *fullname;
1359 };
1360
1361 #define SYMTAB_COMPUNIT(symtab) ((symtab)->compunit_symtab)
1362 #define SYMTAB_LINETABLE(symtab) ((symtab)->linetable)
1363 #define SYMTAB_LANGUAGE(symtab) ((symtab)->language)
1364 #define SYMTAB_BLOCKVECTOR(symtab) \
1365   COMPUNIT_BLOCKVECTOR (SYMTAB_COMPUNIT (symtab))
1366 #define SYMTAB_OBJFILE(symtab) \
1367   COMPUNIT_OBJFILE (SYMTAB_COMPUNIT (symtab))
1368 #define SYMTAB_PSPACE(symtab) (SYMTAB_OBJFILE (symtab)->pspace)
1369 #define SYMTAB_DIRNAME(symtab) \
1370   COMPUNIT_DIRNAME (SYMTAB_COMPUNIT (symtab))
1371
1372 /* Compunit symtabs contain the actual "symbol table", aka blockvector, as well
1373    as the list of all source files (what gdb has historically associated with
1374    the term "symtab").
1375    Additional information is recorded here that is common to all symtabs in a
1376    compilation unit (DWARF or otherwise).
1377
1378    Example:
1379    For the case of a program built out of these files:
1380
1381    foo.c
1382      foo1.h
1383      foo2.h
1384    bar.c
1385      foo1.h
1386      bar.h
1387
1388    This is recorded as:
1389
1390    objfile -> foo.c(cu) -> bar.c(cu) -> NULL
1391                 |            |
1392                 v            v
1393               foo.c        bar.c
1394                 |            |
1395                 v            v
1396               foo1.h       foo1.h
1397                 |            |
1398                 v            v
1399               foo2.h       bar.h
1400                 |            |
1401                 v            v
1402                NULL         NULL
1403
1404    where "foo.c(cu)" and "bar.c(cu)" are struct compunit_symtab objects,
1405    and the files foo.c, etc. are struct symtab objects.  */
1406
1407 struct compunit_symtab
1408 {
1409   /* Unordered chain of all compunit symtabs of this objfile.  */
1410   struct compunit_symtab *next;
1411
1412   /* Object file from which this symtab information was read.  */
1413   struct objfile *objfile;
1414
1415   /* Name of the symtab.
1416      This is *not* intended to be a usable filename, and is
1417      for debugging purposes only.  */
1418   const char *name;
1419
1420   /* Unordered list of file symtabs, except that by convention the "main"
1421      source file (e.g., .c, .cc) is guaranteed to be first.
1422      Each symtab is a file, either the "main" source file (e.g., .c, .cc)
1423      or header (e.g., .h).  */
1424   struct symtab *filetabs;
1425
1426   /* Last entry in FILETABS list.
1427      Subfiles are added to the end of the list so they accumulate in order,
1428      with the main source subfile living at the front.
1429      The main reason is so that the main source file symtab is at the head
1430      of the list, and the rest appear in order for debugging convenience.  */
1431   struct symtab *last_filetab;
1432
1433   /* Non-NULL string that identifies the format of the debugging information,
1434      such as "stabs", "dwarf 1", "dwarf 2", "coff", etc.  This is mostly useful
1435      for automated testing of gdb but may also be information that is
1436      useful to the user.  */
1437   const char *debugformat;
1438
1439   /* String of producer version information, or NULL if we don't know.  */
1440   const char *producer;
1441
1442   /* Directory in which it was compiled, or NULL if we don't know.  */
1443   const char *dirname;
1444
1445   /* List of all symbol scope blocks for this symtab.  It is shared among
1446      all symtabs in a given compilation unit.  */
1447   const struct blockvector *blockvector;
1448
1449   /* Section in objfile->section_offsets for the blockvector and
1450      the linetable.  Probably always SECT_OFF_TEXT.  */
1451   int block_line_section;
1452
1453   /* Symtab has been compiled with both optimizations and debug info so that
1454      GDB may stop skipping prologues as variables locations are valid already
1455      at function entry points.  */
1456   unsigned int locations_valid : 1;
1457
1458   /* DWARF unwinder for this CU is valid even for epilogues (PC at the return
1459      instruction).  This is supported by GCC since 4.5.0.  */
1460   unsigned int epilogue_unwind_valid : 1;
1461
1462   /* struct call_site entries for this compilation unit or NULL.  */
1463   htab_t call_site_htab;
1464
1465   /* The macro table for this symtab.  Like the blockvector, this
1466      is shared between different symtabs in a given compilation unit.
1467      It's debatable whether it *should* be shared among all the symtabs in
1468      the given compilation unit, but it currently is.  */
1469   struct macro_table *macro_table;
1470
1471   /* If non-NULL, then this points to a NULL-terminated vector of
1472      included compunits.  When searching the static or global
1473      block of this compunit, the corresponding block of all
1474      included compunits will also be searched.  Note that this
1475      list must be flattened -- the symbol reader is responsible for
1476      ensuring that this vector contains the transitive closure of all
1477      included compunits.  */
1478   struct compunit_symtab **includes;
1479
1480   /* If this is an included compunit, this points to one includer
1481      of the table.  This user is considered the canonical compunit
1482      containing this one.  An included compunit may itself be
1483      included by another.  */
1484   struct compunit_symtab *user;
1485 };
1486
1487 #define COMPUNIT_OBJFILE(cust) ((cust)->objfile)
1488 #define COMPUNIT_FILETABS(cust) ((cust)->filetabs)
1489 #define COMPUNIT_DEBUGFORMAT(cust) ((cust)->debugformat)
1490 #define COMPUNIT_PRODUCER(cust) ((cust)->producer)
1491 #define COMPUNIT_DIRNAME(cust) ((cust)->dirname)
1492 #define COMPUNIT_BLOCKVECTOR(cust) ((cust)->blockvector)
1493 #define COMPUNIT_BLOCK_LINE_SECTION(cust) ((cust)->block_line_section)
1494 #define COMPUNIT_LOCATIONS_VALID(cust) ((cust)->locations_valid)
1495 #define COMPUNIT_EPILOGUE_UNWIND_VALID(cust) ((cust)->epilogue_unwind_valid)
1496 #define COMPUNIT_CALL_SITE_HTAB(cust) ((cust)->call_site_htab)
1497 #define COMPUNIT_MACRO_TABLE(cust) ((cust)->macro_table)
1498
1499 /* A range adapter to allowing iterating over all the file tables
1500    within a compunit.  */
1501
1502 struct compunit_filetabs : public next_adapter<struct symtab>
1503 {
1504   compunit_filetabs (struct compunit_symtab *cu)
1505     : next_adapter<struct symtab> (cu->filetabs)
1506   {
1507   }
1508 };
1509
1510 /* Return the primary symtab of CUST.  */
1511
1512 extern struct symtab *
1513   compunit_primary_filetab (const struct compunit_symtab *cust);
1514
1515 /* Return the language of CUST.  */
1516
1517 extern enum language compunit_language (const struct compunit_symtab *cust);
1518
1519 \f
1520
1521 /* The virtual function table is now an array of structures which have the
1522    form { int16 offset, delta; void *pfn; }. 
1523
1524    In normal virtual function tables, OFFSET is unused.
1525    DELTA is the amount which is added to the apparent object's base
1526    address in order to point to the actual object to which the
1527    virtual function should be applied.
1528    PFN is a pointer to the virtual function.
1529
1530    Note that this macro is g++ specific (FIXME).  */
1531
1532 #define VTBL_FNADDR_OFFSET 2
1533
1534 /* External variables and functions for the objects described above.  */
1535
1536 /* True if we are nested inside psymtab_to_symtab.  */
1537
1538 extern int currently_reading_symtab;
1539
1540 /* symtab.c lookup functions */
1541
1542 extern const char multiple_symbols_ask[];
1543 extern const char multiple_symbols_all[];
1544 extern const char multiple_symbols_cancel[];
1545
1546 const char *multiple_symbols_select_mode (void);
1547
1548 int symbol_matches_domain (enum language symbol_language, 
1549                            domain_enum symbol_domain,
1550                            domain_enum domain);
1551
1552 /* lookup a symbol table by source file name.  */
1553
1554 extern struct symtab *lookup_symtab (const char *);
1555
1556 /* An object of this type is passed as the 'is_a_field_of_this'
1557    argument to lookup_symbol and lookup_symbol_in_language.  */
1558
1559 struct field_of_this_result
1560 {
1561   /* The type in which the field was found.  If this is NULL then the
1562      symbol was not found in 'this'.  If non-NULL, then one of the
1563      other fields will be non-NULL as well.  */
1564
1565   struct type *type;
1566
1567   /* If the symbol was found as an ordinary field of 'this', then this
1568      is non-NULL and points to the particular field.  */
1569
1570   struct field *field;
1571
1572   /* If the symbol was found as a function field of 'this', then this
1573      is non-NULL and points to the particular field.  */
1574
1575   struct fn_fieldlist *fn_field;
1576 };
1577
1578 /* Find the definition for a specified symbol name NAME
1579    in domain DOMAIN in language LANGUAGE, visible from lexical block BLOCK
1580    if non-NULL or from global/static blocks if BLOCK is NULL.
1581    Returns the struct symbol pointer, or NULL if no symbol is found.
1582    C++: if IS_A_FIELD_OF_THIS is non-NULL on entry, check to see if
1583    NAME is a field of the current implied argument `this'.  If so fill in the
1584    fields of IS_A_FIELD_OF_THIS, otherwise the fields are set to NULL.
1585    The symbol's section is fixed up if necessary.  */
1586
1587 extern struct block_symbol
1588   lookup_symbol_in_language (const char *,
1589                              const struct block *,
1590                              const domain_enum,
1591                              enum language,
1592                              struct field_of_this_result *);
1593
1594 /* Same as lookup_symbol_in_language, but using the current language.  */
1595
1596 extern struct block_symbol lookup_symbol (const char *,
1597                                           const struct block *,
1598                                           const domain_enum,
1599                                           struct field_of_this_result *);
1600
1601 /* Find the definition for a specified symbol search name in domain
1602    DOMAIN, visible from lexical block BLOCK if non-NULL or from
1603    global/static blocks if BLOCK is NULL.  The passed-in search name
1604    should not come from the user; instead it should already be a
1605    search name as retrieved from a
1606    SYMBOL_SEARCH_NAME/MSYMBOL_SEARCH_NAME call.  See definition of
1607    symbol_name_match_type::SEARCH_NAME.  Returns the struct symbol
1608    pointer, or NULL if no symbol is found.  The symbol's section is
1609    fixed up if necessary.  */
1610
1611 extern struct block_symbol lookup_symbol_search_name (const char *search_name,
1612                                                       const struct block *block,
1613                                                       domain_enum domain);
1614
1615 /* A default version of lookup_symbol_nonlocal for use by languages
1616    that can't think of anything better to do.
1617    This implements the C lookup rules.  */
1618
1619 extern struct block_symbol
1620   basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
1621                                 const char *,
1622                                 const struct block *,
1623                                 const domain_enum);
1624
1625 /* Some helper functions for languages that need to write their own
1626    lookup_symbol_nonlocal functions.  */
1627
1628 /* Lookup a symbol in the static block associated to BLOCK, if there
1629    is one; do nothing if BLOCK is NULL or a global block.
1630    Upon success fixes up the symbol's section if necessary.  */
1631
1632 extern struct block_symbol
1633   lookup_symbol_in_static_block (const char *name,
1634                                  const struct block *block,
1635                                  const domain_enum domain);
1636
1637 /* Search all static file-level symbols for NAME from DOMAIN.
1638    Upon success fixes up the symbol's section if necessary.  */
1639
1640 extern struct block_symbol lookup_static_symbol (const char *name,
1641                                                  const domain_enum domain);
1642
1643 /* Lookup a symbol in all files' global blocks.
1644
1645    If BLOCK is non-NULL then it is used for two things:
1646    1) If a target-specific lookup routine for libraries exists, then use the
1647       routine for the objfile of BLOCK, and
1648    2) The objfile of BLOCK is used to assist in determining the search order
1649       if the target requires it.
1650       See gdbarch_iterate_over_objfiles_in_search_order.
1651
1652    Upon success fixes up the symbol's section if necessary.  */
1653
1654 extern struct block_symbol
1655   lookup_global_symbol (const char *name,
1656                         const struct block *block,
1657                         const domain_enum domain);
1658
1659 /* Lookup a symbol in block BLOCK.
1660    Upon success fixes up the symbol's section if necessary.  */
1661
1662 extern struct symbol *
1663   lookup_symbol_in_block (const char *name,
1664                           symbol_name_match_type match_type,
1665                           const struct block *block,
1666                           const domain_enum domain);
1667
1668 /* Look up the `this' symbol for LANG in BLOCK.  Return the symbol if
1669    found, or NULL if not found.  */
1670
1671 extern struct block_symbol
1672   lookup_language_this (const struct language_defn *lang,
1673                         const struct block *block);
1674
1675 /* Lookup a [struct, union, enum] by name, within a specified block.  */
1676
1677 extern struct type *lookup_struct (const char *, const struct block *);
1678
1679 extern struct type *lookup_union (const char *, const struct block *);
1680
1681 extern struct type *lookup_enum (const char *, const struct block *);
1682
1683 /* from blockframe.c: */
1684
1685 /* lookup the function symbol corresponding to the address.  The
1686    return value will not be an inlined function; the containing
1687    function will be returned instead.  */
1688
1689 extern struct symbol *find_pc_function (CORE_ADDR);
1690
1691 /* lookup the function corresponding to the address and section.  The
1692    return value will not be an inlined function; the containing
1693    function will be returned instead.  */
1694
1695 extern struct symbol *find_pc_sect_function (CORE_ADDR, struct obj_section *);
1696
1697 /* lookup the function symbol corresponding to the address and
1698    section.  The return value will be the closest enclosing function,
1699    which might be an inline function.  */
1700
1701 extern struct symbol *find_pc_sect_containing_function
1702   (CORE_ADDR pc, struct obj_section *section);
1703
1704 /* Find the symbol at the given address.  Returns NULL if no symbol
1705    found.  Only exact matches for ADDRESS are considered.  */
1706
1707 extern struct symbol *find_symbol_at_address (CORE_ADDR);
1708
1709 /* Finds the "function" (text symbol) that is smaller than PC but
1710    greatest of all of the potential text symbols in SECTION.  Sets
1711    *NAME and/or *ADDRESS conditionally if that pointer is non-null.
1712    If ENDADDR is non-null, then set *ENDADDR to be the end of the
1713    function (exclusive).  If the optional parameter BLOCK is non-null,
1714    then set *BLOCK to the address of the block corresponding to the
1715    function symbol, if such a symbol could be found during the lookup;
1716    nullptr is used as a return value for *BLOCK if no block is found. 
1717    This function either succeeds or fails (not halfway succeeds).  If
1718    it succeeds, it sets *NAME, *ADDRESS, and *ENDADDR to real
1719    information and returns 1.  If it fails, it sets *NAME, *ADDRESS
1720    and *ENDADDR to zero and returns 0.
1721    
1722    If the function in question occupies non-contiguous ranges,
1723    *ADDRESS and *ENDADDR are (subject to the conditions noted above) set
1724    to the start and end of the range in which PC is found.  Thus
1725    *ADDRESS <= PC < *ENDADDR with no intervening gaps (in which ranges
1726    from other functions might be found).
1727    
1728    This property allows find_pc_partial_function to be used (as it had
1729    been prior to the introduction of non-contiguous range support) by
1730    various tdep files for finding a start address and limit address
1731    for prologue analysis.  This still isn't ideal, however, because we
1732    probably shouldn't be doing prologue analysis (in which
1733    instructions are scanned to determine frame size and stack layout)
1734    for any range that doesn't contain the entry pc.  Moreover, a good
1735    argument can be made that prologue analysis ought to be performed
1736    starting from the entry pc even when PC is within some other range.
1737    This might suggest that *ADDRESS and *ENDADDR ought to be set to the
1738    limits of the entry pc range, but that will cause the 
1739    *ADDRESS <= PC < *ENDADDR condition to be violated; many of the
1740    callers of find_pc_partial_function expect this condition to hold. 
1741
1742    Callers which require the start and/or end addresses for the range
1743    containing the entry pc should instead call
1744    find_function_entry_range_from_pc.  */
1745
1746 extern int find_pc_partial_function (CORE_ADDR pc, const char **name,
1747                                      CORE_ADDR *address, CORE_ADDR *endaddr,
1748                                      const struct block **block = nullptr);
1749
1750 /* Like find_pc_partial_function, above, but *ADDRESS and *ENDADDR are
1751    set to start and end addresses of the range containing the entry pc.
1752
1753    Note that it is not necessarily the case that (for non-NULL ADDRESS
1754    and ENDADDR arguments) the *ADDRESS <= PC < *ENDADDR condition will
1755    hold.
1756
1757    See comment for find_pc_partial_function, above, for further
1758    explanation.  */
1759
1760 extern bool find_function_entry_range_from_pc (CORE_ADDR pc,
1761                                                const char **name,
1762                                                CORE_ADDR *address,
1763                                                CORE_ADDR *endaddr);
1764
1765 /* Return the type of a function with its first instruction exactly at
1766    the PC address.  Return NULL otherwise.  */
1767
1768 extern struct type *find_function_type (CORE_ADDR pc);
1769
1770 /* See if we can figure out the function's actual type from the type
1771    that the resolver returns.  RESOLVER_FUNADDR is the address of the
1772    ifunc resolver.  */
1773
1774 extern struct type *find_gnu_ifunc_target_type (CORE_ADDR resolver_funaddr);
1775
1776 /* Find the GNU ifunc minimal symbol that matches SYM.  */
1777 extern bound_minimal_symbol find_gnu_ifunc (const symbol *sym);
1778
1779 extern void clear_pc_function_cache (void);
1780
1781 /* Expand symtab containing PC, SECTION if not already expanded.  */
1782
1783 extern void expand_symtab_containing_pc (CORE_ADDR, struct obj_section *);
1784
1785 /* lookup full symbol table by address.  */
1786
1787 extern struct compunit_symtab *find_pc_compunit_symtab (CORE_ADDR);
1788
1789 /* lookup full symbol table by address and section.  */
1790
1791 extern struct compunit_symtab *
1792   find_pc_sect_compunit_symtab (CORE_ADDR, struct obj_section *);
1793
1794 extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
1795
1796 extern void reread_symbols (void);
1797
1798 /* Look up a type named NAME in STRUCT_DOMAIN in the current language.
1799    The type returned must not be opaque -- i.e., must have at least one field
1800    defined.  */
1801
1802 extern struct type *lookup_transparent_type (const char *);
1803
1804 extern struct type *basic_lookup_transparent_type (const char *);
1805
1806 /* Macro for name of symbol to indicate a file compiled with gcc.  */
1807 #ifndef GCC_COMPILED_FLAG_SYMBOL
1808 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
1809 #endif
1810
1811 /* Macro for name of symbol to indicate a file compiled with gcc2.  */
1812 #ifndef GCC2_COMPILED_FLAG_SYMBOL
1813 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
1814 #endif
1815
1816 extern int in_gnu_ifunc_stub (CORE_ADDR pc);
1817
1818 /* Functions for resolving STT_GNU_IFUNC symbols which are implemented only
1819    for ELF symbol files.  */
1820
1821 struct gnu_ifunc_fns
1822 {
1823   /* See elf_gnu_ifunc_resolve_addr for its real implementation.  */
1824   CORE_ADDR (*gnu_ifunc_resolve_addr) (struct gdbarch *gdbarch, CORE_ADDR pc);
1825
1826   /* See elf_gnu_ifunc_resolve_name for its real implementation.  */
1827   int (*gnu_ifunc_resolve_name) (const char *function_name,
1828                                  CORE_ADDR *function_address_p);
1829
1830   /* See elf_gnu_ifunc_resolver_stop for its real implementation.  */
1831   void (*gnu_ifunc_resolver_stop) (struct breakpoint *b);
1832
1833   /* See elf_gnu_ifunc_resolver_return_stop for its real implementation.  */
1834   void (*gnu_ifunc_resolver_return_stop) (struct breakpoint *b);
1835 };
1836
1837 #define gnu_ifunc_resolve_addr gnu_ifunc_fns_p->gnu_ifunc_resolve_addr
1838 #define gnu_ifunc_resolve_name gnu_ifunc_fns_p->gnu_ifunc_resolve_name
1839 #define gnu_ifunc_resolver_stop gnu_ifunc_fns_p->gnu_ifunc_resolver_stop
1840 #define gnu_ifunc_resolver_return_stop \
1841   gnu_ifunc_fns_p->gnu_ifunc_resolver_return_stop
1842
1843 extern const struct gnu_ifunc_fns *gnu_ifunc_fns_p;
1844
1845 extern CORE_ADDR find_solib_trampoline_target (struct frame_info *, CORE_ADDR);
1846
1847 struct symtab_and_line
1848 {
1849   /* The program space of this sal.  */
1850   struct program_space *pspace = NULL;
1851
1852   struct symtab *symtab = NULL;
1853   struct symbol *symbol = NULL;
1854   struct obj_section *section = NULL;
1855   struct minimal_symbol *msymbol = NULL;
1856   /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
1857      0 is never a valid line number; it is used to indicate that line number
1858      information is not available.  */
1859   int line = 0;
1860
1861   CORE_ADDR pc = 0;
1862   CORE_ADDR end = 0;
1863   bool explicit_pc = false;
1864   bool explicit_line = false;
1865
1866   /* The probe associated with this symtab_and_line.  */
1867   probe *prob = NULL;
1868   /* If PROBE is not NULL, then this is the objfile in which the probe
1869      originated.  */
1870   struct objfile *objfile = NULL;
1871 };
1872
1873 \f
1874
1875 /* Given a pc value, return line number it is in.  Second arg nonzero means
1876    if pc is on the boundary use the previous statement's line number.  */
1877
1878 extern struct symtab_and_line find_pc_line (CORE_ADDR, int);
1879
1880 /* Same function, but specify a section as well as an address.  */
1881
1882 extern struct symtab_and_line find_pc_sect_line (CORE_ADDR,
1883                                                  struct obj_section *, int);
1884
1885 /* Wrapper around find_pc_line to just return the symtab.  */
1886
1887 extern struct symtab *find_pc_line_symtab (CORE_ADDR);
1888
1889 /* Given a symtab and line number, return the pc there.  */
1890
1891 extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
1892
1893 extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
1894                                CORE_ADDR *);
1895
1896 extern void resolve_sal_pc (struct symtab_and_line *);
1897
1898 /* solib.c */
1899
1900 extern void clear_solib (void);
1901
1902 /* The reason we're calling into a completion match list collector
1903    function.  */
1904 enum class complete_symbol_mode
1905   {
1906     /* Completing an expression.  */
1907     EXPRESSION,
1908
1909     /* Completing a linespec.  */
1910     LINESPEC,
1911   };
1912
1913 extern void default_collect_symbol_completion_matches_break_on
1914   (completion_tracker &tracker,
1915    complete_symbol_mode mode,
1916    symbol_name_match_type name_match_type,
1917    const char *text, const char *word, const char *break_on,
1918    enum type_code code);
1919 extern void default_collect_symbol_completion_matches
1920   (completion_tracker &tracker,
1921    complete_symbol_mode,
1922    symbol_name_match_type name_match_type,
1923    const char *,
1924    const char *,
1925    enum type_code);
1926 extern void collect_symbol_completion_matches
1927   (completion_tracker &tracker,
1928    complete_symbol_mode mode,
1929    symbol_name_match_type name_match_type,
1930    const char *, const char *);
1931 extern void collect_symbol_completion_matches_type (completion_tracker &tracker,
1932                                                     const char *, const char *,
1933                                                     enum type_code);
1934
1935 extern void collect_file_symbol_completion_matches
1936   (completion_tracker &tracker,
1937    complete_symbol_mode,
1938    symbol_name_match_type name_match_type,
1939    const char *, const char *, const char *);
1940
1941 extern completion_list
1942   make_source_files_completion_list (const char *, const char *);
1943
1944 /* Return whether SYM is a function/method, as opposed to a data symbol.  */
1945
1946 extern bool symbol_is_function_or_method (symbol *sym);
1947
1948 /* Return whether MSYMBOL is a function/method, as opposed to a data
1949    symbol */
1950
1951 extern bool symbol_is_function_or_method (minimal_symbol *msymbol);
1952
1953 /* Return whether SYM should be skipped in completion mode MODE.  In
1954    linespec mode, we're only interested in functions/methods.  */
1955
1956 template<typename Symbol>
1957 static bool
1958 completion_skip_symbol (complete_symbol_mode mode, Symbol *sym)
1959 {
1960   return (mode == complete_symbol_mode::LINESPEC
1961           && !symbol_is_function_or_method (sym));
1962 }
1963
1964 /* symtab.c */
1965
1966 int matching_obj_sections (struct obj_section *, struct obj_section *);
1967
1968 extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
1969
1970 /* Given a function symbol SYM, find the symtab and line for the start
1971    of the function.  If FUNFIRSTLINE is true, we want the first line
1972    of real code inside the function.  */
1973 extern symtab_and_line find_function_start_sal (symbol *sym, bool
1974                                                 funfirstline);
1975
1976 /* Same, but start with a function address/section instead of a
1977    symbol.  */
1978 extern symtab_and_line find_function_start_sal (CORE_ADDR func_addr,
1979                                                 obj_section *section,
1980                                                 bool funfirstline);
1981
1982 extern void skip_prologue_sal (struct symtab_and_line *);
1983
1984 /* symtab.c */
1985
1986 extern CORE_ADDR skip_prologue_using_sal (struct gdbarch *gdbarch,
1987                                           CORE_ADDR func_addr);
1988
1989 extern struct symbol *fixup_symbol_section (struct symbol *,
1990                                             struct objfile *);
1991
1992 /* If MSYMBOL is an text symbol, look for a function debug symbol with
1993    the same address.  Returns NULL if not found.  This is necessary in
1994    case a function is an alias to some other function, because debug
1995    information is only emitted for the alias target function's
1996    definition, not for the alias.  */
1997 extern symbol *find_function_alias_target (bound_minimal_symbol msymbol);
1998
1999 /* Symbol searching */
2000 /* Note: struct symbol_search, search_symbols, et.al. are declared here,
2001    instead of making them local to symtab.c, for gdbtk's sake.  */
2002
2003 /* When using search_symbols, a vector of the following structs is
2004    returned.  */
2005 struct symbol_search
2006 {
2007   symbol_search (int block_, struct symbol *symbol_)
2008     : block (block_),
2009       symbol (symbol_)
2010   {
2011     msymbol.minsym = nullptr;
2012     msymbol.objfile = nullptr;
2013   }
2014
2015   symbol_search (int block_, struct minimal_symbol *minsym,
2016                  struct objfile *objfile)
2017     : block (block_),
2018       symbol (nullptr)
2019   {
2020     msymbol.minsym = minsym;
2021     msymbol.objfile = objfile;
2022   }
2023
2024   bool operator< (const symbol_search &other) const
2025   {
2026     return compare_search_syms (*this, other) < 0;
2027   }
2028
2029   bool operator== (const symbol_search &other) const
2030   {
2031     return compare_search_syms (*this, other) == 0;
2032   }
2033
2034   /* The block in which the match was found.  Could be, for example,
2035      STATIC_BLOCK or GLOBAL_BLOCK.  */
2036   int block;
2037
2038   /* Information describing what was found.
2039
2040      If symbol is NOT NULL, then information was found for this match.  */
2041   struct symbol *symbol;
2042
2043   /* If msymbol is non-null, then a match was made on something for
2044      which only minimal_symbols exist.  */
2045   struct bound_minimal_symbol msymbol;
2046
2047 private:
2048
2049   static int compare_search_syms (const symbol_search &sym_a,
2050                                   const symbol_search &sym_b);
2051 };
2052
2053 extern std::vector<symbol_search> search_symbols (const char *,
2054                                                   enum search_domain,
2055                                                   const char *,
2056                                                   int,
2057                                                   const char **);
2058 extern bool treg_matches_sym_type_name (const compiled_regex &treg,
2059                                         const struct symbol *sym);
2060
2061 /* The name of the ``main'' function.
2062    FIXME: cagney/2001-03-20: Can't make main_name() const since some
2063    of the calling code currently assumes that the string isn't
2064    const.  */
2065 extern /*const */ char *main_name (void);
2066 extern enum language main_language (void);
2067
2068 /* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global blocks.
2069    This searches MAIN_OBJFILE as well as any associated separate debug info
2070    objfiles of MAIN_OBJFILE.
2071    Upon success fixes up the symbol's section if necessary.  */
2072
2073 extern struct block_symbol
2074   lookup_global_symbol_from_objfile (struct objfile *main_objfile,
2075                                      const char *name,
2076                                      const domain_enum domain);
2077
2078 /* Return 1 if the supplied producer string matches the ARM RealView
2079    compiler (armcc).  */
2080 int producer_is_realview (const char *producer);
2081
2082 void fixup_section (struct general_symbol_info *ginfo,
2083                     CORE_ADDR addr, struct objfile *objfile);
2084
2085 /* Look up objfile containing BLOCK.  */
2086
2087 struct objfile *lookup_objfile_from_block (const struct block *block);
2088
2089 extern unsigned int symtab_create_debug;
2090
2091 extern unsigned int symbol_lookup_debug;
2092
2093 extern int basenames_may_differ;
2094
2095 int compare_filenames_for_search (const char *filename,
2096                                   const char *search_name);
2097
2098 int compare_glob_filenames_for_search (const char *filename,
2099                                        const char *search_name);
2100
2101 bool iterate_over_some_symtabs (const char *name,
2102                                 const char *real_path,
2103                                 struct compunit_symtab *first,
2104                                 struct compunit_symtab *after_last,
2105                                 gdb::function_view<bool (symtab *)> callback);
2106
2107 void iterate_over_symtabs (const char *name,
2108                            gdb::function_view<bool (symtab *)> callback);
2109
2110
2111 std::vector<CORE_ADDR> find_pcs_for_symtab_line
2112     (struct symtab *symtab, int line, struct linetable_entry **best_entry);
2113
2114 /* Prototype for callbacks for LA_ITERATE_OVER_SYMBOLS.  The callback
2115    is called once per matching symbol SYM.  The callback should return
2116    true to indicate that LA_ITERATE_OVER_SYMBOLS should continue
2117    iterating, or false to indicate that the iteration should end.  */
2118
2119 typedef bool (symbol_found_callback_ftype) (struct block_symbol *bsym);
2120
2121 void iterate_over_symbols (const struct block *block,
2122                            const lookup_name_info &name,
2123                            const domain_enum domain,
2124                            gdb::function_view<symbol_found_callback_ftype> callback);
2125
2126 /* Storage type used by demangle_for_lookup.  demangle_for_lookup
2127    either returns a const char * pointer that points to either of the
2128    fields of this type, or a pointer to the input NAME.  This is done
2129    this way because the underlying functions that demangle_for_lookup
2130    calls either return a std::string (e.g., cp_canonicalize_string) or
2131    a malloc'ed buffer (libiberty's demangled), and we want to avoid
2132    unnecessary reallocation/string copying.  */
2133 class demangle_result_storage
2134 {
2135 public:
2136
2137   /* Swap the std::string storage with STR, and return a pointer to
2138      the beginning of the new string.  */
2139   const char *swap_string (std::string &str)
2140   {
2141     std::swap (m_string, str);
2142     return m_string.c_str ();
2143   }
2144
2145   /* Set the malloc storage to now point at PTR.  Any previous malloc
2146      storage is released.  */
2147   const char *set_malloc_ptr (char *ptr)
2148   {
2149     m_malloc.reset (ptr);
2150     return ptr;
2151   }
2152
2153 private:
2154
2155   /* The storage.  */
2156   std::string m_string;
2157   gdb::unique_xmalloc_ptr<char> m_malloc;
2158 };
2159
2160 const char *
2161   demangle_for_lookup (const char *name, enum language lang,
2162                        demangle_result_storage &storage);
2163
2164 struct symbol *allocate_symbol (struct objfile *);
2165
2166 void initialize_objfile_symbol (struct symbol *);
2167
2168 struct template_symbol *allocate_template_symbol (struct objfile *);
2169
2170 /* Test to see if the symbol of language SYMBOL_LANGUAGE specified by
2171    SYMNAME (which is already demangled for C++ symbols) matches
2172    SYM_TEXT in the first SYM_TEXT_LEN characters.  If so, add it to
2173    the current completion list.  */
2174 void completion_list_add_name (completion_tracker &tracker,
2175                                language symbol_language,
2176                                const char *symname,
2177                                const lookup_name_info &lookup_name,
2178                                const char *text, const char *word);
2179
2180 /* A simple symbol searching class.  */
2181
2182 class symbol_searcher
2183 {
2184 public:
2185   /* Returns the symbols found for the search.  */
2186   const std::vector<block_symbol> &
2187   matching_symbols () const
2188   {
2189     return m_symbols;
2190   }
2191
2192   /* Returns the minimal symbols found for the search.  */
2193   const std::vector<bound_minimal_symbol> &
2194   matching_msymbols () const
2195   {
2196     return m_minimal_symbols;
2197   }
2198
2199   /* Search for all symbols named NAME in LANGUAGE with DOMAIN, restricting
2200      search to FILE_SYMTABS and SEARCH_PSPACE, both of which may be NULL
2201      to search all symtabs and program spaces.  */
2202   void find_all_symbols (const std::string &name,
2203                          const struct language_defn *language,
2204                          enum search_domain search_domain,
2205                          std::vector<symtab *> *search_symtabs,
2206                          struct program_space *search_pspace);
2207
2208   /* Reset this object to perform another search.  */
2209   void reset ()
2210   {
2211     m_symbols.clear ();
2212     m_minimal_symbols.clear ();
2213   }
2214
2215 private:
2216   /* Matching debug symbols.  */
2217   std::vector<block_symbol>  m_symbols;
2218
2219   /* Matching non-debug symbols.  */
2220   std::vector<bound_minimal_symbol> m_minimal_symbols;
2221 };
2222
2223 #endif /* !defined(SYMTAB_H) */