xref: /freebsd-10.3-release/sys/contrib/ia64/libuwx/src/uwx_uinfo.c

/*
 * Copyright (c) 2002,2003 Hewlett-Packard Company
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include "uwx_env.h"
#include "uwx_uinfo.h"
#include "uwx_utable.h"
#include "uwx_scoreboard.h"
#include "uwx_bstream.h"
#include "uwx_trace.h"
#include "uwx_swap.h"

int uwx_count_ones(unsigned int mask);

/*
 *  uwx_uinfo.c
 *
 *  This file contains the routines for reading and decoding
 *  the unwind information block.
 *
 *  The main entry point, uwx_decode_uinfo(), is given a pointer
 *  to an unwind table entry and a pointer (passed by reference)
 *  to be filled in with a pointer to an update vector. It will
 *  read and decode the unwind descriptors contained in the
 *  unwind information block, then build the register state array,
 *  which describes the actions necessary to step from the current
 *  frame to the previous one.
 */

#define COPYIN_UINFO_4(dest, src) \
    (env->remote? \
	(*env->copyin)(UWX_COPYIN_UINFO, (dest), (src), \
						WORDSZ, env->cb_token) : \
	(*(uint32_t *)(dest) = *(uint32_t *)(src), WORDSZ) )

#define COPYIN_UINFO_8(dest, src) \
    (env->remote? \
	(*env->copyin)(UWX_COPYIN_UINFO, (dest), (src), \
						DWORDSZ, env->cb_token) : \
	(*(uint64_t *)(dest) = *(uint64_t *)(src), DWORDSZ) )


/* uwx_default_rstate: Returns the default register state for a leaf routine */

int uwx_default_rstate(struct uwx_env *env, uint64_t **rstatep)
{
    struct uwx_scoreboard *sb;

    sb = uwx_init_scoreboards(env);
    *rstatep = sb->rstate;
    return UWX_OK;
}


/* uwx_decode_uinfo: Decodes unwind info region */

int uwx_decode_uinfo(
    struct uwx_env *env,
    struct uwx_utable_entry *uentry,
    uint64_t **rstatep)
{
    uint64_t uinfohdr;
    unsigned int ulen;
    int len;
    struct uwx_bstream bstream;
    struct uwx_scoreboard *scoreboard;
    int ip_slot;
    int cur_slot;
    int status;
    struct uwx_rhdr rhdr;

    /* Remember the offset from the start of the function */
    /* to the current IP. This helps the client find */
    /* the symbolic information. */

    env->function_offset = env->context.special[UWX_REG_IP] -
						uentry->code_start;

    /* Read the unwind info header using the copyin callback. */
    /* (If we're reading a 32-bit unwind table, we need to */
    /* read the header as two 32-bit pieces to preserve the */
    /* guarantee that we always call copyin for aligned */
    /* 4-byte or 8-byte chunks.) */
    /* Then compute the length of the unwind descriptor */
    /* region and initialize a byte stream to read it. */

    if (uentry->unwind_flags & UNWIND_TBL_32BIT) {
	len = COPYIN_UINFO_4((char *)&uinfohdr, uentry->unwind_info);
	len += COPYIN_UINFO_4((char *)&uinfohdr + WORDSZ,
					uentry->unwind_info + WORDSZ);
	}
    else
	len = COPYIN_UINFO_8((char *)&uinfohdr, uentry->unwind_info);
    if (len != DWORDSZ)
	return UWX_ERR_COPYIN_UINFO;
    if (env->byte_swap)
	uwx_swap8(&uinfohdr);
    if (uentry->unwind_flags & UNWIND_TBL_32BIT)
	ulen = UNW_LENGTH(uinfohdr) * WORDSZ;
    else
	ulen = UNW_LENGTH(uinfohdr) * DWORDSZ;
    uwx_init_bstream(&bstream, env,
		uentry->unwind_info + DWORDSZ, ulen, UWX_COPYIN_UINFO);

    TRACE_R_UIB(uentry, ulen)

    /* Create an initial scoreboard for tracking the unwind state. */

    scoreboard = uwx_init_scoreboards(env);

    /* Prepare to read and decode the unwind regions described */
    /* by the unwind info block. Find the target "ip" slot */
    /* relative to the beginning of the region. The lower 4 bits */
    /* of the actual IP encode the slot number within a bundle. */

    cur_slot = 0;
    ip_slot = (int) ((env->context.special[UWX_REG_IP] & ~0x0fLL)
							- uentry->code_start)
		/ BUNDLESZ * SLOTSPERBUNDLE
		+ (unsigned int) (env->context.special[UWX_REG_IP] & 0x0f);

    /* Loop over the regions in the unwind info block. */

    for (;;) {

	/* Decode the next region header. */
	/* We have an error if we reach the end of the info block, */
	/* since we should have found our target ip slot by then. */
	/* We also have an error if the next byte isn't a region */
	/* header record. */

	status = uwx_decode_rhdr(env, &bstream, &rhdr);
	if (status != UWX_OK)
	    return status;

	/* If a prologue region, get a new scoreboard, pushing */
	/* the previous one onto the prologue stack. Then read */
	/* and decode the prologue region records. */

	if (rhdr.is_prologue) {
	    scoreboard = uwx_new_scoreboard(env, scoreboard);
	    if (scoreboard == 0)
		return UWX_ERR_NOMEM;
	    status = uwx_decode_prologue(env, &bstream,
					    scoreboard, &rhdr, ip_slot);
	}

	/* If a body region, read and decode the body region */
	/* records. If the body has an epilogue count, */
	/* uwx_decode_body will note that in the region header */
	/* record for use at the bottom of the loop. */

	else {
	    status = uwx_decode_body(env, &bstream, scoreboard, &rhdr, ip_slot);
	}

	if (status != UWX_OK)
	    return status;

	TRACE_R_DUMP_SB(scoreboard, rhdr, cur_slot, ip_slot)

	/* If the target ip slot is within this region, we're done. */
	/* Return the scoreboard's register state array. */

	if (ip_slot < rhdr.rlen) {
	    *rstatep = scoreboard->rstate;
	    return UWX_OK;
	}

	/* Otherwise, update the current ip slot, pop the */
	/* scoreboard stack based on the epilogue count, */
	/* and loop back around for the next region. */

	cur_slot += rhdr.rlen;
	ip_slot -= rhdr.rlen;
	if (rhdr.ecount > 0) {
	    scoreboard = uwx_pop_scoreboards(env, scoreboard, rhdr.ecount);
	    if (scoreboard == 0)
		return UWX_ERR_PROLOG_UF;
	}
    }
    /*NOTREACHED*/
}


