Modified current clients of Bitcode-Object serialization to use the

new split-header file configuration (Serialize.h and Deserialize.h)
now in place in the core LLVM repository.

Removed unneeded SerializeTrait specializations for enums in
TokenKinds.h

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

diff --git a/Basic/IdentifierTable.cpp b/Basic/IdentifierTable.cpp
index 760dcf4349815670efaa1ee0a4568dfa768e4258..bbab8682676c083adfeee3e4971228692893e235 100644 (file)
--- a/Basic/IdentifierTable.cpp
+++ b/Basic/IdentifierTable.cpp
@@ -16,7 +16,8 @@
 #include "clang/Basic/LangOptions.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/Bitcode/Serialization.h"
+#include "llvm/Bitcode/Serialize.h"
+#include "llvm/Bitcode/Deserialize.h"
 
 using namespace clang;
 
@@ -381,30 +382,25 @@ SelectorTable::~SelectorTable() {
 // Serialization for IdentifierInfo and IdentifierTable.
 //===----------------------------------------------------------------------===//
 
-void llvm::SerializeTrait<IdentifierInfo>::Serialize(llvm::Serializer& S,
+void llvm::SerializeTrait<IdentifierInfo>::Emit(llvm::Serializer& S,
                                                     const IdentifierInfo& I) {
 
-  S.Emit<tok::TokenKind>(I.getTokenID());
-  S.EmitInt(I.getBuiltinID(),9);
-  S.Emit<tok::ObjCKeywordKind>(I.getObjCKeywordID());  
-  S.Emit(I.hasMacroDefinition());
-  S.Emit(I.isExtensionToken());
-  S.Emit(I.isPoisoned());
-  S.Emit(I.isOtherTargetMacro());
-  S.Emit(I.isCPlusPlusOperatorKeyword());
-  S.Emit(I.isNonPortableBuiltin());   
+  S.EmitInt(I.getTokenID());
+  S.EmitInt(I.getBuiltinID());
+  S.EmitInt(I.getObjCKeywordID());  
+  S.EmitBool(I.hasMacroDefinition());
+  S.EmitBool(I.isExtensionToken());
+  S.EmitBool(I.isPoisoned());
+  S.EmitBool(I.isOtherTargetMacro());
+  S.EmitBool(I.isCPlusPlusOperatorKeyword());
+  S.EmitBool(I.isNonPortableBuiltin());   
 }
 
-void llvm::SerializeTrait<IdentifierInfo>::Deserialize(llvm::Deserializer& D,
-                                                       IdentifierInfo& I) {
-  tok::TokenKind X;
-  I.setTokenID(D.Read<tok::TokenKind>(X));
-
-  I.setBuiltinID(D.ReadInt(9));  
-  
-  tok::ObjCKeywordKind Y;
-  I.setObjCKeywordID(D.Read<tok::ObjCKeywordKind>(Y));
-  
+void llvm::SerializeTrait<IdentifierInfo>::Read(llvm::Deserializer& D,
+                                                IdentifierInfo& I) {
+  I.setTokenID((tok::TokenKind) D.ReadInt());
+  I.setBuiltinID(D.ReadInt());  
+  I.setObjCKeywordID((tok::ObjCKeywordKind) D.ReadInt());  
   I.setHasMacroDefinition(D.ReadBool());
   I.setIsExtensionToken(D.ReadBool());
   I.setIsPoisoned(D.ReadBool());
@@ -413,27 +409,34 @@ void llvm::SerializeTrait<IdentifierInfo>::Deserialize(llvm::Deserializer& D,
   I.setNonPortableBuiltin(D.ReadBool());
 }
 
-void llvm::SerializeTrait<IdentifierTable>::Serialize(llvm::Serializer& S,
-                                                      const IdentifierTable& T){
+void llvm::SerializeTrait<IdentifierTable>::Emit(llvm::Serializer& S,
+                                                 const IdentifierTable& T){
   S.Emit<unsigned>(T.size());
   
   for (clang::IdentifierTable::iterator I=T.begin(), E=T.end(); I != E; ++I) {
-    S.EmitCString(I->getKeyData());
+    S.EmitCStr(I->getKeyData());
     S.Emit(I->getValue());
   }
 }
 
-void llvm::SerializeTrait<IdentifierTable>::Deserialize(llvm::Deserializer& D,
-                                                        IdentifierTable& T) {
+void llvm::SerializeTrait<IdentifierTable>::Read(llvm::Deserializer& D,
+                                                 IdentifierTable& T) {
   unsigned len = D.ReadInt();
   std::vector<char> buff;
   buff.reserve(200);
   
   for (unsigned i = 0; i < len; ++i) {
-    D.ReadCString(buff);
+    D.ReadCStr(buff);
     IdentifierInfo& Info = T.get(&buff[0],&buff[0]+buff.size());
     D.Read(Info);
   }
 }
-  
+
+IdentifierTable*
+llvm::SerializeTrait<IdentifierTable>::Materialize(llvm::Deserializer& D)
+{
+  IdentifierTable* t = new IdentifierTable();
+  D.Read(*t);
+  return t;
+}
 

diff --git a/Basic/TokenKinds.cpp b/Basic/TokenKinds.cpp
index f1c1e9f6788eb98a8af11e1fd217232edf9d1447..324a72d844b3aa68a578b0310435cce298d8fbb0 100644 (file)
--- a/Basic/TokenKinds.cpp
+++ b/Basic/TokenKinds.cpp
@@ -12,7 +12,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/TokenKinds.h"
-#include "llvm/Bitcode/Serialization.h"
+
 #include <cassert>
 using namespace clang;
 
@@ -27,37 +27,3 @@ const char *tok::getTokenName(enum TokenKind Kind) {
   assert(Kind < tok::NUM_TOKENS);
   return TokNames[Kind];
 }
-
-// Serialization traits for TokenKind, PPKeywordKind, and ObjCKeywordKind
-
-void llvm::SerializeTrait<tok::TokenKind>::Serialize(llvm::Serializer& S,
-                                                     tok::TokenKind X) {
-  S.EmitEnum(X,0,tok::NUM_TOKENS-1);
-}
-
-void llvm::SerializeTrait<tok::TokenKind>::Deserialize(llvm::Deserializer& D,
-                                                       tok::TokenKind& X) {
-  X = D.ReadEnum<tok::TokenKind>(0,tok::NUM_TOKENS-1);
-}
-
-void llvm::SerializeTrait<tok::PPKeywordKind>::Serialize(llvm::Serializer& S,
-                                                       tok::PPKeywordKind X) {
-  S.EmitEnum(X,0,tok::NUM_PP_KEYWORDS-1);
-}
-
-void llvm::SerializeTrait<tok::PPKeywordKind>::Deserialize(llvm::Deserializer& D,
-                                                      tok::PPKeywordKind& X) {
-  X = D.ReadEnum<tok::PPKeywordKind>(0,tok::NUM_PP_KEYWORDS-1);
-}
-
-void
-llvm::SerializeTrait<tok::ObjCKeywordKind>::Serialize(llvm::Serializer& S,
-                                                      tok::ObjCKeywordKind X) {
-  S.EmitEnum(X,0,tok::NUM_OBJC_KEYWORDS-1);
-}
-
-void
-llvm::SerializeTrait<tok::ObjCKeywordKind>::Deserialize(llvm::Deserializer& D,
-                                                     tok::ObjCKeywordKind& X) {
-  X = D.ReadEnum<tok::ObjCKeywordKind>(0,tok::NUM_OBJC_KEYWORDS-1);
-}
\ No newline at end of file

diff --git a/Driver/SerializationTest.cpp b/Driver/SerializationTest.cpp
index 811dddbb74b12cd2baf9caaf3e67a4d754dc6917..26a4df85d8bfe0bd9c8e3e4eb06321ac6ca2e242 100644 (file)
--- a/Driver/SerializationTest.cpp
+++ b/Driver/SerializationTest.cpp
@@ -21,7 +21,8 @@
 #include "llvm/System/Path.h"
 #include "llvm/Support/Streams.h"
 #include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Bitcode/Serialization.h"
+#include "llvm/Bitcode/Serialize.h"
+#include "llvm/Bitcode/Deserialize.h"
 #include <stdio.h>
 
 //===----------------------------------------------------------------------===//

diff --git a/include/clang/Basic/IdentifierTable.h b/include/clang/Basic/IdentifierTable.h
index 8e68fd1f01000625778f3e33d92961232db88332..b505176c04a496c7e5539287f038842a080da4a9 100644 (file)
--- a/include/clang/Basic/IdentifierTable.h
+++ b/include/clang/Basic/IdentifierTable.h
@@ -18,15 +18,12 @@
 #include "clang/Basic/TokenKinds.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Bitcode/Serialization.h"
 #include <string> 
 #include <cassert> 
 
-
 namespace llvm {
   template <typename T> struct DenseMapInfo;
-  template <typename T> struct SerializeTrait;
-  class Serializer;
-  class Deserializer;
 }
 
 namespace clang {
@@ -311,21 +308,18 @@ struct DenseMapInfo<clang::Selector> {
 /// Define SerializeTrait to enable serialization for IdentifierInfos.
 template <>
 struct SerializeTrait<clang::IdentifierInfo> {
-  static void Serialize(llvm::Serializer& S, const clang::IdentifierInfo& I);
-  static void Deserialize(llvm::Deserializer& S, clang::IdentifierInfo& I);
+  static void Emit(Serializer& S, const clang::IdentifierInfo& I);
+  static void Read(Deserializer& S, clang::IdentifierInfo& I);
 };
 
 /// Define SerializeTrait to enable serialization for IdentifierTables.  
 template <>
 struct SerializeTrait<clang::IdentifierTable> {
-  static void Serialize(llvm::Serializer& S, const clang::IdentifierTable& X);
-  static void Deserialize(llvm::Deserializer& S, clang::IdentifierTable& X);
+  static void Emit(Serializer& S, const clang::IdentifierTable& X);
+  static void Read(Deserializer& S, clang::IdentifierTable& X);
 
 private:
-  static inline clang::IdentifierTable* Instantiate() { 
-    return new clang::IdentifierTable();
-  }
-  
+  static clang::IdentifierTable* Materialize(Deserializer& D);
   friend class Deserializer;
 };
 

diff --git a/include/clang/Basic/TokenKinds.h b/include/clang/Basic/TokenKinds.h
index 2e213bddf101e5301f76aa4df8693a9d6177381b..e51f0c7f8a035a8a6a75f79d525740a931234e43 100644 (file)
--- a/include/clang/Basic/TokenKinds.h
+++ b/include/clang/Basic/TokenKinds.h
@@ -48,33 +48,4 @@ const char *getTokenName(enum TokenKind Kind);
 }  // end namespace tok
 }  // end namespace clang
 
-//===----------------------------------------------------------------------===//
-// Serialization traits.
-//===----------------------------------------------------------------------===//
-
-namespace llvm {
-  template <typename T> struct SerializeTrait;
-  class Serializer;
-  class Deserializer;
-  
-template<>
-struct SerializeTrait<clang::tok::TokenKind> {
-  static void Serialize(llvm::Serializer& S, clang::tok::TokenKind X);
-  static void Deserialize(llvm::Deserializer& D, clang::tok::TokenKind& X);
-};
-  
-template<>
-struct SerializeTrait<clang::tok::PPKeywordKind> {
-  static void Serialize(llvm::Serializer& S, clang::tok::PPKeywordKind X);
-  static void Deserialize(llvm::Deserializer& D, clang::tok::PPKeywordKind& X);
-};
-
-template<>
-struct SerializeTrait<clang::tok::ObjCKeywordKind> {
-  static void Serialize(llvm::Serializer& S, clang::tok::ObjCKeywordKind X);
-  static void Deserialize(llvm::Deserializer& D, clang::tok::ObjCKeywordKind& X);
-};
-  
-} // end namespace llvm
-
 #endif