[thirdparty/binutils-gdb.git] / sim / common / sim-endian.h

/* The common simulator framework for GDB, the GNU Debugger.

   Copyright 2002-2013 Free Software Foundation, Inc.

   Contributed by Andrew Cagney and Red Hat.

   This file is part of GDB.

   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 3 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, see <http://www.gnu.org/licenses/>.  */


#ifndef _SIM_ENDIAN_H_
#define _SIM_ENDIAN_H_


/* C byte conversion functions */

INLINE_SIM_ENDIAN(unsigned_1) endian_h2t_1(unsigned_1 x);
INLINE_SIM_ENDIAN(unsigned_2) endian_h2t_2(unsigned_2 x);
INLINE_SIM_ENDIAN(unsigned_4) endian_h2t_4(unsigned_4 x);
INLINE_SIM_ENDIAN(unsigned_8) endian_h2t_8(unsigned_8 x);
INLINE_SIM_ENDIAN(unsigned_16) endian_h2t_16(unsigned_16 x);

INLINE_SIM_ENDIAN(unsigned_1) endian_t2h_1(unsigned_1 x);
INLINE_SIM_ENDIAN(unsigned_2) endian_t2h_2(unsigned_2 x);
INLINE_SIM_ENDIAN(unsigned_4) endian_t2h_4(unsigned_4 x);
INLINE_SIM_ENDIAN(unsigned_8) endian_t2h_8(unsigned_8 x);
INLINE_SIM_ENDIAN(unsigned_16) endian_t2h_16(unsigned_16 x);

INLINE_SIM_ENDIAN(unsigned_1) swap_1(unsigned_1 x);
INLINE_SIM_ENDIAN(unsigned_2) swap_2(unsigned_2 x);
INLINE_SIM_ENDIAN(unsigned_4) swap_4(unsigned_4 x);
INLINE_SIM_ENDIAN(unsigned_8) swap_8(unsigned_8 x);
INLINE_SIM_ENDIAN(unsigned_16) swap_16(unsigned_16 x);

INLINE_SIM_ENDIAN(unsigned_1) endian_h2be_1(unsigned_1 x);
INLINE_SIM_ENDIAN(unsigned_2) endian_h2be_2(unsigned_2 x);
INLINE_SIM_ENDIAN(unsigned_4) endian_h2be_4(unsigned_4 x);
INLINE_SIM_ENDIAN(unsigned_8) endian_h2be_8(unsigned_8 x);
INLINE_SIM_ENDIAN(unsigned_16) endian_h2be_16(unsigned_16 x);

INLINE_SIM_ENDIAN(unsigned_1) endian_be2h_1(unsigned_1 x);
INLINE_SIM_ENDIAN(unsigned_2) endian_be2h_2(unsigned_2 x);
INLINE_SIM_ENDIAN(unsigned_4) endian_be2h_4(unsigned_4 x);
INLINE_SIM_ENDIAN(unsigned_8) endian_be2h_8(unsigned_8 x);
INLINE_SIM_ENDIAN(unsigned_16) endian_be2h_16(unsigned_16 x);

INLINE_SIM_ENDIAN(unsigned_1) endian_h2le_1(unsigned_1 x);
INLINE_SIM_ENDIAN(unsigned_2) endian_h2le_2(unsigned_2 x);
INLINE_SIM_ENDIAN(unsigned_4) endian_h2le_4(unsigned_4 x);
INLINE_SIM_ENDIAN(unsigned_8) endian_h2le_8(unsigned_8 x);
INLINE_SIM_ENDIAN(unsigned_16) endian_h2le_16(unsigned_16 x);

INLINE_SIM_ENDIAN(unsigned_1) endian_le2h_1(unsigned_1 x);
INLINE_SIM_ENDIAN(unsigned_2) endian_le2h_2(unsigned_2 x);
INLINE_SIM_ENDIAN(unsigned_4) endian_le2h_4(unsigned_4 x);
INLINE_SIM_ENDIAN(unsigned_8) endian_le2h_8(unsigned_8 x);
INLINE_SIM_ENDIAN(unsigned_16) endian_le2h_16(unsigned_16 x);

INLINE_SIM_ENDIAN(void*) offset_1(unsigned_1 *x, unsigned ws, unsigned w);
INLINE_SIM_ENDIAN(void*) offset_2(unsigned_2 *x, unsigned ws, unsigned w);
INLINE_SIM_ENDIAN(void*) offset_4(unsigned_4 *x, unsigned ws, unsigned w);
INLINE_SIM_ENDIAN(void*) offset_8(unsigned_8 *x, unsigned ws, unsigned w);
INLINE_SIM_ENDIAN(void*) offset_16(unsigned_16 *x, unsigned ws, unsigned w);

INLINE_SIM_ENDIAN(unsigned_16) sim_endian_join_16 (unsigned_8 h, unsigned_8 l);
INLINE_SIM_ENDIAN(unsigned_8) sim_endian_split_16 (unsigned_16 word, int w);


/* SWAP */

#define SWAP_1 swap_1
#define SWAP_2 swap_2
#define SWAP_4 swap_4
#define SWAP_8 swap_8
#define SWAP_16 swap_16


/* HOST to BE */

