sim/ppc/bits.c

   1 /*  This file is part of the program psim.
   2
   3     Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 3 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, see <http://www.gnu.org/licenses/>.
  17
  18     */
  19
  20
  21 #ifndef _BITS_C_
  22 #define _BITS_C_
  23
  24 #include "basics.h"
  25
  26 INLINE_BITS\
  27 (uint64_t)
  28 LSMASKED64 (uint64_t word,
  29             int start,
  30             int stop)
  31 {
  32   word &= LSMASK64 (start, stop);
  33   return word;
  34 }
  35
  36 INLINE_BITS\
  37 (uint64_t)
  38 LSEXTRACTED64 (uint64_t val,
  39                int start,
  40                int stop)
  41 {
  42   val <<= (64 - 1 - start); /* drop high bits */
  43   val >>= (64 - 1 - start) + (stop); /* drop low bits */
  44   return val;
  45 }
  46
  47 INLINE_BITS\
  48 (uint32_t)
  49 MASKED32(uint32_t word,
  50          unsigned start,
  51          unsigned stop)
  52 {
  53   return (word & MASK32(start, stop));
  54 }
  55
  56 INLINE_BITS\
  57 (uint64_t)
  58 MASKED64(uint64_t word,
  59          unsigned start,
  60          unsigned stop)
  61 {
  62   return (word & MASK64(start, stop));
  63 }
  64
  65 INLINE_BITS\
  66 (unsigned_word)
  67 MASKED(unsigned_word word,
  68        unsigned start,
  69        unsigned stop)
  70 {
  71   return ((word) & MASK(start, stop));
  72 }
  73
  74
  75
  76 INLINE_BITS\
  77 (unsigned_word)
  78 EXTRACTED(unsigned_word word,
  79           unsigned start,
  80           unsigned stop)
  81 {
  82   ASSERT(start <= stop);
  83 #if (WITH_TARGET_WORD_BITSIZE == 64)
  84   return _EXTRACTEDn(64, word, start, stop);
  85 #else
  86   if (stop < 32)
  87     return 0;
  88   else
  89     return ((word >> (63 - stop))
  90             & MASK(start+(63-stop), 63));
  91 #endif
  92 }
  93
  94
  95 INLINE_BITS\
  96 (unsigned_word)
  97 INSERTED(unsigned_word word,
  98          unsigned start,
  99          unsigned stop)
 100 {
 101   ASSERT(start <= stop);
 102 #if (WITH_TARGET_WORD_BITSIZE == 64)
 103   return _INSERTEDn(64, word, start, stop);
 104 #else
 105   if (stop < 32)
 106     return 0;
 107   else
 108     return ((word & MASK(start+(63-stop), 63))
 109             << (63 - stop));
 110 #endif
 111 }
 112
 113
 114 INLINE_BITS\
 115 (uint32_t)
 116 ROTL32(uint32_t val,
 117        long shift)
 118 {
 119   ASSERT(shift >= 0 && shift <= 32);
 120   return _ROTLn(32, val, shift);
 121 }
 122
 123
 124 INLINE_BITS\
 125 (uint64_t)
 126 ROTL64(uint64_t val,
 127        long shift)
 128 {
 129   ASSERT(shift >= 0 && shift <= 64);
 130   return _ROTLn(64, val, shift);
 131 }
 132
 133 #endif /* _BITS_C_ */