[deliverable/binutils-gdb.git] / sim / common / sim-bits.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_BITS_H
#define SIM_BITS_H


/* Bit manipulation routines:

   Bit numbering: The bits are numbered according to the target ISA's
   convention.  That being controlled by WITH_TARGET_WORD_MSB.  For
   the PowerPC (WITH_TARGET_WORD_MSB == 0) the numbering is 0..31
   while for the MIPS (WITH_TARGET_WORD_MSB == 31) it is 31..0.

   Size convention: Each macro is in three forms - <MACRO>32 which
   operates in 32bit quantity (bits are numbered 0..31); <MACRO>64
   which operates using 64bit quantites (and bits are numbered 0..63);
   and <MACRO> which operates using the bit size of the target
   architecture (bits are still numbered 0..63), with 32bit
   architectures ignoring the first 32bits leaving bit 32 as the most
   significant.

   NB: Use EXTRACTED, MSEXTRACTED and LSEXTRACTED as a guideline for
   naming.  LSMASK and LSMASKED are wrong.

   BIT*(POS): `*' bit constant with just 1 bit set.

   LSBIT*(OFFSET): `*' bit constant with just 1 bit set - LS bit is
   zero.

   MSBIT*(OFFSET): `*' bit constant with just 1 bit set - MS bit is
   zero.

   MASK*(FIRST, LAST): `*' bit constant with bits [FIRST .. LAST]
   set. The <MACRO> (no size) version permits FIRST >= LAST and
   generates a wrapped bit mask vis ([0..LAST] | [FIRST..LSB]).

   LSMASK*(FIRST, LAST): Like MASK - LS bit is zero.

   MSMASK*(FIRST, LAST): Like MASK - LS bit is zero.

   MASKED*(VALUE, FIRST, LAST): Masks out all but bits [FIRST
   .. LAST].

   LSMASKED*(VALUE, FIRST, LAST): Like MASKED - LS bit is zero.

   MSMASKED*(VALUE, FIRST, LAST): Like MASKED - MS bit is zero.

   EXTRACTED*(VALUE, FIRST, LAST): Masks out bits [FIRST .. LAST] but
   also right shifts the masked value so that bit LAST becomes the
   least significant (right most).

   LSEXTRACTED*(VALUE, FIRST, LAST): Same as extracted - LS bit is
   zero.

   MSEXTRACTED*(VALUE, FIRST, LAST): Same as extracted - MS bit is
   zero.

   SHUFFLED**(VALUE, OLD, NEW): Mask then move a single bit from OLD
   new NEW.

   MOVED**(VALUE, OLD_FIRST, OLD_LAST, NEW_FIRST, NEW_LAST): Moves
   things around so that bits OLD_FIRST..OLD_LAST are masked then
   moved to NEW_FIRST..NEW_LAST.

   INSERTED*(VALUE, FIRST, LAST): Takes VALUE and `inserts' the (LAST
   - FIRST + 1) least significant bits into bit positions [ FIRST
   .. LAST ].  This is almost the complement to EXTRACTED.

   IEA_MASKED(SHOULD_MASK, ADDR): Convert the address to the targets
   natural size.  If in 32bit mode, discard the high 32bits.

   EXTEND*(VALUE): Convert the `*' bit value to the targets natural
   word size.  Sign extend the value if needed.

   align_*(VALUE, BYTES): Round the value so that it is aligned to a
   BYTES boundary.

   ROT*(VALUE, NR_BITS): Return the `*' bit VALUE rotated by NR_BITS
   right (positive) or left (negative).

   ROTL*(VALUE, NR_BITS): Return the `*' bit value rotated by NR_BITS
   left.  0 <= NR_BITS <= `*'.

   ROTR*(VALUE, NR_BITS): Return the `*' bit value rotated by NR_BITS
   right.  0 <= NR_BITS <= N.

   SEXT*(VALUE, SIGN_BIT): Treat SIGN_BIT as VALUEs sign, extend it ti
   `*' bits.

   Note: Only the BIT* and MASK* macros return a constant that can be
   used in variable declarations.

   */


/* compute the number of bits between START and STOP */

#if (WITH_TARGET_WORD_MSB == 0)
#define _MAKE_WIDTH(START, STOP) (STOP - START + 1)
#else
#define _MAKE_WIDTH(START, STOP) (START - STOP + 1)
#endif


/* compute the number shifts required to move a bit between LSB (MSB)
   and POS */

#if (WITH_TARGET_WORD_MSB == 0)
#define _LSB_SHIFT(WIDTH, POS) (WIDTH - 1 - POS)
#else
#define _LSB_SHIFT(WIDTH, POS) (POS)
#endif

#if (WITH_TARGET_WORD_MSB == 0)
#define _MSB_SHIFT(WIDTH, POS) (POS)
#else
#define _MSB_SHIFT(WIDTH, POS) (WIDTH - 1 - POS)
#endif


/* compute the absolute bit position given the OFFSET from the MSB(LSB)
   NB: _MAKE_xxx_POS (WIDTH, _MAKE_xxx_SHIFT (WIDTH, POS)) == POS */

#if (WITH_TARGET_WORD_MSB == 0)
#define _MSB_POS(WIDTH, SHIFT) (SHIFT)
#else
#define _MSB_POS(WIDTH, SHIFT) (WIDTH - 1 - SHIFT)
#endif

#if (WITH_TARGET_WORD_MSB == 0)
#define _LSB_POS(WIDTH, SHIFT) (WIDTH - 1 - SHIFT)
#else
#define _LSB_POS(WIDTH, SHIFT) (SHIFT)
#endif


/* convert a 64 bit position into a corresponding 32bit position. MSB
   pos handles the posibility that the bit lies beyond the 32bit
   boundary */

#if (WITH_TARGET_WORD_MSB == 0)
#define _MSB_32(START, STOP) (START <= STOP \
			      ? (START < 32 ? 0 : START - 32) \
			      : (STOP < 32 ? 0 : STOP - 32))
#define _MSB_16(START, STOP) (START <= STOP \
			      ? (START < 48 ? 0 : START - 48) \
			      : (STOP < 48 ? 0 : STOP - 48))
#else
#define _MSB_32(START, STOP) (START >= STOP \
			      ? (START >= 32 ? 31 : START) \
			      : (STOP >= 32 ? 31 : STOP))
#define _MSB_16(START, STOP) (START >= STOP \
			      ? (START >= 16 ? 15 : START) \
			      : (STOP >= 16 ? 15 : STOP))
#endif

#if (WITH_TARGET_WORD_MSB == 0)
#define _LSB_32(START, STOP) (START <= STOP \
			      ? (STOP < 32 ? 0 : STOP - 32) \
			      : (START < 32 ? 0 : START - 32))
#define _LSB_16(START, STOP) (START <= STOP \
			      ? (STOP < 48 ? 0 : STOP - 48) \
			      : (START < 48 ? 0 : START - 48))
#else
#define _LSB_32(START, STOP) (START >= STOP \
			      ? (STOP >= 32 ? 31 : STOP) \
			      : (START >= 32 ? 31 : START))