#define H2BE_1 endian_h2be_1
#define H2BE_2 endian_h2be_2
#define H2BE_4 endian_h2be_4
#define H2BE_8 endian_h2be_8
#define H2BE_16 endian_h2be_16
#define BE2H_1 endian_be2h_1
#define BE2H_2 endian_be2h_2
#define BE2H_4 endian_be2h_4
#define BE2H_8 endian_be2h_8
#define BE2H_16 endian_be2h_16


/* HOST to LE */

#define H2LE_1 endian_h2le_1
#define H2LE_2 endian_h2le_2
#define H2LE_4 endian_h2le_4
#define H2LE_8 endian_h2le_8
#define H2LE_16 endian_h2le_16
#define LE2H_1 endian_le2h_1
#define LE2H_2 endian_le2h_2
#define LE2H_4 endian_le2h_4
#define LE2H_8 endian_le2h_8
#define LE2H_16 endian_le2h_16


/* HOST to TARGET */

#define H2T_1 endian_h2t_1
#define H2T_2 endian_h2t_2
#define H2T_4 endian_h2t_4
#define H2T_8 endian_h2t_8
#define H2T_16 endian_h2t_16
#define T2H_1 endian_t2h_1
#define T2H_2 endian_t2h_2
#define T2H_4 endian_t2h_4
#define T2H_8 endian_t2h_8
#define T2H_16 endian_t2h_16


/* CONVERT IN PLACE

   These macros, given an argument of unknown size, swap its value in
   place if a host/target conversion is required. */

#define H2T(VARIABLE) \
do { \
  void *vp = &(VARIABLE); \
  switch (sizeof (VARIABLE)) { \
  case 1: *(unsigned_1*)vp = H2T_1(*(unsigned_1*)vp); break; \
  case 2: *(unsigned_2*)vp = H2T_2(*(unsigned_2*)vp); break; \
  case 4: *(unsigned_4*)vp = H2T_4(*(unsigned_4*)vp); break; \
  case 8: *(unsigned_8*)vp = H2T_8(*(unsigned_8*)vp); break; \
  case 16: *(unsigned_16*)vp = H2T_16(*(unsigned_16*)vp); break; \
  } \
} while (0)

#define T2H(VARIABLE) \
do { \
  switch (sizeof(VARIABLE)) { \
  case 1: VARIABLE = T2H_1(VARIABLE); break; \
  case 2: VARIABLE = T2H_2(VARIABLE); break; \
  case 4: VARIABLE = T2H_4(VARIABLE); break; \
  case 8: VARIABLE = T2H_8(VARIABLE); break; \
  /*case 16: VARIABLE = T2H_16(VARIABLE); break;*/ \
  } \
} while (0)

#define SWAP(VARIABLE) \
do { \
  switch (sizeof(VARIABLE)) { \
  case 1: VARIABLE = SWAP_1(VARIABLE); break; \
  case 2: VARIABLE = SWAP_2(VARIABLE); break; \
  case 4: VARIABLE = SWAP_4(VARIABLE); break; \
  case 8: VARIABLE = SWAP_8(VARIABLE); break; \
  /*case 16: VARIABLE = SWAP_16(VARIABLE); break;*/ \
  } \
} while (0)

#define H2BE(VARIABLE) \
do { \
  switch (sizeof(VARIABLE)) { \
  case 1: VARIABLE = H2BE_1(VARIABLE); break; \
  case 2: VARIABLE = H2BE_2(VARIABLE); break; \
  case 4: VARIABLE = H2BE_4(VARIABLE); break; \
  case 8: VARIABLE = H2BE_8(VARIABLE); break; \
  /*case 16: VARIABLE = H2BE_16(VARIABLE); break;*/ \
  } \
} while (0)

#define BE2H(VARIABLE) \
do { \
  switch (sizeof(VARIABLE)) { \
  case 1: VARIABLE = BE2H_1(VARIABLE); break; \
  case 2: VARIABLE = BE2H_2(VARIABLE); break; \
  case 4: VARIABLE = BE2H_4(VARIABLE); break; \
  case 8: VARIABLE = BE2H_8(VARIABLE); break; \
  /*case 16: VARIABLE = BE2H_16(VARIABLE); break;*/ \
  } \
} while (0)

#define H2LE(VARIABLE) \
do { \
  switch (sizeof(VARIABLE)) { \
  case 1: VARIABLE = H2LE_1(VARIABLE); break; \
  case 2: VARIABLE = H2LE_2(VARIABLE); break; \
  case 4: VARIABLE = H2LE_4(VARIABLE); break; \
  case 8: VARIABLE = H2LE_8(VARIABLE); break; \
  /*case 16: VARIABLE = H2LE_16(VARIABLE); break;*/ \
  } \
} while (0)

#define LE2H(VARIABLE) \
do { \
  switch (sizeof(VARIABLE)) { \
  case 1: VARIABLE = LE2H_1(VARIABLE); break; \
  case 2: VARIABLE = LE2H_2(VARIABLE); break; \
  case 4: VARIABLE = LE2H_4(VARIABLE); break; \
  case 8: VARIABLE = LE2H_8(VARIABLE); break; \
  /*case 16: VARIABLE = LE2H_16(VARIABLE); break;*/ \
  } \
} while (0)


/* TARGET WORD:

   Byte swap a quantity the size of the targets word */

