Fix more -Wshorten-64-to-32 warnings.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@50659 91177308-0d34-0410-b5e6-96231b3b80d8

6 files changed, 34 insertions, 30 deletions

diff --git a/include/llvm/ADT/BitVector.h b/include/llvm/ADT/BitVector.h
index a3a8920186..fccb1c6e8a 100644
--- a/include/llvm/ADT/BitVector.h
+++ b/include/llvm/ADT/BitVector.h
@@ -25,7 +25,7 @@ namespace llvm {
 class BitVector {
   typedef unsigned long BitWord;
 
-  enum { BITWORD_SIZE = sizeof(BitWord) * 8 };
+  enum { BITWORD_SIZE = (unsigned)sizeof(BitWord) * 8 };
 
   BitWord  *Bits;        // Actual bits. 
   unsigned Size;         // Size of bitvector in bits.
@@ -103,7 +103,7 @@ public:
     unsigned NumBits = 0;
     for (unsigned i = 0; i < NumBitWords(size()); ++i)
       if (sizeof(BitWord) == 4)
-        NumBits += CountPopulation_32(Bits[i]);
+        NumBits += CountPopulation_32((uint32_t)Bits[i]);
       else if (sizeof(BitWord) == 8)
         NumBits += CountPopulation_64(Bits[i]);
       else
@@ -130,7 +130,7 @@ public:
     for (unsigned i = 0; i < NumBitWords(size()); ++i)
       if (Bits[i] != 0) {
         if (sizeof(BitWord) == 4)
-          return i * BITWORD_SIZE + CountTrailingZeros_32(Bits[i]);
+          return i * BITWORD_SIZE + CountTrailingZeros_32((uint32_t)Bits[i]);
         else if (sizeof(BitWord) == 8)
           return i * BITWORD_SIZE + CountTrailingZeros_64(Bits[i]);
         else
@@ -154,7 +154,7 @@ public:
 
     if (Copy != 0) {
       if (sizeof(BitWord) == 4)
-        return WordPos * BITWORD_SIZE + CountTrailingZeros_32(Copy);
+        return WordPos * BITWORD_SIZE + CountTrailingZeros_32((uint32_t)Copy);
       else if (sizeof(BitWord) == 8)
         return WordPos * BITWORD_SIZE + CountTrailingZeros_64(Copy);
       else
@@ -165,7 +165,7 @@ public:
     for (unsigned i = WordPos+1; i < NumBitWords(size()); ++i)
       if (Bits[i] != 0) {
         if (sizeof(BitWord) == 4)
-          return i * BITWORD_SIZE + CountTrailingZeros_32(Bits[i]);
+          return i * BITWORD_SIZE + CountTrailingZeros_32((uint32_t)Bits[i]);
         else if (sizeof(BitWord) == 8)
           return i * BITWORD_SIZE + CountTrailingZeros_64(Bits[i]);
         else
diff --git a/include/llvm/ADT/SmallPtrSet.h b/include/llvm/ADT/SmallPtrSet.h
index 8b85a67afb..f73a4a9bc4 100644
--- a/include/llvm/ADT/SmallPtrSet.h
+++ b/include/llvm/ADT/SmallPtrSet.h
@@ -121,7 +121,7 @@ private:
   bool isSmall() const { return CurArray == &SmallArray[0]; }
 
   unsigned Hash(const void *Ptr) const {
-    return ((uintptr_t)Ptr >> 4) & (CurArraySize-1);
+    return static_cast<unsigned>(((uintptr_t)Ptr >> 4) & (CurArraySize-1));
   }
   const void * const *FindBucketFor(const void *Ptr) const;
   void shrink_and_clear();
diff --git a/include/llvm/ADT/SmallVector.h b/include/llvm/ADT/SmallVector.h
index 6d279725ad..2da6a788eb 100644
--- a/include/llvm/ADT/SmallVector.h
+++ b/include/llvm/ADT/SmallVector.h
@@ -190,7 +190,7 @@ public:
   ///
   template<typename in_iter>
   void append(in_iter in_start, in_iter in_end) {
-    unsigned NumInputs = std::distance(in_start, in_end);
+    size_type NumInputs = std::distance(in_start, in_end);
     // Grow allocated space if needed.
     if (End+NumInputs > Capacity)
       grow(size()+NumInputs);
@@ -242,7 +242,7 @@ public:
       *I = Elt;
       return I;
     }
-    unsigned EltNo = I-Begin;
+    size_t EltNo = I-Begin;
     grow();
     I = Begin+EltNo;
     goto Retry;
@@ -255,12 +255,12 @@ public:
       return end()-1;
     }
     
-    unsigned NumToInsert = std::distance(From, To);
+    size_t NumToInsert = std::distance(From, To);
     // Convert iterator to elt# to avoid invalidating iterator when we reserve()
-    unsigned InsertElt = I-begin();
+    size_t InsertElt = I-begin();
     
     // Ensure there is enough space.
-    reserve(size() + NumToInsert);
+    reserve(static_cast<unsigned>(size() + NumToInsert));
     
     // Uninvalidate the iterator.
     I = begin()+InsertElt;
@@ -285,7 +285,7 @@ public:
     // Copy over the elements that we're about to overwrite.
     T *OldEnd = End;
     End += NumToInsert;
-    unsigned NumOverwritten = OldEnd-I;
+    size_t NumOverwritten = OldEnd-I;
     std::uninitialized_copy(I, OldEnd, End-NumOverwritten);
     
     // Replace the overwritten part.
@@ -318,7 +318,7 @@ private:
 
   /// grow - double the size of the allocated memory, guaranteeing space for at
   /// least one more element or MinSize if specified.
-  void grow(unsigned MinSize = 0);
+  void grow(size_type MinSize = 0);
 
   void construct_range(T *S, T *E, const T &Elt) {
     for (; S != E; ++S)
@@ -335,10 +335,10 @@ private:
 
 // Define this out-of-line to dissuade the C++ compiler from inlining it.
 template <typename T>
-void SmallVectorImpl<T>::grow(unsigned MinSize) {
-  unsigned CurCapacity = unsigned(Capacity-Begin);
-  unsigned CurSize = unsigned(size());
-  unsigned NewCapacity = 2*CurCapacity;
+void SmallVectorImpl<T>::grow(size_t MinSize) {
+  size_t CurCapacity = Capacity-Begin;
+  size_t CurSize = size();
+  size_t NewCapacity = 2*CurCapacity;
   if (NewCapacity < MinSize)
     NewCapacity = MinSize;
   T *NewElts = reinterpret_cast<T*>(new char[NewCapacity*sizeof(T)]);
@@ -375,20 +375,20 @@ void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
     RHS.grow(size());
   
   // Swap the shared elements.
-  unsigned NumShared = size();
+  size_t NumShared = size();
   if (NumShared > RHS.size()) NumShared = RHS.size();
-  for (unsigned i = 0; i != NumShared; ++i)
+  for (unsigned i = 0; i != static_cast<unsigned>(NumShared); ++i)
     std::swap(Begin[i], RHS[i]);
   
   // Copy over the extra elts.
   if (size() > RHS.size()) {
-    unsigned EltDiff = size() - RHS.size();
+    size_t EltDiff = size() - RHS.size();
     std::uninitialized_copy(Begin+NumShared, End, RHS.End);
     RHS.End += EltDiff;
     destroy_range(Begin+NumShared, End);
     End = Begin+NumShared;
   } else if (RHS.size() > size()) {
-    unsigned EltDiff = RHS.size() - size();
+    size_t EltDiff = RHS.size() - size();
     std::uninitialized_copy(RHS.Begin+NumShared, RHS.End, End);
     End += EltDiff;
     destroy_range(RHS.Begin+NumShared, RHS.End);
@@ -458,7 +458,9 @@ class SmallVector : public SmallVectorImpl<T> {
   typedef typename SmallVectorImpl<T>::U U;
   enum {
     // MinUs - The number of U's require to cover N T's.
-    MinUs = (sizeof(T)*N+sizeof(U)-1)/sizeof(U),
+    MinUs = (static_cast<unsigned int>(sizeof(T))*N +
+             static_cast<unsigned int>(sizeof(U)) - 1) / 
+            static_cast<unsigned int>(sizeof(U)),
     
     // NumInlineEltsElts - The number of elements actually in this array.  There
     // is already one in the parent class, and we have to round up to avoid
@@ -467,7 +469,8 @@ class SmallVector : public SmallVectorImpl<T> {
     
     // NumTsAvailable - The number of T's we actually have space for, which may
     // be more than N due to rounding.
-    NumTsAvailable = (NumInlineEltsElts+1)*sizeof(U) / sizeof(T)
+    NumTsAvailable = (NumInlineEltsElts+1)*static_cast<unsigned int>(sizeof(U))/
+                     static_cast<unsigned int>(sizeof(T))
   };
   U InlineElts[NumInlineEltsElts];
 public:  
diff --git a/include/llvm/ADT/StringExtras.h b/include/llvm/ADT/StringExtras.h
index e4c941007d..3bfd3f5c72 100644
--- a/include/llvm/ADT/StringExtras.h
+++ b/include/llvm/ADT/StringExtras.h
@@ -126,7 +126,7 @@ static inline std::string UppercaseString(const std::string &S) {
 static inline bool StringsEqualNoCase(const std::string &LHS, 
                                       const std::string &RHS) {
   if (LHS.size() != RHS.size()) return false;
-  for (unsigned i = 0, e = LHS.size(); i != e; ++i)
+  for (unsigned i = 0, e = static_cast<unsigned>(LHS.size()); i != e; ++i)
     if (tolower(LHS[i]) != tolower(RHS[i])) return false;
   return true;
 }
@@ -135,7 +135,7 @@ static inline bool StringsEqualNoCase(const std::string &LHS,
 /// case.
 static inline bool StringsEqualNoCase(const std::string &LHS, 
                                       const char *RHS) {
-  for (unsigned i = 0, e = LHS.size(); i != e; ++i) {
+  for (unsigned i = 0, e = static_cast<unsigned>(LHS.size()); i != e; ++i) {
     if (RHS[i] == 0) return false;  // RHS too short.
     if (tolower(LHS[i]) != tolower(RHS[i])) return false;
   }
diff --git a/include/llvm/ADT/StringMap.h b/include/llvm/ADT/StringMap.h
index 27ea5d3ea1..869a87fdce 100644
--- a/include/llvm/ADT/StringMap.h
+++ b/include/llvm/ADT/StringMap.h
@@ -153,13 +153,14 @@ public:
   static StringMapEntry *Create(const char *KeyStart, const char *KeyEnd,
                                 AllocatorTy &Allocator,
                                 InitType InitVal) {
-    unsigned KeyLength = KeyEnd-KeyStart;
+    unsigned KeyLength = static_cast<unsigned>(KeyEnd-KeyStart);
 
     // Okay, the item doesn't already exist, and 'Bucket' is the bucket to fill
     // in.  Allocate a new item with space for the string at the end and a null
     // terminator.
 
-    unsigned AllocSize = sizeof(StringMapEntry)+KeyLength+1;
+    unsigned AllocSize = static_cast<unsigned>(sizeof(StringMapEntry))+
+      KeyLength+1;
     unsigned Alignment = alignof<StringMapEntry>();
 
     StringMapEntry *NewItem =
@@ -236,9 +237,9 @@ class StringMap : public StringMapImpl {
   AllocatorTy Allocator;
   typedef StringMapEntry<ValueTy> MapEntryTy;
 public:
-  StringMap() : StringMapImpl(sizeof(MapEntryTy)) {}
+  StringMap() : StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))) {}
   explicit StringMap(unsigned InitialSize)
-    : StringMapImpl(InitialSize, sizeof(MapEntryTy)) {}
+    : StringMapImpl(InitialSize, static_cast<unsigned>(sizeof(MapEntryTy))) {}
 
   AllocatorTy &getAllocator() { return Allocator; }
   const AllocatorTy &getAllocator() const { return Allocator; }
diff --git a/include/llvm/ADT/UniqueVector.h b/include/llvm/ADT/UniqueVector.h
index 76e8e0b72a..b114b8231e 100644
--- a/include/llvm/ADT/UniqueVector.h
+++ b/include/llvm/ADT/UniqueVector.h
@@ -41,7 +41,7 @@ public:
     if (Val) return Val;
 
     // Compute ID for entry.
-    Val = Vector.size() + 1;
+    Val = static_cast<unsigned>(Vector.size()) + 1;
     
     // Insert in vector.
     Vector.push_back(Entry);