[linux-block.git] / arch / ia64 / kernel / unwind_decoder.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2000 Hewlett-Packard Co
 * Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com>
 *
 * Generic IA-64 unwind info decoder.
 *
 * This file is used both by the Linux kernel and objdump.  Please keep
 * the two copies of this file in sync.
 *
 * You need to customize the decoder by defining the following
 * macros/constants before including this file:
 *
 *  Types:
 *	unw_word	Unsigned integer type with at least 64 bits 
 *
 *  Register names:
 *	UNW_REG_BSP
 *	UNW_REG_BSPSTORE
 *	UNW_REG_FPSR
 *	UNW_REG_LC
 *	UNW_REG_PFS
 *	UNW_REG_PR
 *	UNW_REG_RNAT
 *	UNW_REG_PSP
 *	UNW_REG_RP
 *	UNW_REG_UNAT
 *
 *  Decoder action macros:
 *	UNW_DEC_BAD_CODE(code)
 *	UNW_DEC_ABI(fmt,abi,context,arg)
 *	UNW_DEC_BR_GR(fmt,brmask,gr,arg)
 *	UNW_DEC_BR_MEM(fmt,brmask,arg)
 *	UNW_DEC_COPY_STATE(fmt,label,arg)
 *	UNW_DEC_EPILOGUE(fmt,t,ecount,arg)
 *	UNW_DEC_FRGR_MEM(fmt,grmask,frmask,arg)
 *	UNW_DEC_FR_MEM(fmt,frmask,arg)
 *	UNW_DEC_GR_GR(fmt,grmask,gr,arg)
 *	UNW_DEC_GR_MEM(fmt,grmask,arg)
 *	UNW_DEC_LABEL_STATE(fmt,label,arg)
 *	UNW_DEC_MEM_STACK_F(fmt,t,size,arg)
 *	UNW_DEC_MEM_STACK_V(fmt,t,arg)
 *	UNW_DEC_PRIUNAT_GR(fmt,r,arg)
 *	UNW_DEC_PRIUNAT_WHEN_GR(fmt,t,arg)
 *	UNW_DEC_PRIUNAT_WHEN_MEM(fmt,t,arg)
 *	UNW_DEC_PRIUNAT_WHEN_PSPREL(fmt,pspoff,arg)
 *	UNW_DEC_PRIUNAT_WHEN_SPREL(fmt,spoff,arg)
 *	UNW_DEC_PROLOGUE(fmt,body,rlen,arg)
 *	UNW_DEC_PROLOGUE_GR(fmt,rlen,mask,grsave,arg)
 *	UNW_DEC_REG_PSPREL(fmt,reg,pspoff,arg)
 *	UNW_DEC_REG_REG(fmt,src,dst,arg)
 *	UNW_DEC_REG_SPREL(fmt,reg,spoff,arg)
 *	UNW_DEC_REG_WHEN(fmt,reg,t,arg)
 *	UNW_DEC_RESTORE(fmt,t,abreg,arg)
 *	UNW_DEC_RESTORE_P(fmt,qp,t,abreg,arg)
 *	UNW_DEC_SPILL_BASE(fmt,pspoff,arg)
 *	UNW_DEC_SPILL_MASK(fmt,imaskp,arg)
 *	UNW_DEC_SPILL_PSPREL(fmt,t,abreg,pspoff,arg)
 *	UNW_DEC_SPILL_PSPREL_P(fmt,qp,t,abreg,pspoff,arg)
 *	UNW_DEC_SPILL_REG(fmt,t,abreg,x,ytreg,arg)
 *	UNW_DEC_SPILL_REG_P(fmt,qp,t,abreg,x,ytreg,arg)
 *	UNW_DEC_SPILL_SPREL(fmt,t,abreg,spoff,arg)
 *	UNW_DEC_SPILL_SPREL_P(fmt,qp,t,abreg,pspoff,arg)
 */

static unw_word
unw_decode_uleb128 (unsigned char **dpp)
{
  unsigned shift = 0;
  unw_word byte, result = 0;
  unsigned char *bp = *dpp;

  while (1)
    {
      byte = *bp++;
      result |= (byte & 0x7f) << shift;
      if ((byte & 0x80) == 0)
	break;
      shift += 7;
    }
  *dpp = bp;
  return result;
}

static unsigned char *
unw_decode_x1 (unsigned char *dp, unsigned char code, void *arg)
{
  unsigned char byte1, abreg;
  unw_word t, off;

  byte1 = *dp++;
  t = unw_decode_uleb128 (&dp);
  off = unw_decode_uleb128 (&dp);
  abreg = (byte1 & 0x7f);
  if (byte1 & 0x80)
	  UNW_DEC_SPILL_SPREL(X1, t, abreg, off, arg);
  else
	  UNW_DEC_SPILL_PSPREL(X1, t, abreg, off, arg);
  return dp;
}

