Implemented prototype serialization of pointers, including support

for backpatching.

Added Deserialize::ReadVal.


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

3 files changed, 75 insertions, 29 deletions

diff --git a/include/llvm/Bitcode/Deserialize.h b/include/llvm/Bitcode/Deserialize.h
index 6ee09aaa34..f5adcffe25 100644
--- a/include/llvm/Bitcode/Deserialize.h
+++ b/include/llvm/Bitcode/Deserialize.h
@@ -17,6 +17,9 @@
 
 #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 <vector>
 
 namespace llvm {
@@ -25,10 +28,42 @@ class Deserializer {
   BitstreamReader& Stream;
   SmallVector<uint64_t,10> Record;
   unsigned RecIdx;
+  BumpPtrAllocator Allocator;
+  
+  struct PtrIdInfo {
+    static inline unsigned getEmptyKey() { return ~((unsigned) 0x0); }
+    static inline unsigned getTombstoneKey() { return getEmptyKey()-1; }
+    static inline unsigned getHashValue(unsigned X) { return X; }
+    static inline bool isEqual(unsigned X, unsigned Y) { return X == Y; }
+    static inline bool isPod() { return true; }
+  };
+  
+  struct BPatchNode {
+    BPatchNode* const Next;
+    void*& PtrRef;    
+    BPatchNode(BPatchNode* n, void*& pref) : Next(n), PtrRef(pref) {}
+  };
+  
+  struct BPatchEntry {
+    BPatchNode* Head;
+    void* Ptr;    
+    BPatchEntry() : Head(NULL), Ptr(NULL) {}
+    static inline bool isPod() { return true; }
+  };  
+  
+  typedef llvm::DenseMap<unsigned,BPatchEntry,PtrIdInfo,BPatchEntry> MapTy;
+
+  MapTy BPatchMap;  
+  
 public:
   Deserializer(BitstreamReader& stream);
   ~Deserializer();
-  
+
+  uint64_t ReadInt();
+  bool ReadBool() {
+    return ReadInt() ? true : false;
+  }
+
   template <typename T>
   inline T& Read(T& X) {
     SerializeTrait<T>::Read(*this,X);
@@ -36,39 +71,36 @@ public:
   }
   
   template <typename T>
+  inline T ReadVal() {
+    return SerializeTrait<T>::ReadVal(*this);
+  }
+
+  template <typename T>
   inline T* Materialize() {
     return SerializeTrait<T>::Materialize(*this);
   }
-    
-  uint64_t ReadInt();
-  bool ReadBool() { return ReadInt() ? true : false; }
-  
-  // FIXME: Substitute a better implementation which calculates the minimum
-  // number of bits needed to serialize the enum.
-  template <typename EnumT>
-  EnumT ReadEnum(unsigned MinVal, unsigned MaxVal) { 
-    return static_cast<EnumT>(ReadInt(32));
-  }
   
   char* ReadCStr(char* cstr = NULL, unsigned MaxLen=0, bool isNullTerm=true);
   void ReadCStr(std::vector<char>& buff, bool isNullTerm=false);
+
+  template <typename T>
+  inline T* ReadOwnedPtr() {    
+    unsigned PtrId = ReadInt();
+    T* x = SerializeTrait<T>::Materialize(*this);
+    RegisterPtr(PtrId,x);
+    return x;
+  }
   
+  void ReadPtr(void*& PtrRef);  
+  void RegisterPtr(unsigned PtrId, void* Ptr);
+
+
+  void BackpatchPointers();
 private:
-  void ReadRecord();
-  
-  inline bool inRecord() { 
-    if (Record.size() > 0) {
-      if (RecIdx >= Record.size()) {
-        RecIdx = 0;
-        Record.clear();
-        return false;
-      }
-      else return true;
-    }
-    else return false;
-  }
+  void ReadRecord();  
+  bool inRecord();
 };
-  
+    
 } // end namespace llvm
 
 #endif
diff --git a/include/llvm/Bitcode/Serialization.h b/include/llvm/Bitcode/Serialization.h
index 935452cc1b..02db223053 100644
--- a/include/llvm/Bitcode/Serialization.h
+++ b/include/llvm/Bitcode/Serialization.h
@@ -24,14 +24,14 @@ template <typename T> struct SerializeTrait;
 #define SERIALIZE_INT_TRAIT(TYPE)\
 template <> struct SerializeTrait<TYPE> {\
   static void Emit(Serializer& S, TYPE X);\
-  static void Read(Deserializer& S, TYPE& X); };
+  static void Read(Deserializer& S, TYPE& X);\
+  static TYPE ReadVal(Deserializer& S); };
 
 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(unsigned long long)
 
 #undef SERIALIZE_INT_TRAIT
   
diff --git a/include/llvm/Bitcode/Serialize.h b/include/llvm/Bitcode/Serialize.h
index 061ccaf7c3..dc1fe646f2 100644
--- a/include/llvm/Bitcode/Serialize.h
+++ b/include/llvm/Bitcode/Serialize.h
@@ -18,6 +18,7 @@
 #include "llvm/Bitcode/Serialization.h"
 #include "llvm/Bitcode/BitstreamWriter.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/DenseMap.h"
 
 namespace llvm {
 
@@ -25,6 +26,10 @@ class Serializer {
   BitstreamWriter& Stream;
   SmallVector<uint64_t,10> Record;
   bool inBlock;
+  
+  typedef DenseMap<void*,unsigned> MapTy;
+  MapTy PtrMap;
+  
 public:
   Serializer(BitstreamWriter& stream, unsigned BlockID = 0);
   ~Serializer();
@@ -35,13 +40,22 @@ public:
   void EmitInt(unsigned X);
   void EmitBool(bool X) { EmitInt(X); }
   void EmitCStr(const char* beg, const char* end);
-  void EmitCStr(const char* cstr);    
+  void EmitCStr(const char* cstr);
+  
+  void EmitPtr(void* ptr) { EmitInt(getPtrId(ptr)); }
+  
+  template <typename T>
+  void EmitOwnedPtr(T* ptr) {
+    EmitPtr(ptr);
+    SerializeTrait<T>::Emit(*this,*ptr);    
+  }
 
   void Flush() { if (inRecord()) EmitRecord(); }
   
 private:
   void EmitRecord();
-  inline bool inRecord() { return Record.size() > 0; }  
+  inline bool inRecord() { return Record.size() > 0; }
+  unsigned getPtrId(void* ptr);
 };
 
 } // end namespace llvm