#define _LSB_16(START, STOP) (START >= STOP \
			      ? (STOP >= 16 ? 15 : STOP) \
			      : (START >= 16 ? 15 : START))
#endif

#if (WITH_TARGET_WORD_MSB == 0)
#define _MSB(START, STOP) (START <= STOP ? START : STOP)
#else
#define _MSB(START, STOP) (START >= STOP ? START : STOP)
#endif

#if (WITH_TARGET_WORD_MSB == 0)
#define _LSB(START, STOP) (START <= STOP ? STOP : START)
#else
#define _LSB(START, STOP) (START >= STOP ? STOP : START)
#endif


/* LS/MS Bit operations */

#define LSBIT8(POS)  ((unsigned8) 1 << (POS))
#define LSBIT16(POS) ((unsigned16)1 << (POS))
#define LSBIT32(POS) ((unsigned32)1 << (POS))
#define LSBIT64(POS) ((unsigned64)1 << (POS))

#if (WITH_TARGET_WORD_BITSIZE == 64)
#define LSBIT(POS) LSBIT64 (POS)
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
#define LSBIT(POS) ((unsigned32)((POS) >= 32 \
		                 ? 0 \
			         : (1 << ((POS) >= 32 ? 0 : (POS)))))
#endif
#if (WITH_TARGET_WORD_BITSIZE == 16)
#define LSBIT(POS) ((unsigned16)((POS) >= 16 \
		                 ? 0 \
			         : (1 << ((POS) >= 16 ? 0 : (POS)))))
#endif


#define MSBIT8(POS)  ((unsigned8) 1 << ( 8 - 1 - (POS)))
#define MSBIT16(POS) ((unsigned16)1 << (16 - 1 - (POS)))
#define MSBIT32(POS) ((unsigned32)1 << (32 - 1 - (POS)))
#define MSBIT64(POS) ((unsigned64)1 << (64 - 1 - (POS)))

#if (WITH_TARGET_WORD_BITSIZE == 64)
#define MSBIT(POS) MSBIT64 (POS)
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
#define MSBIT(POS) ((unsigned32)((POS) < 32 \
		                 ? 0 \
		                 : (1 << ((POS) < 32 ? 0 : (64 - 1) - (POS)))))
#endif
#if (WITH_TARGET_WORD_BITSIZE == 16)
#define MSBIT(POS) ((unsigned16)((POS) < 48 \
		                 ? 0 \
		                 : (1 << ((POS) < 48 ? 0 : (64 - 1) - (POS)))))
#endif


/* Bit operations */

#define BIT4(POS)  (1 << _LSB_SHIFT (4, (POS)))
#define BIT5(POS)  (1 << _LSB_SHIFT (5, (POS)))
#define BIT10(POS) (1 << _LSB_SHIFT (10, (POS)))

#if (WITH_TARGET_WORD_MSB == 0)
#define BIT8  MSBIT8
#define BIT16 MSBIT16
#define BIT32 MSBIT32
#define BIT64 MSBIT64
#define BIT   MSBIT
#else
#define BIT8  LSBIT8
#define BIT16 LSBIT16
#define BIT32 LSBIT32
#define BIT64 LSBIT64
#define BIT   LSBIT
#endif


/* multi bit mask */

/* 111111 -> mmll11 -> mm11ll */
#define _MASKn(WIDTH, START, STOP) (((unsigned##WIDTH)(-1) \
				     >> (_MSB_SHIFT (WIDTH, START) \
					 + _LSB_SHIFT (WIDTH, STOP))) \
				    << _LSB_SHIFT (WIDTH, STOP))

#if (WITH_TARGET_WORD_MSB == 0)
#define _POS_LE(START, STOP) (START <= STOP)
#else
#define _POS_LE(START, STOP) (STOP <= START)
#endif

#if (WITH_TARGET_WORD_BITSIZE == 64)
#define MASK(START, STOP) \
     (_POS_LE ((START), (STOP)) \
      ? _MASKn(64, \
	       _MSB ((START), (STOP)), \
	       _LSB ((START), (STOP)) ) \
      : (_MASKn(64, _MSB_POS (64, 0), (STOP)) \
	 | _MASKn(64, (START), _LSB_POS (64, 0))))
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
#define MASK(START, STOP) \
     (_POS_LE ((START), (STOP)) \
      ? (_POS_LE ((STOP), _MSB_POS (64, 31)) \
	 ? 0 \
	 : _MASKn (32, \
		   _MSB_32 ((START), (STOP)), \
		   _LSB_32 ((START), (STOP)))) \
      : (_MASKn (32, \
		 _LSB_32 ((START), (STOP)), \
		 _LSB_POS (32, 0)) \
	 | (_POS_LE ((STOP), _MSB_POS (64, 31)) \
	    ? 0 \
	    : _MASKn (32, \
		      _MSB_POS (32, 0), \
		      _MSB_32 ((START), (STOP))))))
#endif
#if (WITH_TARGET_WORD_BITSIZE == 16)
#define MASK(START, STOP) \
     (_POS_LE ((START), (STOP)) \
      ? (_POS_LE ((STOP), _MSB_POS (64, 15)) \
	 ? 0 \
	 : _MASKn (16, \
		   _MSB_16 ((START), (STOP)), \
		   _LSB_16 ((START), (STOP)))) \
      : (_MASKn (16, \
		 _LSB_16 ((START), (STOP)), \
		 _LSB_POS (16, 0)) \
	 | (_POS_LE ((STOP), _MSB_POS (64, 15)) \
	    ? 0 \
	    : _MASKn (16, \
		      _MSB_POS (16, 0), \
		      _MSB_16 ((START), (STOP))))))
#endif
#if !defined (MASK)
#error "MASK never undefined"
#endif


/* Multi-bit mask on least significant bits */

#define _LSMASKn(WIDTH, FIRST, LAST) _MASKn (WIDTH, \
					     _LSB_POS (WIDTH, FIRST), \
					     _LSB_POS (WIDTH, LAST))

#define LSMASK8(FIRST, LAST)   _LSMASKn ( 8, (FIRST), (LAST))
#define LSMASK16(FIRST, LAST)  _LSMASKn (16, (FIRST), (LAST))
#define LSMASK32(FIRST, LAST)  _LSMASKn (32, (FIRST), (LAST))
#define LSMASK64(FIRST, LAST)  _LSMASKn (64, (FIRST), (LAST))

#define LSMASK(FIRST, LAST) (MASK (_LSB_POS (64, FIRST), _LSB_POS (64, LAST)))


/* Multi-bit mask on most significant bits */

#define _MSMASKn(WIDTH, FIRST, LAST) _MASKn (WIDTH, \
					     _MSB_POS (WIDTH, FIRST), \
					     _MSB_POS (WIDTH, LAST))

#define MSMASK8(FIRST, LAST)  _MSMASKn ( 8, (FIRST), (LAST))
#define MSMASK16(FIRST, LAST) _MSMASKn (16, (FIRST), (LAST))
#define MSMASK32(FIRST, LAST) _MSMASKn (32, (FIRST), (LAST))
#define MSMASK64(FIRST, LAST) _MSMASKn (64, (FIRST), (LAST))

