[binutils.git] / bfd / libhppa.h

/* HP PA-RISC SOM object file format:  definitions internal to BFD.
   Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 98, 1999
   Free Software Foundation, Inc.

   Contributed by the Center for Software Science at the
   University of Utah ([email protected]).

   This file is part of BFD, the Binary File Descriptor library.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#ifndef _HPPA_H
#define _HPPA_H

#define BYTES_IN_WORD 4
#define PA_PAGESIZE 0x1000

#ifndef INLINE
#ifdef __GNUC__
#define INLINE inline
#else
#define INLINE
#endif /* GNU C? */
#endif /* INLINE */

#if __GNUC__ >= 2 && __GNUC_MINOR__ >= 7
/* Declare the functions with the unused attribute to avoid warnings.  */
static INLINE unsigned int assemble_3 (unsigned int)
     __attribute__ ((__unused__));
static INLINE void dis_assemble_3 (unsigned int, unsigned int *)
     __attribute__ ((__unused__));
static INLINE unsigned int assemble_12 (unsigned int, unsigned int)
     __attribute__ ((__unused__));
static INLINE void dis_assemble_12 (unsigned int, unsigned int *,
				    unsigned int *)
     __attribute__ ((__unused__));
static INLINE unsigned long assemble_17 (unsigned int, unsigned int,
					 unsigned int)
     __attribute__ ((__unused__));
static INLINE void dis_assemble_17 (unsigned int, unsigned int *,
				    unsigned int *, unsigned int *)
     __attribute__ ((__unused__));
static INLINE unsigned long assemble_21 (unsigned int)
     __attribute ((__unused__));
static INLINE void dis_assemble_21 (unsigned int, unsigned int *)
     __attribute__ ((__unused__));
static INLINE unsigned long sign_extend (unsigned int, unsigned int)
     __attribute__ ((__unused__));
static INLINE unsigned int ones (int) __attribute ((__unused__));
static INLINE void sign_unext (unsigned int, unsigned int, unsigned int *)
     __attribute__ ((__unused__));
static INLINE unsigned long low_sign_extend (unsigned int, unsigned int)
     __attribute__ ((__unused__));
static INLINE void low_sign_unext (unsigned int, unsigned int, unsigned int *)
     __attribute__ ((__unused__));
static INLINE unsigned long hppa_field_adjust (unsigned long, unsigned long,
					       unsigned short)
     __attribute__ ((__unused__));
static INLINE char bfd_hppa_insn2fmt (unsigned long)
     __attribute__ ((__unused__));
static INLINE  unsigned long hppa_rebuild_insn (bfd *, unsigned long,
						unsigned long, unsigned long)
     __attribute__ ((__unused__));
#endif /* gcc 2.7 or higher */


/* The PA instruction set variants.  */
enum pa_arch {pa10 = 10, pa11 = 11, pa20 = 20};

/* HP PA-RISC relocation types */

enum hppa_reloc_field_selector_type
  {
    R_HPPA_FSEL = 0x0,
    R_HPPA_LSSEL = 0x1,
    R_HPPA_RSSEL = 0x2,
    R_HPPA_LSEL = 0x3,
    R_HPPA_RSEL = 0x4,
    R_HPPA_LDSEL = 0x5,
    R_HPPA_RDSEL = 0x6,
    R_HPPA_LRSEL = 0x7,
    R_HPPA_RRSEL = 0x8,
    R_HPPA_NSEL  = 0x9,
    R_HPPA_NLSEL  = 0xa,
    R_HPPA_NLRSEL  = 0xb,
    R_HPPA_PSEL = 0xc,
    R_HPPA_LPSEL = 0xd,
    R_HPPA_RPSEL = 0xe,
    R_HPPA_TSEL = 0xf,
    R_HPPA_LTSEL = 0x10,
    R_HPPA_RTSEL = 0x11
  };

/* /usr/include/reloc.h defines these to constants.  We want to use
   them in enums, so #undef them before we start using them.  We might
   be able to fix this another way by simply managing not to include
   /usr/include/reloc.h, but currently GDB picks up these defines
   somewhere.  */
#undef e_fsel
#undef e_lssel
#undef e_rssel
#undef e_lsel
#undef e_rsel
#undef e_ldsel
#undef e_rdsel
#undef e_lrsel
#undef e_rrsel
#undef e_nsel
#undef e_nlsel
#undef e_nlrsel
#undef e_psel
#undef e_lpsel
#undef e_rpsel
#undef e_tsel
#undef e_ltsel
#undef e_rtsel
#undef e_one
#undef e_two
#undef e_pcrel
#undef e_con
#undef e_plabel
#undef e_abs

/* for compatibility */
enum hppa_reloc_field_selector_type_alt
  {
    e_fsel = R_HPPA_FSEL,
    e_lssel = R_HPPA_LSSEL,
    e_rssel = R_HPPA_RSSEL,
    e_lsel = R_HPPA_LSEL,
    e_rsel = R_HPPA_RSEL,
    e_ldsel = R_HPPA_LDSEL,
    e_rdsel = R_HPPA_RDSEL,
    e_lrsel = R_HPPA_LRSEL,
    e_rrsel = R_HPPA_RRSEL,
    e_nsel = R_HPPA_NSEL,
    e_nlsel = R_HPPA_NLSEL,
    e_nlrsel = R_HPPA_NLRSEL,
    e_psel = R_HPPA_PSEL,
    e_lpsel = R_HPPA_LPSEL,
    e_rpsel = R_HPPA_RPSEL,
    e_tsel = R_HPPA_TSEL,
    e_ltsel = R_HPPA_LTSEL,
    e_rtsel = R_HPPA_RTSEL
  };

