Home | History | Annotate | Line # | Download | only in ppc
bits.c revision 1.5.26.1 
      1 /*  This file is part of the program psim.
      2 
      3     Copyright (C) 1994-1995, Andrew Cagney <cagney (at) 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_ */
    134