/* uwx_decode_rhdr: Decodes a region header record */

int uwx_decode_rhdr(
    struct uwx_env *env,
    struct uwx_bstream *bstream,
    struct uwx_rhdr *rhdr)
{
    int b0;
    int b1;
    uint64_t val;
    int status;

    /* Get the first byte of the next descriptor record. */
    b0 = uwx_get_byte(bstream);
    if (b0 < 0)
	return UWX_ERR_NOUDESC;

    /* Initialize region header record. */

    rhdr->is_prologue = 0;
    rhdr->rlen = 0;
    rhdr->mask = 0;
    rhdr->grsave = 0;
    rhdr->ecount = 0;

    /* Format R1 */

    if (b0 < 0x40) {
	if ((b0 & 0x20) == 0) {
	    TRACE_I_DECODE_RHDR_1("(R1) prologue", b0)
	    rhdr->is_prologue = 1;
	}
	else
	    TRACE_I_DECODE_RHDR_1("(R1) body", b0)
	rhdr->rlen = b0 & 0x1f;
    }

    /* Format R2 */

    else if (b0 < 0x60) {
	b1 = uwx_get_byte(bstream);
	if (b1 < 0)
	    return UWX_ERR_BADUDESC;
	status = uwx_get_uleb128(bstream, &val);
	if (status != 0)
	    return UWX_ERR_BADUDESC;
	TRACE_I_DECODE_RHDR_2L("(R2) prologue_gr", b0, b1, val)
	rhdr->is_prologue = 1;
	rhdr->rlen = (unsigned int) val;
	rhdr->mask = ((b0 & 0x07) << 1) | (b1 >> 7);
	rhdr->grsave = b1 & 0x7f;
    }

    /* Format R3 */

    else if (b0 < 0x80) {
	status = uwx_get_uleb128(bstream, &val);
	if (status != 0)
	    return UWX_ERR_BADUDESC;
	if ((b0 & 0x03) == 0) {
	    TRACE_I_DECODE_RHDR_1L("(R3) prologue", b0, val)
	    rhdr->is_prologue = 1;
	}
	else
	    TRACE_I_DECODE_RHDR_1L("(R3) body", b0, val)
	rhdr->rlen = (unsigned int) val;
    }

    /* Otherwise, not a region header record. */

    else {
	TRACE_I_DECODE_RHDR_1("(?)", b0)
	return UWX_ERR_BADUDESC;
    }

    return UWX_OK;
}


/* uwx_decode_prologue: Decodes a prologue region */

