From 6d8ab4ae81f0dd8ac80f25b31a3a1eff55126121 Mon Sep 17 00:00:00 2001
From: Ted Kremenek <kremenek@apple.com>
Date: Wed, 7 Nov 2007 22:30:29 +0000
Subject: [PATCH] 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
---
 include/llvm/Bitcode/Deserialize.h | 41 +++++++++++++++++++++++++++---
 include/llvm/Bitcode/Serialize.h   | 30 ++++++++++++++++++++++
 2 files changed, 67 insertions(+), 4 deletions(-)

diff --git a/include/llvm/Bitcode/Deserialize.h b/include/llvm/Bitcode/Deserialize.h
index 9808a152c0b..e77c6c9fa7f 100644
--- 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 8431898deb4..b92d49a7ea0 100644
--- 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(); }
   
-- 
2.34.1