Merge GDB 7.5.1

gdb/symtab.h

 /* Symbol table definitions for GDB.
 
    Copyright (C) 1986, 1988-2004, 2007-2012 Free Software Foundation,
    Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #if !defined (SYMTAB_H)
 #define SYMTAB_H 1
 
 #include "vec.h"
+#include "gdb_vecs.h"
 
 /* Opaque declarations.  */
 struct ui_file;
 struct frame_info;
 struct symbol;
 struct obstack;
 struct objfile;
 struct block;
 struct blockvector;
 struct axs_value;
 struct agent_expr;
 struct program_space;
 struct language_defn;
+struct probe;
 
 /* Some of the structures in this file are space critical.
    The space-critical structures are:
 
      struct general_symbol_info
      struct symbol
      struct partial_symbol
 
    These structures are laid out to encourage good packing.
    They use ENUM_BITFIELD and short int fields, and they order the
@@ skipping 26 matching lines @@
    The third line shows the savings from the optimizations in symtab.h.
    The fourth line shows the savings from the optimizations in
    gdbtypes.h.  Both optimizations are in gdb HEAD now.
 
    --chastain 2003-08-21  */
 
 /* Struct for storing C++ specific information.  Allocated when needed.  */
 
 struct cplus_specific
 {
-  char *demangled_name;
+  const char *demangled_name;
 };
 
 /* Define a structure for the information that is common to all symbol types,
    including minimal symbols, partial symbols, and full symbols.  In a
    multilanguage environment, some language specific information may need to
    be recorded along with each symbol.  */
 
 /* This structure is space critical.  See space comments at the top.  */
 
 struct general_symbol_info
 {
   /* Name of the symbol.  This is a required field.  Storage for the
      name is allocated on the objfile_obstack for the associated
      objfile.  For languages like C++ that make a distinction between
      the mangled name and demangled name, this is the mangled
      name.  */
 
-  char *name;
+  const char *name;
 
   /* Value of the symbol.  Which member of this union to use, and what
      it means, depends on what kind of symbol this is and its
      SYMBOL_CLASS.  See comments there for more details.  All of these
      are in host byte order (though what they point to might be in
      target byte order, e.g. LOC_CONST_BYTES).  */
 
   union
   {
-    /* The fact that this is a long not a LONGEST mainly limits the
-       range of a LOC_CONST.  Since LOC_CONST_BYTES exists, I'm not
-       sure that is a big deal.  */
-    long ivalue;
+    LONGEST ivalue;
 
     struct block *block;
 
     gdb_byte *bytes;
 
     CORE_ADDR address;
 
     /* For opaque typedef struct chain.  */
 
     struct symbol *chain;
   }
   value;
 
   /* Since one and only one language can apply, wrap the language specific
      information inside a union.  */
 
   union
   {
     /* This is used by languages which wish to store a demangled name.
        currently used by Ada, Java, and Objective C.  */
     struct mangled_lang
     {
-      char *demangled_name;
+      const char *demangled_name;
     }
     mangled_lang;
 
     struct cplus_specific *cplus_specific;
   }
   language_specific;
 
   /* Record the source code language that applies to this symbol.
      This is used to select one of the fields from the language specific
      union above.  */
@@ skipping 10 matching lines @@
   short section;
 
   /* The section associated with this symbol.  It can be NULL.  */
 
   struct obj_section *obj_section;
 };
 
 extern void symbol_set_demangled_name (struct general_symbol_info *, char *,
                                        struct objfile *);
 
-extern char *symbol_get_demangled_name (const struct general_symbol_info *);
+extern const char *symbol_get_demangled_name
+  (const struct general_symbol_info *);
 
 extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
 
 /* Note that all the following SYMBOL_* macros are used with the
    SYMBOL argument being either a partial symbol, a minimal symbol or
    a full symbol.  All three types have a ginfo field.  In particular
    the SYMBOL_SET_LANGUAGE, SYMBOL_DEMANGLED_NAME, etc.
    macros cannot be entirely substituted by
    functions, unless the callers are changed to pass in the ginfo
    field only, instead of the SYMBOL parameter.  */
@@ skipping 38 matching lines @@
    specifically need to know whether SYMBOL_NATURAL_NAME and
    SYMBOL_LINKAGE_NAME are different.  */
 
 /* Return SYMBOL's "natural" name, i.e. the name that it was called in
    the original source code.  In languages like C++ where symbols may
    be mangled for ease of manipulation by the linker, this is the
    demangled name.  */
 
 #define SYMBOL_NATURAL_NAME(symbol) \
   (symbol_natural_name (&(symbol)->ginfo))