#define MSMASK(FIRST, LAST) (MASK (_MSB_POS (64, FIRST), _MSB_POS (64, LAST)))


#if (WITH_TARGET_WORD_MSB == 0)
#define MASK8  MSMASK8
#define MASK16 MSMASK16
#define MASK32 MSMASK32
#define MASK64 MSMASK64
#else
#define MASK8  LSMASK8
#define MASK16 LSMASK16
#define MASK32 LSMASK32
#define MASK64 LSMASK64
#endif


/* mask the required bits, leaving them in place */

INLINE_SIM_BITS(unsigned8)  LSMASKED8  (unsigned8  word, int first, int last);
INLINE_SIM_BITS(unsigned16) LSMASKED16 (unsigned16 word, int first, int last);
INLINE_SIM_BITS(unsigned32) LSMASKED32 (unsigned32 word, int first, int last);
INLINE_SIM_BITS(unsigned64) LSMASKED64 (unsigned64 word, int first, int last);

INLINE_SIM_BITS(unsigned_word) LSMASKED (unsigned_word word, int first, int last);

INLINE_SIM_BITS(unsigned8)  MSMASKED8  (unsigned8  word, int first, int last);
INLINE_SIM_BITS(unsigned16) MSMASKED16 (unsigned16 word, int first, int last);
INLINE_SIM_BITS(unsigned32) MSMASKED32 (unsigned32 word, int first, int last);
INLINE_SIM_BITS(unsigned64) MSMASKED64 (unsigned64 word, int first, int last);

INLINE_SIM_BITS(unsigned_word) MSMASKED (unsigned_word word, int first, int last);

#if (WITH_TARGET_WORD_MSB == 0)
#define MASKED8  MSMASKED8
#define MASKED16 MSMASKED16
#define MASKED32 MSMASKED32
#define MASKED64 MSMASKED64
#define MASKED   MSMASKED
#else
#define MASKED8  LSMASKED8
#define MASKED16 LSMASKED16
#define MASKED32 LSMASKED32
#define MASKED64 LSMASKED64
#define MASKED LSMASKED
#endif


/* extract the required bits aligning them with the lsb */

INLINE_SIM_BITS(unsigned8)  LSEXTRACTED8  (unsigned8  val, int start, int stop);
INLINE_SIM_BITS(unsigned16) LSEXTRACTED16 (unsigned16 val, int start, int stop);
INLINE_SIM_BITS(unsigned32) LSEXTRACTED32 (unsigned32 val, int start, int stop);
INLINE_SIM_BITS(unsigned64) LSEXTRACTED64 (unsigned64 val, int start, int stop);

INLINE_SIM_BITS(unsigned_word) LSEXTRACTED (unsigned_word val, int start, int stop);

INLINE_SIM_BITS(unsigned8)  MSEXTRACTED8  (unsigned8  val, int start, int stop);
INLINE_SIM_BITS(unsigned16) MSEXTRACTED16 (unsigned16 val, int start, int stop);
INLINE_SIM_BITS(unsigned32) MSEXTRACTED32 (unsigned32 val, int start, int stop);
INLINE_SIM_BITS(unsigned64) MSEXTRACTED64 (unsigned64 val, int start, int stop);

INLINE_SIM_BITS(unsigned_word) MSEXTRACTED (unsigned_word val, int start, int stop);

#if (WITH_TARGET_WORD_MSB == 0)
#define EXTRACTED8  MSEXTRACTED8
#define EXTRACTED16 MSEXTRACTED16
#define EXTRACTED32 MSEXTRACTED32
#define EXTRACTED64 MSEXTRACTED64
#define EXTRACTED   MSEXTRACTED
#else
#define EXTRACTED8  LSEXTRACTED8
#define EXTRACTED16 LSEXTRACTED16
#define EXTRACTED32 LSEXTRACTED32
#define EXTRACTED64 LSEXTRACTED64
#define EXTRACTED   LSEXTRACTED
#endif


