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

/*  This file is part of the program psim.

    Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au>
    Copyright (C) 1997, Free Software Foundation, Inc.

    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 _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);


/* SWAP */

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


/* HOST to BE */

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


/* HOST to LE */

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


/* HOST to TARGET */

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


/* 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(X) H2T_8(X)
#define T2H_word(X) T2H_8(X)
#define H2BE_word(X) H2BE_8(X)
#define BE2H_word(X) BE2H_8(X)
#define H2LE_word(X) H2LE_8(X)
#define LE2H_word(X) LE2H_8(X)
#define SWAP_word(X) SWAP_8(X)
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
#define H2T_word(X) H2T_4(X)
#define T2H_word(X) T2H_4(X)
#define H2BE_word(X) H2BE_4(X)
#define BE2H_word(X) BE2H_4(X)
#define H2LE_word(X) H2LE_4(X)
#define LE2H_word(X) LE2H_4(X)
#define SWAP_word(X) SWAP_4(X)
#endif


/* TARGET CELL:

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

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


/* 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) ((unsigned_8)((unsigned_16)(X) >> 64))
#define VL8_16(X) ((unsigned_8)(X))

#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) (V16_8(I0,0) | V16_8(I1,1))


#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 (SIM_ENDIAN_INLINE & INCLUDE_MODULE)
# include "sim-endian.c"
#endif

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