Add explicit keywords.

[oota-llvm.git] / include / llvm / Support / MathExtras.h

diff --git a/include/llvm/Support/MathExtras.h b/include/llvm/Support/MathExtras.h
index 7f3c2432d0abb421373e3cbeeb58f1a64d56915a..f57beed09391f71c50616b11439c32289892508f 100644 (file)
--- a/include/llvm/Support/MathExtras.h
+++ b/include/llvm/Support/MathExtras.h
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -55,27 +55,27 @@ inline bool isUInt32(int64_t Value) {
 /// isMask_32 - This function returns true if the argument is a sequence of ones
 /// starting at the least significant bit with the remainder zero (32 bit
 /// version).   Ex. isMask_32(0x0000FFFFU) == true.
-inline const bool isMask_32(uint32_t Value) {
+inline bool isMask_32(uint32_t Value) {
   return Value && ((Value + 1) & Value) == 0;
 }
 
 /// isMask_64 - This function returns true if the argument is a sequence of ones
 /// starting at the least significant bit with the remainder zero (64 bit
 /// version).
-inline const bool isMask_64(uint64_t Value) {
+inline bool isMask_64(uint64_t Value) {
   return Value && ((Value + 1) & Value) == 0;
 }
 
 /// isShiftedMask_32 - This function returns true if the argument contains a  
 /// sequence of ones with the remainder zero (32 bit version.)
 /// Ex. isShiftedMask_32(0x0000FF00U) == true.
-inline const bool isShiftedMask_32(uint32_t Value) {
+inline bool isShiftedMask_32(uint32_t Value) {
   return isMask_32((Value - 1) | Value);
 }
 
 /// isShiftedMask_64 - This function returns true if the argument contains a  
 /// sequence of ones with the remainder zero (64 bit version.)
-inline const bool isShiftedMask_64(uint64_t Value) {
+inline bool isShiftedMask_64(uint64_t Value) {
   return isMask_64((Value - 1) | Value);
 }
 
@@ -109,7 +109,7 @@ inline uint16_t ByteSwap_16(uint16_t Value) {
 /// 32-bit argument, Value.
 inline uint32_t ByteSwap_32(uint32_t Value) {
 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
-       return __builtin_bswap32(Value);
+  return __builtin_bswap32(Value);
 #elif defined(_MSC_VER) && !defined(_DEBUG)
   return _byteswap_ulong(Value);
 #else
@@ -125,7 +125,7 @@ inline uint32_t ByteSwap_32(uint32_t Value) {
 /// 64-bit argument, Value.
 inline uint64_t ByteSwap_64(uint64_t Value) {
 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
-       return __builtin_bswap64(Value);
+  return __builtin_bswap64(Value);
 #elif defined(_MSC_VER) && !defined(_DEBUG)
   return _byteswap_uint64(Value);
 #else
@@ -163,6 +163,14 @@ inline unsigned CountLeadingZeros_32(uint32_t Value) {
   return Count;
 }
 
+/// CountLeadingOnes_32 - this function performs the operation of
+/// counting the number of ones from the most significant bit to the first zero
+/// bit.  Ex. CountLeadingOnes_32(0xFF0FFF00) == 8.
+/// Returns 32 if the word is all ones.
+inline unsigned CountLeadingOnes_32(uint32_t Value) {
+  return CountLeadingZeros_32(~Value);
+}
+
 /// CountLeadingZeros_64 - This function performs the platform optimal form
 /// of counting the number of zeros from the most significant bit to the first 
 /// one bit (64 bit edition.)
@@ -207,6 +215,14 @@ inline unsigned CountLeadingZeros_64(uint64_t Value) {
   return Count;
 }
 
+/// CountLeadingOnes_64 - This function performs the operation
+/// of counting the number of ones from the most significant bit to the first 
+/// zero bit (64 bit edition.)
+/// Returns 64 if the word is all ones.
+inline unsigned CountLeadingOnes_64(uint64_t Value) {
+  return CountLeadingZeros_64(~Value);
+}
+
 /// CountTrailingZeros_32 - this function performs the platform optimal form of
 /// counting the number of zeros from the least significant bit to the first one
 /// bit.  Ex. CountTrailingZeros_32(0xFF00FF00) == 8.
@@ -224,6 +240,14 @@ inline unsigned CountTrailingZeros_32(uint32_t Value) {
 #endif
 }
 
+/// CountTrailingOnes_32 - this function performs the operation of
+/// counting the number of ones from the least significant bit to the first zero
+/// bit.  Ex. CountTrailingOnes_32(0x00FF00FF) == 8.
+/// Returns 32 if the word is all ones.
+inline unsigned CountTrailingOnes_32(uint32_t Value) {
+  return CountTrailingZeros_32(~Value);
+}
+
 /// CountTrailingZeros_64 - This function performs the platform optimal form
 /// of counting the number of zeros from the least significant bit to the first 
 /// one bit (64 bit edition.)
@@ -243,6 +267,14 @@ inline unsigned CountTrailingZeros_64(uint64_t Value) {
 #endif
 }
 
+/// CountTrailingOnes_64 - This function performs the operation
+/// of counting the number of ones from the least significant bit to the first 
+/// zero bit (64 bit edition.)
+/// Returns 64 if the word is all ones.
+inline unsigned CountTrailingOnes_64(uint64_t Value) {
+  return CountTrailingZeros_64(~Value);
+}
+
 /// CountPopulation_32 - this function counts the number of set bits in a value.
 /// Ex. CountPopulation(0xF000F000) = 8
 /// Returns 0 if the word is zero.
@@ -358,6 +390,13 @@ int IsNAN(double d);
 int IsInf(float f);
 int IsInf(double d);
 
+/// MinAlign - A and B are either alignments or offsets.  Return the minimum
+/// alignment that may be assumed after adding the two together.
+static inline uint64_t MinAlign(uint64_t A, uint64_t B) {
+  // The largest power of 2 that divides both A and B.
+  return (A | B) & -(A | B);
+}
+  
 } // End llvm namespace
 
 #endif