/* move a single bit around */
/* NB: the wierdness (N>O?N-O:0) is to stop a warning from GCC */
#define _SHUFFLEDn(N, WORD, OLD, NEW) \
((OLD) < (NEW) \
 ? (((unsigned##N)(WORD) \
     >> (((NEW) > (OLD)) ? ((NEW) - (OLD)) : 0)) \
    & MASK32((NEW), (NEW))) \
 : (((unsigned##N)(WORD) \
     << (((OLD) > (NEW)) ? ((OLD) - (NEW)) : 0)) \
    & MASK32((NEW), (NEW))))

#define SHUFFLED32(WORD, OLD, NEW) _SHUFFLEDn (32, WORD, OLD, NEW)
#define SHUFFLED64(WORD, OLD, NEW) _SHUFFLEDn (64, WORD, OLD, NEW)

#define SHUFFLED(WORD, OLD, NEW) _SHUFFLEDn (_word, WORD, OLD, NEW)


/* Insert a group of bits into a bit position */

INLINE_SIM_BITS(unsigned8)  LSINSERTED8  (unsigned8  val, int start, int stop);
INLINE_SIM_BITS(unsigned16) LSINSERTED16 (unsigned16 val, int start, int stop);
INLINE_SIM_BITS(unsigned32) LSINSERTED32 (unsigned32 val, int start, int stop);
INLINE_SIM_BITS(unsigned64) LSINSERTED64 (unsigned64 val, int start, int stop);
INLINE_SIM_BITS(unsigned_word) LSINSERTED (unsigned_word val, int start, int stop);

INLINE_SIM_BITS(unsigned8)  MSINSERTED8  (unsigned8  val, int start, int stop);
INLINE_SIM_BITS(unsigned16) MSINSERTED16 (unsigned16 val, int start, int stop);
INLINE_SIM_BITS(unsigned32) MSINSERTED32 (unsigned32 val, int start, int stop);
INLINE_SIM_BITS(unsigned64) MSINSERTED64 (unsigned64 val, int start, int stop);
INLINE_SIM_BITS(unsigned_word) MSINSERTED (unsigned_word val, int start, int stop);

#if (WITH_TARGET_WORD_MSB == 0)
#define INSERTED8  MSINSERTED8
#define INSERTED16 MSINSERTED16
#define INSERTED32 MSINSERTED32
#define INSERTED64 MSINSERTED64
#define INSERTED   MSINSERTED
#else
#define INSERTED8  LSINSERTED8
#define INSERTED16 LSINSERTED16
#define INSERTED32 LSINSERTED32
#define INSERTED64 LSINSERTED64
#define INSERTED   LSINSERTED
#endif


/* MOVE bits from one loc to another (combination of extract/insert) */

#define MOVED8(VAL,OH,OL,NH,NL)  INSERTED8 (EXTRACTED8 ((VAL), OH, OL), NH, NL)
#define MOVED16(VAL,OH,OL,NH,NL) INSERTED16(EXTRACTED16((VAL), OH, OL), NH, NL)
#define MOVED32(VAL,OH,OL,NH,NL) INSERTED32(EXTRACTED32((VAL), OH, OL), NH, NL)
#define MOVED64(VAL,OH,OL,NH,NL) INSERTED64(EXTRACTED64((VAL), OH, OL), NH, NL)
#define MOVED(VAL,OH,OL,NH,NL)   INSERTED  (EXTRACTED  ((VAL), OH, OL), NH, NL)


/* Sign extend the quantity to the targets natural word size */

#define EXTEND4(X)  (LSSEXT ((X), 3))
#define EXTEND5(X)  (LSSEXT ((X), 4))
#define EXTEND6(X)  (LSSEXT ((X), 5))
#define EXTEND8(X)  ((signed_word)(signed8)(X))
#define EXTEND11(X)  (LSSEXT ((X), 10))
#define EXTEND12(X)  (LSSEXT ((X), 11))
#define EXTEND15(X)  (LSSEXT ((X), 14))
#define EXTEND16(X) ((signed_word)(signed16)(X))
#define EXTEND24(X)  (LSSEXT ((X), 23))
#define EXTEND25(X)  (LSSEXT ((X), 24))
#define EXTEND32(X) ((signed_word)(signed32)(X))
#define EXTEND64(X) ((signed_word)(signed64)(X))

/* depending on MODE return a 64bit or 32bit (sign extended) value */
#if (WITH_TARGET_WORD_BITSIZE == 64)
#define EXTENDED(X)     ((signed64)(signed32)(X))
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
#define EXTENDED(X)     (X)
#endif
#if (WITH_TARGET_WORD_BITSIZE == 16)
#define EXTENDED(X)     (X)
#endif


/* memory alignment macro's */
#define align_up(v, n)		(((v) + (n) - 1) & -(n))
#define align_down(v, n)	((v) & -(n))


/* bit bliting macro's */
#define BLIT32(V, POS, BIT) \
do { \
  if (BIT) \
    V |= BIT32 (POS); \
  else \
    V &= ~BIT32 (POS); \
} while (0)
#define MBLIT32(V, LO, HI, VAL) \
do { \
  (V) = (((V) & ~MASK32 ((LO), (HI))) \
	 | INSERTED32 (VAL, LO, HI)); \
} while (0)


/* some rotate functions.  The generic macro's ROT, ROTL, ROTR are
   intentionally omited. */


INLINE_SIM_BITS(unsigned8)  ROT8  (unsigned8  val, int shift);
INLINE_SIM_BITS(unsigned16) ROT16 (unsigned16 val, int shift);
INLINE_SIM_BITS(unsigned32) ROT32 (unsigned32 val, int shift);
INLINE_SIM_BITS(unsigned64) ROT64 (unsigned64 val, int shift);


INLINE_SIM_BITS(unsigned8)  ROTL8  (unsigned8  val, int shift);
INLINE_SIM_BITS(unsigned16) ROTL16 (unsigned16 val, int shift);
INLINE_SIM_BITS(unsigned32) ROTL32 (unsigned32 val, int shift);
INLINE_SIM_BITS(unsigned64) ROTL64 (unsigned64 val, int shift);


INLINE_SIM_BITS(unsigned8)  ROTR8  (unsigned8  val, int shift);
INLINE_SIM_BITS(unsigned16) ROTR16 (unsigned16 val, int shift);
INLINE_SIM_BITS(unsigned32) ROTR32 (unsigned32 val, int shift);
INLINE_SIM_BITS(unsigned64) ROTR64 (unsigned64 val, int shift);


/* Sign extension operations */

INLINE_SIM_BITS(unsigned8)  LSSEXT8  (signed8  val, int sign_bit);
INLINE_SIM_BITS(unsigned16) LSSEXT16 (signed16 val, int sign_bit);
INLINE_SIM_BITS(unsigned32) LSSEXT32 (signed32 val, int sign_bit);
INLINE_SIM_BITS(unsigned64) LSSEXT64 (signed64 val, int sign_bit);
INLINE_SIM_BITS(unsigned_word) LSSEXT (signed_word val, int sign_bit);

INLINE_SIM_BITS(unsigned8)  MSSEXT8  (signed8  val, int sign_bit);
INLINE_SIM_BITS(unsigned16) MSSEXT16 (signed16 val, int sign_bit);
INLINE_SIM_BITS(unsigned32) MSSEXT32 (signed32 val, int sign_bit);
INLINE_SIM_BITS(unsigned64) MSSEXT64 (signed64 val, int sign_bit);
INLINE_SIM_BITS(unsigned_word) MSSEXT (signed_word val, int sign_bit);

#if (WITH_TARGET_WORD_MSB == 0)
#define SEXT8  MSSEXT8
#define SEXT16 MSSEXT16
#define SEXT32 MSSEXT32
#define SEXT64 MSSEXT64
#define SEXT   MSSEXT
#else
#define SEXT8  LSSEXT8
#define SEXT16 LSSEXT16
#define SEXT32 LSSEXT32
#define SEXT64 LSSEXT64
#define SEXT   LSSEXT
#endif


#if H_REVEALS_MODULE_P (SIM_BITS_INLINE)
#include "sim-bits.c"
#endif

#endif /* SIM_BITS_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_BITS_H
618b526e MF	24	#define SIM_BITS_H
c906108c SS	25
	26
	27	/* Bit manipulation routines:
	28
	29	Bit numbering: The bits are numbered according to the target ISA's
	30	convention. That being controlled by WITH_TARGET_WORD_MSB. For
	31	the PowerPC (WITH_TARGET_WORD_MSB == 0) the numbering is 0..31
	32	while for the MIPS (WITH_TARGET_WORD_MSB == 31) it is 31..0.
	33
	34	Size convention: Each macro is in three forms - <MACRO>32 which
	35	operates in 32bit quantity (bits are numbered 0..31); <MACRO>64
	36	which operates using 64bit quantites (and bits are numbered 0..63);
	37	and <MACRO> which operates using the bit size of the target
	38	architecture (bits are still numbered 0..63), with 32bit
	39	architectures ignoring the first 32bits leaving bit 32 as the most
	40	significant.
	41
	42	NB: Use EXTRACTED, MSEXTRACTED and LSEXTRACTED as a guideline for
	43	naming. LSMASK and LSMASKED are wrong.
	44
	45	BIT(POS): `' bit constant with just 1 bit set.
	46
	47	LSBIT(OFFSET): `' bit constant with just 1 bit set - LS bit is
	48	zero.
	49
	50	MSBIT(OFFSET): `' bit constant with just 1 bit set - MS bit is
	51	zero.
	52
	53	MASK(FIRST, LAST): `' bit constant with bits [FIRST .. LAST]
	54	set. The <MACRO> (no size) version permits FIRST >= LAST and
	55	generates a wrapped bit mask vis ([0..LAST] \| [FIRST..LSB]).
	56
	57	LSMASK*(FIRST, LAST): Like MASK - LS bit is zero.
	58
	59	MSMASK*(FIRST, LAST): Like MASK - LS bit is zero.
	60
	61	MASKED*(VALUE, FIRST, LAST): Masks out all but bits [FIRST
	62	.. LAST].
	63
	64	LSMASKED*(VALUE, FIRST, LAST): Like MASKED - LS bit is zero.
	65
	66	MSMASKED*(VALUE, FIRST, LAST): Like MASKED - MS bit is zero.
	67
	68	EXTRACTED*(VALUE, FIRST, LAST): Masks out bits [FIRST .. LAST] but
	69	also right shifts the masked value so that bit LAST becomes the
	70	least significant (right most).
	71
	72	LSEXTRACTED*(VALUE, FIRST, LAST): Same as extracted - LS bit is
	73	zero.
	74
	75	MSEXTRACTED*(VALUE, FIRST, LAST): Same as extracted - MS bit is
	76	zero.
	77
	78	SHUFFLED**(VALUE, OLD, NEW): Mask then move a single bit from OLD
	79	new NEW.
	80
	81	MOVED**(VALUE, OLD_FIRST, OLD_LAST, NEW_FIRST, NEW_LAST): Moves
	82	things around so that bits OLD_FIRST..OLD_LAST are masked then
	83	moved to NEW_FIRST..NEW_LAST.
	84
	85	INSERTED*(VALUE, FIRST, LAST): Takes VALUE and `inserts' the (LAST
	86	- FIRST + 1) least significant bits into bit positions [ FIRST
	87	.. LAST ]. This is almost the complement to EXTRACTED.
	88
89	IEA_MASKED(SHOULD_MASK, ADDR): Convert the address to the targets
90	natural size. If in 32bit mode, discard the high 32bits.
91
92	EXTEND(VALUE): Convert the `' bit value to the targets natural
93	word size. Sign extend the value if needed.
94
0ede24f2 MF	95	align_*(VALUE, BYTES): Round the value so that it is aligned to a
0ede24f2 MF	96	BYTES boundary.
c906108c SS	97
	98	ROT(VALUE, NR_BITS): Return the `' bit VALUE rotated by NR_BITS
	99	right (positive) or left (negative).
	100
	101	ROTL(VALUE, NR_BITS): Return the `' bit value rotated by NR_BITS
	102	left. 0 <= NR_BITS <= `*'.
	103
	104	ROTR(VALUE, NR_BITS): Return the `' bit value rotated by NR_BITS
	105	right. 0 <= NR_BITS <= N.
	106
	107	SEXT*(VALUE, SIGN_BIT): Treat SIGN_BIT as VALUEs sign, extend it ti
	108	`*' bits.
	109
	110	Note: Only the BIT* and MASK* macros return a constant that can be
	111	used in variable declarations.
	112
	113	*/
	114
	115
	116	/* compute the number of bits between START and STOP */
	117
	118	#if (WITH_TARGET_WORD_MSB == 0)
	119	#define _MAKE_WIDTH(START, STOP) (STOP - START + 1)
	120	#else
	121	#define _MAKE_WIDTH(START, STOP) (START - STOP + 1)
	122	#endif
	123
	124
	125
	126	/* compute the number shifts required to move a bit between LSB (MSB)
	127	and POS */
	128
	129	#if (WITH_TARGET_WORD_MSB == 0)
	130	#define _LSB_SHIFT(WIDTH, POS) (WIDTH - 1 - POS)
	131	#else
	132	#define _LSB_SHIFT(WIDTH, POS) (POS)
	133	#endif
	134
	135	#if (WITH_TARGET_WORD_MSB == 0)
	136	#define _MSB_SHIFT(WIDTH, POS) (POS)
	137	#else
	138	#define _MSB_SHIFT(WIDTH, POS) (WIDTH - 1 - POS)
	139	#endif
	140
	141
	142	/* compute the absolute bit position given the OFFSET from the MSB(LSB)
	143	NB: _MAKE_xxx_POS (WIDTH, _MAKE_xxx_SHIFT (WIDTH, POS)) == POS */
	144
	145	#if (WITH_TARGET_WORD_MSB == 0)
	146	#define _MSB_POS(WIDTH, SHIFT) (SHIFT)
	147	#else
	148	#define _MSB_POS(WIDTH, SHIFT) (WIDTH - 1 - SHIFT)
	149	#endif
	150
	151	#if (WITH_TARGET_WORD_MSB == 0)
	152	#define _LSB_POS(WIDTH, SHIFT) (WIDTH - 1 - SHIFT)
	153	#else
	154	#define _LSB_POS(WIDTH, SHIFT) (SHIFT)
	155	#endif
	156
	157
	158	/* convert a 64 bit position into a corresponding 32bit position. MSB
	159	pos handles the posibility that the bit lies beyond the 32bit
	160	boundary */
161
162	#if (WITH_TARGET_WORD_MSB == 0)
163	#define _MSB_32(START, STOP) (START <= STOP \
164	? (START < 32 ? 0 : START - 32) \
165	: (STOP < 32 ? 0 : STOP - 32))
3c765a54 AC	166	#define _MSB_16(START, STOP) (START <= STOP \
	167	? (START < 48 ? 0 : START - 48) \
	168	: (STOP < 48 ? 0 : STOP - 48))
