Merge GDB 7.5.1

gdb/dwarf2expr.h

 /* DWARF 2 Expression Evaluator.
 
    Copyright (C) 2001-2003, 2005, 2007-2012 Free Software Foundation,
    Inc.
 
    Contributed by Daniel Berlin <dan@dberlin.org>.
 
    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 (DWARF2EXPR_H)
 #define DWARF2EXPR_H
 
+#include "leb128.h"
+#include "gdbtypes.h"
+
 struct dwarf_expr_context;
 
 /* Virtual method table for struct dwarf_expr_context below.  */
 
 struct dwarf_expr_context_funcs
 {
   /* Return the value of register number REGNUM.  */
   CORE_ADDR (*read_reg) (void *baton, int regnum);
 
   /* Read LENGTH bytes at ADDR into BUF.  */
@@ skipping 10 matching lines @@
   /* Return the PC for the frame.  */
   CORE_ADDR (*get_frame_pc) (void *baton);
 
   /* Return the thread-local storage address for
      DW_OP_GNU_push_tls_address.  */
   CORE_ADDR (*get_tls_address) (void *baton, CORE_ADDR offset);
 
   /* Execute DW_AT_location expression for the DWARF expression subroutine in
      the DIE at DIE_OFFSET in the CU from CTX.  Do not touch STACK while it
      being passed to and returned from the called DWARF subroutine.  */
-  void (*dwarf_call) (struct dwarf_expr_context *ctx, size_t die_offset);
+  void (*dwarf_call) (struct dwarf_expr_context *ctx, cu_offset die_offset);
 
   /* Return the base type given by the indicated DIE.  This can throw
      an exception if the DIE is invalid or does not represent a base
      type.  If can also be NULL in the special case where the
      callbacks are not performing evaluation, and thus it is
      meaningful to substitute a stub type of the correct size.  */
-  struct type *(*get_base_type) (struct dwarf_expr_context *ctx, size_t die);
+  struct type *(*get_base_type) (struct dwarf_expr_context *ctx, cu_offset die);
 
   /* Push on DWARF stack an entry evaluated for DW_TAG_GNU_call_site's
-     DWARF_REG/FB_OFFSET at the caller of specified BATON.  If DWARF register
-     number DWARF_REG specifying the push_dwarf_reg_entry_value parameter is
-     not -1 FB_OFFSET is ignored.  Otherwise FB_OFFSET specifies stack
-     parameter offset against caller's stack pointer (which equals the callee's
-     frame base).  If DEREF_SIZE is not -1 then use
-     DW_AT_GNU_call_site_data_value instead of DW_AT_GNU_call_site_value.  */
+     parameter matching KIND and KIND_U at the caller of specified BATON.
+     If DEREF_SIZE is not -1 then use DW_AT_GNU_call_site_data_value instead of
+     DW_AT_GNU_call_site_value.  */
   void (*push_dwarf_reg_entry_value) (struct dwarf_expr_context *ctx,
-                                      int dwarf_reg, CORE_ADDR fb_offset,
+                                      enum call_site_parameter_kind kind,
+                                      union call_site_parameter_u kind_u,
                                       int deref_size);
 
+  /* Return the address indexed by DW_OP_GNU_addr_index.
+     This can throw an exception if the index is out of range.  */
+  CORE_ADDR (*get_addr_index) (void *baton, unsigned int index);
+
 #if 0
   /* Not yet implemented.  */
 
   /* Return the `object address' for DW_OP_push_object_address.  */
   CORE_ADDR (*get_object_address) (void *baton);
 #endif
 };
 
 /* The location of a value.  */
 enum dwarf_value_location
@@ skipping 47 matching lines @@
   /* Target architecture to use for address operations.  */
   struct gdbarch *gdbarch;
 
   /* Target address size in bytes.  */
   int addr_size;
 
   /* DW_FORM_ref_addr size in bytes.  If -1 DWARF is executed from a frame
      context and operations depending on DW_FORM_ref_addr are not allowed.  */
   int ref_addr_size;
 