#if (WITH_TARGET_WORD_BITSIZE == 64)
#define H2T_word H2T_8
#define T2H_word T2H_8
#define H2BE_word H2BE_8
#define BE2H_word BE2H_8
#define H2LE_word H2LE_8
#define LE2H_word LE2H_8
#define SWAP_word SWAP_8
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
#define H2T_word H2T_4
#define T2H_word T2H_4
#define H2BE_word H2BE_4
#define BE2H_word BE2H_4
#define H2LE_word H2LE_4
#define LE2H_word LE2H_4
#define SWAP_word SWAP_4
#endif


/* TARGET CELL:

   Byte swap a quantity the size of the targets IEEE 1275 memory cell */

#define H2T_cell H2T_4
#define T2H_cell T2H_4
#define H2BE_cell H2BE_4
#define BE2H_cell BE2H_4
#define H2LE_cell H2LE_4
#define LE2H_cell LE2H_4
#define SWAP_cell SWAP_4


/* HOST Offsets:

   Address of high/low sub-word within a host word quantity.

   Address of sub-word N within a host word quantity.  NOTE: Numbering
   is BIG endian always. */

#define AH1_2(X) (unsigned_1*)offset_2((X), 1, 0)
#define AL1_2(X) (unsigned_1*)offset_2((X), 1, 1)

#define AH2_4(X) (unsigned_2*)offset_4((X), 2, 0)
#define AL2_4(X) (unsigned_2*)offset_4((X), 2, 1)

#define AH4_8(X) (unsigned_4*)offset_8((X), 4, 0)
#define AL4_8(X) (unsigned_4*)offset_8((X), 4, 1)

#define AH8_16(X) (unsigned_8*)offset_16((X), 8, 0)
#define AL8_16(X) (unsigned_8*)offset_16((X), 8, 1)

#if (WITH_TARGET_WORD_BITSIZE == 64)
#define AH_word(X) AH4_8(X)
#define AL_word(X) AL4_8(X)
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
#define AH_word(X) AH2_4(X)
#define AL_word(X) AL2_4(X)
#endif


#define A1_2(X,N) (unsigned_1*)offset_2((X), 1, (N))

#define A1_4(X,N) (unsigned_1*)offset_4((X), 1, (N))
#define A2_4(X,N) (unsigned_2*)offset_4((X), 2, (N))

#define A1_8(X,N) (unsigned_1*)offset_8((X), 1, (N))
#define A2_8(X,N) (unsigned_2*)offset_8((X), 2, (N))
#define A4_8(X,N) (unsigned_4*)offset_8((X), 4, (N))

#define A1_16(X,N) (unsigned_1*)offset_16((X), 1, (N))
#define A2_16(X,N) (unsigned_2*)offset_16((X), 2, (N))
#define A4_16(X,N) (unsigned_4*)offset_16((X), 4, (N))
#define A8_16(X,N) (unsigned_8*)offset_16((X), 8, (N))


/* HOST Components:

   Value of sub-word within a host word quantity */

#define VH1_2(X) ((unsigned_1)((unsigned_2)(X) >> 8))
#define VL1_2(X) (unsigned_1)(X)

#define VH2_4(X) ((unsigned_2)((unsigned_4)(X) >> 16))
#define VL2_4(X) ((unsigned_2)(X))

#define VH4_8(X) ((unsigned_4)((unsigned_8)(X) >> 32))
#define VL4_8(X) ((unsigned_4)(X))

#define VH8_16(X) (sim_endian_split_16 ((X), 0))
#define VL8_16(X) (sim_endian_split_16 ((X), 1))

#if (WITH_TARGET_WORD_BITSIZE == 64)
#define VH_word(X) VH4_8(X)
#define VL_word(X) VL4_8(X)
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
#define VH_word(X) VH2_4(X)
#define VL_word(X) VL2_4(X)
#endif


#define V1_2(X,N) ((unsigned_1)((unsigned_2)(X) >> ( 8 * (1 - (N)))))

#define V1_4(X,N) ((unsigned_1)((unsigned_4)(X) >> ( 8 * (3 - (N)))))
#define V2_4(X,N) ((unsigned_2)((unsigned_4)(X) >> (16 * (1 - (N)))))

#define V1_8(X,N) ((unsigned_1)((unsigned_8)(X) >> ( 8 * (7 - (N)))))
#define V2_8(X,N) ((unsigned_2)((unsigned_8)(X) >> (16 * (3 - (N)))))
#define V4_8(X,N) ((unsigned_4)((unsigned_8)(X) >> (32 * (1 - (N)))))

#define V1_16(X,N) (*A1_16 (&(X),N))
#define V2_16(X,N) (*A2_16 (&(X),N))
#define V4_16(X,N) (*A4_16 (&(X),N))
#define V8_16(X,N) (*A8_16 (&(X),N))


/* Reverse - insert sub-word into word quantity */

#define V2_H1(X) ((unsigned_2)(unsigned_1)(X) <<  8)
#define V2_L1(X) ((unsigned_2)(unsigned_1)(X))

#define V4_H2(X) ((unsigned_4)(unsigned_2)(X) << 16)
#define V4_L2(X) ((unsigned_4)(unsigned_2)(X))

#define V8_H4(X) ((unsigned_8)(unsigned_4)(X) << 32)
#define V8_L4(X) ((unsigned_8)(unsigned_4)(X))

#define V16_H8(X) ((unsigned_16)(unsigned_8)(X) << 64)
#define V16_L8(X) ((unsigned_16)(unsigned_8)(X))