-extern char *symbol_natural_name (const struct general_symbol_info *symbol);
+extern const char *symbol_natural_name
+  (const struct general_symbol_info *symbol);
 
 /* Return SYMBOL's name from the point of view of the linker.  In
    languages like C++ where symbols may be mangled for ease of
    manipulation by the linker, this is the mangled name; otherwise,
    it's the same as SYMBOL_NATURAL_NAME.  */
 
 #define SYMBOL_LINKAGE_NAME(symbol)     (symbol)->ginfo.name
 
 /* Return the demangled name for a symbol based on the language for
    that symbol.  If no demangled name exists, return NULL.  */
 #define SYMBOL_DEMANGLED_NAME(symbol) \
   (symbol_demangled_name (&(symbol)->ginfo))
-extern char *symbol_demangled_name (const struct general_symbol_info *symbol);
+extern const char *symbol_demangled_name
+  (const struct general_symbol_info *symbol);
 
 /* Macro that returns a version of the name of a symbol that is
    suitable for output.  In C++ this is the "demangled" form of the
    name if demangle is on and the "mangled" form of the name if
    demangle is off.  In other languages this is just the symbol name.
    The result should never be NULL.  Don't use this for internal
    purposes (e.g. storing in a hashtable): it's only suitable for output.
 
    N.B. symbol may be anything with a ginfo member,
    e.g., struct symbol or struct minimal_symbol.  */
 
 #define SYMBOL_PRINT_NAME(symbol)                                       \
   (demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
 extern int demangle;
 
-/* Macro that tests a symbol for a match against a specified name string.
-   First test the unencoded name, then looks for and test a C++ encoded
-   name if it exists.  Note that whitespace is ignored while attempting to
-   match a C++ encoded name, so that "foo::bar(int,long)" is the same as
-   "foo :: bar (int, long)".
-   Evaluates to zero if the match fails, or nonzero if it succeeds.  */
-
-/* Macro that tests a symbol for a match against a specified name
-   string.  It tests against SYMBOL_NATURAL_NAME, and it ignores
-   whitespace and trailing parentheses.  (See strcmp_iw for details
-   about its behavior.)  */
-
-#define SYMBOL_MATCHES_NATURAL_NAME(symbol, name)                       \
-  (strcmp_iw (SYMBOL_NATURAL_NAME (symbol), (name)) == 0)
-
 /* Macro that returns the name to be used when sorting and searching symbols.
    In  C++, Chill, and Java, we search for the demangled form of a name,
    and so sort symbols accordingly.  In Ada, however, we search by mangled
    name.  If there is no distinct demangled name, then SYMBOL_SEARCH_NAME
    returns the same value (same pointer) as SYMBOL_LINKAGE_NAME.  */
 #define SYMBOL_SEARCH_NAME(symbol)                                       \
    (symbol_search_name (&(symbol)->ginfo))
-extern char *symbol_search_name (const struct general_symbol_info *);
+extern const char *symbol_search_name (const struct general_symbol_info *);
 
-/* Analogous to SYMBOL_MATCHES_NATURAL_NAME, but uses the search
-   name.  */
+/* Return non-zero if NAME matches the "search" name of SYMBOL.
+   Whitespace and trailing parentheses are ignored.
+   See strcmp_iw for details about its behavior.  */
 #define SYMBOL_MATCHES_SEARCH_NAME(symbol, name)                        \
   (strcmp_iw (SYMBOL_SEARCH_NAME (symbol), (name)) == 0)
 
 /* Classification types for a minimal symbol.  These should be taken as
    "advisory only", since if gdb can't easily figure out a
    classification it simply selects mst_unknown.  It may also have to
    guess when it can't figure out which is a better match between two
    types (mst_data versus mst_bss) for example.  Since the minimal
    symbol info is sometimes derived from the BFD library's view of a
    file, we need to live with what information bfd supplies.  */
@@ skipping 46 matching lines @@
 
   struct general_symbol_info ginfo;
 
   /* Size of this symbol.  end_psymtab in dbxread.c uses this
      information to calculate the end of the partial symtab based on the
      address of the last symbol plus the size of the last symbol.  */
 
   unsigned long size;
 
   /* Which source file is this symbol in?  Only relevant for mst_file_*.  */
-  char *filename;
+  const char *filename;
 
   /* Classification type for this minimal symbol.  */
 
   ENUM_BITFIELD(minimal_symbol_type) type : 8;
 
+  /* Non-zero if this symbol was created by gdb.
+     Such symbols do not appear in the output of "info var|fun".  */
+  unsigned int created_by_gdb : 1;
+
   /* Two flag bits provided for the use of the target.  */
   unsigned int target_flag_1 : 1;
   unsigned int target_flag_2 : 1;
 
   /* Minimal symbols with the same hash key are kept on a linked
      list.  This is the link.  */
 
   struct minimal_symbol *hash_next;
 
   /* Minimal symbols are stored in two different hash tables.  This is
      the `next' pointer for the demangled hash table.  */
 
   struct minimal_symbol *demangled_hash_next;
 };
 
 #define MSYMBOL_TARGET_FLAG_1(msymbol)  (msymbol)->target_flag_1
 #define MSYMBOL_TARGET_FLAG_2(msymbol)  (msymbol)->target_flag_2