gdb/dwarf2-frame.h

   1 /* Frame unwinder for frames with DWARF Call Frame Information.
   2
   3    Copyright (C) 2003-2018 Free Software Foundation, Inc.
   4
   5    Contributed by Mark Kettenis.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #ifndef DWARF2_FRAME_H
  23 #define DWARF2_FRAME_H 1
  24
  25 struct gdbarch;
  26 struct objfile;
  27 struct frame_info;
  28 struct dwarf2_per_cu_data;
  29 struct agent_expr;
  30 struct axs_value;
  31
  32 /* Register rule.  */
  33
  34 enum dwarf2_frame_reg_rule
  35 {
  36   /* Make certain that 0 maps onto the correct enum value; the
  37      corresponding structure is being initialized using memset zero.
  38      This indicates that CFI didn't provide any information at all
  39      about a register, leaving how to obtain its value totally
  40      unspecified.  */
  41   DWARF2_FRAME_REG_UNSPECIFIED = 0,
  42
  43   /* The term "undefined" comes from the DWARF2 CFI spec which this
  44      code is moddeling; it indicates that the register's value is
  45      "undefined".  GCC uses the less formal term "unsaved".  Its
  46      definition is a combination of REG_UNDEFINED and REG_UNSPECIFIED.
  47      The failure to differentiate the two helps explain a few problems
  48      with the CFI generated by GCC.  */
  49   DWARF2_FRAME_REG_UNDEFINED,
  50   DWARF2_FRAME_REG_SAVED_OFFSET,
  51   DWARF2_FRAME_REG_SAVED_REG,
  52   DWARF2_FRAME_REG_SAVED_EXP,
  53   DWARF2_FRAME_REG_SAME_VALUE,
  54
  55   /* These are defined in Dwarf3.  */
  56   DWARF2_FRAME_REG_SAVED_VAL_OFFSET,
  57   DWARF2_FRAME_REG_SAVED_VAL_EXP,
  58
  59   /* These aren't defined by the DWARF2 CFI specification, but are
  60      used internally by GDB.  */
  61   DWARF2_FRAME_REG_FN,          /* Call a registered function.  */
  62   DWARF2_FRAME_REG_RA,          /* Return Address.  */
  63   DWARF2_FRAME_REG_RA_OFFSET,   /* Return Address with offset.  */
  64   DWARF2_FRAME_REG_CFA,         /* Call Frame Address.  */
  65   DWARF2_FRAME_REG_CFA_OFFSET   /* Call Frame Address with offset.  */
  66 };
  67
  68 /* Register state.  */
  69
  70 struct dwarf2_frame_state_reg
  71 {
  72   /* Each register save state can be described in terms of a CFA slot,
  73      another register, or a location expression.  */
  74   union {
  75     LONGEST offset;
  76     ULONGEST reg;
  77     struct
  78     {
  79       const gdb_byte *start;
  80       ULONGEST len;
  81     } exp;
  82     struct value *(*fn) (struct frame_info *this_frame, void **this_cache,
  83                          int regnum);
  84   } loc;
  85   enum dwarf2_frame_reg_rule how;
  86 };
  87
  88 enum cfa_how_kind
  89 {
  90   CFA_UNSET,
  91   CFA_REG_OFFSET,
  92   CFA_EXP
  93 };
  94
  95 struct dwarf2_frame_state_reg_info
  96 {
  97   dwarf2_frame_state_reg_info () = default;
  98   ~dwarf2_frame_state_reg_info ()
  99   {
 100     delete prev;
 101     xfree (reg);
 102   }
 103
 104   /* Copy constructor.  */
 105   dwarf2_frame_state_reg_info (const dwarf2_frame_state_reg_info &src)
 106     : num_regs (src.num_regs), cfa_offset (src.cfa_offset),
 107       cfa_reg (src.cfa_reg), cfa_how (src.cfa_how), cfa_exp (src.cfa_exp),
 108       prev (src.prev)
 109   {
 110     size_t size = src.num_regs * sizeof (struct dwarf2_frame_state_reg);
 111
 112     reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
 113     memcpy (reg, src.reg, size);
 114   }
 115
 116   /* Assignment operator for both move-assignment and copy-assignment.  */
 117   dwarf2_frame_state_reg_info&
 118   operator= (dwarf2_frame_state_reg_info rhs)
 119   {
 120     swap (*this, rhs);
 121     return *this;
 122   }
 123
 124   /* Move constructor.  */
 125   dwarf2_frame_state_reg_info (dwarf2_frame_state_reg_info &&rhs) noexcept
 126     : reg (rhs.reg), num_regs (rhs.num_regs), cfa_offset (rhs.cfa_offset),
 127       cfa_reg (rhs.cfa_reg), cfa_how (rhs.cfa_how), cfa_exp (rhs.cfa_exp),
 128       prev (rhs.prev)
 129   {
 130     rhs.prev = nullptr;
 131     rhs.reg = nullptr;
 132   }
 133
 134 /* Assert that the register set RS is large enough to store gdbarch_num_regs
 135    columns.  If necessary, enlarge the register set.  */
 136   void alloc_regs (int num_regs_requested)
 137   {
 138     if (num_regs_requested <= num_regs)
 139       return;
 140
 141     size_t size = sizeof (struct dwarf2_frame_state_reg);
 142
 143     reg = (struct dwarf2_frame_state_reg *)
 144       xrealloc (reg, num_regs_requested * size);
 145
 146     /* Initialize newly allocated registers.  */
 147     memset (reg + num_regs, 0, (num_regs_requested - num_regs) * size);
 148     num_regs = num_regs_requested;
 149   }
 150
 151   struct dwarf2_frame_state_reg *reg = NULL;
 152   int num_regs = 0;
 153
 154   LONGEST cfa_offset = 0;
 155   ULONGEST cfa_reg = 0;
 156   enum cfa_how_kind cfa_how = CFA_UNSET;
 157   const gdb_byte *cfa_exp = NULL;
 158
 159   /* Used to implement DW_CFA_remember_state.  */
 160   struct dwarf2_frame_state_reg_info *prev = NULL;
 161
 162 private:
 163   friend void swap (dwarf2_frame_state_reg_info& lhs,
 164                     dwarf2_frame_state_reg_info& rhs)
 165   {
 166     using std::swap;
 167
 168     swap (lhs.reg, rhs.reg);
 169     swap (lhs.num_regs, rhs.num_regs);
 170     swap (lhs.cfa_offset, rhs.cfa_offset);
 171     swap (lhs.cfa_reg, rhs.cfa_reg);
 172     swap (lhs.cfa_how, rhs.cfa_how);
 173     swap (lhs.cfa_exp, rhs.cfa_exp);
 174     swap (lhs.prev, rhs.prev);
 175   }
 176 };
 177
 178 struct dwarf2_cie;
 179
 180 /* Structure describing a frame state.  */
 181
 182 struct dwarf2_frame_state
 183 {
 184   dwarf2_frame_state (CORE_ADDR pc, struct dwarf2_cie *cie);
 185
 186   /* Each register save state can be described in terms of a CFA slot,
 187      another register, or a location expression.  */
 188   struct dwarf2_frame_state_reg_info regs {};
 189
 190   /* The PC described by the current frame state.  */
 191   CORE_ADDR pc;
 192
 193   /* Initial register set from the CIE.
 194      Used to implement DW_CFA_restore.  */
 195   struct dwarf2_frame_state_reg_info initial {};
 196
 197   /* The information we care about from the CIE.  */
 198   const LONGEST data_align;
 199   const ULONGEST code_align;
 200   const ULONGEST retaddr_column;
 201
 202   /* Flags for known producer quirks.  */
 203
 204   /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
 205      and DW_CFA_def_cfa_offset takes a factored offset.  */
 206   bool armcc_cfa_offsets_sf = false;
 207
 208   /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
 209      the CFA is defined as REG - OFFSET rather than REG + OFFSET.  */
 210   bool armcc_cfa_offsets_reversed = false;
 211 };
 212
 213 /* When this is true the DWARF frame unwinders can be used if they are
 214    registered with the gdbarch.  Not all architectures can or do use the
 215    DWARF unwinders.  Setting this to true on a target that does not
 216    otherwise support the DWARF unwinders has no effect.  */
 217 extern int dwarf2_frame_unwinders_enabled_p;
 218
 219 /* Set the architecture-specific register state initialization
 220    function for GDBARCH to INIT_REG.  */
 221
 222 extern void dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
 223                                        void (*init_reg) (struct gdbarch *, int,
 224                                              struct dwarf2_frame_state_reg *,
 225                                              struct frame_info *));
 226
 227 /* Set the architecture-specific signal trampoline recognition
 228    function for GDBARCH to SIGNAL_FRAME_P.  */
 229
 230 extern void
 231   dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
 232                                    int (*signal_frame_p) (struct gdbarch *,
 233                                                           struct frame_info *));
 234
 235 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
 236    register numbers.  */
 237
 238 extern void
 239   dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
 240                                   int (*adjust_regnum) (struct gdbarch *,
 241                                                         int, int));
 242
 243 /* Append the DWARF-2 frame unwinders to GDBARCH's list.  */
 244
 245 void dwarf2_append_unwinders (struct gdbarch *gdbarch);
 246
 247 /* Return the frame base methods for the function that contains PC, or
 248    NULL if it can't be handled by the DWARF CFI frame unwinder.  */
 249
 250 extern const struct frame_base *
 251   dwarf2_frame_base_sniffer (struct frame_info *this_frame);
 252
 253 /* Compute the DWARF CFA for a frame.  */
 254
 255 CORE_ADDR dwarf2_frame_cfa (struct frame_info *this_frame);
 256
 257 /* Find the CFA information for PC.
 258
 259    Return 1 if a register is used for the CFA, or 0 if another
 260    expression is used.  Throw an exception on error.
 261
 262    GDBARCH is the architecture to use.
 263    DATA is the per-CU data.
 264
 265    REGNUM_OUT is an out parameter that is set to the register number.
 266    OFFSET_OUT is the offset to use from this register.
 267    These are only filled in when 1 is returned.
 268
 269    TEXT_OFFSET_OUT, CFA_START_OUT, and CFA_END_OUT describe the CFA
 270    in other cases.  These are only used when 0 is returned.  */
 271
 272 extern int dwarf2_fetch_cfa_info (struct gdbarch *gdbarch, CORE_ADDR pc,
 273                                   struct dwarf2_per_cu_data *data,
 274                                   int *regnum_out, LONGEST *offset_out,
 275                                   CORE_ADDR *text_offset_out,
 276                                   const gdb_byte **cfa_start_out,
 277                                   const gdb_byte **cfa_end_out);
 278
 279 #endif /* dwarf2-frame.h */