enum hppa_reloc_expr_type
  {
    R_HPPA_E_ONE = 0,
    R_HPPA_E_TWO = 1,
    R_HPPA_E_PCREL = 2,
    R_HPPA_E_CON = 3,
    R_HPPA_E_PLABEL = 7,
    R_HPPA_E_ABS = 18
  };

/* for compatibility */
enum hppa_reloc_expr_type_alt
  {
    e_one = R_HPPA_E_ONE,
    e_two = R_HPPA_E_TWO,
    e_pcrel = R_HPPA_E_PCREL,
    e_con = R_HPPA_E_CON,
    e_plabel = R_HPPA_E_PLABEL,
    e_abs = R_HPPA_E_ABS
  };


/* Relocations for function calls must be accompanied by parameter
   relocation bits.  These bits describe exactly where the caller has
   placed the function's arguments and where it expects to find a return
   value.

   Both ELF and SOM encode this information within the addend field
   of the call relocation.  (Note this could break very badly if one
   was to make a call like bl foo + 0x12345678).

   The high order 10 bits contain parameter relocation information,
   the low order 22 bits contain the constant offset.  */
   
#define HPPA_R_ARG_RELOC(a)	(((a) >> 22) & 0x3FF)
#define HPPA_R_CONSTANT(a)	((((int)(a)) << 10) >> 10)
#define HPPA_R_ADDEND(r,c)	(((r) << 22) + ((c) & 0x3FFFFF))
#define HPPA_WIDE	       (0) /* PSW W-bit, need to check! FIXME */

/* These macros get bit fields using HP's numbering (MSB = 0),
 * but note that "MASK" assumes that the LSB bits are what's
 * wanted.
 */
#ifndef GET_FIELD
#define GET_FIELD(X, FROM, TO) \
  ((X) >> (31 - (TO)) & ((1 << ((TO) - (FROM) + 1)) - 1))
#endif  
#define GET_BIT(X, WHICH) \
  GET_FIELD (X, WHICH, WHICH)

#define MASK(SIZE) \
  (~((-1) << SIZE))
  
#define CATENATE(X, XSIZE, Y, YSIZE) \
  (((X & MASK (XSIZE)) << YSIZE) | (Y & MASK (YSIZE)))

#define ELEVEN(X) \
  CATENATE (GET_BIT (X, 10), 1, GET_FIELD (X, 0, 9), 10)
  
/* Some functions to manipulate PA instructions.  */

/* NOTE: these use the HP convention that f{1} is the _left_ most
 *       bit (MSB) of f; they sometimes have to impose an assumption
 *       about the size of a field; and as far as I can tell, most
 *       aren't used.
 */

static INLINE unsigned long
sign_extend (x, len)
     unsigned int x, len;
{
  return (int)(x >> (len - 1) ? (-1 << len) | x : x);
}

static INLINE unsigned int
assemble_3 (x)
     unsigned int x;
{
  return CATENATE (GET_BIT (x, 2), 1, GET_FIELD (x, 0, 1), 2);
}

static INLINE void
dis_assemble_3 (x, r)
     unsigned int x;
     unsigned int *r;
{
  *r = (((x & 4) >> 2) | ((x & 3) << 1)) & 7;
}

static INLINE unsigned int
assemble_6 (x, y)
     unsigned int x, y;
{
  return (((x & 0x1) << 5) + (32 - (y & 0x1f)));
}

static INLINE unsigned int
assemble_12 (x, y)
     unsigned int x, y;
{
  return CATENATE (CATENATE (y, 1, GET_BIT (x, 10), 1), 2,
 		   GET_FIELD (x, 0, 9), 9);
}

static INLINE void
dis_assemble_12 (as12, x, y)
     unsigned int as12;
     unsigned int *x, *y;
{
  *y = (as12 & 0x800) >> 11;
  *x = ((as12 & 0x3ff) << 1) | ((as12 & 0x400) >> 10);
}

static INLINE unsigned long
assemble_16 (x, y)
     unsigned int x, y;
{
  /* Depends on PSW W-bit !*/
  unsigned int temp;

  if (HPPA_WIDE)
    temp = CATENATE (CATENATE (GET_BIT (y, 13), 1,
			       (GET_BIT (y, 13) ^ GET_BIT (x, 0)), 1), 2,
		     CATENATE ((GET_BIT (y, 13) ^ GET_BIT (x, 1)), 1,
			       GET_FIELD (y, 0, 12), 13), 14);
  else
    temp = CATENATE (CATENATE (GET_BIT (y, 13), 1, GET_BIT (y, 13), 1), 2,
		     CATENATE (GET_BIT (y, 13), 1, GET_FIELD (y, 0, 12), 13), 14);

  return sign_extend (temp, 16);
}


static INLINE unsigned long
assemble_16a (x, y, z)
     unsigned int x, y, z;
{
  /* Depends on PSW W-bit !*/
  unsigned int temp;

  if (HPPA_WIDE)
    temp = CATENATE (CATENATE (z, 1, (z ^ GET_BIT (x, 0)), 1), 2,
		     CATENATE ((z ^ GET_BIT (x, 1)), 1, y, 11), 12);
  else 
      temp = CATENATE (CATENATE (z, 1, z, 1), 2, CATENATE (z, 1, y, 11), 12);

  return sign_extend ((temp << 2), 16);
}

static INLINE unsigned long
assemble_17 (x, y, z)
     unsigned int x, y, z;
{
  unsigned long temp;

  temp = CATENATE (CATENATE (z, 1, x, 5), 6,
		   CATENATE (GET_BIT (y, 10), 1, GET_FIELD (y, 0, 9), 10), 11);
  
  return temp;
}

