* sparc-nat.c: Include "inf-ptrace.h".

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

diff --git a/gdb/dwarf2expr.h b/gdb/dwarf2expr.h
index 3d0fcb33e7b07f4109b2b2fd23dee7e06f388613..f22d085273da7c22e63d0523e0dd4f2a243b8da1 100644 (file)
--- a/gdb/dwarf2expr.h
+++ b/gdb/dwarf2expr.h
@@ -36,13 +36,8 @@ struct dwarf_expr_context
      to all of the callback functions.  */
   void *baton;
 
-  /* Return the value of register number REGNUM.  LVALP will be set
-     to the kind of lval this register is (generally lval_register
-     for the current frame's registers or lval_memory for a register
-     saved to the stack).  For lval_memory ADDRP will be set to the
-     saved location of the register.  */
-  CORE_ADDR (*read_reg) (void *baton, int regnum, enum lval_type *lvalp,
-                        CORE_ADDR *addrp);
+  /* Return the value of register number REGNUM.  */
+  CORE_ADDR (*read_reg) (void *baton, int regnum);
 
   /* Read LENGTH bytes at ADDR into BUF.  */
   void (*read_mem) (void *baton, char *buf, CORE_ADDR addr,
@@ -77,15 +72,54 @@ struct dwarf_expr_context
   int recursion_depth, max_recursion_depth;
 
   /* Non-zero if the result is in a register.  The register number
-     will be in REGNUM, and the result will be the contents of the
-     register.  */
+     will be on the expression stack.  */
   int in_reg;
 
-  /* If the result is in a register, the register number.  */
-  int regnum;
+  /* An array of pieces.  PIECES points to its first element;
+     NUM_PIECES is its length.
+
+     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 in_reg flag, and the size given as the operand to
+     DW_OP_piece.  We then pop the top value from the stack, clear the
+     in_reg flag, and resume evaluation.
+
+     The Dwarf spec doesn't say whether DW_OP_piece pops the top value
+     from the stack.  We do, ensuring that clients of this interface
+     expecting to see a value left on the top of the stack (say, code
+     evaluating frame base expressions or CFA's specified with
+     DW_CFA_def_cfa_expression) will get an error if the expression
+     actually marks all the values it computes as pieces.
+
+     If an expression never uses DW_OP_piece, num_pieces will be zero.
+     (It would be nice to present these cases as expressions yielding
+     a single piece, with in_reg clear, so that callers need not
+     distinguish between the no-DW_OP_piece and one-DW_OP_piece cases.
+     But expressions with no DW_OP_piece operations have no value to
+     place in a piece's 'size' field; the size comes from the
+     surrounding data.  So the two cases need to be handled
+     separately.)  */
+  int num_pieces;
+  struct dwarf_expr_piece *pieces;
 };
 
-struct dwarf_expr_context *new_dwarf_expr_context ();
+
+/* A piece of an object, as recorded by DW_OP_piece.  */
+struct dwarf_expr_piece
+{
+  /* If IN_REG is zero, then the piece is in memory, and VALUE is its address.
+     If IN_REG is non-zero, then the piece is in a register, and VALUE
+     is the register number.  */
+  int in_reg;
+
+  /* This piece's address or register number.  */
+  CORE_ADDR value;
+
+  /* The length of the piece, in bytes.  */
+  ULONGEST size;
+};
+
+struct dwarf_expr_context *new_dwarf_expr_context (void);
 void free_dwarf_expr_context (struct dwarf_expr_context *ctx);
 
 void dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value);
@@ -99,5 +133,7 @@ unsigned char *read_uleb128 (unsigned char *buf, unsigned char *buf_end,
                             ULONGEST * r);
 unsigned char *read_sleb128 (unsigned char *buf, unsigned char *buf_end,
                             LONGEST * r);
+CORE_ADDR dwarf2_read_address (unsigned char *buf, unsigned char *buf_end,
+                              int *bytes_read);
 
 #endif