static unsigned char *
unw_decode_x2 (unsigned char *dp, unsigned char code, void *arg)
{
  unsigned char byte1, byte2, abreg, x, ytreg;
  unw_word t;

  byte1 = *dp++; byte2 = *dp++;
  t = unw_decode_uleb128 (&dp);
  abreg = (byte1 & 0x7f);
  ytreg = byte2;
  x = (byte1 >> 7) & 1;
  if ((byte1 & 0x80) == 0 && ytreg == 0)
    UNW_DEC_RESTORE(X2, t, abreg, arg);
  else
    UNW_DEC_SPILL_REG(X2, t, abreg, x, ytreg, arg);
  return dp;
}

static unsigned char *
unw_decode_x3 (unsigned char *dp, unsigned char code, void *arg)
{
  unsigned char byte1, byte2, abreg, qp;
  unw_word t, off;

  byte1 = *dp++; byte2 = *dp++;
  t = unw_decode_uleb128 (&dp);
  off = unw_decode_uleb128 (&dp);

  qp = (byte1 & 0x3f);
  abreg = (byte2 & 0x7f);

  if (byte1 & 0x80)
    UNW_DEC_SPILL_SPREL_P(X3, qp, t, abreg, off, arg);
  else
    UNW_DEC_SPILL_PSPREL_P(X3, qp, t, abreg, off, arg);
  return dp;
}

static unsigned char *
unw_decode_x4 (unsigned char *dp, unsigned char code, void *arg)
{
  unsigned char byte1, byte2, byte3, qp, abreg, x, ytreg;
  unw_word t;

  byte1 = *dp++; byte2 = *dp++; byte3 = *dp++;
  t = unw_decode_uleb128 (&dp);

  qp = (byte1 & 0x3f);
  abreg = (byte2 & 0x7f);
  x = (byte2 >> 7) & 1;
  ytreg = byte3;

  if ((byte2 & 0x80) == 0 && byte3 == 0)
    UNW_DEC_RESTORE_P(X4, qp, t, abreg, arg);
  else
    UNW_DEC_SPILL_REG_P(X4, qp, t, abreg, x, ytreg, arg);
  return dp;
}

static unsigned char *
unw_decode_r1 (unsigned char *dp, unsigned char code, void *arg)
{
  int body = (code & 0x20) != 0;
  unw_word rlen;

  rlen = (code & 0x1f);
  UNW_DEC_PROLOGUE(R1, body, rlen, arg);
  return dp;
}

static unsigned char *
unw_decode_r2 (unsigned char *dp, unsigned char code, void *arg)
{
  unsigned char byte1, mask, grsave;
  unw_word rlen;

  byte1 = *dp++;

  mask = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
  grsave = (byte1 & 0x7f);
  rlen = unw_decode_uleb128 (&dp);
  UNW_DEC_PROLOGUE_GR(R2, rlen, mask, grsave, arg);
  return dp;
}

static unsigned char *
unw_decode_r3 (unsigned char *dp, unsigned char code, void *arg)
{
  unw_word rlen;

  rlen = unw_decode_uleb128 (&dp);
  UNW_DEC_PROLOGUE(R3, ((code & 0x3) == 1), rlen, arg);
  return dp;
}

static unsigned char *
unw_decode_p1 (unsigned char *dp, unsigned char code, void *arg)
{
  unsigned char brmask = (code & 0x1f);

  UNW_DEC_BR_MEM(P1, brmask, arg);
  return dp;
}

static unsigned char *
unw_decode_p2_p5 (unsigned char *dp, unsigned char code, void *arg)
{
  if ((code & 0x10) == 0)
    {
      unsigned char byte1 = *dp++;

      UNW_DEC_BR_GR(P2, ((code & 0xf) << 1) | ((byte1 >> 7) & 1),
		    (byte1 & 0x7f), arg);
    }
  else if ((code & 0x08) == 0)
    {
      unsigned char byte1 = *dp++, r, dst;

      r = ((code & 0x7) << 1) | ((byte1 >> 7) & 1);
      dst = (byte1 & 0x7f);
      switch (r)
	{
	case 0: UNW_DEC_REG_GR(P3, UNW_REG_PSP, dst, arg); break;
	case 1: UNW_DEC_REG_GR(P3, UNW_REG_RP, dst, arg); break;
	case 2: UNW_DEC_REG_GR(P3, UNW_REG_PFS, dst, arg); break;
	case 3: UNW_DEC_REG_GR(P3, UNW_REG_PR, dst, arg); break;
	case 4: UNW_DEC_REG_GR(P3, UNW_REG_UNAT, dst, arg); break;
	case 5: UNW_DEC_REG_GR(P3, UNW_REG_LC, dst, arg); break;
	case 6: UNW_DEC_RP_BR(P3, dst, arg); break;
	case 7: UNW_DEC_REG_GR(P3, UNW_REG_RNAT, dst, arg); break;
	case 8: UNW_DEC_REG_GR(P3, UNW_REG_BSP, dst, arg); break;
	case 9: UNW_DEC_REG_GR(P3, UNW_REG_BSPSTORE, dst, arg); break;
	case 10: UNW_DEC_REG_GR(P3, UNW_REG_FPSR, dst, arg); break;
	case 11: UNW_DEC_PRIUNAT_GR(P3, dst, arg); break;
	default: UNW_DEC_BAD_CODE(r); break;
	}
    }
  else if ((code & 0x7) == 0)
    UNW_DEC_SPILL_MASK(P4, dp, arg);
  else if ((code & 0x7) == 1)
    {
      unw_word grmask, frmask, byte1, byte2, byte3;

      byte1 = *dp++; byte2 = *dp++; byte3 = *dp++;
      grmask = ((byte1 >> 4) & 0xf);
      frmask = ((byte1 & 0xf) << 16) | (byte2 << 8) | byte3;
      UNW_DEC_FRGR_MEM(P5, grmask, frmask, arg);
    }
  else
    UNW_DEC_BAD_CODE(code);
  return dp;
}

