[deliverable/linux.git] / arch / parisc / kernel / unwind.c

/*
 * Kernel unwinding support
 *
 * (c) 2002-2004 Randolph Chung <tausq@debian.org>
 *
 * Derived partially from the IA64 implementation. The PA-RISC
 * Runtime Architecture Document is also a useful reference to
 * understand what is happening here
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/kallsyms.h>
#include <linux/sort.h>

#include <asm/uaccess.h>
#include <asm/assembly.h>
#include <asm/asm-offsets.h>
#include <asm/ptrace.h>

#include <asm/unwind.h>

/* #define DEBUG 1 */
#ifdef DEBUG
#define dbg(x...) printk(x)
#else
#define dbg(x...)
#endif

#define KERNEL_START (KERNEL_BINARY_TEXT_START)

extern struct unwind_table_entry __start___unwind[];
extern struct unwind_table_entry __stop___unwind[];

static spinlock_t unwind_lock;
/*
 * the kernel unwind block is not dynamically allocated so that
 * we can call unwind_init as early in the bootup process as 
 * possible (before the slab allocator is initialized)
 */
static struct unwind_table kernel_unwind_table __read_mostly;
static LIST_HEAD(unwind_tables);

static inline const struct unwind_table_entry *
find_unwind_entry_in_table(const struct unwind_table *table, unsigned long addr)
{
	const struct unwind_table_entry *e = NULL;
	unsigned long lo, hi, mid;

	lo = 0; 
	hi = table->length - 1; 
	
	while (lo <= hi) {
		mid = (hi - lo) / 2 + lo;
		e = &table->table[mid];
		if (addr < e->region_start)
			hi = mid - 1;
		else if (addr > e->region_end)
			lo = mid + 1;
		else
			return e;
	}

	return NULL;
}

static const struct unwind_table_entry *
find_unwind_entry(unsigned long addr)
{
	struct unwind_table *table;
	const struct unwind_table_entry *e = NULL;

	if (addr >= kernel_unwind_table.start && 
	    addr <= kernel_unwind_table.end)
		e = find_unwind_entry_in_table(&kernel_unwind_table, addr);
	else 
		list_for_each_entry(table, &unwind_tables, list) {
			if (addr >= table->start && 
			    addr <= table->end)
				e = find_unwind_entry_in_table(table, addr);
			if (e)
				break;
		}

	return e;
}

static void
unwind_table_init(struct unwind_table *table, const char *name,
		  unsigned long base_addr, unsigned long gp,
		  void *table_start, void *table_end)
{
	struct unwind_table_entry *start = table_start;
	struct unwind_table_entry *end = 
		(struct unwind_table_entry *)table_end - 1;

	table->name = name;
	table->base_addr = base_addr;
	table->gp = gp;
	table->start = base_addr + start->region_start;
	table->end = base_addr + end->region_end;
	table->table = (struct unwind_table_entry *)table_start;
	table->length = end - start + 1;
	INIT_LIST_HEAD(&table->list);

	for (; start <= end; start++) {
		if (start < end && 
		    start->region_end > (start+1)->region_start) {
			printk("WARNING: Out of order unwind entry! %p and %p\n", start, start+1);
		}

		start->region_start += base_addr;
		start->region_end += base_addr;
	}
}

static int cmp_unwind_table_entry(const void *a, const void *b)
{
	return ((const struct unwind_table_entry *)a)->region_start
	     - ((const struct unwind_table_entry *)b)->region_start;
}

static void
unwind_table_sort(struct unwind_table_entry *start,
		  struct unwind_table_entry *finish)
{
	sort(start, finish - start, sizeof(struct unwind_table_entry),
	     cmp_unwind_table_entry, NULL);
}

