[deliverable/binutils-gdb.git] / gdb / dwarf2-frame.h

/* Frame unwinder for frames with DWARF Call Frame Information.

   Copyright (C) 2003-2018 Free Software Foundation, Inc.

   Contributed by Mark Kettenis.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#ifndef DWARF2_FRAME_H
#define DWARF2_FRAME_H 1

struct gdbarch;
struct objfile;
struct frame_info;
struct dwarf2_per_cu_data;
struct agent_expr;
struct axs_value;

/* Register rule.  */

enum dwarf2_frame_reg_rule
{
  /* Make certain that 0 maps onto the correct enum value; the
     corresponding structure is being initialized using memset zero.
     This indicates that CFI didn't provide any information at all
     about a register, leaving how to obtain its value totally
     unspecified.  */
  DWARF2_FRAME_REG_UNSPECIFIED = 0,

  /* The term "undefined" comes from the DWARF2 CFI spec which this
     code is moddeling; it indicates that the register's value is
     "undefined".  GCC uses the less formal term "unsaved".  Its
     definition is a combination of REG_UNDEFINED and REG_UNSPECIFIED.
     The failure to differentiate the two helps explain a few problems
     with the CFI generated by GCC.  */
  DWARF2_FRAME_REG_UNDEFINED,
  DWARF2_FRAME_REG_SAVED_OFFSET,
  DWARF2_FRAME_REG_SAVED_REG,
  DWARF2_FRAME_REG_SAVED_EXP,
  DWARF2_FRAME_REG_SAME_VALUE,

  /* These are defined in Dwarf3.  */
  DWARF2_FRAME_REG_SAVED_VAL_OFFSET,
  DWARF2_FRAME_REG_SAVED_VAL_EXP,

  /* These aren't defined by the DWARF2 CFI specification, but are
     used internally by GDB.  */
  DWARF2_FRAME_REG_FN,		/* Call a registered function.  */
  DWARF2_FRAME_REG_RA,		/* Return Address.  */
  DWARF2_FRAME_REG_RA_OFFSET,	/* Return Address with offset.  */
  DWARF2_FRAME_REG_CFA,		/* Call Frame Address.  */
  DWARF2_FRAME_REG_CFA_OFFSET	/* Call Frame Address with offset.  */
};

/* Register state.  */

struct dwarf2_frame_state_reg
{
  /* Each register save state can be described in terms of a CFA slot,
     another register, or a location expression.  */
  union {
    LONGEST offset;
    ULONGEST reg;
    struct
    {
      const gdb_byte *start;
      ULONGEST len;
    } exp;
    struct value *(*fn) (struct frame_info *this_frame, void **this_cache,
			 int regnum);
  } loc;
  enum dwarf2_frame_reg_rule how;
};

enum cfa_how_kind
{
  CFA_UNSET,
  CFA_REG_OFFSET,
  CFA_EXP
};

struct dwarf2_frame_state_reg_info
{
  dwarf2_frame_state_reg_info () = default;
  ~dwarf2_frame_state_reg_info ()
  {
    delete prev;
    xfree (reg);
  }

  /* Copy constructor.  */
  dwarf2_frame_state_reg_info (const dwarf2_frame_state_reg_info &src)
    : num_regs (src.num_regs), cfa_offset (src.cfa_offset),
      cfa_reg (src.cfa_reg), cfa_how (src.cfa_how), cfa_exp (src.cfa_exp),
      prev (src.prev)
  {
    size_t size = src.num_regs * sizeof (struct dwarf2_frame_state_reg);

    reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
    memcpy (reg, src.reg, size);
  }

  /* Assignment operator for both move-assignment and copy-assignment.  */
  dwarf2_frame_state_reg_info&
  operator= (dwarf2_frame_state_reg_info rhs)
  {
    swap (*this, rhs);
    return *this;
  }

  /* Move constructor.  */
  dwarf2_frame_state_reg_info (dwarf2_frame_state_reg_info &&rhs) noexcept
    : reg (rhs.reg), num_regs (rhs.num_regs), cfa_offset (rhs.cfa_offset),
      cfa_reg (rhs.cfa_reg), cfa_how (rhs.cfa_how), cfa_exp (rhs.cfa_exp),
      prev (rhs.prev)
  {
    rhs.prev = nullptr;
    rhs.reg = nullptr;
  }

/* Assert that the register set RS is large enough to store gdbarch_num_regs
   columns.  If necessary, enlarge the register set.  */
  void alloc_regs (int num_regs_requested)
  {
    if (num_regs_requested <= num_regs)
      return;

    size_t size = sizeof (struct dwarf2_frame_state_reg);

    reg = (struct dwarf2_frame_state_reg *)
      xrealloc (reg, num_regs_requested * size);

    /* Initialize newly allocated registers.  */
    memset (reg + num_regs, 0, (num_regs_requested - num_regs) * size);
    num_regs = num_regs_requested;
  }