static INLINE void
dis_assemble_17 (as17, x, y, z)
     unsigned int as17;
     unsigned int *x, *y, *z;
{

  *z = (as17 & 0x10000) >> 16;
  *x = (as17 & 0x0f800) >> 11;
  *y = (((as17 & 0x00400) >> 10) | ((as17 & 0x3ff) << 1)) & 0x7ff;
}

static INLINE unsigned long
assemble_21 (x)
     unsigned int x;
{
  unsigned long temp;

  temp = ((x & 1) << 20) |
    ((x & 0xffe) << 8) |
    ((x & 0xc000) >> 7) |
    ((x & 0x1f0000) >> 14) |
    ((x & 0x003000) >> 12);
  return temp & 0x1fffff;
}

static INLINE unsigned long
assemble_22 (a,b,c,d)
     unsigned int a,b,c,d;
{
  unsigned long temp;
  
  temp = CATENATE (CATENATE (d, 1, a, 5), 6,
		   CATENATE (b, 5, ELEVEN (c), 11), 16);

  return sign_extend (temp, 22);
}

static INLINE void
dis_assemble_21 (as21, x)
     unsigned int as21, *x;
{
  unsigned long temp;


  temp = (as21 & 0x100000) >> 20;
  temp |= (as21 & 0x0ffe00) >> 8;
  temp |= (as21 & 0x000180) << 7;
  temp |= (as21 & 0x00007c) << 14;
  temp |= (as21 & 0x000003) << 12;
  *x = temp;
}

static INLINE unsigned int
ones (n)
     int n;
{
  unsigned int len_ones;
  int i;

  i = 0;
  len_ones = 0;
  while (i < n)
    {
      len_ones = (len_ones << 1) | 1;
      i++;
    }

  return len_ones;
}

static INLINE void
sign_unext (x, len, result)
     unsigned int x, len;
     unsigned int *result;
{
  unsigned int len_ones;

  len_ones = ones (len);

  *result = x & len_ones;
}

static INLINE unsigned long
low_sign_extend (x, len)
     unsigned int x, len;
{
  return (int)((x & 0x1 ? (-1 << (len - 1)) : 0) | x >> 1);
}

static INLINE void
low_sign_unext (x, len, result)
     unsigned int x, len;
     unsigned int *result;
{
  unsigned int temp;
  unsigned int sign;
  unsigned int rest;
  unsigned int one_bit_at_len;
  unsigned int len_ones;

  len_ones = ones (len);
  one_bit_at_len = 1 << (len - 1);

  sign_unext (x, len, &temp);
  sign = temp & one_bit_at_len;
  sign >>= (len - 1);

  rest = temp & (len_ones ^ one_bit_at_len);
  rest <<= 1;

  *result = rest | sign;
}

/* Handle field selectors for PA instructions.  */

static INLINE unsigned long
hppa_field_adjust (value, constant_value, r_field)
     unsigned long value;
     unsigned long constant_value;
     unsigned short r_field;
{
  switch (r_field)
    {
    case e_fsel:		/* F  : no change		      */
    case e_nsel:		/* N  : no change		       */
      value += constant_value;
      break;

    case e_lssel:		/* LS : if (bit 21) then add 0x800
				   arithmetic shift right 11 bits */
      value += constant_value;
      if (value & 0x00000400)
	value += 0x800;
      value = (value & 0xfffff800) >> 11;
      break;

    case e_rssel:		/* RS : Sign extend from bit 21	*/
      value += constant_value;
      if (value & 0x00000400)
	value |= 0xfffff800;
      else
	value &= 0x7ff;
      break;

    case e_lsel:		/* L  : Arithmetic shift right 11 bits */
    case e_nlsel:		/* NL  : Arithmetic shift right 11 bits */
      value += constant_value;
      value = (value & 0xfffff800) >> 11;
      break;

    case e_rsel:		/* R  : Set bits 0-20 to zero	  */
      value += constant_value;
      value = value & 0x7ff;
      break;

    case e_ldsel:		/* LD : Add 0x800, arithmetic shift
				   right 11 bits		  */
      value += constant_value;
      value += 0x800;
      value = (value & 0xfffff800) >> 11;
      break;

    case e_rdsel:		/* RD : Set bits 0-20 to one	   */
      value += constant_value;
      value |= 0xfffff800;
      break;

    case e_lrsel:		/* LR : L with "rounded" constant      */
    case e_nlrsel:		/* NLR : NL with "rounded" constant      */
      value = value + ((constant_value + 0x1000) & 0xffffe000);
      value = (value & 0xfffff800) >> 11;
      break;

    case e_rrsel:		/* RR : R with "rounded" constant      */
      value = value + ((constant_value + 0x1000) & 0xffffe000);
      value = (value & 0x7ff) + constant_value - ((constant_value + 0x1000) & 0xffffe000);
      break;

    default:
      abort ();
    }
  return value;

}

/* PA-RISC OPCODES */
#define get_opcode(insn)	((insn) & 0xfc000000) >> 26

/* FIXME: this list is incomplete.  It should also be an enumerated
   type rather than #defines.  */

#define LDO	0x0d
#define LDB	0x10
#define LDH	0x11
#define LDW	0x12
#define LDWM	0x13
#define STB	0x18
#define STH	0x19
#define STW	0x1a
#define STWM	0x1b
#define COMICLR	0x24
#define SUBI	0x25
#define SUBIO	0x25
#define ADDIT	0x2c
#define ADDITO	0x2c
#define ADDI	0x2d
#define ADDIO	0x2d
#define LDIL	0x08
#define ADDIL	0x0a