struct unwind_table *
unwind_table_add(const char *name, unsigned long base_addr, 
		 unsigned long gp,
                 void *start, void *end)
{
	struct unwind_table *table;
	unsigned long flags;
	struct unwind_table_entry *s = (struct unwind_table_entry *)start;
	struct unwind_table_entry *e = (struct unwind_table_entry *)end;

	unwind_table_sort(s, e);

	table = kmalloc(sizeof(struct unwind_table), GFP_USER);
	if (table == NULL)
		return NULL;
	unwind_table_init(table, name, base_addr, gp, start, end);
	spin_lock_irqsave(&unwind_lock, flags);
	list_add_tail(&table->list, &unwind_tables);
	spin_unlock_irqrestore(&unwind_lock, flags);

	return table;
}

void unwind_table_remove(struct unwind_table *table)
{
	unsigned long flags;

	spin_lock_irqsave(&unwind_lock, flags);
	list_del(&table->list);
	spin_unlock_irqrestore(&unwind_lock, flags);

	kfree(table);
}

/* Called from setup_arch to import the kernel unwind info */
int unwind_init(void)
{
	long start, stop;
	register unsigned long gp __asm__ ("r27");

	start = (long)&__start___unwind[0];
	stop = (long)&__stop___unwind[0];

	spin_lock_init(&unwind_lock);

	printk("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n", 
	    start, stop,
	    (stop - start) / sizeof(struct unwind_table_entry));

	unwind_table_init(&kernel_unwind_table, "kernel", KERNEL_START,
			  gp, 
			  &__start___unwind[0], &__stop___unwind[0]);
#if 0
	{
		int i;
		for (i = 0; i < 10; i++)
		{
			printk("region 0x%x-0x%x\n", 
				__start___unwind[i].region_start, 
				__start___unwind[i].region_end);
		}
	}
#endif
	return 0;
}

#ifdef CONFIG_64BIT
#define get_func_addr(fptr) fptr[2]
#else
#define get_func_addr(fptr) fptr[0]
#endif

static int unwind_special(struct unwind_frame_info *info, unsigned long pc, int frame_size)
{
	extern void handle_interruption(int, struct pt_regs *);
	static unsigned long *hi = (unsigned long *)&handle_interruption;

	if (pc == get_func_addr(hi)) {
		struct pt_regs *regs = (struct pt_regs *)(info->sp - frame_size - PT_SZ_ALGN);
		dbg("Unwinding through handle_interruption()\n");
		info->prev_sp = regs->gr[30];
		info->prev_ip = regs->iaoq[0];

		return 1;
	}

	return 0;
}