c906108c SS	169	#else
	170	#define _MSB_32(START, STOP) (START >= STOP \
	171	? (START >= 32 ? 31 : START) \
	172	: (STOP >= 32 ? 31 : STOP))
3c765a54 AC	173	#define _MSB_16(START, STOP) (START >= STOP \
	174	? (START >= 16 ? 15 : START) \
	175	: (STOP >= 16 ? 15 : STOP))
c906108c SS	176	#endif
	177
	178	#if (WITH_TARGET_WORD_MSB == 0)
	179	#define _LSB_32(START, STOP) (START <= STOP \
	180	? (STOP < 32 ? 0 : STOP - 32) \
	181	: (START < 32 ? 0 : START - 32))
3c765a54 AC	182	#define _LSB_16(START, STOP) (START <= STOP \
	183	? (STOP < 48 ? 0 : STOP - 48) \
	184	: (START < 48 ? 0 : START - 48))
c906108c SS	185	#else
	186	#define _LSB_32(START, STOP) (START >= STOP \
	187	? (STOP >= 32 ? 31 : STOP) \
	188	: (START >= 32 ? 31 : START))
3c765a54 AC	189	#define _LSB_16(START, STOP) (START >= STOP \
	190	? (STOP >= 16 ? 15 : STOP) \
	191	: (START >= 16 ? 15 : START))
c906108c SS	192	#endif
	193
	194	#if (WITH_TARGET_WORD_MSB == 0)
	195	#define _MSB(START, STOP) (START <= STOP ? START : STOP)
	196	#else
	197	#define _MSB(START, STOP) (START >= STOP ? START : STOP)
	198	#endif
	199
	200	#if (WITH_TARGET_WORD_MSB == 0)
	201	#define _LSB(START, STOP) (START <= STOP ? STOP : START)
	202	#else
	203	#define _LSB(START, STOP) (START >= STOP ? STOP : START)
	204	#endif
	205
	206
	207	/* LS/MS Bit operations */
	208
	209	#define LSBIT8(POS) ((unsigned8) 1 << (POS))
	210	#define LSBIT16(POS) ((unsigned16)1 << (POS))
	211	#define LSBIT32(POS) ((unsigned32)1 << (POS))
	212	#define LSBIT64(POS) ((unsigned64)1 << (POS))
	213
	214	#if (WITH_TARGET_WORD_BITSIZE == 64)
	215	#define LSBIT(POS) LSBIT64 (POS)