static unsigned char *
unw_decode_p6 (unsigned char *dp, unsigned char code, void *arg)
{
  int gregs = (code & 0x10) != 0;
  unsigned char mask = (code & 0x0f);

  if (gregs)
    UNW_DEC_GR_MEM(P6, mask, arg);
  else
    UNW_DEC_FR_MEM(P6, mask, arg);
  return dp;
}

static unsigned char *
unw_decode_p7_p10 (unsigned char *dp, unsigned char code, void *arg)
{
  unsigned char r, byte1, byte2;
  unw_word t, size;

  if ((code & 0x10) == 0)
    {
      r = (code & 0xf);
      t = unw_decode_uleb128 (&dp);
      switch (r)
	{
	case 0:
	  size = unw_decode_uleb128 (&dp);
	  UNW_DEC_MEM_STACK_F(P7, t, size, arg);
	  break;

	case 1: UNW_DEC_MEM_STACK_V(P7, t, arg); break;
	case 2: UNW_DEC_SPILL_BASE(P7, t, arg); break;
	case 3: UNW_DEC_REG_SPREL(P7, UNW_REG_PSP, t, arg); break;
	case 4: UNW_DEC_REG_WHEN(P7, UNW_REG_RP, t, arg); break;
	case 5: UNW_DEC_REG_PSPREL(P7, UNW_REG_RP, t, arg); break;
	case 6: UNW_DEC_REG_WHEN(P7, UNW_REG_PFS, t, arg); break;
	case 7: UNW_DEC_REG_PSPREL(P7, UNW_REG_PFS, t, arg); break;
	case 8: UNW_DEC_REG_WHEN(P7, UNW_REG_PR, t, arg); break;
	case 9: UNW_DEC_REG_PSPREL(P7, UNW_REG_PR, t, arg); break;
	case 10: UNW_DEC_REG_WHEN(P7, UNW_REG_LC, t, arg); break;
	case 11: UNW_DEC_REG_PSPREL(P7, UNW_REG_LC, t, arg); break;
	case 12: UNW_DEC_REG_WHEN(P7, UNW_REG_UNAT, t, arg); break;
	case 13: UNW_DEC_REG_PSPREL(P7, UNW_REG_UNAT, t, arg); break;
	case 14: UNW_DEC_REG_WHEN(P7, UNW_REG_FPSR, t, arg); break;
	case 15: UNW_DEC_REG_PSPREL(P7, UNW_REG_FPSR, t, arg); break;
	default: UNW_DEC_BAD_CODE(r); break;
	}
    }
  else
    {
      switch (code & 0xf)
	{
	case 0x0: /* p8 */
	  {
	    r = *dp++;
	    t = unw_decode_uleb128 (&dp);
	    switch (r)
	      {
	      case  1: UNW_DEC_REG_SPREL(P8, UNW_REG_RP, t, arg); break;
	      case  2: UNW_DEC_REG_SPREL(P8, UNW_REG_PFS, t, arg); break;
	      case  3: UNW_DEC_REG_SPREL(P8, UNW_REG_PR, t, arg); break;
	      case  4: UNW_DEC_REG_SPREL(P8, UNW_REG_LC, t, arg); break;
	      case  5: UNW_DEC_REG_SPREL(P8, UNW_REG_UNAT, t, arg); break;
	      case  6: UNW_DEC_REG_SPREL(P8, UNW_REG_FPSR, t, arg); break;
	      case  7: UNW_DEC_REG_WHEN(P8, UNW_REG_BSP, t, arg); break;
	      case  8: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSP, t, arg); break;
	      case  9: UNW_DEC_REG_SPREL(P8, UNW_REG_BSP, t, arg); break;
	      case 10: UNW_DEC_REG_WHEN(P8, UNW_REG_BSPSTORE, t, arg); break;
	      case 11: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
	      case 12: UNW_DEC_REG_SPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
	      case 13: UNW_DEC_REG_WHEN(P8, UNW_REG_RNAT, t, arg); break;
	      case 14: UNW_DEC_REG_PSPREL(P8, UNW_REG_RNAT, t, arg); break;
	      case 15: UNW_DEC_REG_SPREL(P8, UNW_REG_RNAT, t, arg); break;
	      case 16: UNW_DEC_PRIUNAT_WHEN_GR(P8, t, arg); break;
	      case 17: UNW_DEC_PRIUNAT_PSPREL(P8, t, arg); break;
	      case 18: UNW_DEC_PRIUNAT_SPREL(P8, t, arg); break;
	      case 19: UNW_DEC_PRIUNAT_WHEN_MEM(P8, t, arg); break;
	      default: UNW_DEC_BAD_CODE(r); break;
	    }
	  }
	  break;

	case 0x1:
	  byte1 = *dp++; byte2 = *dp++;
	  UNW_DEC_GR_GR(P9, (byte1 & 0xf), (byte2 & 0x7f), arg);
	  break;

	case 0xf: /* p10 */
	  byte1 = *dp++; byte2 = *dp++;
	  UNW_DEC_ABI(P10, byte1, byte2, arg);
	  break;

	case 0x9:
	  return unw_decode_x1 (dp, code, arg);

	case 0xa:
	  return unw_decode_x2 (dp, code, arg);

	case 0xb:
	  return unw_decode_x3 (dp, code, arg);

	case 0xc:
	  return unw_decode_x4 (dp, code, arg);

	default:
	  UNW_DEC_BAD_CODE(code);
	  break;
	}
    }
  return dp;
}

