#ifndef _BITS_H_
#define _BITS_H_
+
/* bit manipulation routines:
Bit numbering: The bits are numbered according to the PowerPC
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).
- SHUFFLE*(VALUE, OLD, NEW): Moves things around so that bit pos OLD
- is extracted and than moved to bit pos NEW.
+ 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
+
*/
-/* Bit operators */
+#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) (((natural##WIDTH)(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_64BIT_TARGET)
+#if (WITH_TARGET_WORD_BITSIZE == 64)
#define BIT(POS) BIT64(POS)
#else
#define BIT(POS) (((POS) < 32) ? 0 : _BITn(32, (POS)-32))
/* multi bit mask */
+#define _MASKn(WIDTH, START, STOP) \
+(((((unsigned##WIDTH)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)
-#if (WITH_64BIT_TARGET)
-#define MASK(START, STOP) (((START) <= (STOP)) \
- ? _MASKn(64, START, STOP) \
- : (_MASKn(64, 0, STOP) \
- | _MASKn(64, START, 63)))
+/* 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))))
+#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
-#define MASKED32(WORD, START, STOP) _MASKEDn(32, WORD, START, STOP)
-#define MASKED64(WORD, START, STOP) _MASKEDn(64, WORD, START, STOP)
-#define MASKED10(WORD, START, STOP) _MASKEDn(10, WORD, START, STOP)
+/* mask the required bits, leaving them in place */
+
+INLINE_BITS\
+(unsigned32) MASKED32
+(unsigned32 word,
+ unsigned start,
+ unsigned stop);
+
+INLINE_BITS\
+(unsigned64) MASKED64
+(unsigned64 word,
+ unsigned start,
+ unsigned stop);
+
+INLINE_BITS\
+(unsigned_word) MASKED
+(unsigned_word word,
+ unsigned start,
+ unsigned stop);
+
+INLINE_BITS\
+(unsigned64) LSMASKED64
+(unsigned64 word,
+ int first,
+ int last);
+
+
+/* extract the required bits aligning them with the lsb */
+#define _EXTRACTEDn(WIDTH, WORD, START, STOP) \
+((((natural##WIDTH)(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)
-#define EXTRACTED10(WORD, START, STOP) _EXTRACTEDn(10, WORD, START, STOP)
-#define MASKED(WORD, START, STOP) ((natural_word)(WORD) & MASK(START, STOP))
-#if (WITH_64BITS_TARGET)
-#define EXTRACTED(WORD, START, STOP) _EXTRACTEDn(64, WORD, START, STOP)
-#else
-#define EXTRACTED(WORD, START, STOP) (STOP < 32 \
- ? 0 \
- : (((natural_word)WORD \
- >> (63 - (STOP))) \
- && MASK(START+(63-STOP), 63)))
-#endif
+INLINE_BITS\
+(unsigned_word) EXTRACTED
+(unsigned_word val,
+ unsigned start,
+ unsigned stop);
+INLINE_BITS\
+(unsigned64) LSEXTRACTED64
+(unsigned64 val,
+ int start,
+ int stop);
-#define SHUFFLE32(WORD, OLD, NEW) _SHUFFLEn(32, WORD, OLD, NEW)
-#define SHUFFLE64(WORD, OLD, NEW) _SHUFFLEn(64, WORD, OLD, NEW)
-#define SHUFFLE(WORD, OLD, NEW) _SHUFFLEn(_word, WORD, OLD, NEW)
+/* move a single bit around */
/* NB: the wierdness (N>O?N-O:0) is to stop a warning from GCC */
-#define _SHUFFLEn(N, WORD, OLD, NEW) \
+#define _SHUFFLEDn(N, WORD, OLD, NEW) \
((OLD) < (NEW) \
? (((unsigned##N)(WORD) \
>> (((NEW) > (OLD)) ? ((NEW) - (OLD)) : 0)) \
<< (((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) \
+(((natural##N)(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_64BIT_TARGET)
+#if (WITH_TARGET_WORD_BITSIZE == 64)
#define EXTENDED(X) ((signed64)(signed32)(X))
#else
#define EXTENDED(X) (X)
#endif
-
-
/* memory alignment macro's */
-#define _ALIGNa(A,X) (((X) + ((A)-1)) & ~((A)-1))
+#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 { \
else \
V &= ~BIT32(POS); \
} while (0)
-#define MLIT32(V, LO, HI, VAL) \
+#define MBLIT32(V, LO, HI, VAL) \
do { \
(V) = (((V) & ~MASK32((LO), (HI))) \
- | ((VAL) << _MAKE_SHIFT(32,HI))); \
+ | INSERTED32(VAL, LO, HI)); \
} while (0)
+/* some rotate functions to make things easier
-/* Things for creating single bit set values */
-/* MakeBit */
-#define _MAKE_SHIFT(WIDTH, pos) (WIDTH - 1 - (pos))
-#define _BITn(WIDTH, pos) (((natural##WIDTH)(1)) \
- << _MAKE_SHIFT(WIDTH, pos))
-/* MakeBitMask */
-#define _MASKn(WIDTH, START, STOP) (((((unsigned##WIDTH)0) - 1) \
- >> (WIDTH - ((STOP) - (START) + 1))) \
- << (WIDTH - 1 - (STOP)))
+ 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\
+(unsigned32) ROTL32
+(unsigned32 val,
+ long shift);
-/* mask the required bits, leaving them in place */
-#define _MASKEDn(WIDTH, WORD, START, STOP) \
-(((natural##WIDTH)(WORD)) & MASK##WIDTH(START, STOP))
+INLINE_BITS\
+(unsigned64) ROTL64
+(unsigned64 val,
+ long shift);
-/* extract the required bits aligning them with the lsb */
-#define _EXTRACTEDn(WIDTH, WORD, START, STOP) \
-((((natural##WIDTH)(WORD)) >> (WIDTH - (STOP) - 1)) \
- & _MASKn(WIDTH, WIDTH-1+(START)-(STOP), WIDTH-1))
+
+#if (BITS_INLINE & INCLUDE_MODULE)
+#include "bits.c"
+#endif
#endif /* _BITS_H_ */
projects / deliverable / binutils-gdb.git / blobdiff