#define MOVB	0x32
#define MOVIB	0x33
#define COMBT	0x20
#define COMBF	0x22
#define COMIBT	0x21
#define COMIBF	0x23
#define ADDBT	0x28
#define ADDBF	0x2a
#define ADDIBT	0x29
#define ADDIBF	0x2b
#define BVB	0x30
#define BB	0x31

#define BL	0x3a
#define BLE	0x39
#define BE	0x38

  
/* Given a machine instruction, return its format.

   FIXME:  opcodes which do not map to a known format
   should return an error of some sort.  */

static INLINE char
bfd_hppa_insn2fmt (insn)
     unsigned long insn;
{
  char fmt = -1;
  unsigned char op = get_opcode (insn);
  
  switch (op)
    {
    case ADDI:
    case ADDIT:
    case SUBI:
      fmt = 11;
      break;
    case MOVB:
    case MOVIB:
    case COMBT:
    case COMBF:
    case COMIBT:
    case COMIBF:
    case ADDBT:
    case ADDBF:
    case ADDIBT:
    case ADDIBF:
    case BVB:
    case BB:
      fmt = 12;
      break;
    case LDO:
    case LDB:
    case LDH:
    case LDW:
    case LDWM:
    case STB:
    case STH:
    case STW:
    case STWM:
      fmt = 14;
      break;
    case BL:
    case BE:
    case BLE:
      fmt = 17;
      break;
    case LDIL:
    case ADDIL:
      fmt = 21;
      break;
    default:
      fmt = 32;
      break;
    }
  return fmt;
}


/* Insert VALUE into INSN using R_FORMAT to determine exactly what
   bits to change.  */
   
static INLINE unsigned long
hppa_rebuild_insn (abfd, insn, value, r_format)
     bfd *abfd ATTRIBUTE_UNUSED;
     unsigned long insn;
     unsigned long value;
     unsigned long r_format;
{
  unsigned long const_part;
  unsigned long rebuilt_part;

  switch (r_format)
    {
    case 11:
      {
	unsigned w1, w;

	const_part = insn & 0xffffe002;
	dis_assemble_12 (value, &w1, &w);
	rebuilt_part = (w1 << 2) | w;
	return const_part | rebuilt_part;
      }

    case 12:
      {
	unsigned w1, w;

	const_part = insn & 0xffffe002;
	dis_assemble_12 (value, &w1, &w);
	rebuilt_part = (w1 << 2) | w;
	return const_part | rebuilt_part;
      }

    case 14:
      {
	unsigned int ext;
	
	const_part = insn & 0xffffc000;
	low_sign_unext (value, 14, &ext);
	return const_part | ext;
      }

    case 17:
      {
	unsigned w1, w2, w;

	const_part = insn & 0xffe0e002;
	dis_assemble_17 (value, &w1, &w2, &w);
	rebuilt_part = (w2 << 2) | (w1 << 16) | w;
	return const_part | rebuilt_part;
      }

    case 21:
      {
	unsigned int w;

	const_part = insn & 0xffe00000;
	dis_assemble_21 (value, &w);
	return const_part | w;
      }

    case 32:
      const_part = 0;
      return value;

    default:
      abort ();
    }
  return insn;
}

#endif /* _HPPA_H */
Commit	Line	Data
252b5132	1	/* HP PA-RISC SOM object file format: definitions internal to BFD.
5f771d47 ILT	2	Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 98, 1999
5f771d47 ILT	3	Free Software Foundation, Inc.
252b5132 RH	4
	5	Contributed by the Center for Software Science at the
	6	University of Utah ([email protected]).
	7
	8	This file is part of BFD, the Binary File Descriptor library.
	9
	10	This program is free software; you can redistribute it and/or modify
	11	it under the terms of the GNU General Public License as published by
	12	the Free Software Foundation; either version 2 of the License, or
	13	(at your option) any later version.
	14
	15	This program is distributed in the hope that it will be useful,
	16	but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	GNU General Public License for more details.
	19
	20	You should have received a copy of the GNU General Public License
	21	along with this program; if not, write to the Free Software
	22	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	23
	24	#ifndef _HPPA_H
	25	#define _HPPA_H
	26
	27	#define BYTES_IN_WORD 4
	28	#define PA_PAGESIZE 0x1000
	29
	30	#ifndef INLINE
	31	#ifdef __GNUC__
	32	#define INLINE inline
	33	#else
	34	#define INLINE
	35	#endif /* GNU C? */
	36	#endif /* INLINE */
	37
	38	#if __GNUC__ >= 2 && __GNUC_MINOR__ >= 7
	39	/* Declare the functions with the unused attribute to avoid warnings. */
	40	static INLINE unsigned int assemble_3 (unsigned int)
	41	__attribute__ ((__unused__));
	42	static INLINE void dis_assemble_3 (unsigned int, unsigned int *)
	43	__attribute__ ((__unused__));
	44	static INLINE unsigned int assemble_12 (unsigned int, unsigned int)
	45	__attribute__ ((__unused__));
	46	static INLINE void dis_assemble_12 (unsigned int, unsigned int *,
	47	unsigned int *)
	48	__attribute__ ((__unused__));
	49	static INLINE unsigned long assemble_17 (unsigned int, unsigned int,
	50	unsigned int)
	51	__attribute__ ((__unused__));
	52	static INLINE void dis_assemble_17 (unsigned int, unsigned int *,
	53	unsigned int , unsigned int )
	54	__attribute__ ((__unused__));
	55	static INLINE unsigned long assemble_21 (unsigned int)
	56	__attribute ((__unused__));
	57	static INLINE void dis_assemble_21 (unsigned int, unsigned int *)
	58	__attribute__ ((__unused__));
	59	static INLINE unsigned long sign_extend (unsigned int, unsigned int)
	60	__attribute__ ((__unused__));
	61	static INLINE unsigned int ones (int) __attribute ((__unused__));
	62	static INLINE void sign_unext (unsigned int, unsigned int, unsigned int *)
	63	__attribute__ ((__unused__));
	64	static INLINE unsigned long low_sign_extend (unsigned int, unsigned int)
	65	__attribute__ ((__unused__));
	66	static INLINE void low_sign_unext (unsigned int, unsigned int, unsigned int *)
	67	__attribute__ ((__unused__));