3c765a54 AC	216	#endif
3c765a54 AC	217	#if (WITH_TARGET_WORD_BITSIZE == 32)
c906108c SS	218	#define LSBIT(POS) ((unsigned32)((POS) >= 32 \
	219	? 0 \
	220	: (1 << ((POS) >= 32 ? 0 : (POS)))))
	221	#endif
3c765a54 AC	222	#if (WITH_TARGET_WORD_BITSIZE == 16)
	223	#define LSBIT(POS) ((unsigned16)((POS) >= 16 \
	224	? 0 \
	225	: (1 << ((POS) >= 16 ? 0 : (POS)))))
	226	#endif
c906108c SS	227
	228
	229	#define MSBIT8(POS) ((unsigned8) 1 << ( 8 - 1 - (POS)))
	230	#define MSBIT16(POS) ((unsigned16)1 << (16 - 1 - (POS)))
	231	#define MSBIT32(POS) ((unsigned32)1 << (32 - 1 - (POS)))
	232	#define MSBIT64(POS) ((unsigned64)1 << (64 - 1 - (POS)))
	233
	234	#if (WITH_TARGET_WORD_BITSIZE == 64)
	235	#define MSBIT(POS) MSBIT64 (POS)
3c765a54 AC	236	#endif
3c765a54 AC	237	#if (WITH_TARGET_WORD_BITSIZE == 32)
c906108c SS	238	#define MSBIT(POS) ((unsigned32)((POS) < 32 \
	239	? 0 \
	240	: (1 << ((POS) < 32 ? 0 : (64 - 1) - (POS)))))
	241	#endif
3c765a54 AC	242	#if (WITH_TARGET_WORD_BITSIZE == 16)
	243	#define MSBIT(POS) ((unsigned16)((POS) < 48 \
	244	? 0 \
	245	: (1 << ((POS) < 48 ? 0 : (64 - 1) - (POS)))))
	246	#endif
c906108c SS	247
	248
	249	/* Bit operations */
	250
	251	#define BIT4(POS) (1 << _LSB_SHIFT (4, (POS)))
	252	#define BIT5(POS) (1 << _LSB_SHIFT (5, (POS)))
	253	#define BIT10(POS) (1 << _LSB_SHIFT (10, (POS)))
	254
	255	#if (WITH_TARGET_WORD_MSB == 0)
	256	#define BIT8 MSBIT8
	257	#define BIT16 MSBIT16
	258	#define BIT32 MSBIT32
	259	#define BIT64 MSBIT64
	260	#define BIT MSBIT
	261	#else
	262	#define BIT8 LSBIT8
	263	#define BIT16 LSBIT16
	264	#define BIT32 LSBIT32
	265	#define BIT64 LSBIT64
	266	#define BIT LSBIT
	267	#endif
	268
	269
	270
	271	/* multi bit mask */
	272
	273	/* 111111 -> mmll11 -> mm11ll */
	274	#define _MASKn(WIDTH, START, STOP) (((unsigned##WIDTH)(-1) \
	275	>> (_MSB_SHIFT (WIDTH, START) \
	276	+ _LSB_SHIFT (WIDTH, STOP))) \
	277	<< _LSB_SHIFT (WIDTH, STOP))
	278
	279	#if (WITH_TARGET_WORD_MSB == 0)
	280	#define _POS_LE(START, STOP) (START <= STOP)
	281	#else
	282	#define _POS_LE(START, STOP) (STOP <= START)
	283	#endif
	284
	285	#if (WITH_TARGET_WORD_BITSIZE == 64)
	286	#define MASK(START, STOP) \
	287	(_POS_LE ((START), (STOP)) \
	288	? _MASKn(64, \
	289	_MSB ((START), (STOP)), \
	290	_LSB ((START), (STOP)) ) \
	291	: (_MASKn(64, _MSB_POS (64, 0), (STOP)) \
	292	\| _MASKn(64, (START), _LSB_POS (64, 0))))
	293	#endif
	294	#if (WITH_TARGET_WORD_BITSIZE == 32)
	295	#define MASK(START, STOP) \
	296	(_POS_LE ((START), (STOP)) \
	297	? (_POS_LE ((STOP), _MSB_POS (64, 31)) \
	298	? 0 \
	299	: _MASKn (32, \
	300	_MSB_32 ((START), (STOP)), \
	301	_LSB_32 ((START), (STOP)))) \
	302	: (_MASKn (32, \
	303	_LSB_32 ((START), (STOP)), \
	304	_LSB_POS (32, 0)) \
	305	\| (_POS_LE ((STOP), _MSB_POS (64, 31)) \
	306	? 0 \
	307	: _MASKn (32, \
	308	_MSB_POS (32, 0), \
	309	_MSB_32 ((START), (STOP))))))
	310	#endif
3c765a54 AC	311	#if (WITH_TARGET_WORD_BITSIZE == 16)
	312	#define MASK(START, STOP) \
	313	(_POS_LE ((START), (STOP)) \
	314	? (_POS_LE ((STOP), _MSB_POS (64, 15)) \
	315	? 0 \
	316	: _MASKn (16, \
	317	_MSB_16 ((START), (STOP)), \
	318	_LSB_16 ((START), (STOP)))) \
	319	: (_MASKn (16, \
	320	_LSB_16 ((START), (STOP)), \
	321	_LSB_POS (16, 0)) \
	322	\| (_POS_LE ((STOP), _MSB_POS (64, 15)) \
	323	? 0 \
	324	: _MASKn (16, \
	325	_MSB_POS (16, 0), \
	326	_MSB_16 ((START), (STOP))))))
	327	#endif