static unsigned char *
unw_decode_b1 (unsigned char *dp, unsigned char code, void *arg)
{
  unw_word label = (code & 0x1f);

  if ((code & 0x20) != 0)
    UNW_DEC_COPY_STATE(B1, label, arg);
  else
    UNW_DEC_LABEL_STATE(B1, label, arg);
  return dp;
}

static unsigned char *
unw_decode_b2 (unsigned char *dp, unsigned char code, void *arg)
{
  unw_word t;

  t = unw_decode_uleb128 (&dp);
  UNW_DEC_EPILOGUE(B2, t, (code & 0x1f), arg);
  return dp;
}

static unsigned char *
unw_decode_b3_x4 (unsigned char *dp, unsigned char code, void *arg)
{
  unw_word t, ecount, label;

  if ((code & 0x10) == 0)
    {
      t = unw_decode_uleb128 (&dp);
      ecount = unw_decode_uleb128 (&dp);
      UNW_DEC_EPILOGUE(B3, t, ecount, arg);
    }
  else if ((code & 0x07) == 0)
    {
      label = unw_decode_uleb128 (&dp);
      if ((code & 0x08) != 0)
	UNW_DEC_COPY_STATE(B4, label, arg);
      else
	UNW_DEC_LABEL_STATE(B4, label, arg);
    }
  else
    switch (code & 0x7)
      {
      case 1: return unw_decode_x1 (dp, code, arg);
      case 2: return unw_decode_x2 (dp, code, arg);
      case 3: return unw_decode_x3 (dp, code, arg);
      case 4: return unw_decode_x4 (dp, code, arg);
      default: UNW_DEC_BAD_CODE(code); break;
      }
  return dp;
}

typedef unsigned char *(*unw_decoder) (unsigned char *, unsigned char, void *);

static unw_decoder unw_decode_table[2][8] =
{
  /* prologue table: */
  {
    unw_decode_r1,	/* 0 */
    unw_decode_r1,
    unw_decode_r2,
    unw_decode_r3,
    unw_decode_p1,	/* 4 */
    unw_decode_p2_p5,
    unw_decode_p6,
    unw_decode_p7_p10
  },
  {
    unw_decode_r1,	/* 0 */
    unw_decode_r1,
    unw_decode_r2,
    unw_decode_r3,
    unw_decode_b1,	/* 4 */
    unw_decode_b1,
    unw_decode_b2,
    unw_decode_b3_x4
  }
};

/*
 * Decode one descriptor and return address of next descriptor.
 */