68	static INLINE unsigned long hppa_field_adjust (unsigned long, unsigned long,
69	unsigned short)
70	__attribute__ ((__unused__));
71	static INLINE char bfd_hppa_insn2fmt (unsigned long)
72	__attribute__ ((__unused__));
73	static INLINE unsigned long hppa_rebuild_insn (bfd *, unsigned long,
74	unsigned long, unsigned long)
75	__attribute__ ((__unused__));
76	#endif /* gcc 2.7 or higher */
77
78
79	/* The PA instruction set variants. */
80	enum pa_arch {pa10 = 10, pa11 = 11, pa20 = 20};
81
82	/* HP PA-RISC relocation types */
83
84	enum hppa_reloc_field_selector_type
85	{
86	R_HPPA_FSEL = 0x0,
87	R_HPPA_LSSEL = 0x1,
88	R_HPPA_RSSEL = 0x2,
89	R_HPPA_LSEL = 0x3,
90	R_HPPA_RSEL = 0x4,
91	R_HPPA_LDSEL = 0x5,
92	R_HPPA_RDSEL = 0x6,
93	R_HPPA_LRSEL = 0x7,
94	R_HPPA_RRSEL = 0x8,
95	R_HPPA_NSEL = 0x9,
96	R_HPPA_NLSEL = 0xa,
97	R_HPPA_NLRSEL = 0xb,
98	R_HPPA_PSEL = 0xc,
99	R_HPPA_LPSEL = 0xd,
100	R_HPPA_RPSEL = 0xe,
101	R_HPPA_TSEL = 0xf,
102	R_HPPA_LTSEL = 0x10,
103	R_HPPA_RTSEL = 0x11
104	};
105
106	/* /usr/include/reloc.h defines these to constants. We want to use
107	them in enums, so #undef them before we start using them. We might
108	be able to fix this another way by simply managing not to include
109	/usr/include/reloc.h, but currently GDB picks up these defines
110	somewhere. */
111	#undef e_fsel
112	#undef e_lssel
113	#undef e_rssel
114	#undef e_lsel
115	#undef e_rsel
116	#undef e_ldsel
117	#undef e_rdsel
118	#undef e_lrsel
119	#undef e_rrsel
120	#undef e_nsel
121	#undef e_nlsel
122	#undef e_nlrsel
123	#undef e_psel
124	#undef e_lpsel
125	#undef e_rpsel
126	#undef e_tsel
127	#undef e_ltsel
128	#undef e_rtsel
129	#undef e_one
130	#undef e_two
131	#undef e_pcrel
132	#undef e_con
133	#undef e_plabel
134	#undef e_abs
135
136	/* for compatibility */
137	enum hppa_reloc_field_selector_type_alt
138	{
139	e_fsel = R_HPPA_FSEL,
140	e_lssel = R_HPPA_LSSEL,
141	e_rssel = R_HPPA_RSSEL,
142	e_lsel = R_HPPA_LSEL,
143	e_rsel = R_HPPA_RSEL,
144	e_ldsel = R_HPPA_LDSEL,
145	e_rdsel = R_HPPA_RDSEL,
146	e_lrsel = R_HPPA_LRSEL,
147	e_rrsel = R_HPPA_RRSEL,
148	e_nsel = R_HPPA_NSEL,
149	e_nlsel = R_HPPA_NLSEL,
150	e_nlrsel = R_HPPA_NLRSEL,
151	e_psel = R_HPPA_PSEL,
152	e_lpsel = R_HPPA_LPSEL,
153	e_rpsel = R_HPPA_RPSEL,
154	e_tsel = R_HPPA_TSEL,
155	e_ltsel = R_HPPA_LTSEL,
156	e_rtsel = R_HPPA_RTSEL
157	};
158
159	enum hppa_reloc_expr_type
160	{
161	R_HPPA_E_ONE = 0,
162	R_HPPA_E_TWO = 1,
163	R_HPPA_E_PCREL = 2,
164	R_HPPA_E_CON = 3,
165	R_HPPA_E_PLABEL = 7,
166	R_HPPA_E_ABS = 18
167	};
168
169	/* for compatibility */
170	enum hppa_reloc_expr_type_alt
171	{
172	e_one = R_HPPA_E_ONE,
173	e_two = R_HPPA_E_TWO,
174	e_pcrel = R_HPPA_E_PCREL,
175	e_con = R_HPPA_E_CON,
176	e_plabel = R_HPPA_E_PLABEL,
177	e_abs = R_HPPA_E_ABS
178	};
179
180
37afc161 JL	181	/* Relocations for function calls must be accompanied by parameter
	182	relocation bits. These bits describe exactly where the caller has
	183	placed the function's arguments and where it expects to find a return
	184	value.
	185
	186	Both ELF and SOM encode this information within the addend field
	187	of the call relocation. (Note this could break very badly if one
	188	was to make a call like bl foo + 0x12345678).
	189
	190	The high order 10 bits contain parameter relocation information,
	191	the low order 22 bits contain the constant offset. */
	192
	193	#define HPPA_R_ARG_RELOC(a) (((a) >> 22) & 0x3FF)
	194	#define HPPA_R_CONSTANT(a) ((((int)(a)) << 10) >> 10)
	195	#define HPPA_R_ADDEND(r,c) (((r) << 22) + ((c) & 0x3FFFFF))
