Added methods to batch emit and deserialize owned pointers. This allows

to group the pointer IDs together in the bitstream before their referenced
contents (which will lend itself to more efficient encoding).

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

diff --git a/include/llvm/Bitcode/Deserialize.h b/include/llvm/Bitcode/Deserialize.h
index 9808a152c0bfe3e817f965859d680b1720786c9f..e77c6c9fa7fd901978960fdc98749ab7989195d3 100644 (file)
--- a/include/llvm/Bitcode/Deserialize.h
+++ b/include/llvm/Bitcode/Deserialize.h
@@ -117,15 +117,15 @@ public:
 
   template <typename T>
   inline T* ReadOwnedPtr(bool AutoRegister = true) {
-    unsigned PtrId = ReadInt();
+    unsigned PtrID = ReadInt();    
 
-    if (PtrId == 0)
+    if (!PtrID)
       return NULL;
     
     T* x = SerializeTrait<T>::Materialize(*this);
-    
+
     if (AutoRegister)
-      RegisterPtr(PtrId,x);
+      RegisterPtr(PtrID,x);
     
     return x;
   }
@@ -135,6 +135,39 @@ public:
     Ptr = ReadOwnedPtr<T>(AutoRegister);
   }
   
+  template <typename T1, typename T2>
+  void BatchReadOwnedPtrs(T1*& P1, T2*& P2,
+                          bool A1=true, bool A2=true) {
+
+    unsigned ID1 = ReadInt();
+    unsigned ID2 = ReadInt();
+
+    P1 = (ID1) ? SerializeTrait<T1>::Materialize(*this) : NULL;
+    if (ID1 && A1) RegisterPtr(ID1,P1);
+
+    P2 = (ID2) ? SerializeTrait<T2>::Materialize(*this) : 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) {
+    
+    unsigned ID1 = ReadInt();
+    unsigned ID2 = ReadInt();
+    unsigned ID3 = ReadInt();
+    
+    P1 = (ID1) ? SerializeTrait<T1>::Materialize(*this) : NULL;
+    if (ID1 && A1) RegisterPtr(ID1,P1);    
+    
+    P2 = (ID2) ? SerializeTrait<T2>::Materialize(*this) : NULL;
+    if (ID2 && A2) RegisterPtr(ID2,P2);
+    
+    P3 = (ID3) ? SerializeTrait<T2>::Materialize(*this) : NULL;
+    if (ID3 && A3) RegisterPtr(ID3,P3);
+  }
+    
+  
   template <typename T>
   void ReadPtr(T*& PtrRef, bool AllowBackpatch = true) {
     ReadUIntPtr(reinterpret_cast<uintptr_t&>(PtrRef), AllowBackpatch);

diff --git a/include/llvm/Bitcode/Serialize.h b/include/llvm/Bitcode/Serialize.h
index 8431898deb473685f2c7851c77ba76fb57aba8fe..b92d49a7ea0795b728c11fd85b9e08699aaa9b7d 100644 (file)
--- a/include/llvm/Bitcode/Serialize.h
+++ b/include/llvm/Bitcode/Serialize.h
@@ -54,6 +54,36 @@ public:
     EmitPtr(ptr);
     if (ptr) SerializeTrait<T>::Emit(*this,*ptr);
   }
+  
+  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);
+  }
 
   void FlushRecord() { if (inRecord()) EmitRecord(); }