static inline unsigned char *
unw_decode (unsigned char *dp, int inside_body, void *arg)
{
  unw_decoder decoder;
  unsigned char code;

  code = *dp++;
  decoder = unw_decode_table[inside_body][code >> 5];
  dp = (*decoder) (dp, code, arg);
  return dp;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/*
	3	* Copyright (C) 2000 Hewlett-Packard Co
	4	* Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com>
	5	*
	6	* Generic IA-64 unwind info decoder.
	7	*
	8	* This file is used both by the Linux kernel and objdump. Please keep
	9	* the two copies of this file in sync.
	10	*
	11	* You need to customize the decoder by defining the following
	12	* macros/constants before including this file:
	13	*
	14	* Types:
	15	* unw_word Unsigned integer type with at least 64 bits
	16	*
	17	* Register names:
	18	* UNW_REG_BSP
	19	* UNW_REG_BSPSTORE
	20	* UNW_REG_FPSR
	21	* UNW_REG_LC
	22	* UNW_REG_PFS
	23	* UNW_REG_PR
	24	* UNW_REG_RNAT
	25	* UNW_REG_PSP
	26	* UNW_REG_RP
	27	* UNW_REG_UNAT
	28	*
	29	* Decoder action macros:
	30	* UNW_DEC_BAD_CODE(code)
	31	* UNW_DEC_ABI(fmt,abi,context,arg)
	32	* UNW_DEC_BR_GR(fmt,brmask,gr,arg)
	33	* UNW_DEC_BR_MEM(fmt,brmask,arg)
	34	* UNW_DEC_COPY_STATE(fmt,label,arg)
	35	* UNW_DEC_EPILOGUE(fmt,t,ecount,arg)
	36	* UNW_DEC_FRGR_MEM(fmt,grmask,frmask,arg)
	37	* UNW_DEC_FR_MEM(fmt,frmask,arg)
	38	* UNW_DEC_GR_GR(fmt,grmask,gr,arg)
	39	* UNW_DEC_GR_MEM(fmt,grmask,arg)
	40	* UNW_DEC_LABEL_STATE(fmt,label,arg)
	41	* UNW_DEC_MEM_STACK_F(fmt,t,size,arg)
	42	* UNW_DEC_MEM_STACK_V(fmt,t,arg)
	43	* UNW_DEC_PRIUNAT_GR(fmt,r,arg)
	44	* UNW_DEC_PRIUNAT_WHEN_GR(fmt,t,arg)
	45	* UNW_DEC_PRIUNAT_WHEN_MEM(fmt,t,arg)
	46	* UNW_DEC_PRIUNAT_WHEN_PSPREL(fmt,pspoff,arg)
	47	* UNW_DEC_PRIUNAT_WHEN_SPREL(fmt,spoff,arg)
	48	* UNW_DEC_PROLOGUE(fmt,body,rlen,arg)
	49	* UNW_DEC_PROLOGUE_GR(fmt,rlen,mask,grsave,arg)
	50	* UNW_DEC_REG_PSPREL(fmt,reg,pspoff,arg)
	51	* UNW_DEC_REG_REG(fmt,src,dst,arg)
	52	* UNW_DEC_REG_SPREL(fmt,reg,spoff,arg)
	53	* UNW_DEC_REG_WHEN(fmt,reg,t,arg)
	54	* UNW_DEC_RESTORE(fmt,t,abreg,arg)
	55	* UNW_DEC_RESTORE_P(fmt,qp,t,abreg,arg)
	56	* UNW_DEC_SPILL_BASE(fmt,pspoff,arg)
	57	* UNW_DEC_SPILL_MASK(fmt,imaskp,arg)
	58	* UNW_DEC_SPILL_PSPREL(fmt,t,abreg,pspoff,arg)
	59	* UNW_DEC_SPILL_PSPREL_P(fmt,qp,t,abreg,pspoff,arg)
	60	* UNW_DEC_SPILL_REG(fmt,t,abreg,x,ytreg,arg)
	61	* UNW_DEC_SPILL_REG_P(fmt,qp,t,abreg,x,ytreg,arg)
	62	* UNW_DEC_SPILL_SPREL(fmt,t,abreg,spoff,arg)
	63	* UNW_DEC_SPILL_SPREL_P(fmt,qp,t,abreg,pspoff,arg)
	64	*/
	65
66	static unw_word
67	unw_decode_uleb128 (unsigned char **dpp)
68	{
69	unsigned shift = 0;
70	unw_word byte, result = 0;
71	unsigned char bp = dpp;
72
73	while (1)
74	{
75	byte = *bp++;
76	result \|= (byte & 0x7f) << shift;
77	if ((byte & 0x80) == 0)
78	break;
79	shift += 7;
80	}
81	*dpp = bp;
82	return result;
83	}
84
85	static unsigned char *
86	unw_decode_x1 (unsigned char dp, unsigned char code, void arg)
87	{
88	unsigned char byte1, abreg;
89	unw_word t, off;
90
91	byte1 = *dp++;
92	t = unw_decode_uleb128 (&dp);
93	off = unw_decode_uleb128 (&dp);
94	abreg = (byte1 & 0x7f);
95	if (byte1 & 0x80)
96	UNW_DEC_SPILL_SPREL(X1, t, abreg, off, arg);
97	else
98	UNW_DEC_SPILL_PSPREL(X1, t, abreg, off, arg);
99	return dp;
100	}
101
102	static unsigned char *
103	unw_decode_x2 (unsigned char dp, unsigned char code, void arg)
104	{
105	unsigned char byte1, byte2, abreg, x, ytreg;
106	unw_word t;
107
108	byte1 = dp++; byte2 = dp++;
109	t = unw_decode_uleb128 (&dp);
110	abreg = (byte1 & 0x7f);
111	ytreg = byte2;
112	x = (byte1 >> 7) & 1;
113	if ((byte1 & 0x80) == 0 && ytreg == 0)
114	UNW_DEC_RESTORE(X2, t, abreg, arg);
115	else
116	UNW_DEC_SPILL_REG(X2, t, abreg, x, ytreg, arg);
117	return dp;
118	}
119
120	static unsigned char *
121	unw_decode_x3 (unsigned char dp, unsigned char code, void arg)
122	{
123	unsigned char byte1, byte2, abreg, qp;
124	unw_word t, off;
125
126	byte1 = dp++; byte2 = dp++;
127	t = unw_decode_uleb128 (&dp);
128	off = unw_decode_uleb128 (&dp);
129
130	qp = (byte1 & 0x3f);
131	abreg = (byte2 & 0x7f);
132
133	if (byte1 & 0x80)
134	UNW_DEC_SPILL_SPREL_P(X3, qp, t, abreg, off, arg);
135	else
136	UNW_DEC_SPILL_PSPREL_P(X3, qp, t, abreg, off, arg);
137	return dp;
138	}
139
140	static unsigned char *
141	unw_decode_x4 (unsigned char dp, unsigned char code, void arg)
142	{
143	unsigned char byte1, byte2, byte3, qp, abreg, x, ytreg;
144	unw_word t;
145
146	byte1 = dp++; byte2 = dp++; byte3 = *dp++;
147	t = unw_decode_uleb128 (&dp);
148
149	qp = (byte1 & 0x3f);
150	abreg = (byte2 & 0x7f);
151	x = (byte2 >> 7) & 1;
152	ytreg = byte3;
153
154	if ((byte2 & 0x80) == 0 && byte3 == 0)
155	UNW_DEC_RESTORE_P(X4, qp, t, abreg, arg);
156	else
157	UNW_DEC_SPILL_REG_P(X4, qp, t, abreg, x, ytreg, arg);
158	return dp;
159	}
160
161	static unsigned char *
162	unw_decode_r1 (unsigned char dp, unsigned char code, void arg)
163	{
164	int body = (code & 0x20) != 0;
165	unw_word rlen;
166
167	rlen = (code & 0x1f);
168	UNW_DEC_PROLOGUE(R1, body, rlen, arg);
169	return dp;
170	}
171
172	static unsigned char *
173	unw_decode_r2 (unsigned char dp, unsigned char code, void arg)
174	{
175	unsigned char byte1, mask, grsave;
176	unw_word rlen;
177
178	byte1 = *dp++;
179
180	mask = ((code & 0x7) << 1) \| ((byte1 >> 7) & 1);
181	grsave = (byte1 & 0x7f);
182	rlen = unw_decode_uleb128 (&dp);
183	UNW_DEC_PROLOGUE_GR(R2, rlen, mask, grsave, arg);
184	return dp;
185	}
186
187	static unsigned char *
188	unw_decode_r3 (unsigned char dp, unsigned char code, void arg)
189	{
190	unw_word rlen;
191
192	rlen = unw_decode_uleb128 (&dp);
193	UNW_DEC_PROLOGUE(R3, ((code & 0x3) == 1), rlen, arg);
194	return dp;
195	}
196
197	static unsigned char *
198	unw_decode_p1 (unsigned char dp, unsigned char code, void arg)
199	{
200	unsigned char brmask = (code & 0x1f);
201
202	UNW_DEC_BR_MEM(P1, brmask, arg);
203	return dp;
204	}
205
206	static unsigned char *
207	unw_decode_p2_p5 (unsigned char dp, unsigned char code, void arg)
208	{
209	if ((code & 0x10) == 0)
210	{
211	unsigned char byte1 = *dp++;
212
213	UNW_DEC_BR_GR(P2, ((code & 0xf) << 1) \| ((byte1 >> 7) & 1),
214	(byte1 & 0x7f), arg);
215	}
216	else if ((code & 0x08) == 0)
217	{
218	unsigned char byte1 = *dp++, r, dst;
219
220	r = ((code & 0x7) << 1) \| ((byte1 >> 7) & 1);
221	dst = (byte1 & 0x7f);
222	switch (r)
223	{
224	case 0: UNW_DEC_REG_GR(P3, UNW_REG_PSP, dst, arg); break;
225	case 1: UNW_DEC_REG_GR(P3, UNW_REG_RP, dst, arg); break;
226	case 2: UNW_DEC_REG_GR(P3, UNW_REG_PFS, dst, arg); break;
227	case 3: UNW_DEC_REG_GR(P3, UNW_REG_PR, dst, arg); break;
228	case 4: UNW_DEC_REG_GR(P3, UNW_REG_UNAT, dst, arg); break;
229	case 5: UNW_DEC_REG_GR(P3, UNW_REG_LC, dst, arg); break;
230	case 6: UNW_DEC_RP_BR(P3, dst, arg); break;
231	case 7: UNW_DEC_REG_GR(P3, UNW_REG_RNAT, dst, arg); break;
232	case 8: UNW_DEC_REG_GR(P3, UNW_REG_BSP, dst, arg); break;
233	case 9: UNW_DEC_REG_GR(P3, UNW_REG_BSPSTORE, dst, arg); break;
234	case 10: UNW_DEC_REG_GR(P3, UNW_REG_FPSR, dst, arg); break;
235	case 11: UNW_DEC_PRIUNAT_GR(P3, dst, arg); break;
236	default: UNW_DEC_BAD_CODE(r); break;
237	}
238	}
239	else if ((code & 0x7) == 0)
240	UNW_DEC_SPILL_MASK(P4, dp, arg);
241	else if ((code & 0x7) == 1)
242	{
243	unw_word grmask, frmask, byte1, byte2, byte3;
244
245	byte1 = dp++; byte2 = dp++; byte3 = *dp++;
246	grmask = ((byte1 >> 4) & 0xf);
247	frmask = ((byte1 & 0xf) << 16) \| (byte2 << 8) \| byte3;
248	UNW_DEC_FRGR_MEM(P5, grmask, frmask, arg);
249	}
250	else
251	UNW_DEC_BAD_CODE(code);
252	return dp;
253	}
254
255	static unsigned char *
256	unw_decode_p6 (unsigned char dp, unsigned char code, void arg)
257	{
258	int gregs = (code & 0x10) != 0;
259	unsigned char mask = (code & 0x0f);
260
261	if (gregs)
262	UNW_DEC_GR_MEM(P6, mask, arg);
263	else
264	UNW_DEC_FR_MEM(P6, mask, arg);
265	return dp;
266	}
267
268	static unsigned char *
269	unw_decode_p7_p10 (unsigned char dp, unsigned char code, void arg)
270	{
271	unsigned char r, byte1, byte2;
272	unw_word t, size;
273
274	if ((code & 0x10) == 0)
275	{
276	r = (code & 0xf);
277	t = unw_decode_uleb128 (&dp);
278	switch (r)
279	{
280	case 0:
281	size = unw_decode_uleb128 (&dp);
282	UNW_DEC_MEM_STACK_F(P7, t, size, arg);
283	break;
284
285	case 1: UNW_DEC_MEM_STACK_V(P7, t, arg); break;
286	case 2: UNW_DEC_SPILL_BASE(P7, t, arg); break;
287	case 3: UNW_DEC_REG_SPREL(P7, UNW_REG_PSP, t, arg); break;
288	case 4: UNW_DEC_REG_WHEN(P7, UNW_REG_RP, t, arg); break;
289	case 5: UNW_DEC_REG_PSPREL(P7, UNW_REG_RP, t, arg); break;
290	case 6: UNW_DEC_REG_WHEN(P7, UNW_REG_PFS, t, arg); break;
291	case 7: UNW_DEC_REG_PSPREL(P7, UNW_REG_PFS, t, arg); break;
292	case 8: UNW_DEC_REG_WHEN(P7, UNW_REG_PR, t, arg); break;
293	case 9: UNW_DEC_REG_PSPREL(P7, UNW_REG_PR, t, arg); break;
294	case 10: UNW_DEC_REG_WHEN(P7, UNW_REG_LC, t, arg); break;
295	case 11: UNW_DEC_REG_PSPREL(P7, UNW_REG_LC, t, arg); break;
296	case 12: UNW_DEC_REG_WHEN(P7, UNW_REG_UNAT, t, arg); break;
297	case 13: UNW_DEC_REG_PSPREL(P7, UNW_REG_UNAT, t, arg); break;
298	case 14: UNW_DEC_REG_WHEN(P7, UNW_REG_FPSR, t, arg); break;
299	case 15: UNW_DEC_REG_PSPREL(P7, UNW_REG_FPSR, t, arg); break;
300	default: UNW_DEC_BAD_CODE(r); break;
301	}
302	}
303	else
304	{
305	switch (code & 0xf)
306	{
307	case 0x0: /* p8 */
308	{
309	r = *dp++;
310	t = unw_decode_uleb128 (&dp);
311	switch (r)
312	{
313	case 1: UNW_DEC_REG_SPREL(P8, UNW_REG_RP, t, arg); break;
314	case 2: UNW_DEC_REG_SPREL(P8, UNW_REG_PFS, t, arg); break;
315	case 3: UNW_DEC_REG_SPREL(P8, UNW_REG_PR, t, arg); break;
316	case 4: UNW_DEC_REG_SPREL(P8, UNW_REG_LC, t, arg); break;
317	case 5: UNW_DEC_REG_SPREL(P8, UNW_REG_UNAT, t, arg); break;
318	case 6: UNW_DEC_REG_SPREL(P8, UNW_REG_FPSR, t, arg); break;
319	case 7: UNW_DEC_REG_WHEN(P8, UNW_REG_BSP, t, arg); break;
320	case 8: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSP, t, arg); break;
321	case 9: UNW_DEC_REG_SPREL(P8, UNW_REG_BSP, t, arg); break;
322	case 10: UNW_DEC_REG_WHEN(P8, UNW_REG_BSPSTORE, t, arg); break;
323	case 11: UNW_DEC_REG_PSPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
324	case 12: UNW_DEC_REG_SPREL(P8, UNW_REG_BSPSTORE, t, arg); break;
325	case 13: UNW_DEC_REG_WHEN(P8, UNW_REG_RNAT, t, arg); break;
326	case 14: UNW_DEC_REG_PSPREL(P8, UNW_REG_RNAT, t, arg); break;
327	case 15: UNW_DEC_REG_SPREL(P8, UNW_REG_RNAT, t, arg); break;
328	case 16: UNW_DEC_PRIUNAT_WHEN_GR(P8, t, arg); break;
329	case 17: UNW_DEC_PRIUNAT_PSPREL(P8, t, arg); break;
330	case 18: UNW_DEC_PRIUNAT_SPREL(P8, t, arg); break;
331	case 19: UNW_DEC_PRIUNAT_WHEN_MEM(P8, t, arg); break;
332	default: UNW_DEC_BAD_CODE(r); break;
333	}
334	}
335	break;
336
337	case 0x1:
338	byte1 = dp++; byte2 = dp++;
339	UNW_DEC_GR_GR(P9, (byte1 & 0xf), (byte2 & 0x7f), arg);
340	break;
341
342	case 0xf: /* p10 */
343	byte1 = dp++; byte2 = dp++;
344	UNW_DEC_ABI(P10, byte1, byte2, arg);
345	break;
346
347	case 0x9:
348	return unw_decode_x1 (dp, code, arg);
349
350	case 0xa:
351	return unw_decode_x2 (dp, code, arg);
352
353	case 0xb:
354	return unw_decode_x3 (dp, code, arg);
355
356	case 0xc:
357	return unw_decode_x4 (dp, code, arg);
358
359	default:
360	UNW_DEC_BAD_CODE(code);
361	break;
362	}
363	}
364	return dp;
365	}
366
367	static unsigned char *
368	unw_decode_b1 (unsigned char dp, unsigned char code, void arg)
369	{
370	unw_word label = (code & 0x1f);
371
372	if ((code & 0x20) != 0)
373	UNW_DEC_COPY_STATE(B1, label, arg);
374	else
375	UNW_DEC_LABEL_STATE(B1, label, arg);
376	return dp;
377	}
378
379	static unsigned char *
380	unw_decode_b2 (unsigned char dp, unsigned char code, void arg)
381	{
382	unw_word t;
383
384	t = unw_decode_uleb128 (&dp);
385	UNW_DEC_EPILOGUE(B2, t, (code & 0x1f), arg);
386	return dp;
387	}
388
389	static unsigned char *
390	unw_decode_b3_x4 (unsigned char dp, unsigned char code, void arg)
391	{
392	unw_word t, ecount, label;
393
394	if ((code & 0x10) == 0)
395	{
396	t = unw_decode_uleb128 (&dp);
397	ecount = unw_decode_uleb128 (&dp);
398	UNW_DEC_EPILOGUE(B3, t, ecount, arg);
399	}
400	else if ((code & 0x07) == 0)
401	{
402	label = unw_decode_uleb128 (&dp);
403	if ((code & 0x08) != 0)
404	UNW_DEC_COPY_STATE(B4, label, arg);
405	else
406	UNW_DEC_LABEL_STATE(B4, label, arg);
407	}
408	else
409	switch (code & 0x7)
410	{
411	case 1: return unw_decode_x1 (dp, code, arg);
412	case 2: return unw_decode_x2 (dp, code, arg);
413	case 3: return unw_decode_x3 (dp, code, arg);
414	case 4: return unw_decode_x4 (dp, code, arg);
415	default: UNW_DEC_BAD_CODE(code); break;
416	}
417	return dp;
418	}
419
420	typedef unsigned char (unw_decoder) (unsigned char , unsigned char, void );
421
422	static unw_decoder unw_decode_table[2][8] =
423	{
424	/* prologue table: */
425	{
426	unw_decode_r1, /* 0 */
427	unw_decode_r1,
428	unw_decode_r2,
429	unw_decode_r3,
430	unw_decode_p1, /* 4 */
431	unw_decode_p2_p5,
432	unw_decode_p6,
433	unw_decode_p7_p10
434	},
435	{
436	unw_decode_r1, /* 0 */
437	unw_decode_r1,
438	unw_decode_r2,
439	unw_decode_r3,
440	unw_decode_b1, /* 4 */
441	unw_decode_b1,
442	unw_decode_b2,
443	unw_decode_b3_x4
444	}
445	};
446
447	/*
448	* Decode one descriptor and return address of next descriptor.
449	*/
450	static inline unsigned char *
451	unw_decode (unsigned char dp, int inside_body, void arg)
452	{
453	unw_decoder decoder;
454	unsigned char code;
455
456	code = *dp++;
457	decoder = unw_decode_table[inside_body][code >> 5];
458	dp = (*decoder) (dp, code, arg);
459	return dp;
460	}