5ba624b0	196	#define HPPA_WIDE (0) /* PSW W-bit, need to check! FIXME */
252b5132 RH	197
	198	/* These macros get bit fields using HP's numbering (MSB = 0),
	199	* but note that "MASK" assumes that the LSB bits are what's
	200	* wanted.
	201	*/
	202	#ifndef GET_FIELD
	203	#define GET_FIELD(X, FROM, TO) \
	204	((X) >> (31 - (TO)) & ((1 << ((TO) - (FROM) + 1)) - 1))
	205	#endif
5ba624b0 JL	206	#define GET_BIT(X, WHICH) \
5ba624b0 JL	207	GET_FIELD (X, WHICH, WHICH)
252b5132	208
5ba624b0	209	#define MASK(SIZE) \
252b5132 RH	210	(~((-1) << SIZE))
252b5132 RH	211
5ba624b0 JL	212	#define CATENATE(X, XSIZE, Y, YSIZE) \
5ba624b0 JL	213	(((X & MASK (XSIZE)) << YSIZE) \| (Y & MASK (YSIZE)))
252b5132	214
5ba624b0 JL	215	#define ELEVEN(X) \
5ba624b0 JL	216	CATENATE (GET_BIT (X, 10), 1, GET_FIELD (X, 0, 9), 10)
252b5132 RH	217
	218	/* Some functions to manipulate PA instructions. */
	219
	220	/* NOTE: these use the HP convention that f{1} is the _left_ most
	221	* bit (MSB) of f; they sometimes have to impose an assumption
	222	* about the size of a field; and as far as I can tell, most
	223	* aren't used.
	224	*/
	225
	226	static INLINE unsigned long
	227	sign_extend (x, len)
	228	unsigned int x, len;
	229	{
	230	return (int)(x >> (len - 1) ? (-1 << len) \| x : x);
	231	}
	232
	233	static INLINE unsigned int
	234	assemble_3 (x)
	235	unsigned int x;
	236	{
5ba624b0	237	return CATENATE (GET_BIT (x, 2), 1, GET_FIELD (x, 0, 1), 2);
252b5132 RH	238	}
	239
	240	static INLINE void
	241	dis_assemble_3 (x, r)
	242	unsigned int x;
	243	unsigned int *r;
	244	{
	245	*r = (((x & 4) >> 2) \| ((x & 3) << 1)) & 7;
	246	}
	247
5ba624b0	248	static INLINE unsigned int
252b5132 RH	249	assemble_6 (x, y)
	250	unsigned int x, y;
	251	{
	252	return (((x & 0x1) << 5) + (32 - (y & 0x1f)));
	253	}
	254
	255	static INLINE unsigned int
	256	assemble_12 (x, y)
	257	unsigned int x, y;
	258	{
5ba624b0 JL	259	return CATENATE (CATENATE (y, 1, GET_BIT (x, 10), 1), 2,
5ba624b0 JL	260	GET_FIELD (x, 0, 9), 9);
252b5132 RH	261	}
	262
	263	static INLINE void
	264	dis_assemble_12 (as12, x, y)
	265	unsigned int as12;
	266	unsigned int x, y;
	267	{
	268	*y = (as12 & 0x800) >> 11;
	269	*x = ((as12 & 0x3ff) << 1) \| ((as12 & 0x400) >> 10);
	270	}
	271
5ba624b0	272	static INLINE unsigned long
252b5132 RH	273	assemble_16 (x, y)
	274	unsigned int x, y;
	275	{
	276	/* Depends on PSW W-bit !*/
	277	unsigned int temp;
	278
5ba624b0 JL	279	if (HPPA_WIDE)
	280	temp = CATENATE (CATENATE (GET_BIT (y, 13), 1,
	281	(GET_BIT (y, 13) ^ GET_BIT (x, 0)), 1), 2,
	282	CATENATE ((GET_BIT (y, 13) ^ GET_BIT (x, 1)), 1,
	283	GET_FIELD (y, 0, 12), 13), 14);
	284	else
	285	temp = CATENATE (CATENATE (GET_BIT (y, 13), 1, GET_BIT (y, 13), 1), 2,
	286	CATENATE (GET_BIT (y, 13), 1, GET_FIELD (y, 0, 12), 13), 14);
	287
	288	return sign_extend (temp, 16);
252b5132 RH	289	}
	290
	291