#define V2_1(X,N) ((unsigned_2)(unsigned_1)(X) << ( 8 * (1 - (N))))

#define V4_1(X,N) ((unsigned_4)(unsigned_1)(X) << ( 8 * (3 - (N))))
#define V4_2(X,N) ((unsigned_4)(unsigned_2)(X) << (16 * (1 - (N))))

#define V8_1(X,N) ((unsigned_8)(unsigned_1)(X) << ( 8 * (7 - (N))))
#define V8_2(X,N) ((unsigned_8)(unsigned_2)(X) << (16 * (3 - (N))))
#define V8_4(X,N) ((unsigned_8)(unsigned_4)(X) << (32 * (1 - (N))))

#define V16_1(X,N) ((unsigned_16)(unsigned_1)(X) << ( 8 * (15 - (N))))
#define V16_2(X,N) ((unsigned_16)(unsigned_2)(X) << (16 * (7 - (N))))
#define V16_4(X,N) ((unsigned_16)(unsigned_4)(X) << (32 * (3 - (N))))
#define V16_8(X,N) ((unsigned_16)(unsigned_8)(X) << (64 * (1 - (N))))


/* Reverse - insert N sub-words into single word quantity */

#define U2_1(I0,I1) (V2_1(I0,0) | V2_1(I1,1))
#define U4_1(I0,I1,I2,I3) (V4_1(I0,0) | V4_1(I1,1) | V4_1(I2,2) | V4_1(I3,3))
#define U8_1(I0,I1,I2,I3,I4,I5,I6,I7) \
(V8_1(I0,0) | V8_1(I1,1) | V8_1(I2,2) | V8_1(I3,3) \
 | V8_1(I4,4) | V8_1(I5,5) | V8_1(I6,6) | V8_1(I7,7))
#define U16_1(I0,I1,I2,I3,I4,I5,I6,I7,I8,I9,I10,I11,I12,I13,I14,I15) \
(V16_1(I0,0) | V16_1(I1,1) | V16_1(I2,2) | V16_1(I3,3) \
 | V16_1(I4,4) | V16_1(I5,5) | V16_1(I6,6) | V16_1(I7,7) \
 | V16_1(I8,8) | V16_1(I9,9) | V16_1(I10,10) | V16_1(I11,11) \
 | V16_1(I12,12) | V16_1(I13,13) | V16_1(I14,14) | V16_1(I15,15))

#define U4_2(I0,I1) (V4_2(I0,0) | V4_2(I1,1))
#define U8_2(I0,I1,I2,I3) (V8_2(I0,0) | V8_2(I1,1) | V8_2(I2,2) | V8_2(I3,3))
#define U16_2(I0,I1,I2,I3,I4,I5,I6,I7) \
(V16_2(I0,0) | V16_2(I1,1) | V16_2(I2,2) | V16_2(I3,3) \
 | V16_2(I4,4) | V16_2(I5,5) | V16_2(I6,6) | V16_2(I7,7) )

#define U8_4(I0,I1) (V8_4(I0,0) | V8_4(I1,1))
#define U16_4(I0,I1,I2,I3) (V16_4(I0,0) | V16_4(I1,1) | V16_4(I2,2) | V16_4(I3,3))

#define U16_8(I0,I1) (sim_endian_join_16 (I0, I1))


#if (WITH_TARGET_WORD_BITSIZE == 64)
#define Vword_H(X) V8_H4(X)
#define Vword_L(X) V8_L4(X)
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
#define Vword_H(X) V4_H2(X)
#define Vword_L(X) V4_L2(X)
#endif


#if H_REVEALS_MODULE_P (SIM_ENDIAN_INLINE)
#include "sim-endian.c"
#endif

