disas/libvixl/utils.h

   1 // Copyright 2013, ARM Limited
   2 // All rights reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions are met:
   6 //
   7 //   * Redistributions of source code must retain the above copyright notice,
   8 //     this list of conditions and the following disclaimer.
   9 //   * Redistributions in binary form must reproduce the above copyright notice,
  10 //     this list of conditions and the following disclaimer in the documentation
  11 //     and/or other materials provided with the distribution.
  12 //   * Neither the name of ARM Limited nor the names of its contributors may be
  13 //     used to endorse or promote products derived from this software without
  14 //     specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND
  17 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  20 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26
  27 #ifndef VIXL_UTILS_H
  28 #define VIXL_UTILS_H
  29
  30
  31 #include <string.h>
  32 #include "globals.h"
  33
  34 namespace vixl {
  35
  36 // Check number width.
  37 inline bool is_intn(unsigned n, int64_t x) {
  38   ASSERT((0 < n) && (n < 64));
  39   int64_t limit = 1ULL << (n - 1);
  40   return (-limit <= x) && (x < limit);
  41 }
  42
  43 inline bool is_uintn(unsigned n, int64_t x) {
  44   ASSERT((0 < n) && (n < 64));
  45   return !(x >> n);
  46 }
  47
  48 inline unsigned truncate_to_intn(unsigned n, int64_t x) {
  49   ASSERT((0 < n) && (n < 64));
  50   return (x & ((1ULL << n) - 1));
  51 }
  52
  53 #define INT_1_TO_63_LIST(V)                                                    \
  54 V(1)  V(2)  V(3)  V(4)  V(5)  V(6)  V(7)  V(8)                                 \
  55 V(9)  V(10) V(11) V(12) V(13) V(14) V(15) V(16)                                \
  56 V(17) V(18) V(19) V(20) V(21) V(22) V(23) V(24)                                \
  57 V(25) V(26) V(27) V(28) V(29) V(30) V(31) V(32)                                \
  58 V(33) V(34) V(35) V(36) V(37) V(38) V(39) V(40)                                \
  59 V(41) V(42) V(43) V(44) V(45) V(46) V(47) V(48)                                \
  60 V(49) V(50) V(51) V(52) V(53) V(54) V(55) V(56)                                \
  61 V(57) V(58) V(59) V(60) V(61) V(62) V(63)
  62
  63 #define DECLARE_IS_INT_N(N)                                                    \
  64 inline bool is_int##N(int64_t x) { return is_intn(N, x); }
  65 #define DECLARE_IS_UINT_N(N)                                                   \
  66 inline bool is_uint##N(int64_t x) { return is_uintn(N, x); }
  67 #define DECLARE_TRUNCATE_TO_INT_N(N)                                           \
  68 inline int truncate_to_int##N(int x) { return truncate_to_intn(N, x); }
  69 INT_1_TO_63_LIST(DECLARE_IS_INT_N)
  70 INT_1_TO_63_LIST(DECLARE_IS_UINT_N)
  71 INT_1_TO_63_LIST(DECLARE_TRUNCATE_TO_INT_N)
  72 #undef DECLARE_IS_INT_N
  73 #undef DECLARE_IS_UINT_N
  74 #undef DECLARE_TRUNCATE_TO_INT_N
  75
  76 // Bit field extraction.
  77 inline uint32_t unsigned_bitextract_32(int msb, int lsb, uint32_t x) {
  78   return (x >> lsb) & ((1 << (1 + msb - lsb)) - 1);
  79 }
  80
  81 inline uint64_t unsigned_bitextract_64(int msb, int lsb, uint64_t x) {
  82   return (x >> lsb) & ((static_cast<uint64_t>(1) << (1 + msb - lsb)) - 1);
  83 }
  84
  85 inline int32_t signed_bitextract_32(int msb, int lsb, int32_t x) {
  86   return (x << (31 - msb)) >> (lsb + 31 - msb);
  87 }
  88
  89 inline int64_t signed_bitextract_64(int msb, int lsb, int64_t x) {
  90   return (x << (63 - msb)) >> (lsb + 63 - msb);
  91 }
  92
  93 // floating point representation
  94 uint32_t float_to_rawbits(float value);
  95 uint64_t double_to_rawbits(double value);
  96 float rawbits_to_float(uint32_t bits);
  97 double rawbits_to_double(uint64_t bits);
  98
  99 // Bits counting.
 100 int CountLeadingZeros(uint64_t value, int width);
 101 int CountLeadingSignBits(int64_t value, int width);
 102 int CountTrailingZeros(uint64_t value, int width);
 103 int CountSetBits(uint64_t value, int width);
 104
 105 // Pointer alignment
 106 // TODO: rename/refactor to make it specific to instructions.
 107 template<typename T>
 108 bool IsWordAligned(T pointer) {
 109   ASSERT(sizeof(pointer) == sizeof(intptr_t));   // NOLINT(runtime/sizeof)
 110   return (reinterpret_cast<intptr_t>(pointer) & 3) == 0;
 111 }
 112
 113 // Increment a pointer until it has the specified alignment.
 114 template<class T>
 115 T AlignUp(T pointer, size_t alignment) {
 116   ASSERT(sizeof(pointer) == sizeof(uintptr_t));
 117   uintptr_t pointer_raw = reinterpret_cast<uintptr_t>(pointer);
 118   size_t align_step = (alignment - pointer_raw) % alignment;
 119   ASSERT((pointer_raw + align_step) % alignment == 0);
 120   return reinterpret_cast<T>(pointer_raw + align_step);
 121 }
 122
 123
 124 }  // namespace vixl
 125
 126 #endif  // VIXL_UTILS_H