c906108c SS	328	#if !defined (MASK)
	329	#error "MASK never undefined"
	330	#endif
	331
	332
	333	/* Multi-bit mask on least significant bits */
	334
	335	#define _LSMASKn(WIDTH, FIRST, LAST) _MASKn (WIDTH, \
	336	_LSB_POS (WIDTH, FIRST), \
	337	_LSB_POS (WIDTH, LAST))
	338
	339	#define LSMASK8(FIRST, LAST) _LSMASKn ( 8, (FIRST), (LAST))
	340	#define LSMASK16(FIRST, LAST) _LSMASKn (16, (FIRST), (LAST))
	341	#define LSMASK32(FIRST, LAST) _LSMASKn (32, (FIRST), (LAST))
	342	#define LSMASK64(FIRST, LAST) _LSMASKn (64, (FIRST), (LAST))
	343
	344	#define LSMASK(FIRST, LAST) (MASK (_LSB_POS (64, FIRST), _LSB_POS (64, LAST)))
	345
	346
	347	/* Multi-bit mask on most significant bits */
	348
	349	#define _MSMASKn(WIDTH, FIRST, LAST) _MASKn (WIDTH, \
	350	_MSB_POS (WIDTH, FIRST), \
	351	_MSB_POS (WIDTH, LAST))
	352
	353	#define MSMASK8(FIRST, LAST) _MSMASKn ( 8, (FIRST), (LAST))
	354	#define MSMASK16(FIRST, LAST) _MSMASKn (16, (FIRST), (LAST))
	355	#define MSMASK32(FIRST, LAST) _MSMASKn (32, (FIRST), (LAST))
	356	#define MSMASK64(FIRST, LAST) _MSMASKn (64, (FIRST), (LAST))
	357
	358	#define MSMASK(FIRST, LAST) (MASK (_MSB_POS (64, FIRST), _MSB_POS (64, LAST)))
	359
	360
	361
	362	#if (WITH_TARGET_WORD_MSB == 0)
	363	#define MASK8 MSMASK8
	364	#define MASK16 MSMASK16
	365	#define MASK32 MSMASK32
	366	#define MASK64 MSMASK64
	367	#else
	368	#define MASK8 LSMASK8
	369	#define MASK16 LSMASK16
	370	#define MASK32 LSMASK32
	371	#define MASK64 LSMASK64
	372	#endif
	373
	374
	375
	376	/* mask the required bits, leaving them in place */
	377
	378	INLINE_SIM_BITS(unsigned8) LSMASKED8 (unsigned8 word, int first, int last);
	379	INLINE_SIM_BITS(unsigned16) LSMASKED16 (unsigned16 word, int first, int last);
	380	INLINE_SIM_BITS(unsigned32) LSMASKED32 (unsigned32 word, int first, int last);
	381	INLINE_SIM_BITS(unsigned64) LSMASKED64 (unsigned64 word, int first, int last);
	382
	383	INLINE_SIM_BITS(unsigned_word) LSMASKED (unsigned_word word, int first, int last);
	384
	385	INLINE_SIM_BITS(unsigned8) MSMASKED8 (unsigned8 word, int first, int last);
	386	INLINE_SIM_BITS(unsigned16) MSMASKED16 (unsigned16 word, int first, int last);
	387	INLINE_SIM_BITS(unsigned32) MSMASKED32 (unsigned32 word, int first, int last);
	388	INLINE_SIM_BITS(unsigned64) MSMASKED64 (unsigned64 word, int first, int last);
	389
	390	INLINE_SIM_BITS(unsigned_word) MSMASKED (unsigned_word word, int first, int last);
	391