#endif /* _SIM_ENDIAN_H_ */
Commit	Line	Data
b85e4829 AC	1	/* The common simulator framework for GDB, the GNU Debugger.
b85e4829 AC	2
8acc9f48	3	Copyright 2002-2013 Free Software Foundation, Inc.
b85e4829 AC	4
	5	Contributed by Andrew Cagney and Red Hat.
	6
	7	This file is part of GDB.
	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
4744ac1b	11	the Free Software Foundation; either version 3 of the License, or
b85e4829 AC	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
4744ac1b	20	along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c SS	21
	22
	23	#ifndef _SIM_ENDIAN_H_
	24	#define _SIM_ENDIAN_H_
	25
	26
	27	/* C byte conversion functions */
	28
	29	INLINE_SIM_ENDIAN(unsigned_1) endian_h2t_1(unsigned_1 x);
	30	INLINE_SIM_ENDIAN(unsigned_2) endian_h2t_2(unsigned_2 x);
	31	INLINE_SIM_ENDIAN(unsigned_4) endian_h2t_4(unsigned_4 x);
	32	INLINE_SIM_ENDIAN(unsigned_8) endian_h2t_8(unsigned_8 x);
	33	INLINE_SIM_ENDIAN(unsigned_16) endian_h2t_16(unsigned_16 x);
	34
	35	INLINE_SIM_ENDIAN(unsigned_1) endian_t2h_1(unsigned_1 x);
	36	INLINE_SIM_ENDIAN(unsigned_2) endian_t2h_2(unsigned_2 x);
	37	INLINE_SIM_ENDIAN(unsigned_4) endian_t2h_4(unsigned_4 x);
	38	INLINE_SIM_ENDIAN(unsigned_8) endian_t2h_8(unsigned_8 x);
	39	INLINE_SIM_ENDIAN(unsigned_16) endian_t2h_16(unsigned_16 x);
	40
	41	INLINE_SIM_ENDIAN(unsigned_1) swap_1(unsigned_1 x);
	42	INLINE_SIM_ENDIAN(unsigned_2) swap_2(unsigned_2 x);
	43	INLINE_SIM_ENDIAN(unsigned_4) swap_4(unsigned_4 x);
	44	INLINE_SIM_ENDIAN(unsigned_8) swap_8(unsigned_8 x);
	45	INLINE_SIM_ENDIAN(unsigned_16) swap_16(unsigned_16 x);
	46
	47	INLINE_SIM_ENDIAN(unsigned_1) endian_h2be_1(unsigned_1 x);
	48	INLINE_SIM_ENDIAN(unsigned_2) endian_h2be_2(unsigned_2 x);
	49	INLINE_SIM_ENDIAN(unsigned_4) endian_h2be_4(unsigned_4 x);
	50	INLINE_SIM_ENDIAN(unsigned_8) endian_h2be_8(unsigned_8 x);
	51	INLINE_SIM_ENDIAN(unsigned_16) endian_h2be_16(unsigned_16 x);
	52
	53	INLINE_SIM_ENDIAN(unsigned_1) endian_be2h_1(unsigned_1 x);
	54	INLINE_SIM_ENDIAN(unsigned_2) endian_be2h_2(unsigned_2 x);
	55	INLINE_SIM_ENDIAN(unsigned_4) endian_be2h_4(unsigned_4 x);
	56	INLINE_SIM_ENDIAN(unsigned_8) endian_be2h_8(unsigned_8 x);
	57	INLINE_SIM_ENDIAN(unsigned_16) endian_be2h_16(unsigned_16 x);
	58
	59	INLINE_SIM_ENDIAN(unsigned_1) endian_h2le_1(unsigned_1 x);
	60	INLINE_SIM_ENDIAN(unsigned_2) endian_h2le_2(unsigned_2 x);
	61	INLINE_SIM_ENDIAN(unsigned_4) endian_h2le_4(unsigned_4 x);
	62	INLINE_SIM_ENDIAN(unsigned_8) endian_h2le_8(unsigned_8 x);
	63	INLINE_SIM_ENDIAN(unsigned_16) endian_h2le_16(unsigned_16 x);
	64
	65	INLINE_SIM_ENDIAN(unsigned_1) endian_le2h_1(unsigned_1 x);
	66	INLINE_SIM_ENDIAN(unsigned_2) endian_le2h_2(unsigned_2 x);
	67	INLINE_SIM_ENDIAN(unsigned_4) endian_le2h_4(unsigned_4 x);
	68	INLINE_SIM_ENDIAN(unsigned_8) endian_le2h_8(unsigned_8 x);
	69	INLINE_SIM_ENDIAN(unsigned_16) endian_le2h_16(unsigned_16 x);
	70
	71	INLINE_SIM_ENDIAN(void) offset_1(unsigned_1 x, unsigned ws, unsigned w);
	72	INLINE_SIM_ENDIAN(void) offset_2(unsigned_2 x, unsigned ws, unsigned w);
	73	INLINE_SIM_ENDIAN(void) offset_4(unsigned_4 x, unsigned ws, unsigned w);
	74	INLINE_SIM_ENDIAN(void) offset_8(unsigned_8 x, unsigned ws, unsigned w);
	75	INLINE_SIM_ENDIAN(void) offset_16(unsigned_16 x, unsigned ws, unsigned w);
	76
	77	INLINE_SIM_ENDIAN(unsigned_16) sim_endian_join_16 (unsigned_8 h, unsigned_8 l);
	78	INLINE_SIM_ENDIAN(unsigned_8) sim_endian_split_16 (unsigned_16 word, int w);
	79
	80
	81	/* SWAP */
	82
4c15ccf7 GK	83	#define SWAP_1 swap_1
	84	#define SWAP_2 swap_2
	85	#define SWAP_4 swap_4
	86	#define SWAP_8 swap_8
	87	#define SWAP_16 swap_16
c906108c SS	88
	89
	90	/* HOST to BE */
	91
4c15ccf7 GK	92	#define H2BE_1 endian_h2be_1
	93	#define H2BE_2 endian_h2be_2
	94	#define H2BE_4 endian_h2be_4
	95	#define H2BE_8 endian_h2be_8
	96	#define H2BE_16 endian_h2be_16
	97	#define BE2H_1 endian_be2h_1
	98	#define BE2H_2 endian_be2h_2
	99	#define BE2H_4 endian_be2h_4
	100	#define BE2H_8 endian_be2h_8
	101	#define BE2H_16 endian_be2h_16
c906108c SS	102
	103
	104	/* HOST to LE */
	105
4c15ccf7 GK	106	#define H2LE_1 endian_h2le_1
	107	#define H2LE_2 endian_h2le_2
	108	#define H2LE_4 endian_h2le_4
	109	#define H2LE_8 endian_h2le_8
	110	#define H2LE_16 endian_h2le_16
	111	#define LE2H_1 endian_le2h_1
	112	#define LE2H_2 endian_le2h_2
	113	#define LE2H_4 endian_le2h_4
	114	#define LE2H_8 endian_le2h_8
	115	#define LE2H_16 endian_le2h_16
