Merge a few A64 utils into the CompilerIntrinsics.

src/compiler-intrinsics.h

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_COMPILER_INTRINSICS_H_
 #define V8_COMPILER_INTRINSICS_H_
 
+#include "globals.h"
+#include "checks.h"
+
+
 namespace v8 {
 namespace internal {
 
+// C++ fallback implementations when builtins are not availble.
+int C_CountRedundantLeadingSignBits(int64_t value, int width);
+int C_CountSetBits(uint64_t value, int width);
+
 class CompilerIntrinsics {
  public:
   // Returns number of zero bits preceding least significant 1 bit.
   // Undefined for zero value.
   INLINE(static int CountTrailingZeros(uint32_t value));
+  INLINE(static int CountTrailingZeros(uint64_t value));
 
   // Returns number of zero bits following most significant 1 bit.
   // Undefined for zero value.
   INLINE(static int CountLeadingZeros(uint32_t value));
+  INLINE(static int CountLeadingZeros(uint64_t value));
+
+  // Returns the number of redundant leading sign bits.
+  INLINE(static int CountRedundantLeadingSignBits(int32_t value));
+  INLINE(static int CountRedundantLeadingSignBits(int64_t value));
 
   // Returns the number of bits set.
   INLINE(static int CountSetBits(uint32_t value));
+  INLINE(static int CountSetBits(uint64_t value));
 };
 
 #ifdef __GNUC__
 int CompilerIntrinsics::CountTrailingZeros(uint32_t value) {
   return __builtin_ctz(value);
 }
 
+int CompilerIntrinsics::CountTrailingZeros(uint64_t value) {
+  return __builtin_ctzll(value);
+}
+
 int CompilerIntrinsics::CountLeadingZeros(uint32_t value) {
   return __builtin_clz(value);
 }
 
+int CompilerIntrinsics::CountLeadingZeros(uint64_t value) {
+  return __builtin_clzll(value);
+}
+
+// __builtin_clrsb and derivatives are only availble since GCC4.7.0.
+#define GNUC_AVAILABLE_BUILTIN_CLRSB  ((__GNUC__ >= 4) && (__GNUC_MINOR__ >= 7))
+int CompilerIntrinsics::CountRedundantLeadingSignBits(int32_t value) {
+#if GNUC_AVAILABLE_BUILTIN_CLRSB
+  return __builtin_clrsb(value);
+#else
+  return C_CountRedundantLeadingSignBits(value, 32);
+#endif
+}
+
+int CompilerIntrinsics::CountRedundantLeadingSignBits(int64_t value) {
+#if GNUC_AVAILABLE_BUILTIN_CLRSB
+  return __builtin_clrsbll(value);
+#else
+  return C_CountRedundantLeadingSignBits(value, 64);
+#endif
+}
+#undef GNUC_AVAILABLE_BUILTIN_CLRSB
+
 int CompilerIntrinsics::CountSetBits(uint32_t value) {
   return __builtin_popcount(value);
 }
 
+int CompilerIntrinsics::CountSetBits(uint64_t value) {
+  return __builtin_popcountll(value);
+}
+
 #elif defined(_MSC_VER)
 
 #pragma intrinsic(_BitScanForward)
 #pragma intrinsic(_BitScanReverse)
+#if V8_TARGET_ARCH_X64
+#pragma intrinsic(_BitScanForward64)
+#pragma intrinsic(_BitScanReverse64)
+#endif
 
 int CompilerIntrinsics::CountTrailingZeros(uint32_t value) {
   unsigned long result;  //NOLINT
   _BitScanForward(&result, static_cast<long>(value));  //NOLINT
   return static_cast<int>(result);
 }
 
+int CompilerIntrinsics::CountTrailingZeros(uint64_t value) {
+#if V8_TARGET_ARCH_X64
+  unsigned long result;  //NOLINT
+  _BitScanForward64(&result, static_cast<__int64>(value));  //NOLINT
+  return static_cast<int>(result);
+#else
+  uint32_t low = value & kMaxUInt32;
+  uint32_t high = value >> 32;
+  if (low == 0) {
+    return 32 + CountTrailingZeros(high);
+  } else {
+    return CountTrailingZeros(low);
+  }
+#endif
+}
+
 int CompilerIntrinsics::CountLeadingZeros(uint32_t value) {
   unsigned long result;  //NOLINT
   _BitScanReverse(&result, static_cast<long>(value));  //NOLINT
   return 31 - static_cast<int>(result);
 }
 
+int CompilerIntrinsics::CountLeadingZeros(uint64_t value) {
+#if V8_TARGET_ARCH_X64
+  unsigned long result;  //NOLINT
+  _BitScanReverse64(&result, static_cast<__int64>(value));  //NOLINT
+  return 63 - static_cast<int>(result);
+#else
+  uint32_t low = value & kMaxUInt32;
+  uint32_t high = value >> 32;
+  if (high == 0) {
+    return 32 + CountLeadingZeros(low);
+  } else {
+    return CountLeadingZeros(high);
+  }
+#endif
+}
+
+int CompilerIntrinsics::CountRedundantLeadingSignBits(int32_t value) {
+  uint32_t val = static_cast<uint32_t>((value >= 0) ? value : ~value);
+  return CountLeadingZeros(val, width) - 1;
+}
+
+int CompilerIntrinsics::CountRedundantLeadingSignBits(int64_t value) {
+  uint64_t val = static_cast<uint64_t>((value >= 0) ? value : ~value);
+  return CountLeadingZeros(val, width) - 1;
+}
+
 int CompilerIntrinsics::CountSetBits(uint32_t value) {
-  // Manually count set bits.
-  value = ((value >>  1) & 0x55555555) + (value & 0x55555555);
-  value = ((value >>  2) & 0x33333333) + (value & 0x33333333);
-  value = ((value >>  4) & 0x0f0f0f0f) + (value & 0x0f0f0f0f);
-  value = ((value >>  8) & 0x00ff00ff) + (value & 0x00ff00ff);
-  value = ((value >> 16) & 0x0000ffff) + (value & 0x0000ffff);
-  return value;
+  return C_CountSetBits(value, 32);
+}
+
+int CompilerIntrinsics::CountSetBits(uint64_t value) {
+  return C_CountSetBits(value, 64);
 }
 
 #else
 #error Unsupported compiler
 #endif
 
+
+// Inline function helpers use the intrinsics and disambiguate undefined
+// situations.
+
+inline int CountTrailingZeros(uint32_t value) {
+  if (value == 0) {
+    // The result of the intrinsics is undefined for 0.
+    return 32;
+  }
+  return CompilerIntrinsics::CountTrailingZeros(value);
+}
+inline int CountTrailingZeros(uint64_t value) {
+  if (value == 0) {
+    // The result of the intrinsics is undefined for 0.
+    return 64;
+  }
+  return CompilerIntrinsics::CountTrailingZeros(value);
+}
+inline int CountTrailingZeros(uint64_t value, int width) {
+  ASSERT((width == 32) || (width == 64));
+  if (width == 32) {
+    return CountTrailingZeros(static_cast<uint32_t>(value));
+  } else {
+    return CountTrailingZeros(static_cast<uint64_t>(value));
+  }
+}
+
+inline int CountLeadingZeros(uint32_t value) {
+  if (value == 0) {
+    // The result of the intrinsics is undefined for 0.
+    return 32;
+  }
+  return CompilerIntrinsics::CountLeadingZeros(value);
+}
+inline int CountLeadingZeros(uint64_t value) {
+  if (value == 0) {
+    // The result of the intrinsics is undefined for 0.
+    return 64;
+  }
+  return CompilerIntrinsics::CountLeadingZeros(value);
+}
+inline int CountLeadingZeros(uint64_t value, int width) {
+  ASSERT((width == 32) || (width == 64));
+  if (width == 32) {
+    return CountLeadingZeros(static_cast<uint32_t>(value));
+  } else {
+    return CountLeadingZeros(static_cast<uint64_t>(value));
+  }
+}
+
+inline int CountRedundantLeadingSignBits(int32_t value) {
+  return CompilerIntrinsics::CountRedundantLeadingSignBits(value);
+}
+inline int CountRedundantLeadingSignBits(int64_t value) {
+  return CompilerIntrinsics::CountRedundantLeadingSignBits(value);
+}
+inline int CountRedundantLeadingSignBits(int64_t value, int width) {
+  ASSERT((width == 32) || (width == 64));
+  if (width == 32) {
+    return CountRedundantLeadingSignBits(static_cast<int32_t>(value));
+  } else {
+    return CountRedundantLeadingSignBits(static_cast<int64_t>(value));
+  }
+}
+
+inline int CountSetBits(uint32_t value) {
+  return CompilerIntrinsics::CountSetBits(value);
+}
+inline int CountSetBits(uint64_t value) {
+  return CompilerIntrinsics::CountSetBits(value);
+}
+inline int CountSetBits(uint64_t value, int width) {
+  ASSERT((width == 32) || (width == 64));
+  if (width == 32) {
+    return CountSetBits(static_cast<uint32_t>(value));
+  } else {
+    return CountSetBits(static_cast<uint64_t>(value));
+  }
+}
+
+
 } }  // namespace v8::internal
 
 #endif  // V8_COMPILER_INTRINSICS_H_