  struct dwarf2_frame_state_reg *reg = NULL;
  int num_regs = 0;

  LONGEST cfa_offset = 0;
  ULONGEST cfa_reg = 0;
  enum cfa_how_kind cfa_how = CFA_UNSET;
  const gdb_byte *cfa_exp = NULL;

  /* Used to implement DW_CFA_remember_state.  */
  struct dwarf2_frame_state_reg_info *prev = NULL;

private:
  friend void swap (dwarf2_frame_state_reg_info& lhs,
		    dwarf2_frame_state_reg_info& rhs)
  {
    using std::swap;

    swap (lhs.reg, rhs.reg);
    swap (lhs.num_regs, rhs.num_regs);
    swap (lhs.cfa_offset, rhs.cfa_offset);
    swap (lhs.cfa_reg, rhs.cfa_reg);
    swap (lhs.cfa_how, rhs.cfa_how);
    swap (lhs.cfa_exp, rhs.cfa_exp);
    swap (lhs.prev, rhs.prev);
  }
};

struct dwarf2_cie;

/* Structure describing a frame state.  */

struct dwarf2_frame_state
{
  dwarf2_frame_state (CORE_ADDR pc, struct dwarf2_cie *cie);

  /* Each register save state can be described in terms of a CFA slot,
     another register, or a location expression.  */
  struct dwarf2_frame_state_reg_info regs {};

  /* The PC described by the current frame state.  */
  CORE_ADDR pc;

  /* Initial register set from the CIE.
     Used to implement DW_CFA_restore.  */
  struct dwarf2_frame_state_reg_info initial {};

  /* The information we care about from the CIE.  */
  const LONGEST data_align;
  const ULONGEST code_align;
  const ULONGEST retaddr_column;

  /* Flags for known producer quirks.  */

  /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
     and DW_CFA_def_cfa_offset takes a factored offset.  */
  bool armcc_cfa_offsets_sf = false;

  /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
     the CFA is defined as REG - OFFSET rather than REG + OFFSET.  */
  bool armcc_cfa_offsets_reversed = false;
};

/* When this is true the DWARF frame unwinders can be used if they are
   registered with the gdbarch.  Not all architectures can or do use the
   DWARF unwinders.  Setting this to true on a target that does not
   otherwise support the DWARF unwinders has no effect.  */
extern int dwarf2_frame_unwinders_enabled_p;

/* Set the architecture-specific register state initialization
   function for GDBARCH to INIT_REG.  */

extern void dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
				       void (*init_reg) (struct gdbarch *, int,
					     struct dwarf2_frame_state_reg *,
					     struct frame_info *));

/* Set the architecture-specific signal trampoline recognition
   function for GDBARCH to SIGNAL_FRAME_P.  */

extern void
  dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
				   int (*signal_frame_p) (struct gdbarch *,
							  struct frame_info *));

/* Set the architecture-specific adjustment of .eh_frame and .debug_frame
   register numbers.  */

extern void
  dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
				  int (*adjust_regnum) (struct gdbarch *,
							int, int));

/* Append the DWARF-2 frame unwinders to GDBARCH's list.  */

void dwarf2_append_unwinders (struct gdbarch *gdbarch);

/* Return the frame base methods for the function that contains PC, or
   NULL if it can't be handled by the DWARF CFI frame unwinder.  */

extern const struct frame_base *
  dwarf2_frame_base_sniffer (struct frame_info *this_frame);

/* Compute the DWARF CFA for a frame.  */

CORE_ADDR dwarf2_frame_cfa (struct frame_info *this_frame);

/* Find the CFA information for PC.

   Return 1 if a register is used for the CFA, or 0 if another
   expression is used.  Throw an exception on error.

   GDBARCH is the architecture to use.
   DATA is the per-CU data.

   REGNUM_OUT is an out parameter that is set to the register number.
   OFFSET_OUT is the offset to use from this register.
   These are only filled in when 1 is returned.

   TEXT_OFFSET_OUT, CFA_START_OUT, and CFA_END_OUT describe the CFA
   in other cases.  These are only used when 0 is returned.  */

extern int dwarf2_fetch_cfa_info (struct gdbarch *gdbarch, CORE_ADDR pc,
				  struct dwarf2_per_cu_data *data,
				  int *regnum_out, LONGEST *offset_out,
				  CORE_ADDR *text_offset_out,
				  const gdb_byte **cfa_start_out,
				  const gdb_byte **cfa_end_out);

#endif /* dwarf2-frame.h */
Commit	Line	Data
cfc14b3a MK	1	/* Frame unwinder for frames with DWARF Call Frame Information.
cfc14b3a MK	2
e2882c85	3	Copyright (C) 2003-2018 Free Software Foundation, Inc.
cfc14b3a MK	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
a9762ec7	11	the Free Software Foundation; either version 3 of the License, or
cfc14b3a MK	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
a9762ec7	20	along with this program. If not, see <http://www.gnu.org/licenses/>. */
cfc14b3a MK	21
	22	#ifndef DWARF2_FRAME_H
	23	#define DWARF2_FRAME_H 1
	24