c906108c SS	116
	117
	118	/* HOST to TARGET */
	119
4c15ccf7 GK	120	#define H2T_1 endian_h2t_1
	121	#define H2T_2 endian_h2t_2
	122	#define H2T_4 endian_h2t_4
	123	#define H2T_8 endian_h2t_8
	124	#define H2T_16 endian_h2t_16
	125	#define T2H_1 endian_t2h_1
	126	#define T2H_2 endian_t2h_2
	127	#define T2H_4 endian_t2h_4
	128	#define T2H_8 endian_t2h_8
	129	#define T2H_16 endian_t2h_16
c906108c SS	130
	131
	132	/* CONVERT IN PLACE
	133
	134	These macros, given an argument of unknown size, swap its value in
	135	place if a host/target conversion is required. */
	136
	137	#define H2T(VARIABLE) \
	138	do { \
	139	void *vp = &(VARIABLE); \
	140	switch (sizeof (VARIABLE)) { \
	141	case 1: (unsigned_1)vp = H2T_1((unsigned_1)vp); break; \
	142	case 2: (unsigned_2)vp = H2T_2((unsigned_2)vp); break; \
	143	case 4: (unsigned_4)vp = H2T_4((unsigned_4)vp); break; \
	144	case 8: (unsigned_8)vp = H2T_8((unsigned_8)vp); break; \
	145	case 16: (unsigned_16)vp = H2T_16((unsigned_16)vp); break; \
	146	} \
	147	} while (0)
	148
	149	#define T2H(VARIABLE) \
	150	do { \
	151	switch (sizeof(VARIABLE)) { \
	152	case 1: VARIABLE = T2H_1(VARIABLE); break; \
	153	case 2: VARIABLE = T2H_2(VARIABLE); break; \
	154	case 4: VARIABLE = T2H_4(VARIABLE); break; \
	155	case 8: VARIABLE = T2H_8(VARIABLE); break; \
	156	/case 16: VARIABLE = T2H_16(VARIABLE); break;/ \
	157	} \
	158	} while (0)
	159
	160	#define SWAP(VARIABLE) \
	161	do { \
	162	switch (sizeof(VARIABLE)) { \
	163	case 1: VARIABLE = SWAP_1(VARIABLE); break; \
	164	case 2: VARIABLE = SWAP_2(VARIABLE); break; \
	165	case 4: VARIABLE = SWAP_4(VARIABLE); break; \
	166	case 8: VARIABLE = SWAP_8(VARIABLE); break; \
	167	/case 16: VARIABLE = SWAP_16(VARIABLE); break;/ \
	168	} \
	169	} while (0)
	170
	171	#define H2BE(VARIABLE) \
	172	do { \
	173	switch (sizeof(VARIABLE)) { \
	174	case 1: VARIABLE = H2BE_1(VARIABLE); break; \
	175	case 2: VARIABLE = H2BE_2(VARIABLE); break; \
	176	case 4: VARIABLE = H2BE_4(VARIABLE); break; \
	177	case 8: VARIABLE = H2BE_8(VARIABLE); break; \
	178	/case 16: VARIABLE = H2BE_16(VARIABLE); break;/ \
	179	} \
	180	} while (0)
	181
	182	#define BE2H(VARIABLE) \
	183	do { \
	184	switch (sizeof(VARIABLE)) { \
	185	case 1: VARIABLE = BE2H_1(VARIABLE); break; \
	186	case 2: VARIABLE = BE2H_2(VARIABLE); break; \
	187	case 4: VARIABLE = BE2H_4(VARIABLE); break; \
	188	case 8: VARIABLE = BE2H_8(VARIABLE); break; \
	189	/case 16: VARIABLE = BE2H_16(VARIABLE); break;/ \
	190	} \
	191	} while (0)
	192
	193	#define H2LE(VARIABLE) \
194	do { \
195	switch (sizeof(VARIABLE)) { \
196	case 1: VARIABLE = H2LE_1(VARIABLE); break; \
197	case 2: VARIABLE = H2LE_2(VARIABLE); break; \
198	case 4: VARIABLE = H2LE_4(VARIABLE); break; \
199	case 8: VARIABLE = H2LE_8(VARIABLE); break; \
200	/case 16: VARIABLE = H2LE_16(VARIABLE); break;/ \
201	} \
202	} while (0)
203
204	#define LE2H(VARIABLE) \
205	do { \
206	switch (sizeof(VARIABLE)) { \
207	case 1: VARIABLE = LE2H_1(VARIABLE); break; \
208	case 2: VARIABLE = LE2H_2(VARIABLE); break; \
209	case 4: VARIABLE = LE2H_4(VARIABLE); break; \
210	case 8: VARIABLE = LE2H_8(VARIABLE); break; \
211	/case 16: VARIABLE = LE2H_16(VARIABLE); break;/ \
212	} \
213	} while (0)
214
215
216
217	/* TARGET WORD:
218
219	Byte swap a quantity the size of the targets word */
220
221	#if (WITH_TARGET_WORD_BITSIZE == 64)
4c15ccf7 GK	222	#define H2T_word H2T_8
	223	#define T2H_word T2H_8
	224	#define H2BE_word H2BE_8
	225	#define BE2H_word BE2H_8
	226	#define H2LE_word H2LE_8
	227	#define LE2H_word LE2H_8
	228	#define SWAP_word SWAP_8
