2010-05-27 Michael Snyder <msnyder@msnyder-server.eng.vmware.com>

[binutils-gdb.git] / gdb / dwarf2expr.h

diff --git a/gdb/dwarf2expr.h b/gdb/dwarf2expr.h
index 9d9b127add12683d873363eb6f0619099328af32..a0f4554857a145854ac7a9974f73d98bdb4935e3 100644 (file)
--- a/gdb/dwarf2expr.h
+++ b/gdb/dwarf2expr.h
@@ -1,6 +1,6 @@
 /* DWARF 2 Expression Evaluator.
 
-   Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009
+   Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008, 2009, 2010
    Free Software Foundation, Inc.
 
    Contributed by Daniel Berlin <dan@dberlin.org>.
@@ -26,14 +26,36 @@
 /* The location of a value.  */
 enum dwarf_value_location
 {
-  /* The piece is in memory.  */
+  /* The piece is in memory.
+     The value on the dwarf stack is its address.  */
   DWARF_VALUE_MEMORY,
-  /* The piece is in a register.  */
+
+  /* The piece is in a register.
+     The value on the dwarf stack is the register number.  */
   DWARF_VALUE_REGISTER,
-  /* The piece is on the stack.  */
+
+  /* The piece is on the dwarf stack.  */
   DWARF_VALUE_STACK,
+
   /* The piece is a literal.  */
-  DWARF_VALUE_LITERAL
+  DWARF_VALUE_LITERAL,
+
+  /* The piece was optimized out.  */
+  DWARF_VALUE_OPTIMIZED_OUT
+};
+
+/* The dwarf expression stack.  */
+
+struct dwarf_stack_value
+{
+  CORE_ADDR value;
+
+  /* Non-zero if the piece is in memory and is known to be
+     on the program's stack.  It is always ok to set this to zero.
+     This is used, for example, to optimize memory access from the target.
+     It can vastly speed up backtraces on long latency connections when
+     "set stack-cache on".  */
+  int in_stack_memory;
 };
 
 /* The expression evaluator works with a dwarf_expr_context, describing
@@ -41,7 +63,7 @@ enum dwarf_value_location
 struct dwarf_expr_context
 {
   /* The stack of values, allocated with xmalloc.  */
-  CORE_ADDR *stack;
+  struct dwarf_stack_value *stack;
 
   /* The number of values currently pushed on the stack, and the
      number of elements allocated to the stack.  */
@@ -66,7 +88,7 @@ struct dwarf_expr_context
   /* Return the location expression for the frame base attribute, in
      START and LENGTH.  The result must be live until the current
      expression evaluation is complete.  */
-  void (*get_frame_base) (void *baton, gdb_byte **start, size_t *length);
+  void (*get_frame_base) (void *baton, const gdb_byte **start, size_t *length);
 
   /* Return the CFA for the frame.  */
   CORE_ADDR (*get_frame_cfa) (void *baton);
@@ -99,7 +121,7 @@ struct dwarf_expr_context
   /* For VALUE_LITERAL, a the current literal value's length and
      data.  */
   ULONGEST len;
-  gdb_byte *data;
+  const gdb_byte *data;
 
   /* Initialization status of variable: Non-zero if variable has been
      initialized; zero otherwise.  */
@@ -111,7 +133,7 @@ struct dwarf_expr_context
      Each time DW_OP_piece is executed, we add a new element to the
      end of this array, recording the current top of the stack, the
      current location, and the size given as the operand to
-     DW_OP_piece.  We then pop the top value from the stack, rest the
+     DW_OP_piece.  We then pop the top value from the stack, reset the
      location, and resume evaluation.
 
      The Dwarf spec doesn't say whether DW_OP_piece pops the top value
@@ -133,28 +155,36 @@ struct dwarf_expr_context
 };
 
 
-/* A piece of an object, as recorded by DW_OP_piece.  */
+/* A piece of an object, as recorded by DW_OP_piece or DW_OP_bit_piece.  */
 struct dwarf_expr_piece
 {
   enum dwarf_value_location location;
 
   union
   {
-    /* This piece's address or register number.  */
-    CORE_ADDR value;
+    struct
+    {
+      /* This piece's address or register number.  */
+      CORE_ADDR value;
+      /* Non-zero if the piece is known to be in memory and on
+        the program's stack.  */
+      int in_stack_memory;
+    } expr;
 
     struct
     {
       /* A pointer to the data making up this piece, for literal
         pieces.  */
-      gdb_byte *data;
+      const gdb_byte *data;
       /* The length of the available data.  */
       ULONGEST length;
     } literal;
   } v;
 
-  /* The length of the piece, in bytes.  */
+  /* 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);
@@ -162,16 +192,20 @@ 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 (struct dwarf_expr_context *ctx, CORE_ADDR value);
+void dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value,
+                     int in_stack_memory);
 void dwarf_expr_pop (struct dwarf_expr_context *ctx);
-void dwarf_expr_eval (struct dwarf_expr_context *ctx, unsigned char *addr,
+void dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr,
                      size_t len);
 CORE_ADDR dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n);
+int dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n);
 
 
-gdb_byte *read_uleb128 (gdb_byte *buf, gdb_byte *buf_end, ULONGEST * r);
-gdb_byte *read_sleb128 (gdb_byte *buf, gdb_byte *buf_end, LONGEST * r);
-CORE_ADDR dwarf2_read_address (struct gdbarch *gdbarch, gdb_byte *buf,
-                              gdb_byte *buf_end, int addr_size);
+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);
+CORE_ADDR dwarf2_read_address (struct gdbarch *gdbarch, const gdb_byte *buf,
+                              const gdb_byte *buf_end, int addr_size);
 
 #endif /* dwarf2expr.h */