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

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

   Copyright (C) 2003-2019 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;
  }

  /* Copy constructor.  */
  dwarf2_frame_state_reg_info (const dwarf2_frame_state_reg_info &src)
    : reg (src.reg), cfa_offset (src.cfa_offset),
      cfa_reg (src.cfa_reg), cfa_how (src.cfa_how), cfa_exp (src.cfa_exp),
      prev (src.prev)
  {
  }

  /* 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 (std::move (rhs.reg)), 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;
  }

  /* If necessary, enlarge the register set to hold NUM_REGS_REQUESTED
     registers.  */
  void alloc_regs (int num_regs_requested)
  {
    gdb_assert (num_regs_requested > 0);

    if (num_regs_requested <= reg.size ())
      return;

    reg.resize (num_regs_requested);
  }

  std::vector<struct dwarf2_frame_state_reg> reg;

  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.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 bool 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
	1	/* Frame unwinder for frames with DWARF Call Frame Information.
	2
	3	Copyright (C) 2003-2019 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	}
	102
	103	/* Copy constructor. */
	104	dwarf2_frame_state_reg_info (const dwarf2_frame_state_reg_info &src)
	105	: reg (src.reg), cfa_offset (src.cfa_offset),
	106	cfa_reg (src.cfa_reg), cfa_how (src.cfa_how), cfa_exp (src.cfa_exp),
	107	prev (src.prev)
	108	{
	109	}
	110
	111	/* Assignment operator for both move-assignment and copy-assignment. */
	112	dwarf2_frame_state_reg_info&
	113	operator= (dwarf2_frame_state_reg_info rhs)
	114	{
	115	swap (*this, rhs);
	116	return *this;
	117	}
	118
	119	/* Move constructor. */
	120	dwarf2_frame_state_reg_info (dwarf2_frame_state_reg_info &&rhs) noexcept
	121	: reg (std::move (rhs.reg)), cfa_offset (rhs.cfa_offset),
	122	cfa_reg (rhs.cfa_reg), cfa_how (rhs.cfa_how), cfa_exp (rhs.cfa_exp),
	123	prev (rhs.prev)
	124	{
	125	rhs.prev = nullptr;
	126	}
	127
	128	/* If necessary, enlarge the register set to hold NUM_REGS_REQUESTED
	129	registers. */
	130	void alloc_regs (int num_regs_requested)
	131	{
	132	gdb_assert (num_regs_requested > 0);
	133
	134	if (num_regs_requested <= reg.size ())
	135	return;
	136
	137	reg.resize (num_regs_requested);
	138	}
	139
	140	std::vector<struct dwarf2_frame_state_reg> reg;
	141
	142	LONGEST cfa_offset = 0;
	143	ULONGEST cfa_reg = 0;
	144	enum cfa_how_kind cfa_how = CFA_UNSET;
	145	const gdb_byte *cfa_exp = NULL;
	146
	147	/* Used to implement DW_CFA_remember_state. */
	148	struct dwarf2_frame_state_reg_info *prev = NULL;
	149
	150	private:
	151	friend void swap (dwarf2_frame_state_reg_info& lhs,
	152	dwarf2_frame_state_reg_info& rhs)
	153	{
	154	using std::swap;
	155
	156	swap (lhs.reg, rhs.reg);
	157	swap (lhs.cfa_offset, rhs.cfa_offset);
	158	swap (lhs.cfa_reg, rhs.cfa_reg);
	159	swap (lhs.cfa_how, rhs.cfa_how);
	160	swap (lhs.cfa_exp, rhs.cfa_exp);
	161	swap (lhs.prev, rhs.prev);
	162	}
	163	};
	164
	165	struct dwarf2_cie;
	166
	167	/* Structure describing a frame state. */
	168
	169	struct dwarf2_frame_state
	170	{
	171	dwarf2_frame_state (CORE_ADDR pc, struct dwarf2_cie *cie);
	172
	173	/* Each register save state can be described in terms of a CFA slot,
	174	another register, or a location expression. */
	175	struct dwarf2_frame_state_reg_info regs {};
	176
	177	/* The PC described by the current frame state. */
	178	CORE_ADDR pc;
	179
	180	/* Initial register set from the CIE.
	181	Used to implement DW_CFA_restore. */
	182	struct dwarf2_frame_state_reg_info initial {};
	183
	184	/* The information we care about from the CIE. */
	185	const LONGEST data_align;
	186	const ULONGEST code_align;
	187	const ULONGEST retaddr_column;
	188
	189	/* Flags for known producer quirks. */
	190
	191	/* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
	192	and DW_CFA_def_cfa_offset takes a factored offset. */
	193	bool armcc_cfa_offsets_sf = false;
	194
	195	/* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
	196	the CFA is defined as REG - OFFSET rather than REG + OFFSET. */
	197	bool armcc_cfa_offsets_reversed = false;
	198	};
	199
	200	/* When this is true the DWARF frame unwinders can be used if they are
	201	registered with the gdbarch. Not all architectures can or do use the
	202	DWARF unwinders. Setting this to true on a target that does not
	203	otherwise support the DWARF unwinders has no effect. */
	204	extern bool dwarf2_frame_unwinders_enabled_p;
	205
	206	/* Set the architecture-specific register state initialization
	207	function for GDBARCH to INIT_REG. */
	208
	209	extern void dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
	210	void (init_reg) (struct gdbarch , int,
	211	struct dwarf2_frame_state_reg *,
	212	struct frame_info *));
	213
	214	/* Set the architecture-specific signal trampoline recognition
	215	function for GDBARCH to SIGNAL_FRAME_P. */
	216
	217	extern void
	218	dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
	219	int (signal_frame_p) (struct gdbarch ,
	220	struct frame_info *));
	221
	222	/* Set the architecture-specific adjustment of .eh_frame and .debug_frame
	223	register numbers. */
	224
	225	extern void
	226	dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
	227	int (adjust_regnum) (struct gdbarch ,
	228	int, int));
	229
	230	/* Append the DWARF-2 frame unwinders to GDBARCH's list. */
	231
	232	void dwarf2_append_unwinders (struct gdbarch *gdbarch);
	233
	234	/* Return the frame base methods for the function that contains PC, or
	235	NULL if it can't be handled by the DWARF CFI frame unwinder. */
	236
	237	extern const struct frame_base *
	238	dwarf2_frame_base_sniffer (struct frame_info *this_frame);
	239
	240	/* Compute the DWARF CFA for a frame. */
	241
	242	CORE_ADDR dwarf2_frame_cfa (struct frame_info *this_frame);
	243
	244	/* Find the CFA information for PC.
	245
	246	Return 1 if a register is used for the CFA, or 0 if another
	247	expression is used. Throw an exception on error.
	248
	249	GDBARCH is the architecture to use.
	250	DATA is the per-CU data.
	251
	252	REGNUM_OUT is an out parameter that is set to the register number.
	253	OFFSET_OUT is the offset to use from this register.
	254	These are only filled in when 1 is returned.
	255
	256	TEXT_OFFSET_OUT, CFA_START_OUT, and CFA_END_OUT describe the CFA
	257	in other cases. These are only used when 0 is returned. */
	258
	259	extern int dwarf2_fetch_cfa_info (struct gdbarch *gdbarch, CORE_ADDR pc,
	260	struct dwarf2_per_cu_data *data,
	261	int regnum_out, LONGEST offset_out,
	262	CORE_ADDR *text_offset_out,
	263	const gdb_byte **cfa_start_out,
	264	const gdb_byte **cfa_end_out);
	265
	266	#endif /* dwarf2-frame.h */