static void unwind_frame_regs(struct unwind_frame_info *info)
{
	const struct unwind_table_entry *e;
	unsigned long npc;
	unsigned int insn;
	long frame_size = 0;
	int looking_for_rp, rpoffset = 0;

	e = find_unwind_entry(info->ip);
	if (e == NULL) {
		unsigned long sp;
		extern char _stext[], _etext[];

		dbg("Cannot find unwind entry for 0x%lx; forced unwinding\n", info->ip);

#ifdef CONFIG_KALLSYMS
		/* Handle some frequent special cases.... */
		{
			char symname[KSYM_NAME_LEN];
			char *modname;

			kallsyms_lookup(info->ip, NULL, NULL, &modname,
				symname);

			dbg("info->ip = 0x%lx, name = %s\n", info->ip, symname);

			if (strcmp(symname, "_switch_to_ret") == 0) {
				info->prev_sp = info->sp - CALLEE_SAVE_FRAME_SIZE;
				info->prev_ip = *(unsigned long *)(info->prev_sp - RP_OFFSET);
				dbg("_switch_to_ret @ %lx - setting "
				    "prev_sp=%lx prev_ip=%lx\n", 
				    info->ip, info->prev_sp, 
				    info->prev_ip);
				return;
			} else if (strcmp(symname, "ret_from_kernel_thread") == 0 ||
				   strcmp(symname, "syscall_exit") == 0) {
				info->prev_ip = info->prev_sp = 0;
				return;
			}
		}
#endif

		/* Since we are doing the unwinding blind, we don't know if
		   we are adjusting the stack correctly or extracting the rp
		   correctly. The rp is checked to see if it belongs to the
		   kernel text section, if not we assume we don't have a 
		   correct stack frame and we continue to unwind the stack.
		   This is not quite correct, and will fail for loadable
		   modules. */
		sp = info->sp & ~63;
		do {
			unsigned long tmp;

			info->prev_sp = sp - 64;
			info->prev_ip = 0;
			if (get_user(tmp, (unsigned long *)(info->prev_sp - RP_OFFSET))) 
				break;
			info->prev_ip = tmp;
			sp = info->prev_sp;
		} while (info->prev_ip < (unsigned long)_stext ||
			 info->prev_ip > (unsigned long)_etext);

		info->rp = 0;

		dbg("analyzing func @ %lx with no unwind info, setting "
		    "prev_sp=%lx prev_ip=%lx\n", info->ip, 
		    info->prev_sp, info->prev_ip);
	} else {
		dbg("e->start = 0x%x, e->end = 0x%x, Save_SP = %d, "
		    "Save_RP = %d, Millicode = %d size = %u\n", 
		    e->region_start, e->region_end, e->Save_SP, e->Save_RP, 
		    e->Millicode, e->Total_frame_size);

		looking_for_rp = e->Save_RP;

		for (npc = e->region_start; 
		     (frame_size < (e->Total_frame_size << 3) || 
		      looking_for_rp) && 
		     npc < info->ip; 
		     npc += 4) {

			insn = *(unsigned int *)npc;

			if ((insn & 0xffffc000) == 0x37de0000 ||
			    (insn & 0xffe00000) == 0x6fc00000) {
				/* ldo X(sp), sp, or stwm X,D(sp) */
				frame_size += (insn & 0x1 ? -1 << 13 : 0) | 
					((insn & 0x3fff) >> 1);
				dbg("analyzing func @ %lx, insn=%08x @ "
				    "%lx, frame_size = %ld\n", info->ip,
				    insn, npc, frame_size);
			} else if ((insn & 0xffe00008) == 0x73c00008) {
				/* std,ma X,D(sp) */
				frame_size += (insn & 0x1 ? -1 << 13 : 0) | 
					(((insn >> 4) & 0x3ff) << 3);
				dbg("analyzing func @ %lx, insn=%08x @ "
				    "%lx, frame_size = %ld\n", info->ip,
				    insn, npc, frame_size);
			} else if (insn == 0x6bc23fd9) { 
				/* stw rp,-20(sp) */
				rpoffset = 20;
				looking_for_rp = 0;
				dbg("analyzing func @ %lx, insn=stw rp,"
				    "-20(sp) @ %lx\n", info->ip, npc);
			} else if (insn == 0x0fc212c1) {
				/* std rp,-16(sr0,sp) */
				rpoffset = 16;
				looking_for_rp = 0;
				dbg("analyzing func @ %lx, insn=std rp,"
				    "-16(sp) @ %lx\n", info->ip, npc);
			}
		}

		if (!unwind_special(info, e->region_start, frame_size)) {
			info->prev_sp = info->sp - frame_size;
			if (e->Millicode)
				info->rp = info->r31;
			else if (rpoffset)
				info->rp = *(unsigned long *)(info->prev_sp - rpoffset);
			info->prev_ip = info->rp;
			info->rp = 0;
		}

		dbg("analyzing func @ %lx, setting prev_sp=%lx "
		    "prev_ip=%lx npc=%lx\n", info->ip, info->prev_sp, 
		    info->prev_ip, npc);
	}
}

void unwind_frame_init(struct unwind_frame_info *info, struct task_struct *t, 
		       struct pt_regs *regs)
{
	memset(info, 0, sizeof(struct unwind_frame_info));
	info->t = t;
	info->sp = regs->gr[30];
	info->ip = regs->iaoq[0];
	info->rp = regs->gr[2];
	info->r31 = regs->gr[31];