c906108c SS	229	#endif
c906108c SS	230	#if (WITH_TARGET_WORD_BITSIZE == 32)
4c15ccf7 GK	231	#define H2T_word H2T_4
	232	#define T2H_word T2H_4
	233	#define H2BE_word H2BE_4
	234	#define BE2H_word BE2H_4
	235	#define H2LE_word H2LE_4
	236	#define LE2H_word LE2H_4
	237	#define SWAP_word SWAP_4
c906108c SS	238	#endif
	239
	240
	241
	242	/* TARGET CELL:
	243
	244	Byte swap a quantity the size of the targets IEEE 1275 memory cell */
	245
4c15ccf7 GK	246	#define H2T_cell H2T_4
	247	#define T2H_cell T2H_4
	248	#define H2BE_cell H2BE_4
	249	#define BE2H_cell BE2H_4
	250	#define H2LE_cell H2LE_4
	251	#define LE2H_cell LE2H_4
	252	#define SWAP_cell SWAP_4
c906108c SS	253
	254
	255
	256	/* HOST Offsets:
	257
	258	Address of high/low sub-word within a host word quantity.
	259
	260	Address of sub-word N within a host word quantity. NOTE: Numbering
	261	is BIG endian always. */
	262
	263	#define AH1_2(X) (unsigned_1*)offset_2((X), 1, 0)
	264	#define AL1_2(X) (unsigned_1*)offset_2((X), 1, 1)
	265
	266	#define AH2_4(X) (unsigned_2*)offset_4((X), 2, 0)
	267	#define AL2_4(X) (unsigned_2*)offset_4((X), 2, 1)
	268
	269	#define AH4_8(X) (unsigned_4*)offset_8((X), 4, 0)
	270	#define AL4_8(X) (unsigned_4*)offset_8((X), 4, 1)
	271
	272	#define AH8_16(X) (unsigned_8*)offset_16((X), 8, 0)
	273	#define AL8_16(X) (unsigned_8*)offset_16((X), 8, 1)
	274
	275	#if (WITH_TARGET_WORD_BITSIZE == 64)
	276	#define AH_word(X) AH4_8(X)
	277	#define AL_word(X) AL4_8(X)
	278	#endif
	279	#if (WITH_TARGET_WORD_BITSIZE == 32)
	280	#define AH_word(X) AH2_4(X)
	281	#define AL_word(X) AL2_4(X)
	282	#endif
	283
	284
	285	#define A1_2(X,N) (unsigned_1*)offset_2((X), 1, (N))
	286
	287	#define A1_4(X,N) (unsigned_1*)offset_4((X), 1, (N))
	288	#define A2_4(X,N) (unsigned_2*)offset_4((X), 2, (N))
	289
	290	#define A1_8(X,N) (unsigned_1*)offset_8((X), 1, (N))
	291	#define A2_8(X,N) (unsigned_2*)offset_8((X), 2, (N))
	292	#define A4_8(X,N) (unsigned_4*)offset_8((X), 4, (N))
	293
	294	#define A1_16(X,N) (unsigned_1*)offset_16((X), 1, (N))
	295	#define A2_16(X,N) (unsigned_2*)offset_16((X), 2, (N))
	296	#define A4_16(X,N) (unsigned_4*)offset_16((X), 4, (N))
	297	#define A8_16(X,N) (unsigned_8*)offset_16((X), 8, (N))
	298
	299
	300
	301
	302	/* HOST Components:
	303
	304	Value of sub-word within a host word quantity */
	305
	306	#define VH1_2(X) ((unsigned_1)((unsigned_2)(X) >> 8))
	307	#define VL1_2(X) (unsigned_1)(X)
	308
	309	#define VH2_4(X) ((unsigned_2)((unsigned_4)(X) >> 16))
	310	#define VL2_4(X) ((unsigned_2)(X))
	311
	312	#define VH4_8(X) ((unsigned_4)((unsigned_8)(X) >> 32))
	313	#define VL4_8(X) ((unsigned_4)(X))
	314
	315	#define VH8_16(X) (sim_endian_split_16 ((X), 0))
	316	#define VL8_16(X) (sim_endian_split_16 ((X), 1))