5ba624b0	292	static INLINE unsigned long
252b5132 RH	293	assemble_16a (x, y, z)
	294	unsigned int x, y, z;
	295	{
	296	/* Depends on PSW W-bit !*/
	297	unsigned int temp;
	298
5ba624b0 JL	299	if (HPPA_WIDE)
	300	temp = CATENATE (CATENATE (z, 1, (z ^ GET_BIT (x, 0)), 1), 2,
	301	CATENATE ((z ^ GET_BIT (x, 1)), 1, y, 11), 12);
	302	else
	303	temp = CATENATE (CATENATE (z, 1, z, 1), 2, CATENATE (z, 1, y, 11), 12);
	304
	305	return sign_extend ((temp << 2), 16);
252b5132 RH	306	}
	307
	308	static INLINE unsigned long
	309	assemble_17 (x, y, z)
	310	unsigned int x, y, z;
	311	{
	312	unsigned long temp;
252b5132	313
5ba624b0 JL	314	temp = CATENATE (CATENATE (z, 1, x, 5), 6,
5ba624b0 JL	315	CATENATE (GET_BIT (y, 10), 1, GET_FIELD (y, 0, 9), 10), 11);
252b5132 RH	316
	317	return temp;
	318	}
	319
	320	static INLINE void
	321	dis_assemble_17 (as17, x, y, z)
	322	unsigned int as17;
	323	unsigned int x, y, *z;
	324	{
	325
	326	*z = (as17 & 0x10000) >> 16;
	327	*x = (as17 & 0x0f800) >> 11;
	328	*y = (((as17 & 0x00400) >> 10) \| ((as17 & 0x3ff) << 1)) & 0x7ff;
	329	}
	330
	331	static INLINE unsigned long
	332	assemble_21 (x)
	333	unsigned int x;
	334	{
	335	unsigned long temp;
	336
	337	temp = ((x & 1) << 20) \|
	338	((x & 0xffe) << 8) \|
	339	((x & 0xc000) >> 7) \|
	340	((x & 0x1f0000) >> 14) \|
	341	((x & 0x003000) >> 12);
	342	return temp & 0x1fffff;
	343	}
	344
5ba624b0	345	static INLINE unsigned long
252b5132 RH	346	assemble_22 (a,b,c,d)
	347	unsigned int a,b,c,d;
	348	{
	349	unsigned long temp;
	350
5ba624b0 JL	351	temp = CATENATE (CATENATE (d, 1, a, 5), 6,
5ba624b0 JL	352	CATENATE (b, 5, ELEVEN (c), 11), 16);
252b5132	353
5ba624b0	354	return sign_extend (temp, 22);
252b5132 RH	355	}
	356
	357	static INLINE void
	358	dis_assemble_21 (as21, x)
	359	unsigned int as21, *x;
	360	{
	361	unsigned long temp;
	362
	363
	364	temp = (as21 & 0x100000) >> 20;
	365	temp \|= (as21 & 0x0ffe00) >> 8;
	366	temp \|= (as21 & 0x000180) << 7;
	367	temp \|= (as21 & 0x00007c) << 14;
	368	temp \|= (as21 & 0x000003) << 12;
	369	*x = temp;
	370	}
	371
	372	static INLINE unsigned int
	373	ones (n)
	374	int n;
	375	{
	376	unsigned int len_ones;
	377	int i;
	378
	379	i = 0;
	380	len_ones = 0;
	381	while (i < n)
	382	{
	383	len_ones = (len_ones << 1) \| 1;
	384	i++;
	385	}
	386
	387	return len_ones;
	388	}
	389
	390	static INLINE void
	391	sign_unext (x, len, result)
	392	unsigned int x, len;
	393	unsigned int *result;
	394	{
	395	unsigned int len_ones;
	396
	397	len_ones = ones (len);
	398
	399	*result = x & len_ones;
	400	}
	401
	402	static INLINE unsigned long
	403	low_sign_extend (x, len)
	404	unsigned int x, len;
	405	{
	406	return (int)((x & 0x1 ? (-1 << (len - 1)) : 0) \| x >> 1);
	407	}
	408
	409	static INLINE void
	410	low_sign_unext (x, len, result)
	411	unsigned int x, len;
	412	unsigned int *result;
	413	{
	414	unsigned int temp;
	415	unsigned int sign;
	416	unsigned int rest;
	417	unsigned int one_bit_at_len;
	418	unsigned int len_ones;
419
420	len_ones = ones (len);
421	one_bit_at_len = 1 << (len - 1);
422
423	sign_unext (x, len, &temp);
424	sign = temp & one_bit_at_len;
425	sign >>= (len - 1);
426
427	rest = temp & (len_ones ^ one_bit_at_len);
428	rest <<= 1;
429
430	*result = rest \| sign;
431	}
432
433	/* Handle field selectors for PA instructions. */
434
435	static INLINE unsigned long
436	hppa_field_adjust (value, constant_value, r_field)
437	unsigned long value;
438	unsigned long constant_value;
439	unsigned short r_field;
440	{
441	switch (r_field)
442	{
5ba624b0	443	case e_fsel: /* F : no change */
252b5132 RH	444	case e_nsel: /* N : no change */
	445	value += constant_value;
	446	break;
	447
	448	case e_lssel: /* LS : if (bit 21) then add 0x800
	449	arithmetic shift right 11 bits */
	450	value += constant_value;
	451	if (value & 0x00000400)
	452	value += 0x800;
	453	value = (value & 0xfffff800) >> 11;
	454	break;
	455
5ba624b0	456	case e_rssel: /* RS : Sign extend from bit 21 */
252b5132 RH	457	value += constant_value;
	458	if (value & 0x00000400)
	459	value \|= 0xfffff800;
	460	else
	461	value &= 0x7ff;
	462	break;
	463
	464	case e_lsel: /* L : Arithmetic shift right 11 bits */
	465	case e_nlsel: /* NL : Arithmetic shift right 11 bits */
	466	value += constant_value;
	467	value = (value & 0xfffff800) >> 11;
	468	break;
	469
5ba624b0	470	case e_rsel: /* R : Set bits 0-20 to zero */
252b5132 RH	471	value += constant_value;
	472	value = value & 0x7ff;
	473	break;
	474
	475	case e_ldsel: /* LD : Add 0x800, arithmetic shift
5ba624b0	476	right 11 bits */
252b5132 RH	477	value += constant_value;
	478	value += 0x800;
	479	value = (value & 0xfffff800) >> 11;
	480	break;
	481
5ba624b0	482	case e_rdsel: /* RD : Set bits 0-20 to one */
252b5132 RH	483	value += constant_value;
	484	value \|= 0xfffff800;
	485	break;
	486
	487	case e_lrsel: /* LR : L with "rounded" constant */
	488	case e_nlrsel: /* NLR : NL with "rounded" constant */
	489	value = value + ((constant_value + 0x1000) & 0xffffe000);
	490	value = (value & 0xfffff800) >> 11;
	491	break;
	492
	493	case e_rrsel: /* RR : R with "rounded" constant */
	494	value = value + ((constant_value + 0x1000) & 0xffffe000);
	495	value = (value & 0x7ff) + constant_value - ((constant_value + 0x1000) & 0xffffe000);
	496	break;
	497
	498	default:
	499	abort ();
	500	}
	501	return value;
	502
	503	}
	504
	505	/* PA-RISC OPCODES */
	506	#define get_opcode(insn) ((insn) & 0xfc000000) >> 26
	507
	508	/* FIXME: this list is incomplete. It should also be an enumerated
	509	type rather than #defines. */
	510
	511	#define LDO 0x0d
	512	#define LDB 0x10
	513	#define LDH 0x11
	514	#define LDW 0x12
	515	#define LDWM 0x13
	516	#define STB 0x18
	517	#define STH 0x19
	518	#define STW 0x1a
	519	#define STWM 0x1b
	520	#define COMICLR 0x24
	521	#define SUBI 0x25
	522	#define SUBIO 0x25
	523	#define ADDIT 0x2c
	524	#define ADDITO 0x2c
	525	#define ADDI 0x2d
	526	#define ADDIO 0x2d
	527	#define LDIL 0x08
	528	#define ADDIL 0x0a
	529
	530	#define MOVB 0x32
	531	#define MOVIB 0x33
	532	#define COMBT 0x20
	533	#define COMBF 0x22
	534	#define COMIBT 0x21
	535	#define COMIBF 0x23
	536	#define ADDBT 0x28
	537	#define ADDBF 0x2a
	538	#define ADDIBT 0x29
	539	#define ADDIBF 0x2b
	540	#define BVB 0x30
	541	#define BB 0x31
	542
	543	#define BL 0x3a
	544	#define BLE 0x39
	545	#define BE 0x38
	546