	dbg("(%d) Start unwind from sp=%08lx ip=%08lx\n", 
	    t ? (int)t->pid : -1, info->sp, info->ip);
}

void unwind_frame_init_from_blocked_task(struct unwind_frame_info *info, struct task_struct *t)
{
	struct pt_regs *r = &t->thread.regs;
	struct pt_regs *r2;

	r2 = kmalloc(sizeof(struct pt_regs), GFP_ATOMIC);
	if (!r2)
		return;
	*r2 = *r;
	r2->gr[30] = r->ksp;
	r2->iaoq[0] = r->kpc;
	unwind_frame_init(info, t, r2);
	kfree(r2);
}

void unwind_frame_init_running(struct unwind_frame_info *info, struct pt_regs *regs)
{
	unwind_frame_init(info, current, regs);
}

int unwind_once(struct unwind_frame_info *next_frame)
{
	unwind_frame_regs(next_frame);

	if (next_frame->prev_sp == 0 ||
	    next_frame->prev_ip == 0)
		return -1;

	next_frame->sp = next_frame->prev_sp;
	next_frame->ip = next_frame->prev_ip;
	next_frame->prev_sp = 0;
	next_frame->prev_ip = 0;

	dbg("(%d) Continue unwind to sp=%08lx ip=%08lx\n", 
	    next_frame->t ? (int)next_frame->t->pid : -1, 
	    next_frame->sp, next_frame->ip);

	return 0;
}

int unwind_to_user(struct unwind_frame_info *info)
{
	int ret;
	
	do {
		ret = unwind_once(info);
	} while (!ret && !(info->ip & 3));

	return ret;
}

