Merge GDB 7.5.1

gdb/symfile.h

 /* Definitions for reading symbol files into GDB.
 
    Copyright (C) 1990-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 (SYMFILE_H)
 #define SYMFILE_H
 
 /* This file requires that you first include "bfd.h".  */
 #include "symtab.h"
+#include "gdb_vecs.h"
 
 /* Opaque declarations.  */
 struct target_section;
 struct objfile;
 struct obj_section;
 struct obstack;
 struct block;
+struct probe;
+struct value;
+struct frame_info;
+struct agent_expr;
+struct axs_value;
 
 /* Comparison function for symbol look ups.  */
 
 typedef int (symbol_compare_ftype) (const char *string1,
                                     const char *string2);
 
 /* Partial symbols are stored in the psymbol_cache and pointers to
    them are kept in a dynamically grown array that is obtained from
    malloc and grown as necessary via realloc.  Each objfile typically
    has two of these, one for global symbols and one for static
@@ skipping 104 matching lines @@
   /* Return the symbol table for the "last" file appearing in
      OBJFILE.  */
   struct symtab *(*find_last_source_symtab) (struct objfile *objfile);
 
   /* Forget all cached full file names for OBJFILE.  */
   void (*forget_cached_source_info) (struct objfile *objfile);
 
   /* Expand and iterate over each "partial" symbol table in OBJFILE
      where the source file is named NAME.
 
-     If there is no '/' in the name, a match after a '/' in the symbol
+     If NAME is not absolute, a match after a '/' in the symbol
      table's file name will also work.  FULL_PATH is the absolute file
      name, and REAL_PATH is the same, run through gdb_realpath.
 
      If a match is found, the "partial" symbol table is expanded.
      Then, this calls iterate_over_some_symtabs (or equivalent) over
      all newly-created symbol tables, passing CALLBACK and DATA to it.
      The result of this call is returned.  */
   int (*map_symtabs_matching_filename) (struct objfile *objfile,
                                         const char *name,
                                         const char *full_path,
                                         const char *real_path,
                                         int (*callback) (struct symtab *,
                                                          void *),
                                         void *data);
 
   /* Check to see if the symbol is defined in a "partial" symbol table
      of OBJFILE.  KIND should be either GLOBAL_BLOCK or STATIC_BLOCK,
      depending on whether we want to search global symbols or static
      symbols.  NAME is the name of the symbol to look for.  DOMAIN
      indicates what sort of symbol to search for.
 
      Returns the newly-expanded symbol table in which the symbol is
-     defined, or NULL if no such symbol table exists.  */
+     defined, or NULL if no such symbol table exists.  If OBJFILE
+     contains !TYPE_OPAQUE symbol prefer its symtab.  If it contains
+     only TYPE_OPAQUE symbol(s), return at least that symtab.  */
   struct symtab *(*lookup_symbol) (struct objfile *objfile,
                                    int kind, const char *name,
                                    domain_enum domain);
 
   /* This is called to expand symbol tables before looking up a
      symbol.  A backend can choose to implement this and then have its
      `lookup_symbol' hook always return NULL, or the reverse.  (It
      doesn't make sense to implement both.)  The arguments are as for
      `lookup_symbol'.  */
   void (*pre_expand_symtabs_matching) (struct objfile *objfile,
@@ skipping 61 matching lines @@
                                 symbol_compare_ftype *match,
                                 symbol_compare_ftype *ordered_compare);
 
   /* Expand all symbol tables in OBJFILE matching some criteria.
 
      FILE_MATCHER is called for each file in OBJFILE.  The file name
      and the DATA argument are passed to it.  If it returns zero, this
      file is skipped.  If FILE_MATCHER is NULL such file is not skipped.
 
      Otherwise, if KIND does not match this symbol is skipped.
-     
+
      If even KIND matches, then NAME_MATCHER is called for each symbol
-     defined in the file.  The current language, the symbol name and
-     DATA are passed to NAME_MATCHER.  The symbol "natural" name should
-     be passed to NAME_MATCHER for all languages except Ada, where
-     the encoded name is passed instead (see la_symbol_name_compare in
-     struct language_defn for more details on this).
+     defined in the file.  The symbol "search" name and DATA are passed
+     to NAME_MATCHER.
 
      If NAME_MATCHER returns zero, then this symbol is skipped.
 
      Otherwise, this symbol's symbol table is expanded.
 
      DATA is user data that is passed unmodified to the callback
      functions.  */
   void (*expand_symtabs_matching)
     (struct objfile *objfile,
      int (*file_matcher) (const char *, void *),
-     int (*name_matcher) (const struct language_defn *, const char *, void *),
+     int (*name_matcher) (const char *, void *),
      enum search_domain kind,
      void *data);
 
   /* Return the symbol table from OBJFILE that contains PC and
      SECTION.  Return NULL if there is no such symbol table.  This
      should return the symbol table that contains a symbol whose
      address exactly matches PC, or, if there is no exact match, the
      symbol table that contains a symbol whose address is closest to
      PC.  */
   struct symtab *(*find_pc_sect_symtab) (struct objfile *objfile,
                                          struct minimal_symbol *msymbol,
                                          CORE_ADDR pc,
                                          struct obj_section *section,
                                          int warn_if_readin);
 
   /* Call a callback for every file defined in OBJFILE whose symtab is
      not already read in.  FUN is the callback.  It is passed the file's
      FILENAME, the file's FULLNAME (if need_fullname is non-zero), and
      the DATA passed to this function.  */
   void (*map_symbol_filenames) (struct objfile *objfile,
                                 symbol_filename_ftype *fun, void *data,
                                 int need_fullname);
 };
 
