[deliverable/binutils-gdb.git] / bfd / libhppa.h

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

   Contributed by the Center for Software Science at the
   University of Utah (pa-gdb-bugs@cs.utah.edu).

   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 (((x & 1) << 2) | ((x & 6) >> 1)) & 7;
}

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      /* PA 2.0 */
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     /* PA 2.0 */
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     /* PA 2.0 */
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;
  int           q;

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