547
548	/* Given a machine instruction, return its format.
549
550	FIXME: opcodes which do not map to a known format
551	should return an error of some sort. */
552
553	static INLINE char
554	bfd_hppa_insn2fmt (insn)
555	unsigned long insn;
556	{
557	char fmt = -1;
558	unsigned char op = get_opcode (insn);
559
560	switch (op)
561	{
562	case ADDI:
563	case ADDIT:
564	case SUBI:
565	fmt = 11;
566	break;
567	case MOVB:
568	case MOVIB:
569	case COMBT:
570	case COMBF:
571	case COMIBT:
572	case COMIBF:
573	case ADDBT:
574	case ADDBF:
575	case ADDIBT:
576	case ADDIBF:
577	case BVB:
578	case BB:
579	fmt = 12;
580	break;
581	case LDO:
582	case LDB:
583	case LDH:
584	case LDW:
585	case LDWM:
586	case STB:
587	case STH:
588	case STW:
589	case STWM:
590	fmt = 14;
591	break;
592	case BL:
593	case BE:
594	case BLE:
595	fmt = 17;
596	break;
597	case LDIL:
598	case ADDIL:
599	fmt = 21;
600	break;
601	default:
602	fmt = 32;
603	break;
604	}
605	return fmt;
606	}
607
608
609	/* Insert VALUE into INSN using R_FORMAT to determine exactly what
610	bits to change. */
611
612	static INLINE unsigned long
613	hppa_rebuild_insn (abfd, insn, value, r_format)
5f771d47	614	bfd *abfd ATTRIBUTE_UNUSED;
252b5132 RH	615	unsigned long insn;
	616	unsigned long value;
	617	unsigned long r_format;
	618	{
	619	unsigned long const_part;
	620	unsigned long rebuilt_part;
	621
	622	switch (r_format)
	623	{
	624	case 11:
	625	{
	626	unsigned w1, w;
	627
	628	const_part = insn & 0xffffe002;
	629	dis_assemble_12 (value, &w1, &w);
	630	rebuilt_part = (w1 << 2) \| w;
	631	return const_part \| rebuilt_part;
	632	}
	633
	634	case 12:
	635	{
	636	unsigned w1, w;
	637
	638	const_part = insn & 0xffffe002;
	639	dis_assemble_12 (value, &w1, &w);
	640	rebuilt_part = (w1 << 2) \| w;
	641	return const_part \| rebuilt_part;
	642	}
	643
	644	case 14:
	645	{
	646	unsigned int ext;
	647
	648	const_part = insn & 0xffffc000;
	649	low_sign_unext (value, 14, &ext);
	650	return const_part \| ext;
	651	}
	652
	653	case 17:
	654	{
	655	unsigned w1, w2, w;
	656
	657	const_part = insn & 0xffe0e002;
	658	dis_assemble_17 (value, &w1, &w2, &w);
	659	rebuilt_part = (w2 << 2) \| (w1 << 16) \| w;
	660	return const_part \| rebuilt_part;
	661	}
	662
	663	case 21:
	664	{
	665	unsigned int w;
	666
	667	const_part = insn & 0xffe00000;
	668	dis_assemble_21 (value, &w);
	669	return const_part \| w;
	670	}
	671
	672	case 32:
	673	const_part = 0;
	674	return value;
	675
	676	default:
	677	abort ();
	678	}
679	return insn;
680	}
681
682	#endif /* _HPPA_H */