317
318	#if (WITH_TARGET_WORD_BITSIZE == 64)
319	#define VH_word(X) VH4_8(X)
320	#define VL_word(X) VL4_8(X)
321	#endif
322	#if (WITH_TARGET_WORD_BITSIZE == 32)
323	#define VH_word(X) VH2_4(X)
324	#define VL_word(X) VL2_4(X)
325	#endif
326
327
328	#define V1_2(X,N) ((unsigned_1)((unsigned_2)(X) >> ( 8 * (1 - (N)))))
329
330	#define V1_4(X,N) ((unsigned_1)((unsigned_4)(X) >> ( 8 * (3 - (N)))))
331	#define V2_4(X,N) ((unsigned_2)((unsigned_4)(X) >> (16 * (1 - (N)))))
332
333	#define V1_8(X,N) ((unsigned_1)((unsigned_8)(X) >> ( 8 * (7 - (N)))))
334	#define V2_8(X,N) ((unsigned_2)((unsigned_8)(X) >> (16 * (3 - (N)))))
335	#define V4_8(X,N) ((unsigned_4)((unsigned_8)(X) >> (32 * (1 - (N)))))
336
337	#define V1_16(X,N) (*A1_16 (&(X),N))
338	#define V2_16(X,N) (*A2_16 (&(X),N))
339	#define V4_16(X,N) (*A4_16 (&(X),N))
340	#define V8_16(X,N) (*A8_16 (&(X),N))
341
342
343	/* Reverse - insert sub-word into word quantity */
344
345	#define V2_H1(X) ((unsigned_2)(unsigned_1)(X) << 8)
346	#define V2_L1(X) ((unsigned_2)(unsigned_1)(X))
347
348	#define V4_H2(X) ((unsigned_4)(unsigned_2)(X) << 16)
349	#define V4_L2(X) ((unsigned_4)(unsigned_2)(X))
350
351	#define V8_H4(X) ((unsigned_8)(unsigned_4)(X) << 32)
352	#define V8_L4(X) ((unsigned_8)(unsigned_4)(X))
353
354	#define V16_H8(X) ((unsigned_16)(unsigned_8)(X) << 64)
355	#define V16_L8(X) ((unsigned_16)(unsigned_8)(X))
356
357
358	#define V2_1(X,N) ((unsigned_2)(unsigned_1)(X) << ( 8 * (1 - (N))))
359
360	#define V4_1(X,N) ((unsigned_4)(unsigned_1)(X) << ( 8 * (3 - (N))))
361	#define V4_2(X,N) ((unsigned_4)(unsigned_2)(X) << (16 * (1 - (N))))
362
363	#define V8_1(X,N) ((unsigned_8)(unsigned_1)(X) << ( 8 * (7 - (N))))
364	#define V8_2(X,N) ((unsigned_8)(unsigned_2)(X) << (16 * (3 - (N))))
365	#define V8_4(X,N) ((unsigned_8)(unsigned_4)(X) << (32 * (1 - (N))))
366
367	#define V16_1(X,N) ((unsigned_16)(unsigned_1)(X) << ( 8 * (15 - (N))))
368	#define V16_2(X,N) ((unsigned_16)(unsigned_2)(X) << (16 * (7 - (N))))
369	#define V16_4(X,N) ((unsigned_16)(unsigned_4)(X) << (32 * (3 - (N))))
370	#define V16_8(X,N) ((unsigned_16)(unsigned_8)(X) << (64 * (1 - (N))))
371
372
373	/* Reverse - insert N sub-words into single word quantity */
374
375	#define U2_1(I0,I1) (V2_1(I0,0) \| V2_1(I1,1))
376	#define U4_1(I0,I1,I2,I3) (V4_1(I0,0) \| V4_1(I1,1) \| V4_1(I2,2) \| V4_1(I3,3))
377	#define U8_1(I0,I1,I2,I3,I4,I5,I6,I7) \
378	(V8_1(I0,0) \| V8_1(I1,1) \| V8_1(I2,2) \| V8_1(I3,3) \
379	\| V8_1(I4,4) \| V8_1(I5,5) \| V8_1(I6,6) \| V8_1(I7,7))
380	#define U16_1(I0,I1,I2,I3,I4,I5,I6,I7,I8,I9,I10,I11,I12,I13,I14,I15) \
381	(V16_1(I0,0) \| V16_1(I1,1) \| V16_1(I2,2) \| V16_1(I3,3) \
382	\| V16_1(I4,4) \| V16_1(I5,5) \| V16_1(I6,6) \| V16_1(I7,7) \
383	\| V16_1(I8,8) \| V16_1(I9,9) \| V16_1(I10,10) \| V16_1(I11,11) \
384	\| V16_1(I12,12) \| V16_1(I13,13) \| V16_1(I14,14) \| V16_1(I15,15))
385
386	#define U4_2(I0,I1) (V4_2(I0,0) \| V4_2(I1,1))
387	#define U8_2(I0,I1,I2,I3) (V8_2(I0,0) \| V8_2(I1,1) \| V8_2(I2,2) \| V8_2(I3,3))
388	#define U16_2(I0,I1,I2,I3,I4,I5,I6,I7) \
389	(V16_2(I0,0) \| V16_2(I1,1) \| V16_2(I2,2) \| V16_2(I3,3) \
390	\| V16_2(I4,4) \| V16_2(I5,5) \| V16_2(I6,6) \| V16_2(I7,7) )
391
392	#define U8_4(I0,I1) (V8_4(I0,0) \| V8_4(I1,1))
393	#define U16_4(I0,I1,I2,I3) (V16_4(I0,0) \| V16_4(I1,1) \| V16_4(I2,2) \| V16_4(I3,3))
394
395	#define U16_8(I0,I1) (sim_endian_join_16 (I0, I1))
396
397
398	#if (WITH_TARGET_WORD_BITSIZE == 64)
399	#define Vword_H(X) V8_H4(X)
400	#define Vword_L(X) V8_L4(X)
401	#endif
402	#if (WITH_TARGET_WORD_BITSIZE == 32)
403	#define Vword_H(X) V4_H2(X)
404	#define Vword_L(X) V4_L2(X)
405	#endif
406
407
408
409
410	#if H_REVEALS_MODULE_P (SIM_ENDIAN_INLINE)
411	#include "sim-endian.c"
412	#endif
413
414	#endif /* _SIM_ENDIAN_H_ */