int uwx_decode_prologue(
    struct uwx_env *env,
    struct uwx_bstream *bstream,
    struct uwx_scoreboard *scoreboard,
    struct uwx_rhdr *rhdr,
    int ip_slot)
{
    int status;
    int reg;
    int mask;
    int b0;
    int b1;
    int b2;
    int b3;
    int r;
    int t;
    int i;
    uint64_t parm1;
    uint64_t parm2;
    uint64_t newrstate[NSBREG];
    int tspill[NSBREG];
    int priunat_mem_rstate;
    int t_priunat_mem;
    unsigned int gr_mem_mask;
    unsigned int br_mem_mask;
    unsigned int fr_mem_mask;
    unsigned int gr_gr_mask;
    unsigned int br_gr_mask;
    int ngr;
    int nbr;
    int nfr;
    unsigned int spill_base;
    unsigned int gr_base;
    unsigned int br_base;
    unsigned int fr_base;

    /* Initialize an array of register states from the current */
    /* scoreboard, along with a parallel array of spill times. */
    /* We use this as a temporary scoreboard, then update the */
    /* real scoreboard at the end of the procedure. */
    /* We initialize the spill time to (rhdr.rlen - 1) so that */
    /* spills without a "when" descriptor will take effect */
    /* at the end of the prologue region. */
    /* (Boundary condition: all actions in a zero-length prologue */
    /* will appear to have happened in the instruction slot */
    /* immediately preceding the prologue.) */

    for (i = 0; i < env->nsbreg; i++) {
	newrstate[i] = scoreboard->rstate[i];
	tspill[i] = rhdr->rlen - 1;
    }
    priunat_mem_rstate = UWX_DISP_NONE;
    t_priunat_mem = rhdr->rlen - 1;

    fr_mem_mask = 0;
    gr_mem_mask = 0;
    br_mem_mask = 0;
    gr_gr_mask = 0;
    br_gr_mask = 0;
    nfr = 0;
    ngr = 0;
    nbr = 0;
    spill_base = 0;

    /* If prologue_gr header record supplied mask and grsave, */
    /* record these in the scoreboard. */

    reg = rhdr->grsave;
    mask = rhdr->mask;
    if (mask & 0x8) {
	newrstate[SBREG_RP] = UWX_DISP_REG(UWX_REG_GR(reg));
	reg++;
    }
    if (mask & 0x4) {
	newrstate[SBREG_PFS] = UWX_DISP_REG(UWX_REG_GR(reg));
	reg++;
    }
    if (mask & 0x2) {
	newrstate[SBREG_PSP] = UWX_DISP_REG(UWX_REG_GR(reg));
	reg++;
    }
    if (mask & 0x1) {
	newrstate[SBREG_PREDS] = UWX_DISP_REG(UWX_REG_GR(reg));
	reg++;
    }

    /* Read prologue descriptor records until */
    /* we hit another region header. */

    for (;;) {

	b0 = uwx_get_byte(bstream);

	if (b0 < 0x80) {
	    /* Return the last byte read to the byte stream, since it's */
	    /* really the first byte of the next region header record. */
	    if (b0 >= 0)
		(void) uwx_unget_byte(bstream, b0);
	    break;
	}

	switch ((b0 & 0x70) >> 4) {

	    case 0:			/* 1000 xxxx */
	    case 1:			/* 1001 xxxx */
		/* Format P1 (br_mem) */
		TRACE_I_DECODE_PROLOGUE_1("(P1) br_mem", b0)
		br_mem_mask = b0 & 0x1f;
		break;

	    case 2:			/* 1010 xxxx */
		/* Format P2 (br_gr) */
		b1 = uwx_get_byte(bstream);
		if (b1 < 0)
		    return UWX_ERR_BADUDESC;
		TRACE_I_DECODE_PROLOGUE_2("(P2) br_gr", b0, b1)
		mask = ((b0 & 0x0f) << 1) | (b1 >> 7);
		reg = b1 & 0x7f;
		br_gr_mask = mask;
		for (i = 0; i < NSB_BR && mask != 0; i++) {
		    if (mask & 0x01) {
			newrstate[SBREG_BR + i] = UWX_DISP_REG(UWX_REG_GR(reg));
			reg++;
		    }
		    mask = mask >> 1;
		}
		break;

	    case 3:			/* 1011 xxxx */
		/* Format P3 */
		if (b0 < 0xb8) {
		    b1 = uwx_get_byte(bstream);
		    if (b1 < 0)
			return UWX_ERR_BADUDESC;
		    r = ((b0 & 0x3) << 1) | (b1 >> 7);
		    reg = b1 & 0x7f;
		    switch (r) {
			case 0:		/* psp_gr */
			    TRACE_I_DECODE_PROLOGUE_2("(P3) psp_gr", b0, b1)
			    newrstate[SBREG_PSP] = UWX_DISP_REG(UWX_REG_GR(reg));
			    break;
			case 1:		/* rp_gr */
			    TRACE_I_DECODE_PROLOGUE_2("(P3) rp_gr", b0, b1)
			    newrstate[SBREG_RP] = UWX_DISP_REG(UWX_REG_GR(reg));
			    break;
			case 2:		/* pfs_gr */
			    TRACE_I_DECODE_PROLOGUE_2("(P3) pfs_gr", b0, b1)
			    newrstate[SBREG_PFS] = UWX_DISP_REG(UWX_REG_GR(reg));
			    break;
			case 3:		/* preds_gr */
			    TRACE_I_DECODE_PROLOGUE_2("(P3) preds_gr", b0, b1)
			    newrstate[SBREG_PREDS] =
					UWX_DISP_REG(UWX_REG_GR(reg));
			    break;
			case 4:		/* unat_gr */
			    TRACE_I_DECODE_PROLOGUE_2("(P3) unat_gr", b0, b1)
			    newrstate[SBREG_UNAT] =
					UWX_DISP_REG(UWX_REG_GR(reg));
			    break;
			case 5:		/* lc_gr */
			    TRACE_I_DECODE_PROLOGUE_2("(P3) lc_gr", b0, b1)
			    newrstate[SBREG_LC] =
					UWX_DISP_REG(UWX_REG_GR(reg));
			    break;
			case 6:		/* rp_br */
			    TRACE_I_DECODE_PROLOGUE_2("(P3) rp_br", b0, b1)
			    scoreboard->rstate[SBREG_RP] =
					UWX_DISP_REG(UWX_REG_BR(reg));
			    break;
			case 7:		/* rnat_gr */
			    TRACE_I_DECODE_PROLOGUE_2("(P3) rnat_gr", b0, b1)
			    newrstate[SBREG_RNAT] =
					UWX_DISP_REG(UWX_REG_GR(reg));
			    break;
			case 8:		/* bsp_gr */
			    TRACE_I_DECODE_PROLOGUE_2("(P3) bsp_gr", b0, b1)
			    /* Don't track BSP yet */
			    return UWX_ERR_CANTUNWIND;
			    break;
			case 9:		/* bspstore_gr */
			    TRACE_I_DECODE_PROLOGUE_2("(P3) bspstore_gr", b0, b1)
			    /* Don't track BSPSTORE yet */
			    return UWX_ERR_CANTUNWIND;
			    break;
			case 10:	/* fpsr_gr */
			    TRACE_I_DECODE_PROLOGUE_2("(P3) fpsr_gr", b0, b1)
			    newrstate[SBREG_FPSR] =
					UWX_DISP_REG(UWX_REG_GR(reg));
			    break;
			case 11:	/* priunat_gr */
			    TRACE_I_DECODE_PROLOGUE_2("(P3) priunat_gr", b0, b1)
			    newrstate[SBREG_PRIUNAT] =
					UWX_DISP_REG(UWX_REG_GR(reg));
			    break;
			default:
			    TRACE_I_DECODE_PROLOGUE_2("(P3) ??", b0, b1)
			    return UWX_ERR_BADUDESC;
		    }
		}

		/* Format P4 (spill_mask) */
		else if (b0 == 0xb8) {
		    TRACE_I_DECODE_PROLOGUE_1("(P4) spill_mask", b0)
		    /* The spill_mask descriptor is followed by */
		    /* an imask field whose length is determined */
		    /* by the region length: there are two mask */
		    /* bits per instruction slot in the region. */
		    /* We decode these bits two at a time, counting */
		    /* the number of FRs, GRs, and BRs that are */
		    /* saved up to the slot of interest. Other */
		    /* descriptors describe which sets of these */
		    /* registers are spilled, and we put those */
		    /* two pieces of information together at the */
		    /* end of the main loop. */
		    t = 0;
		    while (t < rhdr->rlen) {
			b1 = uwx_get_byte(bstream);
			if (b1 < 0)
			    return UWX_ERR_BADUDESC;
			for (i = 0; i < 4 && (t + i) < ip_slot; i++) {
			    switch (b1 & 0xc0) {
				case 0x00: break;
				case 0x40: nfr++; break;
				case 0x80: ngr++; break;
				case 0xc0: nbr++; break;
			    }
			    b1 = b1 << 2;
			}
			t += 4;
		    }
		}

		/* Format P5 (frgr_mem) */
		else if (b0 == 0xb9) {
		    b1 = uwx_get_byte(bstream);
		    if (b1 < 0)
			return UWX_ERR_BADUDESC;
		    b2 = uwx_get_byte(bstream);
		    if (b2 < 0)
			return UWX_ERR_BADUDESC;
		    b3 = uwx_get_byte(bstream);
		    if (b3 < 0)
			return UWX_ERR_BADUDESC;
		    TRACE_I_DECODE_PROLOGUE_4("(P5) frgr_mem", b0, b1, b2, b3)
		    gr_mem_mask = b1 >> 4;
		    fr_mem_mask = ((b1 & 0x0f) << 16) | (b2 << 8) | b3;
		}

		/* Invalid descriptor record */
		else {
		    TRACE_I_DECODE_PROLOGUE_1("(?)", b0)
		    return UWX_ERR_BADUDESC;
		}

		break;

	    case 4:			/* 1100 xxxx */
		/* Format P6 (fr_mem) */
		TRACE_I_DECODE_PROLOGUE_1("(P6) fr_mem", b0)
		fr_mem_mask = b0 & 0x0f;
		break;

	    case 5:			/* 1101 xxxx */
		/* Format P6 (gr_mem) */
		TRACE_I_DECODE_PROLOGUE_1("(P6) gr_mem", b0)
		gr_mem_mask = b0 & 0x0f;
		break;

	    case 6:			/* 1110 xxxx */
		/* Format P7 */
		r = b0 & 0xf;
		status = uwx_get_uleb128(bstream, &parm1);
		if (status != 0)
		    return UWX_ERR_BADUDESC;
		switch (r) {
		    case 0:		/* mem_stack_f */
			status = uwx_get_uleb128(bstream, &parm2);
			if (status != 0)
			    return UWX_ERR_BADUDESC;
			TRACE_I_DECODE_PROLOGUE_1LL("(P7) mem_stack_f", b0, parm1, parm2)
			newrstate[SBREG_PSP] = UWX_DISP_SPPLUS(parm2 * 16);
			tspill[SBREG_PSP] = (int) parm1;
			break;
		    case 1:		/* mem_stack_v */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) mem_stack_v", b0, parm1)
			tspill[SBREG_PSP] = (int) parm1;
			break;
		    case 2:		/* spill_base */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) spill_base", b0, parm1)
			spill_base = 4 * (unsigned int) parm1;
			break;
		    case 3:		/* psp_sprel */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) psp_sprel", b0, parm1)
			newrstate[SBREG_PSP] = UWX_DISP_SPREL(parm1 * 4);
			break;
		    case 4:		/* rp_when */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) rp_when", b0, parm1)
			tspill[SBREG_RP] = (int) parm1;
			break;
		    case 5:		/* rp_psprel */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) rp_psprel", b0, parm1)
			newrstate[SBREG_RP] = UWX_DISP_PSPREL(parm1 * 4);
			break;
		    case 6:		/* pfs_when */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) pfs_when", b0, parm1)
			tspill[SBREG_PFS] = (int) parm1;
			break;
		    case 7:		/* pfs_psprel */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) pfs_psprel", b0, parm1)
			newrstate[SBREG_PFS] = UWX_DISP_PSPREL(parm1 * 4);
			break;
		    case 8:		/* preds_when */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) preds_when", b0, parm1)
			tspill[SBREG_PREDS] = (int) parm1;
			break;
		    case 9:		/* preds_psprel */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) preds_psprel", b0, parm1)
			newrstate[SBREG_PREDS] = UWX_DISP_PSPREL(parm1 * 4);
			break;
		    case 10:	/* lc_when */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) lc_when", b0, parm1)
			tspill[SBREG_LC] = (int) parm1;
			break;
		    case 11:	/* lc_psprel */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) lc_psprel", b0, parm1)
			newrstate[SBREG_LC] = UWX_DISP_PSPREL(parm1 * 4);
			break;
		    case 12:	/* unat_when */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) unat_when", b0, parm1)
			tspill[SBREG_UNAT] = (int) parm1;
			break;
		    case 13:	/* unat_psprel */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) unat_psprel", b0, parm1)
			newrstate[SBREG_UNAT] = UWX_DISP_PSPREL(parm1 * 4);
			break;
		    case 14:	/* fpsr_when */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) fpsr_when", b0, parm1)
			tspill[SBREG_FPSR] = (int) parm1;
			break;
		    case 15:	/* fpsr_psprel */
			TRACE_I_DECODE_PROLOGUE_1L("(P7) fpsr_psprel", b0, parm1)
			newrstate[SBREG_FPSR] = UWX_DISP_PSPREL(parm1 * 4);
			break;
		}
		break;

	    case 7:			/* 1111 xxxx */
		/* Format P8 */
		if (b0 == 0xf0) {
		    b1 = uwx_get_byte(bstream);
		    if (b1 < 0)
			return UWX_ERR_BADUDESC;
		    status = uwx_get_uleb128(bstream, &parm1);
		    if (status != 0)
			return UWX_ERR_BADUDESC;
		    switch (b1) {
			case 1:		/* rp_sprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) rp_sprel", b0, b1, parm1)
			    newrstate[SBREG_RP] = UWX_DISP_SPREL(parm1 * 4);
			    break;
			case 2:		/* pfs_sprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) pfs_sprel", b0, b1, parm1)
			    newrstate[SBREG_PFS] = UWX_DISP_SPREL(parm1 * 4);
			    break;
			case 3:		/* preds_sprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) preds_sprel", b0, b1, parm1)
			    newrstate[SBREG_PREDS] = UWX_DISP_SPREL(parm1 * 4);
			    break;
			case 4:		/* lc_sprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) lc_sprel", b0, b1, parm1)
			    newrstate[SBREG_LC] = UWX_DISP_SPREL(parm1 * 4);
			    break;
			case 5:		/* unat_sprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) unat_sprel", b0, b1, parm1)
			    newrstate[SBREG_UNAT] = UWX_DISP_SPREL(parm1 * 4);
			    break;
			case 6:		/* fpsr_sprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) fpsr_sprel", b0, b1, parm1)
			    newrstate[SBREG_FPSR] = UWX_DISP_SPREL(parm1 * 4);
			    break;
			case 7:		/* bsp_when */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) bsp_when", b0, b1, parm1)
			    /* Don't track BSP yet */
			    return UWX_ERR_CANTUNWIND;
			    break;
			case 8:		/* bsp_psprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) bsp_psprel", b0, b1, parm1)
			    /* Don't track BSP yet */
			    return UWX_ERR_CANTUNWIND;
			    break;
			case 9:		/* bsp_sprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) bsp_sprel", b0, b1, parm1)
			    /* Don't track BSP yet */
			    return UWX_ERR_CANTUNWIND;
			    break;
			case 10:	/* bspstore_when */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) bspstore_when", b0, b1, parm1)
			    /* Don't track BSP yet */
			    return UWX_ERR_CANTUNWIND;
			    break;
			case 11:	/* bspstore_psprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) bspstore_psprel", b0, b1, parm1)
			    /* Don't track BSP yet */
			    return UWX_ERR_CANTUNWIND;
			    break;
			case 12:	/* bspstore_sprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) bspstore_sprel", b0, b1, parm1)
			    /* Don't track BSP yet */
			    return UWX_ERR_CANTUNWIND;
			    break;
			case 13:	/* rnat_when */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) rnat_when", b0, b1, parm1)
			    tspill[SBREG_RNAT] = (int) parm1;
			    break;
			case 14:	/* rnat_psprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) rnat_psprel", b0, b1, parm1)
			    newrstate[SBREG_RNAT] = UWX_DISP_PSPREL(parm1 * 4);
			    break;
			case 15:	/* rnat_sprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) rnat_sprel", b0, b1, parm1)
			    newrstate[SBREG_RNAT] = UWX_DISP_SPREL(parm1 * 4);
			    break;
			case 16:	/* priunat_when_gr */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) priunat_when_gr", b0, b1, parm1)
			    tspill[SBREG_PRIUNAT] = (int) parm1;
			    break;
			case 17:	/* priunat_psprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) priunat_psprel", b0, b1, parm1)
			    priunat_mem_rstate = UWX_DISP_PSPREL(parm1 * 4);
			    break;
			case 18:	/* priunat_sprel */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) priunat_sprel", b0, b1, parm1)
			    priunat_mem_rstate = UWX_DISP_SPREL(parm1 * 4);
			    break;
			case 19:	/* priunat_when_mem */
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) priunat_when_mem", b0, b1, parm1)
			    t_priunat_mem = (int) parm1;
			    break;
			default:
			    TRACE_I_DECODE_PROLOGUE_2L("(P8) ??", b0, b1, parm1)
			    return UWX_ERR_BADUDESC;
		    }
		}

		/* Format P9 (gr_gr) */
		else if (b0 == 0xf1) {
		    b1 = uwx_get_byte(bstream);
		    if (b1 < 0)
			return UWX_ERR_BADUDESC;
		    b2 = uwx_get_byte(bstream);
		    if (b2 < 0)
			return UWX_ERR_BADUDESC;
		    TRACE_I_DECODE_PROLOGUE_3("(P9) gr_gr", b0, b1, b2)
		    mask = b1 & 0x0f;
		    reg = b2 & 0x7f;
		    gr_gr_mask = mask;
		    for (i = 0; i < NSB_GR && mask != 0; i++) {
			if (mask & 0x01) {
			    newrstate[SBREG_GR + i] =
					UWX_DISP_REG(UWX_REG_GR(reg));
			    reg++;
			}
			mask = mask >> 1;
		    }
		}

		/* Format X1 */
		else if (b0 == 0xf9) {
		    TRACE_I_DECODE_PROLOGUE_1("(X1)", b0)
		    b1 = uwx_get_byte(bstream);
		    if (b1 < 0)
			return UWX_ERR_BADUDESC;
		    /* Don't support X-format descriptors yet */
		    return UWX_ERR_CANTUNWIND;
		}

		/* Format X2 */
		else if (b0 == 0xfa) {
		    TRACE_I_DECODE_PROLOGUE_1("(X2)", b0)
		    b1 = uwx_get_byte(bstream);
		    if (b1 < 0)
			return UWX_ERR_BADUDESC;
		    b2 = uwx_get_byte(bstream);
		    if (b2 < 0)
			return UWX_ERR_BADUDESC;
		    /* Don't support X-format descriptors yet */
		    return UWX_ERR_CANTUNWIND;
		}

		/* Format X3 */
		else if (b0 == 0xfb) {
		    TRACE_I_DECODE_PROLOGUE_1("(X3)", b0)
		    b1 = uwx_get_byte(bstream);
		    if (b1 < 0)
			return UWX_ERR_BADUDESC;
		    b2 = uwx_get_byte(bstream);
		    if (b2 < 0)
			return UWX_ERR_BADUDESC;
		    /* Don't support X-format descriptors yet */
		    return UWX_ERR_CANTUNWIND;
		}

		/* Format X4 */
		else if (b0 == 0xfc) {
		    TRACE_I_DECODE_PROLOGUE_1("(X4)", b0)
		    b1 = uwx_get_byte(bstream);
		    if (b1 < 0)
			return UWX_ERR_BADUDESC;
		    b2 = uwx_get_byte(bstream);
		    if (b2 < 0)
			return UWX_ERR_BADUDESC;
		    b3 = uwx_get_byte(bstream);
		    if (b3 < 0)
			return UWX_ERR_BADUDESC;
		    /* Don't support X-format descriptors yet */
		    return UWX_ERR_CANTUNWIND;
		}

		/* Format P10 */
		else if (b0 == 0xff) {
		    b1 = uwx_get_byte(bstream);
		    if (b1 < 0)
			return UWX_ERR_BADUDESC;
		    b2 = uwx_get_byte(bstream);
		    if (b2 < 0)
			return UWX_ERR_BADUDESC;
		    TRACE_I_DECODE_PROLOGUE_3("(P10) abi", b0, b1, b2)
		    env->abi_context = (b1 << 8) | b2;
		    return UWX_ABI_FRAME;
		}

		/* Invalid descriptor record */
		else {
		    TRACE_I_DECODE_PROLOGUE_1("(?)", b0)
		    return UWX_ERR_BADUDESC;
		}
		break;
	}
    }

    /* Process the masks of spilled GRs, FRs, and BRs to */
    /* determine when and where each register was saved. */

    fr_base = spill_base + 16 * uwx_count_ones(fr_mem_mask);
    br_base = fr_base + 8 * uwx_count_ones(br_mem_mask);
    gr_base = br_base + 8 * uwx_count_ones(gr_mem_mask);
    TRACE_I_DECODE_PROLOGUE_SPILL_BASE(spill_base)
    TRACE_I_DECODE_PROLOGUE_MASKS(gr_mem_mask, gr_gr_mask)
    TRACE_I_DECODE_PROLOGUE_NSPILL(ngr)
    for (i = 0; ngr > 0 && i <= NSB_GR; i++) {
	if (gr_mem_mask & 1) {
	    newrstate[SBREG_GR + i] = UWX_DISP_PSPREL(gr_base);
	    tspill[SBREG_GR + i] = 0;
	    gr_base -= 8;
	    ngr--;
	}
	else if (gr_gr_mask & 1) {
	    tspill[SBREG_GR + i] = 0;
	    ngr--;
	}
	gr_gr_mask = gr_gr_mask >> 1;
	gr_mem_mask = gr_mem_mask >> 1;
    }
    for (i = 0; nbr > 0 && i <= NSB_BR; i++) {
	if (br_mem_mask & 1) {
	    newrstate[SBREG_BR + i] = UWX_DISP_PSPREL(br_base);
	    tspill[SBREG_BR + i] = 0;
	    br_base -= 8;
	    nbr--;
	}
	else if (br_gr_mask & 1) {
	    tspill[SBREG_BR + i] = 0;
	    nbr--;
	}
	br_gr_mask = br_gr_mask >> 1;
	br_mem_mask = br_mem_mask >> 1;
    }
    for (i = 0; nfr > 0 && i <= NSB_FR; i++) {
	if (fr_mem_mask & 1) {
	    newrstate[SBREG_FR + i] = UWX_DISP_PSPREL(fr_base);
	    tspill[SBREG_FR + i] = 0;
	    fr_base -= 8;
	    nfr--;
	}
	fr_mem_mask = fr_mem_mask >> 1;
    }

    /* Update the scoreboard. */

    for (i = 0; i < env->nsbreg; i++) {
	if (ip_slot > tspill[i])
	    scoreboard->rstate[i] = newrstate[i];
    }
    if (priunat_mem_rstate != UWX_DISP_NONE && ip_slot > t_priunat_mem)
	scoreboard->rstate[SBREG_PRIUNAT] = priunat_mem_rstate;

    return UWX_OK;
}