+/* Structure of functions used for probe support.  If one of these functions
+   is provided, all must be.  */
+
+struct sym_probe_fns
+{
+  /* If non-NULL, return an array of probe objects.
+
+     The returned value does not have to be freed and it has lifetime of the
+     OBJFILE.  */
+  VEC (probe_p) *(*sym_get_probes) (struct objfile *);
+
+  /* Return the number of arguments available to PROBE.  PROBE will
+     have come from a call to this objfile's sym_get_probes method.
+     If you provide an implementation of sym_get_probes, you must
+     implement this method as well.  */
+  unsigned (*sym_get_probe_argument_count) (struct objfile *objfile,
+                                            struct probe *probe);
+
+  /* Evaluate the Nth argument available to PROBE.  PROBE will have
+     come from a call to this objfile's sym_get_probes method.  N will
+     be between 0 and the number of arguments available to this probe.
+     FRAME is the frame in which the evaluation is done; the frame's
+     PC will match the address of the probe.  If you provide an
+     implementation of sym_get_probes, you must implement this method
+     as well.  */
+  struct value *(*sym_evaluate_probe_argument) (struct objfile *objfile,
+                                                struct probe *probe,
+                                                unsigned n);
+
+  /* Compile the Nth probe argument to an agent expression.  PROBE
+     will have come from a call to this objfile's sym_get_probes
+     method.  N will be between 0 and the number of arguments
+     available to this probe.  EXPR and VALUE are the agent expression
+     that is being updated.  */
+  void (*sym_compile_to_ax) (struct objfile *objfile,
+                             struct probe *probe,
+                             struct agent_expr *expr,
+                             struct axs_value *value,
+                             unsigned n);
+
+  /* Relocate the probe section of OBJFILE.  */
+  void (*sym_relocate_probe) (struct objfile *objfile,
+                              struct section_offsets *new_offsets,
+                              struct section_offsets *delta);
+};
+
 /* Structure to keep track of symbol reading functions for various
    object file types.  */
 
 struct sym_fns
 {
 
   /* BFD flavour that we handle, or (as a special kludge, see
      xcoffread.c, (enum bfd_flavour)-1 for xcoff).  */
 
   enum bfd_flavour sym_flavour;
@@ skipping 50 matching lines @@
      information.  */
 
   void (*sym_read_linetable) (void);
 
   /* Relocate the contents of a debug section SECTP.  The
      contents are stored in BUF if it is non-NULL, or returned in a
      malloc'd buffer otherwise.  */
 
   bfd_byte *(*sym_relocate) (struct objfile *, asection *sectp, bfd_byte *buf);
 
+  /* If non-NULL, this objfile has probe support, and all the probe
+     functions referred to here will be non-NULL.  */
+  const struct sym_probe_fns *sym_probe_fns;
+
   /* The "quick" (aka partial) symbol functions for this symbol
      reader.  */
   const struct quick_symbol_functions *qf;
 };
 
 extern struct section_addr_info *
   build_section_addr_info_from_objfile (const struct objfile *objfile);
 
 extern void relative_addr_info_to_section_offsets
   (struct section_offsets *section_offsets, int num_sections,
@@ skipping 202 matching lines @@
 struct dwarf2_debug_sections {
   struct dwarf2_section_names info;
   struct dwarf2_section_names abbrev;
   struct dwarf2_section_names line;
   struct dwarf2_section_names loc;
   struct dwarf2_section_names macinfo;
   struct dwarf2_section_names macro;
   struct dwarf2_section_names str;
   struct dwarf2_section_names ranges;
   struct dwarf2_section_names types;
+  struct dwarf2_section_names addr;
   struct dwarf2_section_names frame;
   struct dwarf2_section_names eh_frame;
   struct dwarf2_section_names gdb_index;
   /* This field has no meaning, but exists solely to catch changes to
      this structure which are not reflected in some instance.  */
   int sentinel;
 };
 
 extern int dwarf2_has_info (struct objfile *,
                             const struct dwarf2_debug_sections *);
@@ skipping 26 matching lines @@
 
 extern void mdebug_build_psymtabs (struct objfile *,
                                    const struct ecoff_debug_swap *,
                                    struct ecoff_debug_info *);
 
 extern void elfmdebug_build_psymtabs (struct objfile *,
                                       const struct ecoff_debug_swap *,
                                       asection *);
 
 #endif /* !defined(SYMFILE_H) */