392	#if (WITH_TARGET_WORD_MSB == 0)
393	#define MASKED8 MSMASKED8
394	#define MASKED16 MSMASKED16
395	#define MASKED32 MSMASKED32
396	#define MASKED64 MSMASKED64
397	#define MASKED MSMASKED
398	#else
399	#define MASKED8 LSMASKED8
400	#define MASKED16 LSMASKED16
401	#define MASKED32 LSMASKED32
402	#define MASKED64 LSMASKED64
403	#define MASKED LSMASKED
404	#endif
405
406
407
408	/* extract the required bits aligning them with the lsb */
409
410	INLINE_SIM_BITS(unsigned8) LSEXTRACTED8 (unsigned8 val, int start, int stop);
411	INLINE_SIM_BITS(unsigned16) LSEXTRACTED16 (unsigned16 val, int start, int stop);
412	INLINE_SIM_BITS(unsigned32) LSEXTRACTED32 (unsigned32 val, int start, int stop);
413	INLINE_SIM_BITS(unsigned64) LSEXTRACTED64 (unsigned64 val, int start, int stop);
414
415	INLINE_SIM_BITS(unsigned_word) LSEXTRACTED (unsigned_word val, int start, int stop);
416
417	INLINE_SIM_BITS(unsigned8) MSEXTRACTED8 (unsigned8 val, int start, int stop);
418	INLINE_SIM_BITS(unsigned16) MSEXTRACTED16 (unsigned16 val, int start, int stop);
419	INLINE_SIM_BITS(unsigned32) MSEXTRACTED32 (unsigned32 val, int start, int stop);
420	INLINE_SIM_BITS(unsigned64) MSEXTRACTED64 (unsigned64 val, int start, int stop);
421
422	INLINE_SIM_BITS(unsigned_word) MSEXTRACTED (unsigned_word val, int start, int stop);
423
424	#if (WITH_TARGET_WORD_MSB == 0)
425	#define EXTRACTED8 MSEXTRACTED8
426	#define EXTRACTED16 MSEXTRACTED16
427	#define EXTRACTED32 MSEXTRACTED32
428	#define EXTRACTED64 MSEXTRACTED64
429	#define EXTRACTED MSEXTRACTED
430	#else
431	#define EXTRACTED8 LSEXTRACTED8
432	#define EXTRACTED16 LSEXTRACTED16
433	#define EXTRACTED32 LSEXTRACTED32
434	#define EXTRACTED64 LSEXTRACTED64
435	#define EXTRACTED LSEXTRACTED
436	#endif
437
438
439
440	/* move a single bit around */
441	/* NB: the wierdness (N>O?N-O:0) is to stop a warning from GCC */
442	#define _SHUFFLEDn(N, WORD, OLD, NEW) \
443	((OLD) < (NEW) \
444	? (((unsigned##N)(WORD) \
445	>> (((NEW) > (OLD)) ? ((NEW) - (OLD)) : 0)) \
446	& MASK32((NEW), (NEW))) \
447	: (((unsigned##N)(WORD) \
448	<< (((OLD) > (NEW)) ? ((OLD) - (NEW)) : 0)) \
449	& MASK32((NEW), (NEW))))
450
451	#define SHUFFLED32(WORD, OLD, NEW) _SHUFFLEDn (32, WORD, OLD, NEW)
452	#define SHUFFLED64(WORD, OLD, NEW) _SHUFFLEDn (64, WORD, OLD, NEW)
453
454	#define SHUFFLED(WORD, OLD, NEW) _SHUFFLEDn (_word, WORD, OLD, NEW)
455
456
457	/* Insert a group of bits into a bit position */
458
459	INLINE_SIM_BITS(unsigned8) LSINSERTED8 (unsigned8 val, int start, int stop);
460	INLINE_SIM_BITS(unsigned16) LSINSERTED16 (unsigned16 val, int start, int stop);
461	INLINE_SIM_BITS(unsigned32) LSINSERTED32 (unsigned32 val, int start, int stop);
462	INLINE_SIM_BITS(unsigned64) LSINSERTED64 (unsigned64 val, int start, int stop);
463	INLINE_SIM_BITS(unsigned_word) LSINSERTED (unsigned_word val, int start, int stop);
464
465	INLINE_SIM_BITS(unsigned8) MSINSERTED8 (unsigned8 val, int start, int stop);
466	INLINE_SIM_BITS(unsigned16) MSINSERTED16 (unsigned16 val, int start, int stop);
467	INLINE_SIM_BITS(unsigned32) MSINSERTED32 (unsigned32 val, int start, int stop);
468	INLINE_SIM_BITS(unsigned64) MSINSERTED64 (unsigned64 val, int start, int stop);
469	INLINE_SIM_BITS(unsigned_word) MSINSERTED (unsigned_word val, int start, int stop);
470
471	#if (WITH_TARGET_WORD_MSB == 0)
472	#define INSERTED8 MSINSERTED8
473	#define INSERTED16 MSINSERTED16
474	#define INSERTED32 MSINSERTED32
475	#define INSERTED64 MSINSERTED64
476	#define INSERTED MSINSERTED
477	#else
478	#define INSERTED8 LSINSERTED8
479	#define INSERTED16 LSINSERTED16
480	#define INSERTED32 LSINSERTED32
481	#define INSERTED64 LSINSERTED64
482	#define INSERTED LSINSERTED
483	#endif
484
485
486
487	/* MOVE bits from one loc to another (combination of extract/insert) */
488
489	#define MOVED8(VAL,OH,OL,NH,NL) INSERTED8 (EXTRACTED8 ((VAL), OH, OL), NH, NL)
490	#define MOVED16(VAL,OH,OL,NH,NL) INSERTED16(EXTRACTED16((VAL), OH, OL), NH, NL)
491	#define MOVED32(VAL,OH,OL,NH,NL) INSERTED32(EXTRACTED32((VAL), OH, OL), NH, NL)
492	#define MOVED64(VAL,OH,OL,NH,NL) INSERTED64(EXTRACTED64((VAL), OH, OL), NH, NL)
493	#define MOVED(VAL,OH,OL,NH,NL) INSERTED (EXTRACTED ((VAL), OH, OL), NH, NL)
494
495
496
497	/* Sign extend the quantity to the targets natural word size */
498
499	#define EXTEND4(X) (LSSEXT ((X), 3))
500	#define EXTEND5(X) (LSSEXT ((X), 4))
8e394ffc	501	#define EXTEND6(X) (LSSEXT ((X), 5))
c906108c SS	502	#define EXTEND8(X) ((signed_word)(signed8)(X))
c906108c SS	503	#define EXTEND11(X) (LSSEXT ((X), 10))
8e394ffc	504	#define EXTEND12(X) (LSSEXT ((X), 11))
c906108c SS	505	#define EXTEND15(X) (LSSEXT ((X), 14))
	506	#define EXTEND16(X) ((signed_word)(signed16)(X))
	507	#define EXTEND24(X) (LSSEXT ((X), 23))
8e394ffc	508	#define EXTEND25(X) (LSSEXT ((X), 24))
c906108c SS	509	#define EXTEND32(X) ((signed_word)(signed32)(X))
	510	#define EXTEND64(X) ((signed_word)(signed64)(X))
	511
	512	/* depending on MODE return a 64bit or 32bit (sign extended) value */
	513	#if (WITH_TARGET_WORD_BITSIZE == 64)
	514	#define EXTENDED(X) ((signed64)(signed32)(X))
	515	#endif
	516	#if (WITH_TARGET_WORD_BITSIZE == 32)
	517	#define EXTENDED(X) (X)
	518	#endif
3c765a54 AC	519	#if (WITH_TARGET_WORD_BITSIZE == 16)
	520	#define EXTENDED(X) (X)
	521	#endif
c906108c SS	522
	523
	524	/* memory alignment macro's */
0ede24f2 MF	525	#define align_up(v, n) (((v) + (n) - 1) & -(n))
0ede24f2 MF	526	#define align_down(v, n) ((v) & -(n))
c906108c SS	527
	528
	529	/* bit bliting macro's */
	530	#define BLIT32(V, POS, BIT) \
	531	do { \
	532	if (BIT) \
	533	V \|= BIT32 (POS); \
	534	else \
	535	V &= ~BIT32 (POS); \
	536	} while (0)
	537	#define MBLIT32(V, LO, HI, VAL) \
	538	do { \
	539	(V) = (((V) & ~MASK32 ((LO), (HI))) \
	540	\| INSERTED32 (VAL, LO, HI)); \
	541	} while (0)
	542
	543
	544
	545	/* some rotate functions. The generic macro's ROT, ROTL, ROTR are
	546	intentionally omited. */
	547
	548
	549	INLINE_SIM_BITS(unsigned8) ROT8 (unsigned8 val, int shift);
	550	INLINE_SIM_BITS(unsigned16) ROT16 (unsigned16 val, int shift);
	551	INLINE_SIM_BITS(unsigned32) ROT32 (unsigned32 val, int shift);
	552	INLINE_SIM_BITS(unsigned64) ROT64 (unsigned64 val, int shift);
	553
	554
	555	INLINE_SIM_BITS(unsigned8) ROTL8 (unsigned8 val, int shift);
	556	INLINE_SIM_BITS(unsigned16) ROTL16 (unsigned16 val, int shift);
	557	INLINE_SIM_BITS(unsigned32) ROTL32 (unsigned32 val, int shift);
	558	INLINE_SIM_BITS(unsigned64) ROTL64 (unsigned64 val, int shift);
	559
	560
	561	INLINE_SIM_BITS(unsigned8) ROTR8 (unsigned8 val, int shift);
	562	INLINE_SIM_BITS(unsigned16) ROTR16 (unsigned16 val, int shift);
	563	INLINE_SIM_BITS(unsigned32) ROTR32 (unsigned32 val, int shift);
	564	INLINE_SIM_BITS(unsigned64) ROTR64 (unsigned64 val, int shift);
	565
	566
	567
	568	/* Sign extension operations */
	569
	570	INLINE_SIM_BITS(unsigned8) LSSEXT8 (signed8 val, int sign_bit);
	571	INLINE_SIM_BITS(unsigned16) LSSEXT16 (signed16 val, int sign_bit);
	572	INLINE_SIM_BITS(unsigned32) LSSEXT32 (signed32 val, int sign_bit);
	573	INLINE_SIM_BITS(unsigned64) LSSEXT64 (signed64 val, int sign_bit);
	574	INLINE_SIM_BITS(unsigned_word) LSSEXT (signed_word val, int sign_bit);
	575
	576	INLINE_SIM_BITS(unsigned8) MSSEXT8 (signed8 val, int sign_bit);
	577	INLINE_SIM_BITS(unsigned16) MSSEXT16 (signed16 val, int sign_bit);
	578	INLINE_SIM_BITS(unsigned32) MSSEXT32 (signed32 val, int sign_bit);
	579	INLINE_SIM_BITS(unsigned64) MSSEXT64 (signed64 val, int sign_bit);
	580	INLINE_SIM_BITS(unsigned_word) MSSEXT (signed_word val, int sign_bit);
	581
	582	#if (WITH_TARGET_WORD_MSB == 0)
	583	#define SEXT8 MSSEXT8
	584	#define SEXT16 MSSEXT16
	585	#define SEXT32 MSSEXT32
	586	#define SEXT64 MSSEXT64
	587	#define SEXT MSSEXT
	588	#else
	589	#define SEXT8 LSSEXT8
	590	#define SEXT16 LSSEXT16
591	#define SEXT32 LSSEXT32
592	#define SEXT64 LSSEXT64
593	#define SEXT LSSEXT
594	#endif
595
596
597
598	#if H_REVEALS_MODULE_P (SIM_BITS_INLINE)
599	#include "sim-bits.c"
600	#endif
601
618b526e	602	#endif /* SIM_BITS_H */