ecc9ac84	25	struct gdbarch;
cfc14b3a	26	struct objfile;
e6e5e94c	27	struct frame_info;
9f6f94ff TT	28	struct dwarf2_per_cu_data;
	29	struct agent_expr;
	30	struct axs_value;
cfc14b3a	31
05cbe71a MK	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
46ea248b AO	55	/* These are defined in Dwarf3. */
	56	DWARF2_FRAME_REG_SAVED_VAL_OFFSET,
	57	DWARF2_FRAME_REG_SAVED_VAL_EXP,
	58
05cbe71a MK	59	/* These aren't defined by the DWARF2 CFI specification, but are
05cbe71a MK	60	used internally by GDB. */
b39cc962	61	DWARF2_FRAME_REG_FN, /* Call a registered function. */
05cbe71a	62	DWARF2_FRAME_REG_RA, /* Return Address. */
8d5a9abc	63	DWARF2_FRAME_REG_RA_OFFSET, /* Return Address with offset. */
ea7963f0 FR	64	DWARF2_FRAME_REG_CFA, /* Call Frame Address. */
ea7963f0 FR	65	DWARF2_FRAME_REG_CFA_OFFSET /* Call Frame Address with offset. */
05cbe71a MK	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;
b348037f YQ	77	struct
	78	{
	79	const gdb_byte *start;
	80	ULONGEST len;
	81	} exp;
b39cc962 DJ	82	struct value (fn) (struct frame_info this_frame, void *this_cache,
b39cc962 DJ	83	int regnum);
05cbe71a	84	} loc;
05cbe71a MK	85	enum dwarf2_frame_reg_rule how;
	86	};
	87
b41c5a85 JW	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	{
1c90d9f0 YQ	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	}
b41c5a85	133
1c90d9f0 YQ	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;
b41c5a85 JW	158
b41c5a85 JW	159	/* Used to implement DW_CFA_remember_state. */
1c90d9f0 YQ	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	}
b41c5a85 JW	176	};
b41c5a85 JW	177
afe37d6b YQ	178	struct dwarf2_cie;
afe37d6b YQ	179
b41c5a85 JW	180	/* Structure describing a frame state. */
	181
	182	struct dwarf2_frame_state
	183	{
afe37d6b	184	dwarf2_frame_state (CORE_ADDR pc, struct dwarf2_cie *cie);
afe37d6b	185
b41c5a85 JW	186	/* Each register save state can be described in terms of a CFA slot,
b41c5a85 JW	187	another register, or a location expression. */
afe37d6b	188	struct dwarf2_frame_state_reg_info regs {};
b41c5a85 JW	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. */
afe37d6b	195	struct dwarf2_frame_state_reg_info initial {};
b41c5a85 JW	196
b41c5a85 JW	197	/* The information we care about from the CIE. */
afe37d6b YQ	198	const LONGEST data_align;
	199	const ULONGEST code_align;
	200	const ULONGEST retaddr_column;
b41c5a85 JW	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. */
afe37d6b	206	bool armcc_cfa_offsets_sf = false;
b41c5a85 JW	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. */
afe37d6b	210	bool armcc_cfa_offsets_reversed = false;
b41c5a85 JW	211	};
b41c5a85 JW	212
3c3bb058 AB	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
8f22cb90 MK	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,
aff37fc1 DM	224	struct dwarf2_frame_state_reg *,
aff37fc1 DM	225	struct frame_info *));
8f22cb90	226
3ed09a32 DJ	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
4fc771b8 DJ	235	/* Set the architecture-specific adjustment of .eh_frame and .debug_frame
4fc771b8 DJ	236	register numbers. */
4bf8967c AS	237
4bf8967c AS	238	extern void
4fc771b8 DJ	239	dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
	240	int (adjust_regnum) (struct gdbarch ,
	241	int, int));
4bf8967c	242
4a4e5149	243	/* Append the DWARF-2 frame unwinders to GDBARCH's list. */
cfc14b3a	244
4a4e5149	245	void dwarf2_append_unwinders (struct gdbarch *gdbarch);
cfc14b3a MK	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
05cbe71a	250	extern const struct frame_base *
4a4e5149	251	dwarf2_frame_base_sniffer (struct frame_info *this_frame);
cfc14b3a	252
e7802207 TT	253	/* Compute the DWARF CFA for a frame. */
	254
	255	CORE_ADDR dwarf2_frame_cfa (struct frame_info *this_frame);
	256
a8fd5589 TT	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);
9f6f94ff	278
cfc14b3a	279	#endif /* dwarf2-frame.h */