unsigned long return_address(unsigned int level)
{
	struct unwind_frame_info info;
	struct pt_regs r;
	unsigned long sp;

	/* initialize unwind info */
	asm volatile ("copy %%r30, %0" : "=r"(sp));
	memset(&r, 0, sizeof(struct pt_regs));
	r.iaoq[0] = (unsigned long) current_text_addr();
	r.gr[2] = (unsigned long) __builtin_return_address(0);
	r.gr[30] = sp;
	unwind_frame_init(&info, current, &r);

	/* unwind stack */
	++level;
	do {
		if (unwind_once(&info) < 0 || info.ip == 0)
			return 0;
		if (!__kernel_text_address(info.ip)) {
			return 0;
		}
	} while (info.ip && level--);

	return info.ip;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Kernel unwinding support
	3	*
	4	* (c) 2002-2004 Randolph Chung <tausq@debian.org>
	5	*
	6	* Derived partially from the IA64 implementation. The PA-RISC
	7	* Runtime Architecture Document is also a useful reference to
	8	* understand what is happening here
	9	*/
	10
1da177e4 LT	11	#include <linux/kernel.h>
1da177e4 LT	12	#include <linux/init.h>
e6fc0449	13	#include <linux/sched.h>
1da177e4 LT	14	#include <linux/slab.h>
1da177e4 LT	15	#include <linux/kallsyms.h>
8f78df87	16	#include <linux/sort.h>
1da177e4 LT	17
	18	#include <asm/uaccess.h>
	19	#include <asm/assembly.h>
05dc16d6 RC	20	#include <asm/asm-offsets.h>
05dc16d6 RC	21	#include <asm/ptrace.h>
1da177e4 LT	22
	23	#include <asm/unwind.h>
	24
	25	/* #define DEBUG 1 */
	26	#ifdef DEBUG
	27	#define dbg(x...) printk(x)
	28	#else
	29	#define dbg(x...)
	30	#endif
	31
33a932d1	32	#define KERNEL_START (KERNEL_BINARY_TEXT_START)
e036306a	33
1da177e4 LT	34	extern struct unwind_table_entry __start___unwind[];
	35	extern struct unwind_table_entry __stop___unwind[];
	36
	37	static spinlock_t unwind_lock;
	38	/*
	39	* the kernel unwind block is not dynamically allocated so that
	40	* we can call unwind_init as early in the bootup process as
	41	* possible (before the slab allocator is initialized)
	42	*/
8039de10	43	static struct unwind_table kernel_unwind_table __read_mostly;
1da177e4 LT	44	static LIST_HEAD(unwind_tables);
	45
	46	static inline const struct unwind_table_entry *
	47	find_unwind_entry_in_table(const struct unwind_table *table, unsigned long addr)
	48	{
	49	const struct unwind_table_entry *e = NULL;
	50	unsigned long lo, hi, mid;
	51
	52	lo = 0;
	53	hi = table->length - 1;
	54
	55	while (lo <= hi) {
	56	mid = (hi - lo) / 2 + lo;
	57	e = &table->table[mid];
	58	if (addr < e->region_start)
	59	hi = mid - 1;
	60	else if (addr > e->region_end)
	61	lo = mid + 1;
	62	else
	63	return e;
	64	}
	65
	66	return NULL;
	67	}
	68
	69	static const struct unwind_table_entry *
	70	find_unwind_entry(unsigned long addr)
	71	{
	72	struct unwind_table *table;
	73	const struct unwind_table_entry *e = NULL;
	74
	75	if (addr >= kernel_unwind_table.start &&
	76	addr <= kernel_unwind_table.end)
	77	e = find_unwind_entry_in_table(&kernel_unwind_table, addr);
	78	else
	79	list_for_each_entry(table, &unwind_tables, list) {
	80	if (addr >= table->start &&
	81	addr <= table->end)
	82	e = find_unwind_entry_in_table(table, addr);
	83	if (e)
	84	break;
	85	}
	86
	87	return e;
	88	}
	89
	90	static void
	91	unwind_table_init(struct unwind_table table, const char name,
	92	unsigned long base_addr, unsigned long gp,
	93	void table_start, void table_end)
	94	{
	95	struct unwind_table_entry *start = table_start;
	96	struct unwind_table_entry *end =
	97	(struct unwind_table_entry *)table_end - 1;
	98
	99	table->name = name;
	100	table->base_addr = base_addr;
	101	table->gp = gp;
	102	table->start = base_addr + start->region_start;
	103	table->end = base_addr + end->region_end;
	104	table->table = (struct unwind_table_entry *)table_start;
	105	table->length = end - start + 1;
	106	INIT_LIST_HEAD(&table->list);
	107
108	for (; start <= end; start++) {
109	if (start < end &&
110	start->region_end > (start+1)->region_start) {
111	printk("WARNING: Out of order unwind entry! %p and %p\n", start, start+1);
112	}
113
114	start->region_start += base_addr;
115	start->region_end += base_addr;
116	}
117	}
118
8f78df87 HD	119	static int cmp_unwind_table_entry(const void a, const void b)
	120	{
	121	return ((const struct unwind_table_entry *)a)->region_start
	122	- ((const struct unwind_table_entry *)b)->region_start;
	123	}
	124
1da177e4 LT	125	static void
	126	unwind_table_sort(struct unwind_table_entry *start,
	127	struct unwind_table_entry *finish)
	128	{
8f78df87 HD	129	sort(start, finish - start, sizeof(struct unwind_table_entry),
8f78df87 HD	130	cmp_unwind_table_entry, NULL);
1da177e4 LT	131	}
	132
	133	struct unwind_table *
	134	unwind_table_add(const char *name, unsigned long base_addr,
	135	unsigned long gp,
	136	void start, void end)
	137	{
	138	struct unwind_table *table;
	139	unsigned long flags;
	140	struct unwind_table_entry s = (struct unwind_table_entry )start;
	141	struct unwind_table_entry e = (struct unwind_table_entry )end;
	142
	143	unwind_table_sort(s, e);
	144
	145	table = kmalloc(sizeof(struct unwind_table), GFP_USER);
	146	if (table == NULL)
	147	return NULL;
	148	unwind_table_init(table, name, base_addr, gp, start, end);
	149	spin_lock_irqsave(&unwind_lock, flags);
	150	list_add_tail(&table->list, &unwind_tables);
	151	spin_unlock_irqrestore(&unwind_lock, flags);
	152
	153	return table;
	154	}
	155
	156	void unwind_table_remove(struct unwind_table *table)
	157	{
	158	unsigned long flags;
	159
	160	spin_lock_irqsave(&unwind_lock, flags);
	161	list_del(&table->list);
	162	spin_unlock_irqrestore(&unwind_lock, flags);
	163
	164	kfree(table);
	165	}
	166
	167	/* Called from setup_arch to import the kernel unwind info */
f0514ae3	168	int unwind_init(void)
1da177e4 LT	169	{
	170	long start, stop;
	171	register unsigned long gp __asm__ ("r27");
	172
	173	start = (long)&__start___unwind[0];
	174	stop = (long)&__stop___unwind[0];
	175
	176	spin_lock_init(&unwind_lock);
	177
	178	printk("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n",
	179	start, stop,
	180	(stop - start) / sizeof(struct unwind_table_entry));
	181
	182	unwind_table_init(&kernel_unwind_table, "kernel", KERNEL_START,
	183	gp,
	184	&__start___unwind[0], &__stop___unwind[0]);
	185	#if 0
	186	{
	187	int i;
	188	for (i = 0; i < 10; i++)
	189	{
	190	printk("region 0x%x-0x%x\n",
	191	__start___unwind[i].region_start,
	192	__start___unwind[i].region_end);
	193	}
	194	}
	195	#endif
	196	return 0;
	197	}
	198
05dc16d6 RC	199	#ifdef CONFIG_64BIT
	200	#define get_func_addr(fptr) fptr[2]
	201	#else
	202	#define get_func_addr(fptr) fptr[0]
	203	#endif
	204
	205	static int unwind_special(struct unwind_frame_info *info, unsigned long pc, int frame_size)
	206	{
78199943 KM	207	extern void handle_interruption(int, struct pt_regs *);
78199943 KM	208	static unsigned long hi = (unsigned long )&handle_interruption;
05dc16d6 RC	209
	210	if (pc == get_func_addr(hi)) {
	211	struct pt_regs regs = (struct pt_regs )(info->sp - frame_size - PT_SZ_ALGN);
	212	dbg("Unwinding through handle_interruption()\n");
	213	info->prev_sp = regs->gr[30];
	214	info->prev_ip = regs->iaoq[0];
	215
	216	return 1;
	217	}
	218
	219	return 0;
	220	}
	221
1da177e4 LT	222	static void unwind_frame_regs(struct unwind_frame_info *info)
	223	{
	224	const struct unwind_table_entry *e;
	225	unsigned long npc;
	226	unsigned int insn;
	227	long frame_size = 0;
	228	int looking_for_rp, rpoffset = 0;
	229
	230	e = find_unwind_entry(info->ip);
	231	if (e == NULL) {
	232	unsigned long sp;
	233	extern char _stext[], _etext[];
	234
	235	dbg("Cannot find unwind entry for 0x%lx; forced unwinding\n", info->ip);
	236
	237	#ifdef CONFIG_KALLSYMS
	238	/* Handle some frequent special cases.... */
	239	{
9281acea	240	char symname[KSYM_NAME_LEN];
cb957795	241	char *modname;
1da177e4	242
cb957795 KM	243	kallsyms_lookup(info->ip, NULL, NULL, &modname,
cb957795 KM	244	symname);
1da177e4 LT	245
	246	dbg("info->ip = 0x%lx, name = %s\n", info->ip, symname);
	247
	248	if (strcmp(symname, "_switch_to_ret") == 0) {
	249	info->prev_sp = info->sp - CALLEE_SAVE_FRAME_SIZE;
	250	info->prev_ip = (unsigned long )(info->prev_sp - RP_OFFSET);
	251	dbg("_switch_to_ret @ %lx - setting "
	252	"prev_sp=%lx prev_ip=%lx\n",
	253	info->ip, info->prev_sp,
	254	info->prev_ip);
	255	return;
	256	} else if (strcmp(symname, "ret_from_kernel_thread") == 0 \|\|
	257	strcmp(symname, "syscall_exit") == 0) {
	258	info->prev_ip = info->prev_sp = 0;
	259	return;
	260	}
	261	}
	262	#endif
	263
	264	/* Since we are doing the unwinding blind, we don't know if
	265	we are adjusting the stack correctly or extracting the rp
	266	correctly. The rp is checked to see if it belongs to the
	267	kernel text section, if not we assume we don't have a
	268	correct stack frame and we continue to unwind the stack.
	269	This is not quite correct, and will fail for loadable
	270	modules. */
	271	sp = info->sp & ~63;
	272	do {
	273	unsigned long tmp;
	274
	275	info->prev_sp = sp - 64;
	276	info->prev_ip = 0;
	277	if (get_user(tmp, (unsigned long *)(info->prev_sp - RP_OFFSET)))
	278	break;
	279	info->prev_ip = tmp;
	280	sp = info->prev_sp;
	281	} while (info->prev_ip < (unsigned long)_stext \|\|
	282	info->prev_ip > (unsigned long)_etext);
	283
	284	info->rp = 0;
	285
	286	dbg("analyzing func @ %lx with no unwind info, setting "
	287	"prev_sp=%lx prev_ip=%lx\n", info->ip,
	288	info->prev_sp, info->prev_ip);
	289	} else {
	290	dbg("e->start = 0x%x, e->end = 0x%x, Save_SP = %d, "
	291	"Save_RP = %d, Millicode = %d size = %u\n",
	292	e->region_start, e->region_end, e->Save_SP, e->Save_RP,
	293	e->Millicode, e->Total_frame_size);
	294
	295	looking_for_rp = e->Save_RP;
	296
	297	for (npc = e->region_start;
	298	(frame_size < (e->Total_frame_size << 3) \|\|
	299	looking_for_rp) &&
	300	npc < info->ip;
	301	npc += 4) {
	302
	303	insn = (unsigned int )npc;
	304
	305	if ((insn & 0xffffc000) == 0x37de0000 \|\|
	306	(insn & 0xffe00000) == 0x6fc00000) {
	307	/* ldo X(sp), sp, or stwm X,D(sp) */
	308	frame_size += (insn & 0x1 ? -1 << 13 : 0) \|
309	((insn & 0x3fff) >> 1);
310	dbg("analyzing func @ %lx, insn=%08x @ "
311	"%lx, frame_size = %ld\n", info->ip,
312	insn, npc, frame_size);
313	} else if ((insn & 0xffe00008) == 0x73c00008) {
314	/* std,ma X,D(sp) */
315	frame_size += (insn & 0x1 ? -1 << 13 : 0) \|
316	(((insn >> 4) & 0x3ff) << 3);
317	dbg("analyzing func @ %lx, insn=%08x @ "
318	"%lx, frame_size = %ld\n", info->ip,
319	insn, npc, frame_size);
320	} else if (insn == 0x6bc23fd9) {
321	/* stw rp,-20(sp) */
322	rpoffset = 20;
323	looking_for_rp = 0;
324	dbg("analyzing func @ %lx, insn=stw rp,"
325	"-20(sp) @ %lx\n", info->ip, npc);
326	} else if (insn == 0x0fc212c1) {
327	/* std rp,-16(sr0,sp) */
328	rpoffset = 16;
329	looking_for_rp = 0;
330	dbg("analyzing func @ %lx, insn=std rp,"
331	"-16(sp) @ %lx\n", info->ip, npc);
332	}
333	}
334
05dc16d6 RC	335	if (!unwind_special(info, e->region_start, frame_size)) {
	336	info->prev_sp = info->sp - frame_size;
	337	if (e->Millicode)
	338	info->rp = info->r31;
	339	else if (rpoffset)
	340	info->rp = (unsigned long )(info->prev_sp - rpoffset);
	341	info->prev_ip = info->rp;
	342	info->rp = 0;
	343	}
1da177e4 LT	344
	345	dbg("analyzing func @ %lx, setting prev_sp=%lx "
	346	"prev_ip=%lx npc=%lx\n", info->ip, info->prev_sp,
	347	info->prev_ip, npc);
	348	}
	349	}
	350
	351	void unwind_frame_init(struct unwind_frame_info info, struct task_struct t,
	352	struct pt_regs *regs)
	353	{
	354	memset(info, 0, sizeof(struct unwind_frame_info));
	355	info->t = t;
	356	info->sp = regs->gr[30];
	357	info->ip = regs->iaoq[0];
	358	info->rp = regs->gr[2];
	359	info->r31 = regs->gr[31];
	360
	361	dbg("(%d) Start unwind from sp=%08lx ip=%08lx\n",
	362	t ? (int)t->pid : -1, info->sp, info->ip);
	363	}
	364
	365	void unwind_frame_init_from_blocked_task(struct unwind_frame_info info, struct task_struct t)
	366	{
	367	struct pt_regs *r = &t->thread.regs;
	368	struct pt_regs *r2;
	369
e0e7ed48	370	r2 = kmalloc(sizeof(struct pt_regs), GFP_ATOMIC);
1da177e4 LT	371	if (!r2)
	372	return;
	373	r2 = r;
	374	r2->gr[30] = r->ksp;
	375	r2->iaoq[0] = r->kpc;
	376	unwind_frame_init(info, t, r2);
	377	kfree(r2);
	378	}
	379
	380	void unwind_frame_init_running(struct unwind_frame_info info, struct pt_regs regs)
	381	{
	382	unwind_frame_init(info, current, regs);
	383	}
	384
	385	int unwind_once(struct unwind_frame_info *next_frame)
	386	{
	387	unwind_frame_regs(next_frame);
	388
	389	if (next_frame->prev_sp == 0 \|\|
	390	next_frame->prev_ip == 0)
	391	return -1;
	392
	393	next_frame->sp = next_frame->prev_sp;
	394	next_frame->ip = next_frame->prev_ip;
	395	next_frame->prev_sp = 0;
	396	next_frame->prev_ip = 0;
	397
	398	dbg("(%d) Continue unwind to sp=%08lx ip=%08lx\n",
	399	next_frame->t ? (int)next_frame->t->pid : -1,
	400	next_frame->sp, next_frame->ip);
	401
	402	return 0;
	403	}
	404
	405	int unwind_to_user(struct unwind_frame_info *info)
	406	{
	407	int ret;
	408
	409	do {
	410	ret = unwind_once(info);
	411	} while (!ret && !(info->ip & 3));
	412
	413	return ret;
	414	}
11e17809 HD	415
	416	unsigned long return_address(unsigned int level)
	417	{
	418	struct unwind_frame_info info;
	419	struct pt_regs r;
	420	unsigned long sp;
	421
	422	/* initialize unwind info */
	423	asm volatile ("copy %%r30, %0" : "=r"(sp));
	424	memset(&r, 0, sizeof(struct pt_regs));
	425	r.iaoq[0] = (unsigned long) current_text_addr();
	426	r.gr[2] = (unsigned long) __builtin_return_address(0);
	427	r.gr[30] = sp;
	428	unwind_frame_init(&info, current, &r);
	429
	430	/* unwind stack */
	431	++level;
	432	do {
	433	if (unwind_once(&info) < 0 \|\| info.ip == 0)
	434	return 0;
	435	if (!__kernel_text_address(info.ip)) {
	436	return 0;
	437	}
	438	} while (info.ip && level--);
	439
	440	return info.ip;
	441	}