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

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

   Copyright 2002-2022 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

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