Removed trailing whitespace.

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

1 files changed, 43 insertions, 43 deletions

diff --git a/include/llvm/Bitcode/Serialize.h b/include/llvm/Bitcode/Serialize.h
index eae9e7cdc8..6fe4f0228d 100644
--- a/include/llvm/Bitcode/Serialize.h
+++ b/include/llvm/Bitcode/Serialize.h
@@ -26,10 +26,10 @@ class Serializer {
   BitstreamWriter& Stream;
   SmallVector<uint64_t,10> Record;
   unsigned BlockLevel;
-  
+
   typedef DenseMap<const void*,unsigned> MapTy;
   MapTy PtrMap;
-  
+
 public:
   explicit Serializer(BitstreamWriter& stream);
   ~Serializer();
@@ -37,26 +37,26 @@ public:
   //==------------------------------------------------==//
   // Template-based dispatch to emit arbitrary types.
   //==------------------------------------------------==//
-  
-  template <typename T> 
+
+  template <typename T>
   inline void Emit(const T& X) { SerializeTrait<T>::Emit(*this,X); }
-  
+
   //==------------------------------------------------==//
   // Methods to emit primitive types.
-  //==------------------------------------------------==//  
-  
+  //==------------------------------------------------==//
+
   void EmitInt(uint64_t X);
   void EmitSInt(int64_t X);
-  
+
   inline void EmitBool(bool X) { EmitInt(X); }
   void EmitCStr(const char* beg, const char* end);
   void EmitCStr(const char* cstr);
-  
+
   void EmitPtr(const void* ptr) { EmitInt(getPtrId(ptr)); }
-  
+
   template <typename T>
   inline void EmitRef(const T& ref) { EmitPtr(&ref); }
-  
+
   // Emit a pointer and the object pointed to.  (This has no relation to the
   // OwningPtr<> class.)
   template <typename T>
@@ -64,18 +64,18 @@ public:
     EmitPtr(ptr);
     if (ptr) SerializeTrait<T>::Emit(*this,*ptr);
   }
-  
-  
+
+
   //==------------------------------------------------==//
   // Batch emission of pointers.
   //==------------------------------------------------==//
-    
+
   template <typename T1, typename T2>
   void BatchEmitOwnedPtrs(T1* p1, T2* p2) {
     EmitPtr(p1);
     EmitPtr(p2);
     if (p1) SerializeTrait<T1>::Emit(*this,*p1);
-    if (p2) SerializeTrait<T2>::Emit(*this,*p2);    
+    if (p2) SerializeTrait<T2>::Emit(*this,*p2);
   }
 
   template <typename T1, typename T2, typename T3>
@@ -87,7 +87,7 @@ public:
     if (p2) SerializeTrait<T2>::Emit(*this,*p2);
     if (p3) SerializeTrait<T3>::Emit(*this,*p3);
   }
-  
+
   template <typename T1, typename T2, typename T3, typename T4>
   void BatchEmitOwnedPtrs(T1* p1, T2* p2, T3* p3, T4& p4) {
     EmitPtr(p1);
@@ -108,99 +108,99 @@ public:
     for (unsigned i = 0; i < NumPtrs; ++i)
       if (Ptrs[i]) SerializeTrait<T>::Emit(*this,*Ptrs[i]);
   }
-  
+
   template <typename T1, typename T2>
   void BatchEmitOwnedPtrs(unsigned NumT1Ptrs, T1* const * Ptrs, T2* p2) {
-    
+
     for (unsigned i = 0; i < NumT1Ptrs; ++i)
       EmitPtr(Ptrs[i]);
-    
+
     EmitPtr(p2);
-    
+
     for (unsigned i = 0; i < NumT1Ptrs; ++i)
       if (Ptrs[i]) SerializeTrait<T1>::Emit(*this,*Ptrs[i]);
-    
+
     if (p2) SerializeTrait<T2>::Emit(*this,*p2);
   }
-  
+
   template <typename T1, typename T2, typename T3>
   void BatchEmitOwnedPtrs(unsigned NumT1Ptrs, T1* const * Ptrs,
                           T2* p2, T3* p3) {
-    
+
     for (unsigned i = 0; i < NumT1Ptrs; ++i)
       EmitPtr(Ptrs[i]);
-    
+
     EmitPtr(p2);
     EmitPtr(p3);
-    
+
     for (unsigned i = 0; i < NumT1Ptrs; ++i)
       if (Ptrs[i]) SerializeTrait<T1>::Emit(*this,*Ptrs[i]);
-    
+
     if (p2) SerializeTrait<T2>::Emit(*this,*p2);
     if (p3) SerializeTrait<T3>::Emit(*this,*p3);
   }
-  
+
   //==------------------------------------------------==//
   // Emitter Functors
   //==------------------------------------------------==//
-  
+
   template <typename T>
   struct Emitter0 {
-    Serializer& S;    
+    Serializer& S;
     Emitter0(Serializer& s) : S(s) {}
     void operator()(const T& x) const {
       SerializeTrait<T>::Emit(S,x);
     }
   };
-  
+
   template <typename T, typename Arg1>
   struct Emitter1 {
     Serializer& S;
     Arg1 A1;
-    
+
     Emitter1(Serializer& s, Arg1 a1) : S(s), A1(a1) {}
     void operator()(const T& x) const {
       SerializeTrait<T>::Emit(S,x,A1);
     }
   };
-  
+
   template <typename T, typename Arg1, typename Arg2>
   struct Emitter2 {
     Serializer& S;
     Arg1 A1;
     Arg2 A2;
-    
+
     Emitter2(Serializer& s, Arg1 a1, Arg2 a2) : S(s), A1(a1), A2(a2) {}
     void operator()(const T& x) const {
       SerializeTrait<T>::Emit(S,x,A1,A2);
     }
   };
-  
+
   template <typename T>
   Emitter0<T> MakeEmitter() {
     return Emitter0<T>(*this);
   }
-  
+
   template <typename T, typename Arg1>
   Emitter1<T,Arg1> MakeEmitter(Arg1 a1) {
     return Emitter1<T,Arg1>(*this,a1);
   }
-  
+
   template <typename T, typename Arg1, typename Arg2>
   Emitter2<T,Arg1,Arg2> MakeEmitter(Arg1 a1, Arg2 a2) {
     return Emitter2<T,Arg1,Arg2>(*this,a1,a2);
   }
-  
+
   //==------------------------------------------------==//
   // Misc. query and block/record manipulation methods.
-  //==------------------------------------------------==//  
-    
+  //==------------------------------------------------==//
+
   bool isRegistered(const void* p) const;
-  
-  void FlushRecord() { if (inRecord()) EmitRecord(); }  
+
+  void FlushRecord() { if (inRecord()) EmitRecord(); }
   void EnterBlock(unsigned BlockID = 8, unsigned CodeLen = 3);
-  void ExitBlock();    
-  
+  void ExitBlock();
+
 private:
   void EmitRecord();
   inline bool inRecord() { return Record.size() > 0; }