gdb/dwarf2expr.h

   1 /* DWARF 2 Expression Evaluator.
   2
   3    Copyright (C) 2001-2003, 2005, 2007-2012 Free Software Foundation,
   4    Inc.
   5
   6    Contributed by Daniel Berlin <dan@dberlin.org>.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #if !defined (DWARF2EXPR_H)
  24 #define DWARF2EXPR_H
  25
  26 struct dwarf_expr_context;
  27
  28 /* Offset relative to the start of its containing CU (compilation unit).  */
  29 typedef struct
  30 {
  31   unsigned int cu_off;
  32 } cu_offset;
  33
  34 /* Offset relative to the start of its .debug_info or .debug_types section.  */
  35 typedef struct
  36 {
  37   unsigned int sect_off;
  38 } sect_offset;
  39
  40 /* Virtual method table for struct dwarf_expr_context below.  */
  41
  42 struct dwarf_expr_context_funcs
  43 {
  44   /* Return the value of register number REGNUM.  */
  45   CORE_ADDR (*read_reg) (void *baton, int regnum);
  46
  47   /* Read LENGTH bytes at ADDR into BUF.  */
  48   void (*read_mem) (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t length);
  49
  50   /* Return the location expression for the frame base attribute, in
  51      START and LENGTH.  The result must be live until the current
  52      expression evaluation is complete.  */
  53   void (*get_frame_base) (void *baton, const gdb_byte **start, size_t *length);
  54
  55   /* Return the CFA for the frame.  */
  56   CORE_ADDR (*get_frame_cfa) (void *baton);
  57
  58   /* Return the PC for the frame.  */
  59   CORE_ADDR (*get_frame_pc) (void *baton);
  60
  61   /* Return the thread-local storage address for
  62      DW_OP_GNU_push_tls_address.  */
  63   CORE_ADDR (*get_tls_address) (void *baton, CORE_ADDR offset);
  64
  65   /* Execute DW_AT_location expression for the DWARF expression subroutine in
  66      the DIE at DIE_OFFSET in the CU from CTX.  Do not touch STACK while it
  67      being passed to and returned from the called DWARF subroutine.  */
  68   void (*dwarf_call) (struct dwarf_expr_context *ctx, cu_offset die_offset);
  69
  70   /* Return the base type given by the indicated DIE.  This can throw
  71      an exception if the DIE is invalid or does not represent a base
  72      type.  If can also be NULL in the special case where the
  73      callbacks are not performing evaluation, and thus it is
  74      meaningful to substitute a stub type of the correct size.  */
  75   struct type *(*get_base_type) (struct dwarf_expr_context *ctx, cu_offset die);
  76
  77   /* Push on DWARF stack an entry evaluated for DW_TAG_GNU_call_site's
  78      DWARF_REG/FB_OFFSET at the caller of specified BATON.  If DWARF register
  79      number DWARF_REG specifying the push_dwarf_reg_entry_value parameter is
  80      not -1 FB_OFFSET is ignored.  Otherwise FB_OFFSET specifies stack
  81      parameter offset against caller's stack pointer (which equals the callee's
  82      frame base).  If DEREF_SIZE is not -1 then use
  83      DW_AT_GNU_call_site_data_value instead of DW_AT_GNU_call_site_value.  */
  84   void (*push_dwarf_reg_entry_value) (struct dwarf_expr_context *ctx,
  85                                       int dwarf_reg, CORE_ADDR fb_offset,
  86                                       int deref_size);
  87
  88 #if 0
  89   /* Not yet implemented.  */
  90
  91   /* Return the `object address' for DW_OP_push_object_address.  */
  92   CORE_ADDR (*get_object_address) (void *baton);
  93 #endif
  94 };
  95
  96 /* The location of a value.  */
  97 enum dwarf_value_location
  98 {
  99   /* The piece is in memory.
 100      The value on the dwarf stack is its address.  */
 101   DWARF_VALUE_MEMORY,
 102
 103   /* The piece is in a register.
 104      The value on the dwarf stack is the register number.  */
 105   DWARF_VALUE_REGISTER,
 106
 107   /* The piece is on the dwarf stack.  */
 108   DWARF_VALUE_STACK,
 109
 110   /* The piece is a literal.  */
 111   DWARF_VALUE_LITERAL,
 112
 113   /* The piece was optimized out.  */
 114   DWARF_VALUE_OPTIMIZED_OUT,
 115
 116   /* The piece is an implicit pointer.  */
 117   DWARF_VALUE_IMPLICIT_POINTER
 118 };
 119
 120 /* The dwarf expression stack.  */
 121
 122 struct dwarf_stack_value
 123 {
 124   struct value *value;
 125
 126   /* Non-zero if the piece is in memory and is known to be
 127      on the program's stack.  It is always ok to set this to zero.
 128      This is used, for example, to optimize memory access from the target.
 129      It can vastly speed up backtraces on long latency connections when
 130      "set stack-cache on".  */
 131   int in_stack_memory;
 132 };
 133
 134 /* The expression evaluator works with a dwarf_expr_context, describing
 135    its current state and its callbacks.  */
 136 struct dwarf_expr_context
 137 {
 138   /* The stack of values, allocated with xmalloc.  */
 139   struct dwarf_stack_value *stack;
 140
 141   /* The number of values currently pushed on the stack, and the
 142      number of elements allocated to the stack.  */
 143   int stack_len, stack_allocated;
 144
 145   /* Target architecture to use for address operations.  */
 146   struct gdbarch *gdbarch;
 147
 148   /* Target address size in bytes.  */
 149   int addr_size;
 150
 151   /* DW_FORM_ref_addr size in bytes.  If -1 DWARF is executed from a frame
 152      context and operations depending on DW_FORM_ref_addr are not allowed.  */
 153   int ref_addr_size;
 154
 155   /* Offset used to relocate DW_OP_addr argument.  */
 156   CORE_ADDR offset;
 157
 158   /* An opaque argument provided by the caller, which will be passed
 159      to all of the callback functions.  */
 160   void *baton;
 161
 162   /* Callback functions.  */
 163   const struct dwarf_expr_context_funcs *funcs;
 164
 165   /* The current depth of dwarf expression recursion, via DW_OP_call*,
 166      DW_OP_fbreg, DW_OP_push_object_address, etc., and the maximum
 167      depth we'll tolerate before raising an error.  */
 168   int recursion_depth, max_recursion_depth;
 169
 170   /* Location of the value.  */
 171   enum dwarf_value_location location;
 172
 173   /* For DWARF_VALUE_LITERAL, the current literal value's length and
 174      data.  For DWARF_VALUE_IMPLICIT_POINTER, LEN is the offset of the
 175      target DIE of cu_offset kind.  */
 176   ULONGEST len;
 177   const gdb_byte *data;
 178
 179   /* Initialization status of variable: Non-zero if variable has been
 180      initialized; zero otherwise.  */
 181   int initialized;
 182
 183   /* An array of pieces.  PIECES points to its first element;
 184      NUM_PIECES is its length.
 185
 186      Each time DW_OP_piece is executed, we add a new element to the
 187      end of this array, recording the current top of the stack, the
 188      current location, and the size given as the operand to
 189      DW_OP_piece.  We then pop the top value from the stack, reset the
 190      location, and resume evaluation.
 191
 192      The Dwarf spec doesn't say whether DW_OP_piece pops the top value
 193      from the stack.  We do, ensuring that clients of this interface
 194      expecting to see a value left on the top of the stack (say, code
 195      evaluating frame base expressions or CFA's specified with
 196      DW_CFA_def_cfa_expression) will get an error if the expression
 197      actually marks all the values it computes as pieces.
 198
 199      If an expression never uses DW_OP_piece, num_pieces will be zero.
 200      (It would be nice to present these cases as expressions yielding
 201      a single piece, so that callers need not distinguish between the
 202      no-DW_OP_piece and one-DW_OP_piece cases.  But expressions with
 203      no DW_OP_piece operations have no value to place in a piece's
 204      'size' field; the size comes from the surrounding data.  So the
 205      two cases need to be handled separately.)  */
 206   int num_pieces;
 207   struct dwarf_expr_piece *pieces;
 208 };
 209
 210
 211 /* A piece of an object, as recorded by DW_OP_piece or DW_OP_bit_piece.  */
 212 struct dwarf_expr_piece
 213 {
 214   enum dwarf_value_location location;
 215
 216   union
 217   {
 218     struct
 219     {
 220       /* This piece's address, for DWARF_VALUE_MEMORY pieces.  */
 221       CORE_ADDR addr;
 222       /* Non-zero if the piece is known to be in memory and on
 223          the program's stack.  */
 224       int in_stack_memory;
 225     } mem;
 226
 227     /* The piece's register number, for DWARF_VALUE_REGISTER pieces.  */
 228     int regno;
 229
 230     /* The piece's literal value, for DWARF_VALUE_STACK pieces.  */
 231     struct value *value;
 232
 233     struct
 234     {
 235       /* A pointer to the data making up this piece,
 236          for DWARF_VALUE_LITERAL pieces.  */
 237       const gdb_byte *data;
 238       /* The length of the available data.  */
 239       ULONGEST length;
 240     } literal;
 241
 242     /* Used for DWARF_VALUE_IMPLICIT_POINTER.  */
 243     struct
 244     {
 245       /* The referent DIE from DW_OP_GNU_implicit_pointer.  */
 246       cu_offset die;
 247       /* The byte offset into the resulting data.  */
 248       LONGEST offset;
 249     } ptr;
 250   } v;
 251
 252   /* The length of the piece, in bits.  */
 253   ULONGEST size;
 254   /* The piece offset, in bits.  */
 255   ULONGEST offset;
 256 };
 257
 258 struct dwarf_expr_context *new_dwarf_expr_context (void);
 259 void free_dwarf_expr_context (struct dwarf_expr_context *ctx);
 260 struct cleanup *
 261     make_cleanup_free_dwarf_expr_context (struct dwarf_expr_context *ctx);
 262
 263 void dwarf_expr_push_address (struct dwarf_expr_context *ctx,
 264                               CORE_ADDR value,
 265                               int in_stack_memory);
 266 void dwarf_expr_eval (struct dwarf_expr_context *ctx, const gdb_byte *addr,
 267                       size_t len);
 268 struct value *dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n);
 269 CORE_ADDR dwarf_expr_fetch_address (struct dwarf_expr_context *ctx, int n);
 270 int dwarf_expr_fetch_in_stack_memory (struct dwarf_expr_context *ctx, int n);
 271
 272
 273 const gdb_byte *read_uleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
 274                               ULONGEST * r);
 275 const gdb_byte *read_sleb128 (const gdb_byte *buf, const gdb_byte *buf_end,
 276                               LONGEST * r);
 277
 278 const char *dwarf_stack_op_name (unsigned int);
 279
 280 void dwarf_expr_require_composition (const gdb_byte *, const gdb_byte *,
 281                                      const char *);
 282
 283 /* Stub dwarf_expr_context_funcs implementations.  */
 284
 285 void ctx_no_get_frame_base (void *baton, const gdb_byte **start,
 286                             size_t *length);
 287 CORE_ADDR ctx_no_get_frame_cfa (void *baton);
 288 CORE_ADDR ctx_no_get_frame_pc (void *baton);
 289 CORE_ADDR ctx_no_get_tls_address (void *baton, CORE_ADDR offset);
 290 void ctx_no_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset);
 291 struct type *ctx_no_get_base_type (struct dwarf_expr_context *ctx,
 292                                    cu_offset die);
 293 void ctx_no_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
 294                                         int dwarf_reg, CORE_ADDR fb_offset,
 295                                         int deref_size);
 296
 297 int dwarf_block_to_dwarf_reg (const gdb_byte *buf, const gdb_byte *buf_end);
 298
 299 int dwarf_block_to_dwarf_reg_deref (const gdb_byte *buf,
 300                                     const gdb_byte *buf_end,
 301                                     CORE_ADDR *deref_size_return);
 302
 303 int dwarf_block_to_fb_offset (const gdb_byte *buf, const gdb_byte *buf_end,
 304                               CORE_ADDR *fb_offset_return);
 305
 306 int dwarf_block_to_sp_offset (struct gdbarch *gdbarch, const gdb_byte *buf,
 307                               const gdb_byte *buf_end,
 308                               CORE_ADDR *sp_offset_return);
 309
 310 #endif /* dwarf2expr.h */