Update LLVM to 92395.

4 files changed, 0 insertions, 822 deletions

diff --git a/include/llvm/Bitcode/Deserialize.h b/include/llvm/Bitcode/Deserialize.h
deleted file mode 100644
index 3266038..0000000
--- a/include/llvm/Bitcode/Deserialize.h
+++ /dev/null
@@ -1,516 +0,0 @@
-//=- Deserialize.h - Generic Object Deserialization from Bitcode --*- C++ -*-=//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the interface for generic object deserialization from
-// LLVM bitcode.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_BITCODE_SERIALIZE_INPUT
-#define LLVM_BITCODE_SERIALIZE_INPUT
-
-#include "llvm/Bitcode/BitstreamReader.h"
-#include "llvm/Bitcode/Serialization.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/Allocator.h"
-#include "llvm/System/DataTypes.h"
-#include <vector>
-
-namespace llvm {
-
-struct BPNode {
-  BPNode* Next;
-  uintptr_t& PtrRef;
-  
-  BPNode(BPNode* n, uintptr_t& pref)
-  : Next(n), PtrRef(pref) {
-    PtrRef = 0;
-  }
-};
-
-struct BPEntry {
-  union { BPNode* Head; void* Ptr; };
-  BPEntry() : Head(NULL) {}
-  void SetPtr(BPNode*& FreeList, void* P);
-};
-
-class BPKey {
-  unsigned Raw;
-public:
-  BPKey(SerializedPtrID PtrId) : Raw(PtrId << 1) { assert (PtrId > 0); }
-  BPKey(unsigned code, unsigned) : Raw(code) {}
-  
-  void MarkFinal() { Raw |= 0x1; }
-  bool hasFinalPtr() const { return Raw & 0x1 ? true : false; }
-  SerializedPtrID getID() const { return Raw >> 1; }
-  
-  static inline BPKey getEmptyKey() { return BPKey(0,0); }
-  static inline BPKey getTombstoneKey() { return BPKey(1,0); }
-  static inline unsigned getHashValue(const BPKey& K) { return K.Raw & ~0x1; }
-  
-  static bool isEqual(const BPKey& K1, const BPKey& K2) {
-    return (K1.Raw ^ K2.Raw) & ~0x1 ? false : true;
-  }
-};
-  
-template <>
-struct isPodLike<BPKey> { static const bool value = true; };
-template <>
-struct isPodLike<BPEntry> { static const bool value = true; };
-  
-class Deserializer {
-
-  //===----------------------------------------------------------===//
-  // Internal type definitions.
-  //===----------------------------------------------------------===//
-
-
-  typedef llvm::DenseMap<BPKey,BPEntry,BPKey,BPEntry> MapTy;
-
-  //===----------------------------------------------------------===//
-  // Publicly visible types.
-  //===----------------------------------------------------------===//
-
-public:
-  struct Location {
-    uint64_t BitNo;
-    unsigned BlockID;
-    unsigned NumWords;
-
-    Location(uint64_t bit, unsigned bid, unsigned words)
-    : BitNo(bit), BlockID(bid), NumWords(words) {}
-
-    Location() : BitNo(0), BlockID(0), NumWords(0) {}
-
-    Location& operator=(Location& RHS) {
-      BitNo = RHS.BitNo;
-      BlockID = RHS.BlockID;
-      NumWords = RHS.NumWords;
-      return *this;
-    }
-
-    bool operator==(const Location& RHS) const { return BitNo == RHS.BitNo; }
-    bool operator!=(const Location& RHS) const { return BitNo != RHS.BitNo; }
-
-    bool contains(const Location& RHS) const {
-      if (RHS.BitNo < BitNo)
-        return false;
-
-      if ((RHS.BitNo - BitNo) >> 5 < NumWords)
-        return true;
-
-      return false;
-    }
-  };
-
-  //===----------------------------------------------------------===//
-  // Internal data members.
-  //===----------------------------------------------------------===//
-
-private:
-  BitstreamCursor Stream;
-  SmallVector<uint64_t,20> Record;
-  unsigned RecIdx;
-  BumpPtrAllocator Allocator;
-  BPNode* FreeList;
-  MapTy BPatchMap;
-  llvm::SmallVector<Location,8> BlockStack;
-  unsigned AbbrevNo;
-  unsigned RecordCode;
-  uint64_t StreamStart;
-
-  //===----------------------------------------------------------===//
-  // Public Interface.
-  //===----------------------------------------------------------===//
-
-public:
-  Deserializer(BitstreamReader& stream);
-  ~Deserializer();
-
-  uint64_t ReadInt();
-  int64_t ReadSInt();
-  SerializedPtrID ReadPtrID() { return (SerializedPtrID) ReadInt(); }
-
-
-  bool ReadBool() {
-    return ReadInt() ? true : false;
-  }
-
-  template <typename T>
-  inline T& Read(T& X) {
-    SerializeTrait<T>::Read(*this,X);
-    return X;
-  }
-
-  template <typename T>
-  inline T* Create() {
-    return SerializeTrait<T>::Create(*this);
-  }
-
-  char* ReadCStr(char* cstr = NULL, unsigned MaxLen=0, bool isNullTerm=true);
-  void ReadCStr(std::vector<char>& buff, bool isNullTerm=false, unsigned Idx=0);
-
-  template <typename T>
-  inline T* ReadOwnedPtr(bool AutoRegister = true) {
-    SerializedPtrID PtrID = ReadPtrID();
-
-    if (!PtrID)
-      return NULL;
-
-    T* x = SerializeTrait<T>::Create(*this);
-
-    if (AutoRegister)
-      RegisterPtr(PtrID,x);
-
-    return x;
-  }
-
-  template <typename T, typename Arg1>
-  inline T* ReadOwnedPtr(Arg1& arg1, bool AutoRegister = true) {
-    SerializedPtrID PtrID = ReadPtrID();
-
-    if (!PtrID)
-      return NULL;
-
-    T* x = SerializeTrait<T>::Create(*this, arg1);
-
-    if (AutoRegister)
-      RegisterPtr(PtrID,x);
-
-    return x;
-  }
-
-  template <typename T>
-  inline void ReadOwnedPtr(T*& Ptr, bool AutoRegister = true) {
-    Ptr = ReadOwnedPtr<T>(AutoRegister);
-  }
-
-  template <typename T1, typename T2>
-  void BatchReadOwnedPtrs(T1*& P1, T2*& P2,
-                          bool A1=true, bool A2=true) {
-
-    SerializedPtrID ID1 = ReadPtrID();
-    SerializedPtrID ID2 = ReadPtrID();
-
-    P1 = (ID1) ? SerializeTrait<T1>::Create(*this) : NULL;
-    if (ID1 && A1) RegisterPtr(ID1,P1);
-
-    P2 = (ID2) ? SerializeTrait<T2>::Create(*this) : NULL;
-    if (ID2 && A2) RegisterPtr(ID2,P2);
-  }
-
-  template <typename T1, typename T2, typename Arg1>
-  void BatchReadOwnedPtrs(T1*& P1, T2*& P2, Arg1& arg1,
-                          bool A1=true, bool A2=true) {
-
-    SerializedPtrID ID1 = ReadPtrID();
-    SerializedPtrID ID2 = ReadPtrID();
-
-    P1 = (ID1) ? SerializeTrait<T1>::Create(*this, arg1) : NULL;
-    if (ID1 && A1) RegisterPtr(ID1,P1);
-
-    P2 = (ID2) ? SerializeTrait<T2>::Create(*this, arg1) : NULL;
-    if (ID2 && A2) RegisterPtr(ID2,P2);
-  }
-
-  template <typename T1, typename T2, typename T3>
-  void BatchReadOwnedPtrs(T1*& P1, T2*& P2, T3*& P3,
-                          bool A1=true, bool A2=true, bool A3=true) {
-
-    SerializedPtrID ID1 = ReadPtrID();
-    SerializedPtrID ID2 = ReadPtrID();
-    SerializedPtrID ID3 = ReadPtrID();
-
-    P1 = (ID1) ? SerializeTrait<T1>::Create(*this) : NULL;
-    if (ID1 && A1) RegisterPtr(ID1,P1);
-
-    P2 = (ID2) ? SerializeTrait<T2>::Create(*this) : NULL;
-    if (ID2 && A2) RegisterPtr(ID2,P2);
-
-    P3 = (ID3) ? SerializeTrait<T3>::Create(*this) : NULL;
-    if (ID3 && A3) RegisterPtr(ID3,P3);
-  }
-
-  template <typename T1, typename T2, typename T3, typename Arg1>
-  void BatchReadOwnedPtrs(T1*& P1, T2*& P2, T3*& P3, Arg1& arg1,
-                          bool A1=true, bool A2=true, bool A3=true) {
-
-    SerializedPtrID ID1 = ReadPtrID();
-    SerializedPtrID ID2 = ReadPtrID();
-    SerializedPtrID ID3 = ReadPtrID();
-
-    P1 = (ID1) ? SerializeTrait<T1>::Create(*this, arg1) : NULL;
-    if (ID1 && A1) RegisterPtr(ID1,P1);
-
-    P2 = (ID2) ? SerializeTrait<T2>::Create(*this, arg1) : NULL;
-    if (ID2 && A2) RegisterPtr(ID2,P2);
-
-    P3 = (ID3) ? SerializeTrait<T3>::Create(*this, arg1) : NULL;
-    if (ID3 && A3) RegisterPtr(ID3,P3);
-  }
-
-  template <typename T>
-  void BatchReadOwnedPtrs(unsigned NumPtrs, T** Ptrs, bool AutoRegister=true) {
-    llvm::SmallVector<SerializedPtrID,10> BatchIDVec;
-
-    for (unsigned i = 0; i < NumPtrs; ++i)
-      BatchIDVec.push_back(ReadPtrID());
-
-    for (unsigned i = 0; i < NumPtrs; ++i) {
-      SerializedPtrID& PtrID = BatchIDVec[i];
-
-      T* p = PtrID ? SerializeTrait<T>::Create(*this) : NULL;
-
-      if (PtrID && AutoRegister)
-        RegisterPtr(PtrID,p);
-
-      Ptrs[i] = p;
-    }
-  }
-
-  template <typename T, typename Arg1>
-  void BatchReadOwnedPtrs(unsigned NumPtrs, T** Ptrs, Arg1& arg1,
-                          bool AutoRegister=true) {
-
-    llvm::SmallVector<SerializedPtrID,10> BatchIDVec;
-
-    for (unsigned i = 0; i < NumPtrs; ++i)
-      BatchIDVec.push_back(ReadPtrID());
-
-    for (unsigned i = 0; i < NumPtrs; ++i) {
-      SerializedPtrID& PtrID = BatchIDVec[i];
-
-      T* p = PtrID ? SerializeTrait<T>::Create(*this, arg1) : NULL;
-
-      if (PtrID && AutoRegister)
-        RegisterPtr(PtrID,p);
-
-      Ptrs[i] = p;
-    }
-  }
-
-  template <typename T1, typename T2>
-  void BatchReadOwnedPtrs(unsigned NumT1Ptrs, T1** Ptrs, T2*& P2,
-                          bool A1=true, bool A2=true) {
-
-    llvm::SmallVector<SerializedPtrID,10> BatchIDVec;
-
-    for (unsigned i = 0; i < NumT1Ptrs; ++i)
-      BatchIDVec.push_back(ReadPtrID());
-
-    SerializedPtrID ID2 = ReadPtrID();
-
-    for (unsigned i = 0; i < NumT1Ptrs; ++i) {
-      SerializedPtrID& PtrID = BatchIDVec[i];
-
-      T1* p = PtrID ? SerializeTrait<T1>::Create(*this) : NULL;
-
-      if (PtrID && A1)
-        RegisterPtr(PtrID,p);
-
-      Ptrs[i] = p;
-    }
-
-    P2 = (ID2) ? SerializeTrait<T2>::Create(*this) : NULL;
-    if (ID2 && A2) RegisterPtr(ID2,P2);
-  }
-
-  template <typename T1, typename T2, typename Arg1>
-  void BatchReadOwnedPtrs(unsigned NumT1Ptrs, T1** Ptrs, T2*& P2, Arg1& arg1,
-                          bool A1=true, bool A2=true) {
-
-    llvm::SmallVector<SerializedPtrID,10> BatchIDVec;
-
-    for (unsigned i = 0; i < NumT1Ptrs; ++i)
-      BatchIDVec.push_back(ReadPtrID());
-
-    SerializedPtrID ID2 = ReadPtrID();
-
-    for (unsigned i = 0; i < NumT1Ptrs; ++i) {
-      SerializedPtrID& PtrID = BatchIDVec[i];
-
-      T1* p = PtrID ? SerializeTrait<T1>::Create(*this, arg1) : NULL;
-
-      if (PtrID && A1)
-        RegisterPtr(PtrID,p);
-
-      Ptrs[i] = p;
-    }
-
-    P2 = (ID2) ? SerializeTrait<T2>::Create(*this, arg1) : NULL;
-    if (ID2 && A2) RegisterPtr(ID2,P2);
-  }
-
-  template <typename T1, typename T2, typename T3>
-  void BatchReadOwnedPtrs(unsigned NumT1Ptrs, T1** Ptrs,
-                          T2*& P2, T3*& P3,
-                          bool A1=true, bool A2=true, bool A3=true) {
-
-    llvm::SmallVector<SerializedPtrID,10> BatchIDVec;
-
-    for (unsigned i = 0; i < NumT1Ptrs; ++i)
-      BatchIDVec.push_back(ReadPtrID());
-
-    SerializedPtrID ID2 = ReadPtrID();
-    SerializedPtrID ID3 = ReadPtrID();
-
-    for (unsigned i = 0; i < NumT1Ptrs; ++i) {
-      SerializedPtrID& PtrID = BatchIDVec[i];
-
-      T1* p = PtrID ? SerializeTrait<T1>::Create(*this) : NULL;
-
-      if (PtrID && A1)
-        RegisterPtr(PtrID,p);
-
-      Ptrs[i] = p;
-    }
-
-    P2 = (ID2) ? SerializeTrait<T2>::Create(*this) : NULL;
-    if (ID2 && A2) RegisterPtr(ID2,P2);
-
-    P3 = (ID3) ? SerializeTrait<T3>::Create(*this) : NULL;
-    if (ID3 && A3) RegisterPtr(ID3,P3);
-  }
-
-  template <typename T1, typename T2, typename T3, typename Arg1>
-  void BatchReadOwnedPtrs(unsigned NumT1Ptrs, T1** Ptrs,
-                          T2*& P2, T3*& P3, Arg1& arg1,
-                          bool A1=true, bool A2=true, bool A3=true) {
-
-    llvm::SmallVector<SerializedPtrID,10> BatchIDVec;
-
-    for (unsigned i = 0; i < NumT1Ptrs; ++i)
-      BatchIDVec.push_back(ReadPtrID());
-
-    SerializedPtrID ID2 = ReadPtrID();
-    SerializedPtrID ID3 = ReadPtrID();
-
-    for (unsigned i = 0; i < NumT1Ptrs; ++i) {
-      SerializedPtrID& PtrID = BatchIDVec[i];
-
-      T1* p = PtrID ? SerializeTrait<T1>::Create(*this, arg1) : NULL;
-
-      if (PtrID && A1)
-        RegisterPtr(PtrID,p);
-
-      Ptrs[i] = p;
-    }
-
-    P2 = (ID2) ? SerializeTrait<T2>::Create(*this, arg1) : NULL;
-    if (ID2 && A2) RegisterPtr(ID2,P2);
-
-    P3 = (ID3) ? SerializeTrait<T3>::Create(*this, arg1) : NULL;
-    if (ID3 && A3) RegisterPtr(ID3,P3);
-  }
-
-  template <typename T>
-  void ReadPtr(T*& PtrRef, bool AllowBackpatch = true) {
-    ReadUIntPtr(reinterpret_cast<uintptr_t&>(PtrRef), AllowBackpatch);
-  }
-
-  template <typename T>
-  void ReadPtr(const T*& PtrRef, bool AllowBackpatch = true) {
-    ReadPtr(const_cast<T*&>(PtrRef), AllowBackpatch);
-  }
-
-
-  template <typename T>
-  void ReadPtr(T*& PtrRef, const SerializedPtrID& PtrID,
-               bool AllowBackpatch = true) {
-    ReadUIntPtr(reinterpret_cast<uintptr_t&>(PtrRef), PtrID, AllowBackpatch);
-  }
-
-  template <typename T>
-  void ReadPtr(const T*& PtrRef, const SerializedPtrID& PtrID,
-               bool AllowBackpatch = true) {
-
-    ReadPtr(const_cast<T*&>(PtrRef), PtrID, AllowBackpatch);
-  }
-
-  template <typename T>
-  T* ReadPtr() { T* x = 0; ReadPtr<T>(x,false); return x; }
-
-  void ReadUIntPtr(uintptr_t& PtrRef, const SerializedPtrID& PtrID,
-                   bool AllowBackpatch = true);
-
-  void ReadUIntPtr(uintptr_t& PtrRef, bool AllowBackpatch = true) {
-    ReadUIntPtr(PtrRef,ReadPtrID(),AllowBackpatch);
-  }
-
-  template <typename T>
-  T& ReadRef() {
-    T* p = reinterpret_cast<T*>(ReadInternalRefPtr());
-    return *p;
-  }
-
-  void RegisterPtr(const SerializedPtrID& PtrID, const void* Ptr);
-
-  void RegisterPtr(const void* Ptr) {
-    RegisterPtr(ReadPtrID(),Ptr);
-  }
-
-  template<typename T>
-  void RegisterRef(const T& x) {
-    RegisterPtr(&x);
-  }
-
-  template<typename T>
-  void RegisterRef(const SerializedPtrID& PtrID, const T& x) {
-    RegisterPtr(PtrID,&x);
-  }
-
-  Location getCurrentBlockLocation();
-  unsigned getCurrentBlockID();
-  unsigned getAbbrevNo();
-
-  bool FinishedBlock(Location BlockLoc);
-  bool JumpTo(const Location& BlockLoc);
-  void Rewind();
-
-  bool AtEnd();
-  bool inRecord();
-  void SkipBlock();
-  bool SkipToBlock(unsigned BlockID);
-
-  unsigned getRecordCode();
-
-  BitstreamCursor &getStream() { return Stream; }
-
-private:
-  bool AdvanceStream();
-  void ReadRecord();
-
-  uintptr_t ReadInternalRefPtr();
-
-  static inline bool HasFinalPtr(MapTy::value_type& V) {
-    return V.first.hasFinalPtr();
-  }
-
-  static inline uintptr_t GetFinalPtr(MapTy::value_type& V) {
-    return reinterpret_cast<uintptr_t>(V.second.Ptr);
-  }
-
-  static inline BPNode* GetBPNode(MapTy::value_type& V) {
-    return V.second.Head;
-  }
-
-  static inline void SetBPNode(MapTy::value_type& V, BPNode* N) {
-    V.second.Head = N;
-  }
-
-  void SetPtr(MapTy::value_type& V, const void* P) {
-    V.first.MarkFinal();
-    V.second.SetPtr(FreeList,const_cast<void*>(P));
-  }
-};
-
-} // end namespace llvm
-
-#endif
diff --git a/include/llvm/Bitcode/Serialization.h b/include/llvm/Bitcode/Serialization.h
deleted file mode 100644
index 2f0d350..0000000
--- a/include/llvm/Bitcode/Serialization.h
+++ /dev/null
@@ -1,68 +0,0 @@
-//==- Serialization.h - Generic Object Serialization to Bitcode ---*- C++ -*-=//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines traits for primitive types used for both object
-// serialization and deserialization.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_BITCODE_SERIALIZE
-#define LLVM_BITCODE_SERIALIZE
-
-#include "llvm/Bitcode/SerializationFwd.h"
-
-namespace llvm {
-
-/// SerializeTrait - SerializeTrait bridges between the Serializer/Deserializer
-///  and the functions that serialize objects of specific types.  The default
-///  behavior is to call static methods of the class for the object being
-///  serialized, but this behavior can be changed by specializing this
-///  template.  Classes only need to implement the methods corresponding
-///  to the serialization scheme they want to support.  For example, "Read"
-///  and "ReadVal" correspond to different deserialization schemes which make
-///  sense for different types; a class need only implement one of them.
-///  Serialization and deserialization of pointers are specially handled
-///  by the Serializer and Deserializer using the EmitOwnedPtr, etc. methods.
-///  To serialize the actual object referred to by a pointer, the class
-///  of the object either must implement the methods called by the default
-///  behavior of SerializeTrait, or specialize SerializeTrait.  This latter
-///  is useful when one cannot add methods to an existing class (for example).
-template <typename T>
-struct SerializeTrait {
-  static inline void Emit(Serializer& S, const T& X) { X.Emit(S); }
-  static inline void Read(Deserializer& D, T& X) { X.Read(D); }
-  static inline T* Create(Deserializer& D) { return T::Create(D); }
-
-  template <typename Arg1>
-  static inline T* Create(Deserializer& D, Arg1& arg1) {
-    return T::Create(D, arg1);
-  }
-};
-
-#define SERIALIZE_INT_TRAIT(TYPE)\
-template <> struct SerializeTrait<TYPE> {\
-  static void Emit(Serializer& S, TYPE X);\
-  static void Read(Deserializer& S, TYPE& X); };
-
-SERIALIZE_INT_TRAIT(bool)
-SERIALIZE_INT_TRAIT(unsigned char)
-SERIALIZE_INT_TRAIT(unsigned short)
-SERIALIZE_INT_TRAIT(unsigned int)
-SERIALIZE_INT_TRAIT(unsigned long)
-
-SERIALIZE_INT_TRAIT(signed char)
-SERIALIZE_INT_TRAIT(signed short)
-SERIALIZE_INT_TRAIT(signed int)
-SERIALIZE_INT_TRAIT(signed long)
-
-#undef SERIALIZE_INT_TRAIT
-
-} // end namespace llvm
-
-#endif
diff --git a/include/llvm/Bitcode/SerializationFwd.h b/include/llvm/Bitcode/SerializationFwd.h
deleted file mode 100644
index 7224190..0000000
--- a/include/llvm/Bitcode/SerializationFwd.h
+++ /dev/null
@@ -1,27 +0,0 @@
-//==- SerializationFwd.h - Forward references for Serialization ---*- C++ -*-=//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides forward references for bitcode object serialization.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_BITCODE_SERIALIZE_FWD
-#define LLVM_BITCODE_SERIALIZE_FWD
-
-namespace llvm {
-
-class Serializer;
-class Deserializer;
-template <typename T> struct SerializeTrait;
-
-typedef unsigned SerializedPtrID;
-
-} // end namespace llvm
-
-#endif
diff --git a/include/llvm/Bitcode/Serialize.h b/include/llvm/Bitcode/Serialize.h
deleted file mode 100644
index 6fe4f02..0000000
--- a/include/llvm/Bitcode/Serialize.h
+++ /dev/null
@@ -1,211 +0,0 @@
-//==- Serialize.h - Generic Object Serialization to Bitcode -------*- C++ -*-=//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the interface for generic object serialization to
-// LLVM bitcode.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_BITCODE_SERIALIZE_OUTPUT
-#define LLVM_BITCODE_SERIALIZE_OUTPUT
-
-#include "llvm/Bitcode/Serialization.h"
-#include "llvm/Bitcode/BitstreamWriter.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/DenseMap.h"
-
-namespace llvm {
-
-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();
-
-  //==------------------------------------------------==//
-  // Template-based dispatch to emit arbitrary types.
-  //==------------------------------------------------==//
-
-  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>
-  inline void EmitOwnedPtr(T* ptr) {
-    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);
-  }
-
-  template <typename T1, typename T2, typename T3>
-  void BatchEmitOwnedPtrs(T1* p1, T2* p2, T3* p3) {
-    EmitPtr(p1);
-    EmitPtr(p2);
-    EmitPtr(p3);
-    if (p1) SerializeTrait<T1>::Emit(*this,*p1);
-    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);
-    EmitPtr(p2);
-    EmitPtr(p3);
-    EmitPtr(p4);
-    if (p1) SerializeTrait<T1>::Emit(*this,*p1);
-    if (p2) SerializeTrait<T2>::Emit(*this,*p2);
-    if (p3) SerializeTrait<T3>::Emit(*this,*p3);
-    if (p4) SerializeTrait<T4>::Emit(*this,*p4);
-  }
-
-  template <typename T>
-  void BatchEmitOwnedPtrs(unsigned NumPtrs, T* const * Ptrs) {
-    for (unsigned i = 0; i < NumPtrs; ++i)
-      EmitPtr(Ptrs[i]);
-
-    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;
-    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 EnterBlock(unsigned BlockID = 8, unsigned CodeLen = 3);
-  void ExitBlock();
-
-private:
-  void EmitRecord();
-  inline bool inRecord() { return Record.size() > 0; }
-  SerializedPtrID getPtrId(const void* ptr);
-};
-
-} // end namespace llvm
-#endif