/*	$NetBSD: stackframe.c,v 1.9 2016/07/31 19:33:18 dholland Exp $	*/

/* Contributed to the NetBSD foundation by Cherry G. Mathew <cherry@mahiti.org>
 * This file contains routines to use decoded unwind descriptor entries
 * to build a stack configuration. The unwinder consults the stack 
 * configuration to fetch registers used to unwind the frame.
 * References:
 *	[1] section. 11.4.2.6., Itanium Software Conventions and 
 *			Runtime Architecture Guide.
 */

#include <sys/cdefs.h>
#include <sys/param.h>
#include <sys/systm.h>


#include <ia64/unwind/decode.h>
#include <ia64/unwind/stackframe.h>

//#define UNWIND_DIAGNOSTIC

/*
 * Global variables:
 * array of struct recordchain
 * size of record chain array.
 */
struct recordchain strc[MAXSTATERECS];
int rec_cnt = 0;

/*
 * Build a recordchain of a region, given the pointer to unwind table
 * entry, and the number of entries to decode.
 */
void
buildrecordchain(uint64_t unwind_infop, struct recordchain *xxx)
{
	uint64_t unwindstart, unwindend;
	uint64_t unwindlen;
	uint64_t region_len = 0;
	bool region_type = false; /* Prologue */

	struct unwind_hdr_t {
		uint64_t uwh;
	} *uwhp = (void *) unwind_infop;

	char *nextrecp, *recptr = (char *) unwind_infop + sizeof(uint64_t);
	
	unwindstart = (uint64_t) recptr;

	if (UNW_VER(uwhp->uwh) != 1) {
		printf("Wrong unwind version! \n");
		return;
	}
	
	unwindlen = UNW_LENGTH(uwhp->uwh) * sizeof(uint64_t);
	unwindend = unwindstart + unwindlen;

#ifdef UNWIND_DIAGNOSTIC
	printf("recptr = %p \n", recptr);
	printf("unwindlen = %lx \n", unwindlen);
	printf("unwindend = %lx \n", unwindend);
#endif

	/* XXX: Ignore zero length records. */


	for (rec_cnt = 0;
	    rec_cnt < MAXSTATERECS && (uint64_t)recptr < unwindend;
	    rec_cnt++) {
		nextrecp = unwind_decode_R1(recptr, &strc[rec_cnt].udesc);
		if (nextrecp) {
			region_len = strc[rec_cnt].udesc.R1.rlen;
			region_type = strc[rec_cnt].udesc.R1.r;
			strc[rec_cnt].type = R1;
			recptr = nextrecp;
			continue;
		}

		nextrecp = unwind_decode_R2(recptr, &strc[rec_cnt].udesc);
		if (nextrecp) {
			region_len = strc[rec_cnt].udesc.R2.rlen;
			/* R2 regions are prologue regions */
			region_type = false;
			strc[rec_cnt].type = R2;
			recptr = nextrecp;
			continue;
		}

		nextrecp = unwind_decode_R3(recptr, &strc[rec_cnt].udesc);
		if (nextrecp) {
			region_len = strc[rec_cnt].udesc.R3.rlen;
			region_type = strc[rec_cnt].udesc.R3.r;
			strc[rec_cnt].type = R3;
			recptr = nextrecp;
			continue;
		}

		if (region_type == false) {
			/* Prologue Region */
			nextrecp = unwind_decode_P1(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = P1;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_P2(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = P2;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_P3(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = P3;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_P4(recptr,
						    &strc[rec_cnt].udesc,
						    region_len);
			if (nextrecp) {
				strc[rec_cnt].type = P4;
				recptr = nextrecp;
				break;
			}
		
			nextrecp = unwind_decode_P5(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = P5;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_P6(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = P6;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_P7(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = P7;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_P8(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = P8;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_P9(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = P9;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_P10(recptr,
						     &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = P10;
				recptr = nextrecp;
				continue;
			}

			printf("Skipping prologue desc slot :: %d \n", rec_cnt);
		} else {

			nextrecp = unwind_decode_B1(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = B1;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_B2(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = B2;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_B3(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = B3;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_B4(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = B4;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_X1(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = X1;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_X2(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = X2;
				recptr = nextrecp;
				continue;
			}


			nextrecp = unwind_decode_X3(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = X3;
				recptr = nextrecp;
				continue;
			}

			nextrecp = unwind_decode_X4(recptr,
						    &strc[rec_cnt].udesc);
			if (nextrecp) {
				strc[rec_cnt].type = X4;
				recptr = nextrecp;
				continue;
			}

			printf("Skipping body desc slot :: %d \n", rec_cnt);
		}
	}

#ifdef UNWIND_DIAGNOSTIC
	int i;
	for(i = 0;i < rec_cnt;i++) {
		dump_recordchain(&strc[i]);
	}

#endif /* UNWIND_DIAGNOSTIC */
}




/*
 * Debug support: dump a record chain entry
 */
void
dump_recordchain(struct recordchain *rchain)
{

	switch(rchain->type) {
	case R1:
		printf("\t R1:");
		if(rchain->udesc.R1.r)
			printf("body (");
		else
			printf("prologue (");
		printf("rlen = %ld) \n", rchain->udesc.R1.rlen);
		break;

	case R2:
		printf("\t R2:");
		printf("prologue_gr (");
		printf("mask = %x, ", rchain->udesc.R2.mask);
		printf("grsave = %d, ", rchain->udesc.R2.grsave);
		printf("rlen = %ld )\n", rchain->udesc.R2.rlen);
		break;

	case R3:
		printf("\t R3:");
		if(rchain->udesc.R3.r)
			printf("body (");
		else
			printf("prologue (");
		printf("rlen = %ld )\n", rchain->udesc.R3.rlen);
		break;

	case P1:
		printf("\t\tP1:");
		printf("br_mem (brmask = %x) \n", rchain->udesc.P1.brmask);
		break;

	case P2:
		printf("\t\tP2:");
		printf("br_gr(brmask = %x, ", rchain->udesc.P2.brmask);
		printf("gr = %d ) \n", rchain->udesc.P2.gr);
		break;

	case P3:
		printf("\t\tP3:");
		switch(rchain->udesc.P3.r) {
		case 0:
			printf("psp_gr");
			break;
		case 1:
			printf("rp_gr");
			break;
		case 2:
			printf("pfs_gr");
			break;
		case 3:
			printf("preds_gr");
			break;
		case 4:
			printf("unat_gr");
			break;
		case 5:
			printf("lc_gr");
			break;
		case 6:
			printf("rp_br");
			break;
		case 7:
			printf("rnat_gr");
			break;
		case 8:
			printf("bsp_gr");
			break;
		case 9:
			printf("bspstore_gr");
			break;
		case 10:
			printf("fpsr_gr");
			break;
		case 11:
			printf("priunat_gr");
			break;
		default:
			printf("unknown desc: %d", rchain->udesc.P3.r);
				
		}
		printf("(gr/br = %d) \n", rchain->udesc.P3.grbr);

		break;

	case P4:
		printf("P4: (unimplemented): \n");
		break;

	case P5:
		printf("\t\tP5:");
		printf("frgr_mem(grmask = %x, frmask = %x )\n", 
		       rchain->udesc.P5.grmask, rchain->udesc.P5.frmask);
		break;

	case P6:
		printf("\t\tP6: ");
		if(rchain->udesc.P6.r)
			printf("gr_mem( ");
		else
			printf("fr_mem( ");
		printf("rmask = %x) \n", rchain->udesc.P6.rmask);
		break;

	case P7:
		printf("\t\tP7:");
		switch(rchain->udesc.P7.r) {
		case 0:
			printf("memstack_f( ");
			printf("t = %ld, ", rchain->udesc.P7.t);
			printf("size = %ld) \n", rchain->udesc.P7.size);
			break;
		case 1:
			printf("memstack_v( ");
			printf("t = %ld) \n", rchain->udesc.P7.t);
			break;
		case 2:
			printf("spillbase( ");
			printf("pspoff = %ld) \n", rchain->udesc.P7.t);
			break;
		case 3:
			printf("psp_sprel( ");
			printf("spoff = %ld) \n", rchain->udesc.P7.t);
			break;
		case 4:
			printf("rp_when( ");
			printf("t = %ld) \n", rchain->udesc.P7.t);
			break;
		case 5:
			printf("rp_psprel( ");
			printf("pspoff = %ld) \n", rchain->udesc.P7.t);
			break;
		case 6:
			printf("pfs_when( ");
			printf("t = %ld) \n", rchain->udesc.P7.t);
			break;
		case 7:
			printf("pfs_psprel( ");
			printf("pspoff = %ld) \n", rchain->udesc.P7.t);
			break;
		case 8:
			printf("preds_when( ");
			printf("t = %ld) \n", rchain->udesc.P7.t);
			break;
		case 9:
			printf("preds_psprel( ");
			printf("pspoff = %ld) \n", rchain->udesc.P7.t);
			break;
		case 10:
			printf("lc_when( ");
			printf("t = %ld) \n", rchain->udesc.P7.t);
			break;
		case 11:
			printf("lc_psprel( ");
			printf("pspoff = %ld) \n", rchain->udesc.P7.t);
			break;
		case 12:
			printf("unat_when( ");
			printf("t = %ld) \n", rchain->udesc.P7.t);
			break;
		case 13:
			printf("unat_psprel( ");
			printf("pspoff = %ld) \n", rchain->udesc.P7.t);
			break;
		case 14:
			printf("fpsr_when( ");
			printf("t = %ld) \n", rchain->udesc.P7.t);
			break;
		case 15:
			printf("fpsr_psprel( ");
			printf("pspoff = %ld) \n", rchain->udesc.P7.t);
			break;
		default:
			printf("unknown \n");
		}

		break;
			
	case P8:
		printf("\t\tP8:");
		switch(rchain->udesc.P8.r) {
		case 1:
			printf("rp_sprel( ");
			printf("spoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 2:
			printf("pfs_sprel( ");
			printf("spoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 3:
			printf("preds_sprel( ");
			printf("spoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 4:
			printf("lc_sprel( ");
			printf("spoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 5:
			printf("unat_sprel( ");
			printf("spoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 6:
			printf("fpsr_sprel( ");
			printf("spoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 7:
			printf("bsp_when( ");
			printf("t = %ld) \n", rchain->udesc.P8.t);
			break;
		case 8:
			printf("bsp_psprel( ");
			printf("pspoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 9:
			printf("bsp_sprel( ");
			printf("spoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 10:
			printf("bspstore_when( ");
			printf("t = %ld) \n", rchain->udesc.P8.t);
			break;
		case 11:
			printf("bspstore_psprel( ");
			printf("pspoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 12:
			printf("bspstore_sprel( ");
			printf("spoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 13:
			printf("rnat_when( ");
			printf("t = %ld) \n", rchain->udesc.P8.t);
			break;
		case 14:
			printf("rnat_psprel( ");
			printf("pspoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 15:
			printf("rnat_sprel( ");
			printf("spoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 16:
			printf("priunat_when_gr( ");
			printf("t = %ld) \n", rchain->udesc.P8.t);
			break;
		case 17:
			printf("priunat_psprel( ");
			printf("pspoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 18:
			printf("priunat_sprel( ");
			printf("spoff = %ld) \n", rchain->udesc.P8.t);
			break;
		case 19:
			printf("priunat_when_mem( ");
			printf("t = %ld) \n", rchain->udesc.P8.t);
			break;

		default:
			printf("unknown \n");
		}

		break;

	case P9:
		printf("\t\tP9:");
		printf("(grmask = %x, gr = %d) \n", 
		       rchain->udesc.P9.grmask, rchain->udesc.P9.gr);
		break;

	case P10:
		printf("\t\tP10:");
		printf("(abi: ");
		switch(rchain->udesc.P10.abi) {
		case 0:
			printf("Unix SVR4) \n");
			break;
		case 1:
			printf("HP-UX) \n");
			break;
		default:
			printf("Other) \n");
		}
		break;

	case B1:
		printf("\t\tB1:");
		if(rchain->udesc.B1.r)
			printf("copy_state( ");
		else
			printf("label_state( ");
		printf("label = %d) \n", rchain->udesc.B1.label);

		break;

	case B2:
		printf("\t\tB2:");
		printf("(ecount = %d, t = %ld)\n",
		       rchain->udesc.B2.ecount, rchain->udesc.B2.t);

		break;

	case B3:
		printf("\t\tB3:");
		printf("(t = %ld, ecount = %ld) \n",
		       rchain->udesc.B3.t, rchain->udesc.B3.ecount);

		break;

	case B4:
		printf("\t\tB4:");
		if(rchain->udesc.B4.r)
			printf("copy_state( ");
		else
			printf("label_state( ");

		printf("label = %ld) \n", rchain->udesc.B4.label);

		break;


	case X1:
		printf("\tX1:\n ");
		break;

	case X2:
		printf("\tX2:\n");
		break;

	case X3:
		printf("\tX3:\n");
		break;

	case X4:
		printf("\tX4:\n");
		break;
	default:
		printf("\tunknow: \n");
	}

}

/*
 * State record stuff..... based on section 11. and Appendix A. of the 
 * "Itanium Software Conventions and Runtime Architecture Guide"
 */


/*
 * Global variables:
 * 1. Two arrays of staterecords: recordstack[], recordstackcopy[]
 *	XXX:	Since we don't use malloc, we have two arbitrary sized arrays
 *		providing guaranteed memory from the BSS. See the TODO file 
 *		for more details.
 * 2. Two head variables to hold the member index: unwind_rsp,unwind_rscp
 */

struct staterecord recordstack[MAXSTATERECS];
struct staterecord recordstackcopy[MAXSTATERECS];
struct staterecord current_state;
struct staterecord *unwind_rsp, *unwind_rscp;


/* Base of spill area in memory stack frame as a psp relative offset */
uint64_t spill_base = 0;

/*
 * Initialises a staterecord from a given template,
 * with default values as described by the Runtime Spec.
 */
void
initrecord(struct staterecord *target)
{
	target->bsp.where = UNSAVED;
	target->bsp.when = 0;
	target->bsp.offset = INVALID;
	target->psp.where = UNSAVED;
	target->psp.when = 0;
	target->psp.offset = INVALID;
	target->rp.where = UNSAVED;
	target->rp.when = 0;	
	target->rp.offset = INVALID;
	target->pfs.where = UNSAVED;
	target->pfs.when = 0;
	target->pfs.offset = INVALID;
}


/*
 * Modifies a staterecord structure by parsing 
 * a single record chain structure.
 * regionoffset is the offset within a (prologue) region 
 * where the stack unwinding began.
 */
void
modifyrecord(struct staterecord *srec, struct recordchain *rchain, 
	uint64_t regionoffset)
{
	/*
	 * Default start save GR for prologue_save GRs.
	 */
	uint64_t grno = 32;


	switch (rchain->type) {
	
	case R2:
		/*
		 * R2, prologue_gr is the only region encoding
		 * with register save info.
		 */

		grno = rchain->udesc.R2.grsave;

		if (rchain->udesc.R2.mask & R2MASKRP) {
			srec->rp.when = 0;
			srec->rp.where = GRREL;
			srec->rp.offset = grno++;
		}

		if (rchain->udesc.R2.mask & R2MASKPFS) {
			srec->pfs.when = 0;
			srec->pfs.where = GRREL;
			srec->pfs.offset = grno++;
		}

		if (rchain->udesc.R2.mask & R2MASKPSP) {
			srec->psp.when = 0;
			srec->psp.where = GRREL;
			srec->psp.offset = grno++;
		}
		break;

	case P3:
		switch (rchain->udesc.P3.r) {
		case 0: /* psp_gr */
			if (srec->psp.when < regionoffset) {
				srec->psp.where = GRREL;
				srec->psp.offset = rchain->udesc.P3.grbr;
			}
			break;

		case 1: /* rp_gr */
			if (srec->rp.when < regionoffset) {
				srec->rp.where = GRREL;
				srec->rp.offset = rchain->udesc.P3.grbr;
			}
			break;

		case 2: /* pfs_gr */
			if (srec->pfs.when < regionoffset) {
				srec->pfs.where = GRREL;
				srec->pfs.offset = rchain->udesc.P3.grbr;
			}
			break;

		}
		break;


	/*
	 * XXX: P4 spill_mask and P7: spill_base are for GRs, FRs, and BRs. 
	 * We're not particularly worried about those right now.
	 */

	case P7:
		switch (rchain->udesc.P7.r) {

		case 0: /* mem_stack_f */
			if (srec->psp.offset != INVALID) {
				printf("!!!saw mem_stack_f more than once. \n");
			}
			srec->psp.when = rchain->udesc.P7.t;
			if (srec->psp.when < regionoffset) {
				srec->psp.where = IMMED;
				/* spsz.offset is "overloaded" */
				srec->psp.offset = rchain->udesc.P7.size;
			}
			break;

		case 1: /* mem_stack_v */
			srec->psp.when = rchain->udesc.P7.t;
			break;

		case 2: /* spill_base */
			spill_base = rchain->udesc.P7.t;
			break;

		case 3: /* psp_sprel */
			if (srec->psp.when < regionoffset) {
				srec->psp.where = SPREL;
				srec->psp.offset = rchain->udesc.P7.t;
			}
			break;
			
		case 4: /* rp_when */
			srec->rp.when = rchain->udesc.P7.t;
			/*
			 * XXX: Need to set to prologue_gr(grno) for
			 *	the orphan case ie; _gr/_psprel/_sprel
			 *	not set and therefore default to begin
			 *	from the gr specified in prologue_gr.
			 */
			break;

		case 5: /* rp_psprel */
			if (srec->rp.when < regionoffset) {
				srec->rp.where = PSPREL;
				srec->rp.offset = rchain->udesc.P7.t;
			}
			break;

		case 6: /* pfs_when */
			srec->pfs.when = rchain->udesc.P7.t;
			/*
			 * XXX: Need to set to prologue_gr(grno) for
			 *	the orphan case ie; _gr/_psprel/_sprel
			 *	not set and therefore default to begin
			 *	from the gr specified in prologue_gr.
			 */
			break;

		case 7: /* pfs_psprel */
			if (srec->pfs.when < regionoffset) {
				srec->pfs.where = PSPREL;
				srec->pfs.offset = rchain->udesc.P7.t;
			}
			break;

		}
		break;

	case P8:
		switch (rchain->udesc.P8.r) {
		case 1: /* rp_sprel */
			if (srec->rp.when < regionoffset) {
				srec->rp.where = SPREL;
				srec->rp.offset = rchain->udesc.P8.t;
			}
			break;
		case 2: /* pfs_sprel */
			if (srec->pfs.when < regionoffset) {
				srec->pfs.where = SPREL;
				srec->pfs.offset = rchain->udesc.P8.t;

			}
			break;
		}
		break;

	case B1:

		rchain->udesc.B1.r ? switchrecordstack(0) :
			clonerecordstack(0);
		break;

	case B2:
		if (regionoffset < rchain->udesc.B2.t) {
		poprecord(&current_state, rchain->udesc.B2.ecount);
		}
		break;
	case B3:
		if (regionoffset < rchain->udesc.B3.t) {
		poprecord(&current_state, rchain->udesc.B3.ecount);
		}
		break;
	case B4:
		rchain->udesc.B4.r ? switchrecordstack(0) :
			clonerecordstack(0);
		break;

	case X1:
	case X2:
	case X3:
		/* XXX: Todo */
		break;


	case R1:
	case R3:
	case P1:
	case P2:
	case P4:
	case P5:
	case P6:
	case P9:
	case P10:
	default:
		/* Ignore. */
		printf("XXX: Ignored. \n");
	}


}

void
dump_staterecord(struct staterecord *srec)
{
	printf("rp.where: ");
	switch(srec->rp.where) {
	case UNSAVED:
		printf("UNSAVED ");
		break;
	case BRREL:
		printf("BRREL ");
		break;
	case GRREL:
		printf("GRREL ");
		break;
	case SPREL:
		printf("SPREL ");
		break;
	case PSPREL:
		printf("PSPSREL ");
		break;
	default:
		printf("unknown ");
	}

	printf(", rp.when = %lu, ", srec->rp.when);
	printf("rp.offset = %lu \n", srec->rp.offset);


	printf("pfs.where: ");
	switch(srec->pfs.where) {
	case UNSAVED:
		printf("UNSAVED ");
		break;
	case BRREL:
		printf("BRREL ");
		break;
	case GRREL:
		printf("GRREL ");
		break;
	case SPREL:
		printf("SPREL ");
		break;
	case PSPREL:
		printf("PSPSREL ");
		break;
	default:
		printf("unknown ");
	}

	printf(", pfs.when = %lu, ", srec->pfs.when);
	printf("pfs.offset = %lu \n", srec->pfs.offset);
}


/*
 * Push a state record on the record stack.
 */
void
pushrecord(struct staterecord *srec)
{
	if(unwind_rsp >= recordstack + MAXSTATERECS) {
		printf("Push exceeded array size!!! \n");
		return;
	}

	memcpy(unwind_rsp, srec, sizeof(struct staterecord));
	unwind_rsp++;

}

/*
 * Pop n state records off the record stack.
 */
void
poprecord(struct staterecord *srec, int n)
{
	if(unwind_rsp == recordstack) {
		printf("Popped beyond end of Stack!!! \n");
		return;
	}
	unwind_rsp -= n;
	memcpy(srec, unwind_rsp, sizeof(struct staterecord));
#ifdef DEBUG
	memset(unwind_rsp, 0, sizeof(struct staterecord) * n);
#endif

}

/*
 * Clone the whole record stack upto this one.
 */
void
clonerecordstack(u_int label)
{
	memcpy(recordstackcopy, recordstack, 
	       (unwind_rsp - recordstack) * sizeof(struct staterecord));
	unwind_rscp = unwind_rsp;
}

/*
 * Discard the current stack, and adopt a clone.
 */
void
switchrecordstack(u_int label)
{
	memcpy((void *) recordstack, (void *) recordstackcopy, 
	       (unwind_rscp - recordstackcopy) * sizeof(struct staterecord));
	unwind_rsp = unwind_rscp;

}

/*
 * In the context of a procedure:
 * Parses through a record chain, building, pushing and/or popping staterecords,
 * or cloning/destroying stacks of staterecords as required.
 * Parameters are:
 *	rchain: pointer to recordchain array.
 *	procoffset: offset of point of interest, in slots, within procedure
 *                  starting from slot 0
 * This routine obeys [1]
 */
struct staterecord *
buildrecordstack(struct recordchain *rchain, uint64_t procoffset)
{
	/* Current region length, defaults to zero if not specified */
	uint64_t rlen = 0;
	/* Accumulated region length */
	uint64_t roffset = 0;
	/* Offset within current region */
	uint64_t rdepth = 0;

	bool rtype;
	int i;

	/* Start with bottom of staterecord stack. */
	unwind_rsp = recordstack;

	initrecord(&current_state);

	for (i = 0;i < rec_cnt;i++) {

		switch (rchain[i].type) {
		case R1:
			rlen = rchain[i].udesc.R1.rlen;
			if (procoffset < roffset) {
				/*
				 * Overshot Region containing
				 * procoffset. Bail out.
				 */
				goto out;
			}
			rdepth = procoffset - roffset;
			roffset += rlen;
			rtype = rchain[i].udesc.R1.r;
			if (!rtype) {
				pushrecord(&current_state);
			}
			break;

		case R3:
			rlen = rchain[i].udesc.R3.rlen;
			if (procoffset < roffset) {
				/*
				 * Overshot Region containing
				 * procoffset. Bail out.
				 */
				goto out;
			}
			rdepth = procoffset - roffset;
			roffset += rlen;
			rtype = rchain[i].udesc.R3.r;
			if (!rtype) {
				pushrecord(&current_state);
			}
			break;

		case R2:
			rlen = rchain[i].udesc.R2.rlen;
			if (procoffset < roffset) {
				/*
				 * Overshot Region containing
				 * procoffset. Bail out.
				 */
				goto out;
			}
			rdepth = procoffset - roffset;
			roffset += rlen;
			rtype = false; /* prologue region */
			pushrecord(&current_state);

			/* R2 has save info. Continue down. */
			/* FALLTHROUGH */
		case P1:
		case P2:
		case P3:
		case P4:
		case P5:
		case P6:
		case P7:
		case P8:
		case P9:
		case P10:
			modifyrecord(&current_state, &rchain[i], rdepth);
			break;

		case B1:
		case B2:
		case B3:
		case B4:
			modifyrecord(&current_state, &rchain[i],
				     rlen - 1 - rdepth); 
			break;

		case X1:
		case X2:
		case X3:
		case X4:
		default:
			printf("Error: Unknown descriptor type!!! \n");

		}

#if UNWIND_DIAGNOSTIC
		dump_staterecord(&current_state);
#endif


	}

out:

	return &current_state;
}

void
updateregs(struct unwind_frame *uwf, struct staterecord *srec,
	uint64_t procoffset) 
{
	/* XXX: Update uwf for regs other than rp and pfs*/
	uint64_t roffset = 0;

	/* Uses shadow arrays to update uwf from srec in a loop. */
	/* Count of number of regstate elements in struct staterecord */
	int statecount = sizeof(struct staterecord)/sizeof(struct regstate);	
	/* Pointer to current regstate. */
	struct regstate *stptr = (void *) srec;				
	/* Pointer to current unwind_frame element */
	uint64_t *gr = (void *) uwf;

	int i;

#ifdef UNWIND_DIAGNOSTIC
	printf("updateregs(): \n");
	printf("procoffset (slots) = %lu \n", procoffset);
#endif

	for(i = 0; i < statecount; i++) {
		switch (stptr[i].where) { 
		case IMMED: /* currently only mem_stack_f */
			if (stptr[i].when >= procoffset) break;
			uwf->psp -= (stptr[i].offset << 4); 
			break;

		case GRREL:
			if (stptr[i].when >= procoffset) break;
		
			roffset = stptr[i].offset;
			if (roffset == 0) {
				gr[i] = 0;
				break;
			}


			if (roffset < 32) {
				printf("GR%ld: static register save ??? \n",
				       roffset);
				break;
			}

			/* Fetch from bsp + offset - 32 + Adjust for RNAT. */
			roffset -= 32;
			gr[i] = ia64_getrse_gr(uwf->bsp, roffset);
			break;

		case SPREL:
			if (stptr[i].when >= procoffset) break;

			/* Check if frame has been setup. */
			if (srec->psp.offset == INVALID) {
				printf("sprel used without setting up "
				       "stackframe!!! \n");
				break;
			}

			roffset = stptr[i].offset;

			/* Fetch from sp + offset */
			memcpy(&gr[i], (char *) uwf->sp + roffset * 4,
			       sizeof(uint64_t));
			break;


		case PSPREL:
			if (stptr[i].when >= procoffset) break;

			/* Check if frame has been setup. */
			if (srec->psp.offset == INVALID) {
				printf("psprel used without setting up "
				       "stackframe!!! \n");
				break;
			}

			roffset = stptr[i].offset;

			/* Fetch from sp + offset */
			memcpy(&gr[i], (char *) uwf->psp + 16 - (roffset * 4),
			       sizeof(uint64_t));
			break;

		case UNSAVED:
		case BRREL:
		default:
#ifdef UNWIND_DIAGNOSTIC
			printf ("updateregs: reg[%d] is UNSAVED \n", i);
#endif
			break;
			/* XXX: Not implemented yet. */
		}

	}		

}


/*
 * Locates unwind table entry, given unwind table entry info.
 * Expects the variables ia64_unwindtab, and ia64_unwindtablen
 * to be set appropriately.
 */
struct uwtable_ent *
get_unwind_table_entry(uint64_t iprel)
{

	extern uint64_t ia64_unwindtab, ia64_unwindtablen;

	struct uwtable_ent *uwt;
	int tabent;


	for(uwt = (struct uwtable_ent *) ia64_unwindtab, tabent = 0; 
	    /* The Runtime spec tells me the table entries are sorted. */
	    uwt->end <= iprel && tabent < ia64_unwindtablen;
	    uwt++, tabent += sizeof(struct uwtable_ent));


	if (!(uwt->start <= iprel && iprel < uwt->end)) {
#ifdef UNWIND_DIAGNOSTIC
		printf("Entry not found \n");
		printf("iprel = %lx \n", iprel);
		printf("uwt->start = %lx \nuwt->end = %lx \n",
		       uwt->start, uwt->end);
		printf("tabent = %d \n", tabent);
		printf("ia64_unwindtablen = %ld \n", 
		       ia64_unwindtablen);
#endif
		return NULL;
	}

#ifdef UNWIND_DIAGNOSTIC
	printf("uwt->start = %lx \nuwt->end = %lx \n"
	       "uwt->infoptr = %p\n", uwt->start, uwt->end, uwt->infoptr);
#endif

	return uwt;
}


/* 
 * Reads unwind table info and updates register values.
 */
void 
patchunwindframe(struct unwind_frame *uwf, uint64_t iprel, uint64_t relocoffset)
{

	extern struct recordchain strc[];
	struct staterecord *srec;
	struct uwtable_ent *uwt;
	uint64_t infoptr, procoffset, slotoffset;

#if 0 /* does not work - moved to assertion at the call site */
	if (iprel < 0) {
		panic("unwind ip out of range!!! \n");
		return;
	}
#endif

	uwt = get_unwind_table_entry(iprel);

	if (uwt == NULL) return;

	infoptr = (uint64_t) uwt->infoptr + relocoffset;

	if (infoptr > relocoffset) {
		buildrecordchain(infoptr, NULL);
	} else {
		return;
	}
	
	slotoffset = iprel & 3;

	/* procoffset in Number of _slots_ , _not_ a byte offset. */

	procoffset = (((iprel - slotoffset) - (uwt->start)) / 0x10 * 3)
		+ slotoffset; 
	srec = buildrecordstack(strc, procoffset);

	updateregs(uwf, srec, procoffset);
}