123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287 |
- /* This file is part of the program psim.
- Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au>
- 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 _BITS_H_
- #define _BITS_H_
- /* bit manipulation routines:
- Bit numbering: The bits are numbered according to the PowerPC
- convention - the left most (or most significant) is bit 0 while the
- right most (least significant) is bit 1.
- 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..64);
- 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 having bit 32 as the most
- significant.
- BIT*(POS): Quantity with just 1 bit set.
- MASK*(FIRST, LAST): Create a constant bit mask of the specified
- size with bits [FIRST .. LAST] set.
- MASKED*(VALUE, FIRST, LAST): Masks out all but bits [FIRST
- .. LAST].
- LSMASKED*(VALUE, FIRST, LAST): Like MASKED - LS 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.
- 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.
- EXTENDED(VALUE): Convert VALUE (32bits of it) to the targets
- natural size. If in 64bit mode, sign extend the value.
- ALIGN_*(VALUE): Round upwards the value so that it is aligned.
- FLOOR_*(VALUE): Truncate the value so that it is aligned.
- ROTL*(VALUE, NR_BITS): Return the value rotated by NR_BITS
- */
- #define _MAKE_SHIFT(WIDTH, pos) ((WIDTH) - 1 - (pos))
- #if (WITH_TARGET_WORD_MSB == 0)
- #define _LSB_POS(WIDTH, SHIFT) (WIDTH - 1 - SHIFT)
- #else
- #define _LSB_POS(WIDTH, SHIFT) (SHIFT)
- #endif
- /* MakeBit */
- #define _BITn(WIDTH, pos) (((uint##WIDTH##_t)(1)) \
- << _MAKE_SHIFT(WIDTH, pos))
- #define BIT4(POS) (1 << _MAKE_SHIFT(4, POS))
- #define BIT5(POS) (1 << _MAKE_SHIFT(5, POS))
- #define BIT8(POS) (1 << _MAKE_SHIFT(8, POS))
- #define BIT10(POS) (1 << _MAKE_SHIFT(10, POS))
- #define BIT32(POS) _BITn(32, POS)
- #define BIT64(POS) _BITn(64, POS)
- #if (WITH_TARGET_WORD_BITSIZE == 64)
- #define BIT(POS) BIT64(POS)
- #else
- #define BIT(POS) (((POS) < 32) ? 0 : _BITn(32, (POS)-32))
- #endif
- /* multi bit mask */
- #define _MASKn(WIDTH, START, STOP) \
- (((((uint##WIDTH##_t)0) - 1) \
- >> (WIDTH - ((STOP) - (START) + 1))) \
- << (WIDTH - 1 - (STOP)))
- #define MASK32(START, STOP) _MASKn(32, START, STOP)
- #define MASK64(START, STOP) _MASKn(64, START, STOP)
- /* Multi-bit mask on least significant bits */
- #define _LSMASKn(WIDTH, FIRST, LAST) _MASKn (WIDTH, \
- _LSB_POS (WIDTH, FIRST), \
- _LSB_POS (WIDTH, LAST))
- #define LSMASK64(FIRST, LAST) _LSMASKn (64, (FIRST), (LAST))
- #if (WITH_TARGET_WORD_BITSIZE == 64)
- #define MASK(START, STOP) \
- (((START) <= (STOP)) \
- ? _MASKn(64, START, STOP) \
- : (_MASKn(64, 0, STOP) \
- | _MASKn(64, START, 63)))
- #else
- #define MASK(START, STOP) \
- (((START) <= (STOP)) \
- ? (((STOP) < 32) \
- ? 0 \
- : _MASKn(32, \
- (START) < 32 ? 0 : (START) - 32, \
- (STOP)-32)) \
- : (_MASKn(32, \
- (START) < 32 ? 0 : (START) - 32, \
- 31) \
- | (((STOP) < 32) \
- ? 0 \
- : _MASKn(32, \
- 0, \
- (STOP) - 32))))
- #endif
- /* mask the required bits, leaving them in place */
- INLINE_BITS\
- (uint32_t) MASKED32
- (uint32_t word,
- unsigned start,
- unsigned stop);
- INLINE_BITS\
- (uint64_t) MASKED64
- (uint64_t word,
- unsigned start,
- unsigned stop);
- INLINE_BITS\
- (unsigned_word) MASKED
- (unsigned_word word,
- unsigned start,
- unsigned stop);
- INLINE_BITS\
- (uint64_t) LSMASKED64
- (uint64_t word,
- int first,
- int last);
- /* extract the required bits aligning them with the lsb */
- #define _EXTRACTEDn(WIDTH, WORD, START, STOP) \
- ((((uint##WIDTH##_t)(WORD)) >> (WIDTH - (STOP) - 1)) \
- & _MASKn(WIDTH, WIDTH-1+(START)-(STOP), WIDTH-1))
- /* #define EXTRACTED10(WORD, START, STOP) _EXTRACTEDn(10, WORD, START, STOP) */
- #define EXTRACTED32(WORD, START, STOP) _EXTRACTEDn(32, WORD, START, STOP)
- #define EXTRACTED64(WORD, START, STOP) _EXTRACTEDn(64, WORD, START, STOP)
- INLINE_BITS\
- (unsigned_word) EXTRACTED
- (unsigned_word val,
- unsigned start,
- unsigned stop);
- INLINE_BITS\
- (uint64_t) LSEXTRACTED64
- (uint64_t val,
- int start,
- int stop);
- /* 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) \
- ? (((uint##N##_t)(WORD) \
- >> (((NEW) > (OLD)) ? ((NEW) - (OLD)) : 0)) \
- & MASK32((NEW), (NEW))) \
- : (((uint##N##_t)(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)
- /* move a group of bits around */
- #define _INSERTEDn(N, WORD, START, STOP) \
- (((uint##N##_t)(WORD) << _MAKE_SHIFT(N, STOP)) & _MASKn(N, START, STOP))
- #define INSERTED32(WORD, START, STOP) _INSERTEDn(32, WORD, START, STOP)
- #define INSERTED64(WORD, START, STOP) _INSERTEDn(64, WORD, START, STOP)
- INLINE_BITS\
- (unsigned_word) INSERTED
- (unsigned_word val,
- unsigned start,
- unsigned stop);
- /* depending on MODE return a 64bit or 32bit (sign extended) value */
- #if (WITH_TARGET_WORD_BITSIZE == 64)
- #define EXTENDED(X) ((int64_t)(int32_t)(X))
- #else
- #define EXTENDED(X) (X)
- #endif
- /* memory alignment macro's */
- #define _ALIGNa(A,X) (((X) + ((A) - 1)) & ~((A) - 1))
- #define _FLOORa(A,X) ((X) & ~((A) - 1))
- #define ALIGN_8(X) _ALIGNa(8, X)
- #define ALIGN_16(X) _ALIGNa(16, X)
- #define ALIGN_PAGE(X) _ALIGNa(0x1000, X)
- #define FLOOR_PAGE(X) ((X) & ~(0x1000 - 1))
- /* 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 to make things easier
- NOTE: These are functions not macro's as the latter tickles bugs in
- gcc-2.6.3 */
- #define _ROTLn(N, VAL, SHIFT) \
- (((VAL) << (SHIFT)) | ((VAL) >> ((N)-(SHIFT))))
- INLINE_BITS\
- (uint32_t) ROTL32
- (uint32_t val,
- long shift);
- INLINE_BITS\
- (uint64_t) ROTL64
- (uint64_t val,
- long shift);
- #if (BITS_INLINE & INCLUDE_MODULE)
- #include "bits.c"
- #endif
- #endif /* _BITS_H_ */
|