int uwx_count_ones(unsigned int mask)
{
    mask = (mask & 0x55555555) + ((mask & 0xaaaaaaaa) >> 1);
    mask = (mask & 0x33333333) + ((mask & 0xcccccccc) >> 2);
    mask = (mask & 0x0f0f0f0f) + ((mask & 0xf0f0f0f0) >> 4);
    mask = (mask & 0x00ff00ff) + ((mask & 0xff00ff00) >> 8);
    return (mask & 0x0000ffff) + ((mask & 0xffff0000) >> 16);
}

/* uwx_decode_body: Decodes a body region */

int uwx_decode_body(
    struct uwx_env *env,
    struct uwx_bstream *bstream,
    struct uwx_scoreboard *scoreboard,
    struct uwx_rhdr *rhdr,
    int ip_slot)
{
    int status;
    int b0;
    int b1;
    int b2;
    int b3;
    int label;
    int ecount;
    int i;
    uint64_t parm1;
    uint64_t parm2;
    uint64_t newrstate[NSBREG];
    int tspill[NSBREG];
    int t_sp_restore;

    /* Initialize an array of register states from the current */
    /* scoreboard, along with a parallel array of spill times. */
    /* We use this as a temporary scoreboard, then update the */
    /* real scoreboard at the end of the procedure. */
    /* We initialize the spill time to (rhdr.rlen - 1) so that */
    /* spills without a "when" descriptor will take effect */
    /* at the end of the prologue region. */
    /* (Boundary condition: all actions in a zero-length prologue */
    /* will appear to have happened in the instruction slot */
    /* immediately preceding the prologue.) */

    for (i = 0; i < env->nsbreg; i++) {
	newrstate[i] = scoreboard->rstate[i];
	tspill[i] = rhdr->rlen - 1;
    }
    t_sp_restore = rhdr->rlen - 1;

    /* Read body descriptor records until */
    /* we hit another region header. */

    for (;;) {

	b0 = uwx_get_byte(bstream);

	if (b0 < 0x80) {
	    /* Return the last byte read to the byte stream, since it's */
	    /* really the first byte of the next region header record. */
	    if (b0 >= 0)
		(void) uwx_unget_byte(bstream, b0);
	    break;
	}

	/* Format B1 (label_state) */
	if (b0 < 0xa0) {
	    TRACE_I_DECODE_BODY_1("(B1) label_state", b0)
	    label = b0 & 0x1f;
	    status = uwx_label_scoreboard(env, scoreboard, label);
	    if (status != UWX_OK)
		return (status);
	}

	/* Format B1 (copy_state)  */
	else if (b0 < 0xc0) {
	    TRACE_I_DECODE_BODY_1("(B1) copy_state", b0)
	    label = b0 & 0x1f;
	    status = uwx_copy_scoreboard(env, scoreboard, label);
	    if (status != UWX_OK)
		return (status);
	    for (i = 0; i < env->nsbreg; i++) {
		newrstate[i] = scoreboard->rstate[i];
		tspill[i] = rhdr->rlen;
	    }
	}

	/* Format B2 (epilogue) */
	else if (b0 < 0xe0) {
	    ecount = b0 & 0x1f;
	    status = uwx_get_uleb128(bstream, &parm1);
	    if (status != 0)
		return UWX_ERR_BADUDESC;
	    TRACE_I_DECODE_BODY_1L("(B2) epilogue", b0, parm1)
	    rhdr->ecount = ecount + 1;
	    t_sp_restore = rhdr->rlen - (unsigned int) parm1;
	}

	/* Format B3 (epilogue) */
	else if (b0 == 0xe0) {
	    status = uwx_get_uleb128(bstream, &parm1);
	    if (status != 0)
		return UWX_ERR_BADUDESC;
	    status = uwx_get_uleb128(bstream, &parm2);
	    if (status != 0)
		return UWX_ERR_BADUDESC;
	    TRACE_I_DECODE_BODY_1LL("(B3) epilogue", b0, parm1, parm2)
	    t_sp_restore = rhdr->rlen - (unsigned int) parm1;
	    rhdr->ecount = (unsigned int) parm2 + 1;
	}

	/* Format B4 (label_state) */
	else if (b0 == 0xf0) {
	    status = uwx_get_uleb128(bstream, &parm1);
	    if (status != 0)
		return UWX_ERR_BADUDESC;
	    TRACE_I_DECODE_BODY_1L("(B4) label_state", b0, parm1)
	    label = (int) parm1;
	    status = uwx_label_scoreboard(env, scoreboard, label);
	    if (status != UWX_OK)
		return (status);
	}

	/* Format B4 (copy_state) */
	else if (b0 == 0xf8) {
	    status = uwx_get_uleb128(bstream, &parm1);
	    if (status != 0)
		return UWX_ERR_BADUDESC;
	    TRACE_I_DECODE_BODY_1L("(B4) copy_state", b0, parm1)
	    label = (int) parm1;
	    status = uwx_copy_scoreboard(env, scoreboard, label);
	    if (status != UWX_OK)
		return (status);
	    for (i = 0; i < env->nsbreg; i++) {
		newrstate[i] = scoreboard->rstate[i];
		tspill[i] = rhdr->rlen;
	    }
	}

	/* Format X1 */
	else if (b0 == 0xf9) {
	    TRACE_I_DECODE_BODY_1("(X1)", b0)
	    b1 = uwx_get_byte(bstream);
	    if (b1 < 0)
		return UWX_ERR_BADUDESC;
	    /* Don't support X-format descriptors yet */
	    return UWX_ERR_CANTUNWIND;
	}

	/* Format X2 */
	else if (b0 == 0xfa) {
	    TRACE_I_DECODE_BODY_1("(X2)", b0)
	    b1 = uwx_get_byte(bstream);
	    if (b1 < 0)
		return UWX_ERR_BADUDESC;
	    b2 = uwx_get_byte(bstream);
	    if (b2 < 0)
		return UWX_ERR_BADUDESC;
	    /* Don't support X-format descriptors yet */
	    return UWX_ERR_CANTUNWIND;
	}

	/* Format X3 */
	else if (b0 == 0xfb) {
	    TRACE_I_DECODE_BODY_1("(X3)", b0)
	    b1 = uwx_get_byte(bstream);
	    if (b1 < 0)
		return UWX_ERR_BADUDESC;
	    b2 = uwx_get_byte(bstream);
	    if (b2 < 0)
		return UWX_ERR_BADUDESC;
	    /* Don't support X-format descriptors yet */
	    return UWX_ERR_CANTUNWIND;
	}

	/* Format X4 */
	else if (b0 == 0xfc) {
	    TRACE_I_DECODE_BODY_1("(X4)", b0)
	    b1 = uwx_get_byte(bstream);
	    if (b1 < 0)
		return UWX_ERR_BADUDESC;
	    b2 = uwx_get_byte(bstream);
	    if (b2 < 0)
		return UWX_ERR_BADUDESC;
	    b3 = uwx_get_byte(bstream);
	    if (b3 < 0)
		return UWX_ERR_BADUDESC;
	    /* Don't support X-format descriptors yet */
	    return UWX_ERR_CANTUNWIND;
	}

	/* Invalid descriptor record */
	else {
	    TRACE_I_DECODE_BODY_1("(?)", b0)
	    return UWX_ERR_BADUDESC;
	}
    }

    /* Update the scoreboard. */

    for (i = 0; i < env->nsbreg; i++) {
	if (ip_slot > tspill[i])
	    scoreboard->rstate[i] = newrstate[i];
    }

    /* If we've passed the point in the epilogue where sp */
    /* is restored, update the scoreboard entry for PSP */
    /* and reset any entries for registers saved in memory. */

    if (ip_slot > t_sp_restore) {
	scoreboard->rstate[SBREG_PSP] = UWX_DISP_SPPLUS(0);
	for (i = 0; i < env->nsbreg; i++) {
	    if (UWX_GET_DISP_CODE(scoreboard->rstate[i]) == UWX_DISP_SPREL(0) ||
		UWX_GET_DISP_CODE(scoreboard->rstate[i]) == UWX_DISP_PSPREL(0))
		scoreboard->rstate[i] = UWX_DISP_NONE;
	}
    }

    return UWX_OK;
}