xref: /illumos-gate/usr/src/lib/libc/amd64/unwind/unwind_context.h (revision 1da57d55)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Public interface for AMD64 Unwind context
 */

#ifndef _UNWIND_CONTEXT_H
#define	_UNWIND_CONTEXT_H

/*
 * implementation of context structure
 *
 * Register arrays are indexed as specified in reg_num.h
 */
struct _Unwind_Context {
	uint64_t	entry_regs[16];
	uint64_t	current_regs[16];
	uint64_t	cfa;
	uint64_t	pc;
	uint64_t	ra;
	void		*fde;
	_Unwind_Personality_Fn	pfn;
	uint64_t	func;
	void		*lsda;
	uint64_t	range;
};

enum register_rule {
	undefined_rule,
	same_value_rule,	/* target_reg = target_reg */
	offset_rule,		/* target_reg = *(offset + CFA) */
	is_offset_rule,		/* target_reg = offset + CFA */
	register_rule,		/* target_reg = offset + source_reg */
	constant_rule,		/* target_reg = offset */
	indirect_rule		/* target_reg = *(offset + source_reg) */
};

struct register_state {
	uint64_t	offset;
	enum register_rule	rule;
	unsigned char	source_reg;
};

struct eh_frame_fields {
	void		*cie_ops;
	void		*cie_ops_end;
	ptrdiff_t	cie_reloc;
	int		code_align;
	int		data_align;
	int		code_enc;
	void		*fde_ops;
	void		*fde_ops_end;
	ptrdiff_t	fde_reloc;
};

_Unwind_Reason_Code
_Unw_very_boring_personality(int version, int actions, uint64_t exclass,
		struct _Unwind_Exception *exception_object,
		struct _Unwind_Context *ctx);
/*
 * Starting withe an initialized context (from a ucontext)
 * the following routines are sufficient to implement a non-destructive
 * stack walk if modified to access the target processes memory. These
 * routines refer to the local address of an item using names containing
 * `data' names containing `reloc' give the correction to get target
 * process location.
 */

/* ================== find function ====================== */

/*
 * Computes the func and fde fields using pc as the lookup key.
 * Return is 0 or address of fde
 *
 * This is the only function that look into .eh_frame_hdr
 */
void *_Unw_EhfhLookup(struct _Unwind_Context *ctx);

/* =================== analyze function ================== */

/*
 * Fills in personality_fn and lsda fields of the context based
 * the fde entry which must be valid and also partially unpacks
 * fde and cie into *f
 *
 * This is one of two functions that look inside fde's
 */
struct eh_frame_fields *_Unw_Decode_FDE(struct eh_frame_fields *f,
		struct _Unwind_Context *ctx);

/*
 * Computes register values at entry to function based on current
 * register values, pc and fde values in a context
 *
 * This is the other function which looks inside fde's and
 * the only one to look at CFA operations
 *
 * If 'f' is NULL (because no fde was found), a default calculation
 * assuming an FP is done.
 */
uint64_t _Unw_Rollback_Registers(struct eh_frame_fields *f,
		struct _Unwind_Context *ctx);

/* ================= register propagation =============== */

/*
 * Fills in the current register context for the caller
 * based on computed at-entry state of callee
 */
void
_Unw_Propagate_Registers(struct _Unwind_Context *old_ctx,
		struct _Unwind_Context *new_ctx);

/* ================================================= */
enum operand_desc {
	NO_OPR,
	ULEB128_FAC,
	ULEB128,
	ULEB128_SREG,
	SLEB128,
	SLEB128_FAC,
	ADDR,
	SIZE,
	ZTSTRING,
	UNUM6,
	UNUM6_CFAC,
	UNUM8,
	UNUM8_CFAC,
	UNUM16,
	UNUM16_CFAC,
	UNUM32,
	UNUM32_CFAC,
	UNUM64,
	SNUM8,
	SNUM16,
	SNUM32,
	SNUM64,
	BLOCK
};

uint64_t _Unw_get_val(void **datap, ptrdiff_t reloc,
		enum operand_desc opr,
		int daf, int caf, int enc);

#endif	/* _UNWIND_CONTEXT_H */