gdb/dwarf2/loc.h

   1 /* DWARF 2 location expression support for GDB.
   2
   3    Copyright (C) 2003-2020 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #if !defined (DWARF2LOC_H)
  21 #define DWARF2LOC_H
  22
  23 #include "dwarf2/expr.h"
  24
  25 struct symbol_computed_ops;
  26 struct objfile;
  27 struct dwarf2_per_cu_data;
  28 struct dwarf2_loclist_baton;
  29 struct agent_expr;
  30 struct axs_value;
  31
  32 /* This header is private to the DWARF-2 reader.  It is shared between
  33    dwarf2read.c and dwarf2loc.c.  */
  34
  35 /* `set debug entry-values' setting.  */
  36 extern unsigned int entry_values_debug;
  37
  38 /* Find a particular location expression from a location list.  */
  39 const gdb_byte *dwarf2_find_location_expression
  40   (struct dwarf2_loclist_baton *baton,
  41    size_t *locexpr_length,
  42    CORE_ADDR pc);
  43
  44 /* Find the frame base information for FRAMEFUNC at PC.  START is an
  45    out parameter which is set to point to the DWARF expression to
  46    compute.  LENGTH is an out parameter which is set to the length of
  47    the DWARF expression.  This throws an exception on error or if an
  48    expression is not found; the returned length will never be
  49    zero.  */
  50
  51 extern void func_get_frame_base_dwarf_block (struct symbol *framefunc,
  52                                              CORE_ADDR pc,
  53                                              const gdb_byte **start,
  54                                              size_t *length);
  55
  56 /* Evaluate a location description, starting at DATA and with length
  57    SIZE, to find the current location of variable of TYPE in the context
  58    of FRAME.  */
  59
  60 struct value *dwarf2_evaluate_loc_desc (struct type *type,
  61                                         struct frame_info *frame,
  62                                         const gdb_byte *data,
  63                                         size_t size,
  64                                         struct dwarf2_per_cu_data *per_cu);
  65
  66 /* A chain of addresses that might be needed to resolve a dynamic
  67    property.  */
  68
  69 struct property_addr_info
  70 {
  71   /* The type of the object whose dynamic properties, if any, are
  72      being resolved.  */
  73   struct type *type;
  74
  75   /* If not NULL, a buffer containing the object's value.  */
  76   const gdb_byte *valaddr;
  77
  78   /* The address of that object.  */
  79   CORE_ADDR addr;
  80
  81   /* If not NULL, a pointer to the info for the object containing
  82      the object described by this node.  */
  83   struct property_addr_info *next;
  84 };
  85
  86 /* Converts a dynamic property into a static one.  FRAME is the frame in which
  87    the property is evaluated; if NULL, the selected frame (if any) is used
  88    instead.
  89
  90    ADDR_STACK is the stack of addresses that might be needed to evaluate the
  91    property. When evaluating a property that is not related to a type, it can
  92    be NULL.
  93
  94    Returns true if PROP could be converted and the static value is passed
  95    back into VALUE, otherwise returns false.  */
  96
  97 bool dwarf2_evaluate_property (const struct dynamic_prop *prop,
  98                                struct frame_info *frame,
  99                                struct property_addr_info *addr_stack,
 100                                CORE_ADDR *value);
 101
 102 /* A helper for the compiler interface that compiles a single dynamic
 103    property to C code.
 104
 105    STREAM is where the C code is to be written.
 106    RESULT_NAME is the name of the generated variable.
 107    GDBARCH is the architecture to use.
 108    REGISTERS_USED is a bit-vector that is filled to note which
 109    registers are required by the generated expression.
 110    PROP is the property for which code is generated.
 111    ADDRESS is the address at which the property is considered to be
 112    evaluated.
 113    SYM the originating symbol, used for error reporting.  */
 114
 115 void dwarf2_compile_property_to_c (string_file *stream,
 116                                    const char *result_name,
 117                                    struct gdbarch *gdbarch,
 118                                    unsigned char *registers_used,
 119                                    const struct dynamic_prop *prop,
 120                                    CORE_ADDR address,
 121                                    struct symbol *sym);
 122
 123 /* The symbol location baton types used by the DWARF-2 reader (i.e.
 124    SYMBOL_LOCATION_BATON for a LOC_COMPUTED symbol).  "struct
 125    dwarf2_locexpr_baton" is for a symbol with a single location
 126    expression; "struct dwarf2_loclist_baton" is for a symbol with a
 127    location list.  */
 128
 129 struct dwarf2_locexpr_baton
 130 {
 131   /* Pointer to the start of the location expression.  Valid only if SIZE is
 132      not zero.  */
 133   const gdb_byte *data;
 134
 135   /* Length of the location expression.  For optimized out expressions it is
 136      zero.  */
 137   size_t size;
 138
 139   /* When true this location expression is a reference and actually
 140      describes the address at which the value of the attribute can be
 141      found.  When false the expression provides the value of the attribute
 142      directly.  */
 143   bool is_reference;
 144
 145   /* The compilation unit containing the symbol whose location
 146      we're computing.  */
 147   struct dwarf2_per_cu_data *per_cu;
 148 };
 149
 150 struct dwarf2_loclist_baton
 151 {
 152   /* The initial base address for the location list, based on the compilation
 153      unit.  */
 154   CORE_ADDR base_address;
 155
 156   /* Pointer to the start of the location list.  */
 157   const gdb_byte *data;
 158
 159   /* Length of the location list.  */
 160   size_t size;
 161
 162   /* The compilation unit containing the symbol whose location
 163      we're computing.  */
 164   struct dwarf2_per_cu_data *per_cu;
 165
 166   /* Non-zero if the location list lives in .debug_loc.dwo.
 167      The format of entries in this section are different.  */
 168   unsigned char from_dwo;
 169 };
 170
 171 /* The baton used when a dynamic property is an offset to a parent
 172    type.  This can be used, for instance, then the bound of an array
 173    inside a record is determined by the value of another field inside
 174    that record.  */
 175
 176 struct dwarf2_offset_baton
 177 {
 178   /* The offset from the parent type where the value of the property
 179      is stored.  In the example provided above, this would be the offset
 180      of the field being used as the array bound.  */
 181   LONGEST offset;
 182
 183   /* The type of the object whose property is dynamic.  In the example
 184      provided above, this would the array's index type.  */
 185   struct type *type;
 186 };
 187
 188 /* A dynamic property is either expressed as a single location expression
 189    or a location list.  If the property is an indirection, pointing to
 190    another die, keep track of the targeted type in PROPERTY_TYPE.
 191    Alternatively, if the property location gives the property value
 192    directly then it will have PROPERTY_TYPE.  */
 193
 194 struct dwarf2_property_baton
 195 {
 196   /* If the property is an indirection, we need to evaluate the location
 197      in the context of the type PROPERTY_TYPE.  If the property is supplied
 198      by value then it will be of PROPERTY_TYPE.  This field should never be
 199      NULL.  */
 200   struct type *property_type;
 201   union
 202   {
 203     /* Location expression either evaluated in the context of
 204        PROPERTY_TYPE, or a value of type PROPERTY_TYPE.  */
 205     struct dwarf2_locexpr_baton locexpr;
 206
 207     /* Location list to be evaluated in the context of PROPERTY_TYPE.  */
 208     struct dwarf2_loclist_baton loclist;
 209
 210     /* The location is an offset to PROPERTY_TYPE.  */
 211     struct dwarf2_offset_baton offset_info;
 212   };
 213 };
 214
 215 extern const struct symbol_computed_ops dwarf2_locexpr_funcs;
 216 extern const struct symbol_computed_ops dwarf2_loclist_funcs;
 217
 218 extern const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs;
 219 extern const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs;
 220
 221 /* Determined tail calls for constructing virtual tail call frames.  */
 222
 223 struct call_site_chain
 224   {
 225     /* Initially CALLERS == CALLEES == LENGTH.  For partially ambiguous result
 226        CALLERS + CALLEES < LENGTH.  */
 227     int callers, callees, length;
 228
 229     /* Variably sized array with LENGTH elements.  Later [0..CALLERS-1] contain
 230        top (GDB "prev") sites and [LENGTH-CALLEES..LENGTH-1] contain bottom
 231        (GDB "next") sites.  One is interested primarily in the PC field.  */
 232     struct call_site *call_site[1];
 233   };
 234
 235 struct call_site_stuff;
 236 extern gdb::unique_xmalloc_ptr<call_site_chain> call_site_find_chain
 237   (struct gdbarch *gdbarch, CORE_ADDR caller_pc, CORE_ADDR callee_pc);
 238
 239 /* A helper function to convert a DWARF register to an arch register.
 240    ARCH is the architecture.
 241    DWARF_REG is the register.
 242    If DWARF_REG is bad then a complaint is issued and -1 is returned.
 243    Note: Some targets get this wrong.  */
 244
 245 extern int dwarf_reg_to_regnum (struct gdbarch *arch, int dwarf_reg);
 246
 247 /* A wrapper on dwarf_reg_to_regnum to throw an exception if the
 248    DWARF register cannot be translated to an architecture register.
 249    This takes a ULONGEST instead of an int because some callers actually have
 250    a ULONGEST.  Negative values passed as ints will still be flagged as
 251    invalid.  */
 252
 253 extern int dwarf_reg_to_regnum_or_error (struct gdbarch *arch,
 254                                          ULONGEST dwarf_reg);
 255
 256 #endif /* dwarf2loc.h */