-  /* Offset used to relocate DW_OP_addr argument.  */
+  /* Offset used to relocate DW_OP_addr and DW_OP_GNU_addr_index arguments.  */
   CORE_ADDR offset;
 
   /* An opaque argument provided by the caller, which will be passed
      to all of the callback functions.  */
   void *baton;
 
   /* Callback functions.  */
   const struct dwarf_expr_context_funcs *funcs;
 
   /* The current depth of dwarf expression recursion, via DW_OP_call*,
      DW_OP_fbreg, DW_OP_push_object_address, etc., and the maximum
      depth we'll tolerate before raising an error.  */
   int recursion_depth, max_recursion_depth;
 
   /* Location of the value.  */
   enum dwarf_value_location location;
 
   /* For DWARF_VALUE_LITERAL, the current literal value's length and
      data.  For DWARF_VALUE_IMPLICIT_POINTER, LEN is the offset of the
-     target DIE.  */
+     target DIE of cu_offset kind.  */
   ULONGEST len;
   const gdb_byte *data;
 
   /* Initialization status of variable: Non-zero if variable has been
      initialized; zero otherwise.  */
   int initialized;
 
   /* An array of pieces.  PIECES points to its first element;
      NUM_PIECES is its length.
 
@@ skipping 50 matching lines @@
          for DWARF_VALUE_LITERAL pieces.  */
       const gdb_byte *data;
       /* The length of the available data.  */
       ULONGEST length;
     } literal;
 
     /* Used for DWARF_VALUE_IMPLICIT_POINTER.  */
     struct
     {
       /* The referent DIE from DW_OP_GNU_implicit_pointer.  */
-      ULONGEST die;
+      cu_offset die;
       /* The byte offset into the resulting data.  */
       LONGEST offset;
     } ptr;
   } v;
 
   /* The length of the piece, in bits.  */
   ULONGEST size;
   /* The piece offset, in bits.  */
   ULONGEST offset;
 };
 
 struct dwarf_expr_context *new_dwarf_expr_context (void);
 void free_dwarf_expr_context (struct dwarf_expr_context *ctx);
 struct cleanup *
     make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context *ctx);
 
 void dwarf_expr_push_address (struct dwarf_expr_context *ctx,
                               CORE_ADDR value,
                               int in_stack_memory);
 void dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr,
                       size_t len);
 struct value *dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n);
 CORE_ADDR dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n);
 int dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n);
 
-
-const gdb_byte *read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
-                              ULONGEST * r);
-const gdb_byte *read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
-                              LONGEST * r);
-
-const char *dwarf_stack_op_name (unsigned int);
-
 void dwarf_expr_require_composition (const gdb_byte *, const gdb_byte *,
                                      const char *);
 
 /* Stub dwarf_expr_context_funcs implementations.  */
 
 void ctx_no_get_frame_base (void *baton, const gdb_byte **start,
                             size_t *length);
 CORE_ADDR ctx_no_get_frame_cfa (void *baton);
 CORE_ADDR ctx_no_get_frame_pc (void *baton);
 CORE_ADDR ctx_no_get_tls_address (void *baton, CORE_ADDR offset);
-void ctx_no_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset);
-struct type *ctx_no_get_base_type (struct dwarf_expr_context *ctx, size_t die);
+void ctx_no_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset);
+struct type *ctx_no_get_base_type (struct dwarf_expr_context *ctx,
+                                   cu_offset die);
 void ctx_no_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
-                                        int dwarf_reg, CORE_ADDR fb_offset,
+                                        enum call_site_parameter_kind kind,
+                                        union call_site_parameter_u kind_u,
                                         int deref_size);
+CORE_ADDR ctx_no_get_addr_index (void *baton, unsigned int index);
 
 int dwarf_block_to_dwarf_reg (const gdb_byte *buf, const gdb_byte *buf_end);
 
 int dwarf_block_to_dwarf_reg_deref (const gdb_byte *buf,
                                     const gdb_byte *buf_end,
                                     CORE_ADDR *deref_size_return);
 
 int dwarf_block_to_fb_offset (const gdb_byte *buf, const gdb_byte *buf_end,
                               CORE_ADDR *fb_offset_return);
 
 int dwarf_block_to_sp_offset (struct gdbarch *gdbarch, const gdb_byte *buf,
                               const gdb_byte *buf_end,
                               CORE_ADDR *sp_offset_return);
 
+/* Wrappers around the leb128 reader routines to simplify them for our
+   purposes.  */
+
+static inline const gdb_byte *
+gdb_read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
+                  uint64_t *r)
+{
+  size_t bytes_read = read_uleb128_to_uint64 (buf, buf_end, r);
+
+  if (bytes_read == 0)
+    return NULL;
+  return buf + bytes_read;
+}
+
+static inline const gdb_byte *
+gdb_read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
+                  int64_t *r)
+{
+  size_t bytes_read = read_sleb128_to_int64 (buf, buf_end, r);
+
+  if (bytes_read == 0)
+    return NULL;
+  return buf + bytes_read;
+}
+
+static inline const gdb_byte *
+gdb_skip_leb128 (const gdb_byte *buf, const gdb_byte *buf_end)
+{
+  size_t bytes_read = skip_leb128 (buf, buf_end);
+
+  if (bytes_read == 0)
+    return NULL;
+  return buf + bytes_read;
+}
+
+extern const gdb_byte *safe_read_uleb128 (const gdb_byte *buf,
+                                          const gdb_byte *buf_end,
+                                          uint64_t *r);
+
+extern const gdb_byte *safe_read_sleb128 (const gdb_byte *buf,
+                                          const gdb_byte *buf_end,
+                                          int64_t *r);
+
+extern const gdb_byte *safe_skip_leb128 (const gdb_byte *buf,
+                                         const gdb_byte *buf_end);
+
 #endif /* dwarf2expr.h */