diff options
Diffstat (limited to 'clang/lib')
| -rw-r--r-- | clang/lib/AST/ASTContext.cpp | 178 | ||||
| -rw-r--r-- | clang/lib/AST/CMakeLists.txt | 3 | ||||
| -rw-r--r-- | clang/lib/AST/DeclGroup.cpp | 37 | ||||
| -rw-r--r-- | clang/lib/AST/DeclSerialization.cpp | 695 | ||||
| -rw-r--r-- | clang/lib/AST/DeclarationName.cpp | 3 | ||||
| -rw-r--r-- | clang/lib/AST/StmtSerialization.cpp | 1602 | ||||
| -rw-r--r-- | clang/lib/AST/TypeSerialization.cpp | 490 | ||||
| -rw-r--r-- | clang/lib/Basic/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | clang/lib/Basic/FileManager.cpp | 2 | ||||
| -rw-r--r-- | clang/lib/Basic/IdentifierTable.cpp | 159 | ||||
| -rw-r--r-- | clang/lib/Basic/LangOptions.cpp | 60 | ||||
| -rw-r--r-- | clang/lib/Basic/SourceLocation.cpp | 22 | ||||
| -rw-r--r-- | clang/lib/Basic/SourceManager.cpp | 134 |
13 files changed, 2 insertions, 3384 deletions
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp index 159110a0800..a855ecf6b30 100644 --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -21,8 +21,6 @@ #include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetInfo.h" #include "llvm/ADT/StringExtras.h" -#include "llvm/Bitcode/Serialize.h" -#include "llvm/Bitcode/Deserialize.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/MemoryBuffer.h" using namespace clang; @@ -3223,182 +3221,6 @@ QualType ASTContext::getCorrespondingUnsignedType(QualType T) { } } - -//===----------------------------------------------------------------------===// -// Serialization Support -//===----------------------------------------------------------------------===// - -enum { - BasicMetadataBlock = 1, - ASTContextBlock = 2, - DeclsBlock = 3 -}; - -void ASTContext::EmitASTBitcodeBuffer(std::vector<unsigned char> &Buffer) const{ - // Create bitstream. - llvm::BitstreamWriter Stream(Buffer); - - // Emit the preamble. - Stream.Emit((unsigned)'B', 8); - Stream.Emit((unsigned)'C', 8); - Stream.Emit(0xC, 4); - Stream.Emit(0xF, 4); - Stream.Emit(0xE, 4); - Stream.Emit(0x0, 4); - - // Create serializer. - llvm::Serializer S(Stream); - - // ===---------------------------------------------------===/ - // Serialize the "Translation Unit" metadata. - // ===---------------------------------------------------===/ - - // Emit ASTContext. - S.EnterBlock(ASTContextBlock); - S.EmitOwnedPtr(this); - S.ExitBlock(); // exit "ASTContextBlock" - - S.EnterBlock(BasicMetadataBlock); - - // Block for SourceManager and Target. Allows easy skipping - // around to the block for the Selectors during deserialization. - S.EnterBlock(); - - // Emit the SourceManager. - S.Emit(getSourceManager()); - - // Emit the Target. - S.EmitPtr(&Target); - S.EmitCStr(Target.getTargetTriple()); - - S.ExitBlock(); // exit "SourceManager and Target Block" - - // Emit the Selectors. - S.Emit(Selectors); - - // Emit the Identifier Table. - S.Emit(Idents); - - S.ExitBlock(); // exit "BasicMetadataBlock" -} - - -/// Emit - Serialize an ASTContext object to Bitcode. -void ASTContext::Emit(llvm::Serializer& S) const { - S.Emit(LangOpts); - S.EmitRef(SourceMgr); - S.EmitRef(Target); - S.EmitRef(Idents); - S.EmitRef(Selectors); - - // Emit the size of the type vector so that we can reserve that size - // when we reconstitute the ASTContext object. - S.EmitInt(Types.size()); - - for (std::vector<Type*>::const_iterator I=Types.begin(), E=Types.end(); - I!=E;++I) - (*I)->Emit(S); - - S.EmitOwnedPtr(TUDecl); - - // FIXME: S.EmitOwnedPtr(CFConstantStringTypeDecl); -} - - -ASTContext *ASTContext::ReadASTBitcodeBuffer(llvm::MemoryBuffer &Buffer, - FileManager &FMgr) { - // Check if the file is of the proper length. - if (Buffer.getBufferSize() & 0x3) { - // FIXME: Provide diagnostic: "Length should be a multiple of 4 bytes." - return 0; - } - - // Create the bitstream reader. - unsigned char *BufPtr = (unsigned char *)Buffer.getBufferStart(); - llvm::BitstreamReader Stream(BufPtr, BufPtr+Buffer.getBufferSize()); - - if (Stream.Read(8) != 'B' || - Stream.Read(8) != 'C' || - Stream.Read(4) != 0xC || - Stream.Read(4) != 0xF || - Stream.Read(4) != 0xE || - Stream.Read(4) != 0x0) { - // FIXME: Provide diagnostic. - return NULL; - } - - // Create the deserializer. - llvm::Deserializer Dezr(Stream); - - // ===---------------------------------------------------===/ - // Deserialize the "Translation Unit" metadata. - // ===---------------------------------------------------===/ - - // Skip to the BasicMetaDataBlock. First jump to ASTContextBlock - // (which will appear earlier) and record its location. - - bool FoundBlock = Dezr.SkipToBlock(ASTContextBlock); - assert (FoundBlock); - - llvm::Deserializer::Location ASTContextBlockLoc = - Dezr.getCurrentBlockLocation(); - - FoundBlock = Dezr.SkipToBlock(BasicMetadataBlock); - assert (FoundBlock); - - // Read the SourceManager. - SourceManager::CreateAndRegister(Dezr, FMgr); - - { // Read the TargetInfo. - llvm::SerializedPtrID PtrID = Dezr.ReadPtrID(); - char* triple = Dezr.ReadCStr(NULL,0,true); - Dezr.RegisterPtr(PtrID, TargetInfo::CreateTargetInfo(std::string(triple))); - delete [] triple; - } - - // For Selectors, we must read the identifier table first because the - // SelectorTable depends on the identifiers being already deserialized. - llvm::Deserializer::Location SelectorBlkLoc = Dezr.getCurrentBlockLocation(); - Dezr.SkipBlock(); - - // Read the identifier table. - IdentifierTable::CreateAndRegister(Dezr); - - // Now jump back and read the selectors. - Dezr.JumpTo(SelectorBlkLoc); - SelectorTable::CreateAndRegister(Dezr); - - // Now jump back to ASTContextBlock and read the ASTContext. - Dezr.JumpTo(ASTContextBlockLoc); - return Dezr.ReadOwnedPtr<ASTContext>(); -} - -ASTContext* ASTContext::Create(llvm::Deserializer& D) { - - // Read the language options. - LangOptions LOpts; - LOpts.Read(D); - - SourceManager &SM = D.ReadRef<SourceManager>(); - TargetInfo &t = D.ReadRef<TargetInfo>(); - IdentifierTable &idents = D.ReadRef<IdentifierTable>(); - SelectorTable &sels = D.ReadRef<SelectorTable>(); - - unsigned size_reserve = D.ReadInt(); - - ASTContext* A = new ASTContext(LOpts, SM, t, idents, sels, - size_reserve); - - for (unsigned i = 0; i < size_reserve; ++i) - Type::Create(*A,i,D); - - A->TUDecl = cast<TranslationUnitDecl>(D.ReadOwnedPtr<Decl>(*A)); - - // FIXME: A->CFConstantStringTypeDecl = D.ReadOwnedPtr<RecordDecl>(); - - return A; -} - ExternalASTSource::~ExternalASTSource() { } void ExternalASTSource::PrintStats() { } diff --git a/clang/lib/AST/CMakeLists.txt b/clang/lib/AST/CMakeLists.txt index 3fedbf6730d..a282f202f28 100644 --- a/clang/lib/AST/CMakeLists.txt +++ b/clang/lib/AST/CMakeLists.txt @@ -12,7 +12,6 @@ add_clang_library(clangAST DeclCXX.cpp DeclGroup.cpp DeclObjC.cpp - DeclSerialization.cpp DeclTemplate.cpp ExprConstant.cpp Expr.cpp @@ -24,11 +23,9 @@ add_clang_library(clangAST StmtDumper.cpp StmtIterator.cpp StmtPrinter.cpp - StmtSerialization.cpp StmtViz.cpp TemplateName.cpp Type.cpp - TypeSerialization.cpp ) add_dependencies(clangAST ClangDiagnosticAST) diff --git a/clang/lib/AST/DeclGroup.cpp b/clang/lib/AST/DeclGroup.cpp index 64b0399901a..5bdc8817346 100644 --- a/clang/lib/AST/DeclGroup.cpp +++ b/clang/lib/AST/DeclGroup.cpp @@ -15,8 +15,6 @@ #include "clang/AST/Decl.h" #include "clang/AST/ASTContext.h" #include "llvm/Support/Allocator.h" -#include "llvm/Bitcode/Serialize.h" -#include "llvm/Bitcode/Deserialize.h" using namespace clang; DeclGroup* DeclGroup::Create(ASTContext &C, Decl **Decls, unsigned NumDecls) { @@ -27,24 +25,6 @@ DeclGroup* DeclGroup::Create(ASTContext &C, Decl **Decls, unsigned NumDecls) { return static_cast<DeclGroup*>(Mem); } -/// Emit - Serialize a DeclGroup to Bitcode. -void DeclGroup::Emit(llvm::Serializer& S) const { - S.EmitInt(NumDecls); - S.BatchEmitOwnedPtrs(NumDecls, &(*this)[0]); -} - -/// Read - Deserialize a DeclGroup from Bitcode. -DeclGroup* DeclGroup::Read(llvm::Deserializer& D, ASTContext& C) { - unsigned NumDecls = (unsigned) D.ReadInt(); - unsigned Size = sizeof(DeclGroup) + sizeof(Decl*) * NumDecls; - unsigned alignment = llvm::AlignOf<DeclGroup>::Alignment; - DeclGroup* DG = (DeclGroup*) C.Allocate(Size, alignment); - new (DG) DeclGroup(); - DG->NumDecls = NumDecls; - D.BatchReadOwnedPtrs(NumDecls, &(*DG)[0], C); - return DG; -} - DeclGroup::DeclGroup(unsigned numdecls, Decl** decls) : NumDecls(numdecls) { assert(numdecls > 0); assert(decls); @@ -55,20 +35,3 @@ void DeclGroup::Destroy(ASTContext& C) { this->~DeclGroup(); C.Deallocate((void*) this); } - -void DeclGroupRef::Emit(llvm::Serializer& S) const { - if (isSingleDecl()) { - S.EmitBool(false); - S.EmitPtr(D); - } else { - S.EmitBool(true); - S.EmitPtr(&getDeclGroup()); - } -} - -DeclGroupRef DeclGroupRef::ReadVal(llvm::Deserializer& D) { - if (D.ReadBool()) - return DeclGroupRef(D.ReadPtr<Decl>()); - - return DeclGroupRef(D.ReadPtr<DeclGroup>()); -} diff --git a/clang/lib/AST/DeclSerialization.cpp b/clang/lib/AST/DeclSerialization.cpp deleted file mode 100644 index 81fdae2edc7..00000000000 --- a/clang/lib/AST/DeclSerialization.cpp +++ /dev/null @@ -1,695 +0,0 @@ -//===--- DeclSerialization.cpp - Serialization of Decls ---------*- 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 methods that implement bitcode serialization for Decls. -// -//===----------------------------------------------------------------------===// - -#include "clang/AST/ASTContext.h" -#include "clang/AST/Decl.h" -#include "clang/AST/DeclCXX.h" -#include "clang/AST/DeclTemplate.h" -#include "clang/AST/Expr.h" -#include "llvm/Bitcode/Serialize.h" -#include "llvm/Bitcode/Deserialize.h" - -using llvm::Serializer; -using llvm::Deserializer; -using llvm::SerializedPtrID; - -using namespace clang; - -//===----------------------------------------------------------------------===// -// Decl Serialization: Dispatch code to handle specialized decl types. -//===----------------------------------------------------------------------===// - -void Decl::Emit(Serializer& S) const { - S.EmitInt(getKind()); - EmitImpl(S); - S.Emit(getLocation()); - S.EmitBool(InvalidDecl); - // FIXME: HasAttrs? - S.EmitBool(Implicit); - S.EmitInt(IdentifierNamespace); - S.EmitInt(Access); - S.EmitPtr(cast_or_null<Decl>(getDeclContext())); // From Decl. - S.EmitPtr(cast_or_null<Decl>(getLexicalDeclContext())); // From Decl. - if (const DeclContext *DC = dyn_cast<const DeclContext>(this)) - DC->EmitOutRec(S); - - if (getDeclContext() && - !getDeclContext()->isFunctionOrMethod()) { - S.EmitBool(true); - S.EmitOwnedPtr(NextDeclInContext); - } else { - S.EmitBool(false); - S.EmitPtr(NextDeclInContext); - } -} - -Decl* Decl::Create(Deserializer& D, ASTContext& C) { - - Decl *Dcl; - Kind k = static_cast<Kind>(D.ReadInt()); - - switch (k) { - default: - assert (false && "Not implemented."); - - case TranslationUnit: - Dcl = TranslationUnitDecl::CreateImpl(D, C); - break; - - case Namespace: - Dcl = NamespaceDecl::CreateImpl(D, C); - break; - - case Var: - Dcl = VarDecl::CreateImpl(D, C); - break; - - case Enum: - Dcl = EnumDecl::CreateImpl(D, C); - break; - - case EnumConstant: - Dcl = EnumConstantDecl::CreateImpl(D, C); - break; - - case Field: - Dcl = FieldDecl::CreateImpl(D, C); - break; - - case ParmVar: - Dcl = ParmVarDecl::CreateImpl(D, C); - break; - - case OriginalParmVar: - Dcl = OriginalParmVarDecl::CreateImpl(D, C); - break; - - case Function: - Dcl = FunctionDecl::CreateImpl(D, C); - break; - - case OverloadedFunction: - Dcl = OverloadedFunctionDecl::CreateImpl(D, C); - break; - - case Record: - Dcl = RecordDecl::CreateImpl(D, C); - break; - - case Typedef: - Dcl = TypedefDecl::CreateImpl(D, C); - break; - - case TemplateTypeParm: - Dcl = TemplateTypeParmDecl::CreateImpl(D, C); - break; - - case FileScopeAsm: - Dcl = FileScopeAsmDecl::CreateImpl(D, C); - break; - } - - Dcl->Loc = SourceLocation::ReadVal(D); // From Decl. - Dcl->InvalidDecl = D.ReadBool(); - // FIXME: HasAttrs? - Dcl->Implicit = D.ReadBool(); - Dcl->IdentifierNamespace = D.ReadInt(); - Dcl->Access = D.ReadInt(); - - assert(Dcl->DeclCtx.getOpaqueValue() == 0); - - const SerializedPtrID &SemaDCPtrID = D.ReadPtrID(); - const SerializedPtrID &LexicalDCPtrID = D.ReadPtrID(); - - if (SemaDCPtrID == LexicalDCPtrID) { - // Allow back-patching. Observe that we register the variable of the - // *object* for back-patching. Its actual value will get filled in later. - uintptr_t X; - D.ReadUIntPtr(X, SemaDCPtrID); - Dcl->DeclCtx = reinterpret_cast<DeclContext*>(X); - } else { - MultipleDC *MDC = new MultipleDC(); - Dcl->DeclCtx = MDC; - // Allow back-patching. Observe that we register the variable of the - // *object* for back-patching. Its actual value will get filled in later. - D.ReadPtr(MDC->SemanticDC, SemaDCPtrID); - D.ReadPtr(MDC->LexicalDC, LexicalDCPtrID); - } - if (DeclContext *DC = dyn_cast<DeclContext>(Dcl)) - DC->ReadOutRec(D, C); - bool OwnsNext = D.ReadBool(); - if (OwnsNext) - Dcl->NextDeclInContext = D.ReadOwnedPtr<Decl>(C); - else - D.ReadPtr(Dcl->NextDeclInContext); - return Dcl; -} - -//===----------------------------------------------------------------------===// -// Common serialization logic for subclasses of DeclContext. -//===----------------------------------------------------------------------===// - -void DeclContext::EmitOutRec(Serializer& S) const { - bool Owned = !isFunctionOrMethod(); - S.EmitBool(Owned); - if (Owned) - S.EmitOwnedPtr(FirstDecl); - else - S.EmitPtr(FirstDecl); - S.EmitPtr(LastDecl); -} - -void DeclContext::ReadOutRec(Deserializer& D, ASTContext& C) { - bool Owned = D.ReadBool(); - if (Owned) - FirstDecl = cast_or_null<Decl>(D.ReadOwnedPtr<Decl>(C)); - else - D.ReadPtr(FirstDecl); - D.ReadPtr(LastDecl); -} - -//===----------------------------------------------------------------------===// -// Common serialization logic for subclasses of NamedDecl. -//===----------------------------------------------------------------------===// - -void NamedDecl::EmitInRec(Serializer& S) const { - S.EmitInt(Name.getNameKind()); - - switch (Name.getNameKind()) { - case DeclarationName::Identifier: - S.EmitPtr(Name.getAsIdentifierInfo()); - break; - - case DeclarationName::ObjCZeroArgSelector: - case DeclarationName::ObjCOneArgSelector: - case DeclarationName::ObjCMultiArgSelector: - Name.getObjCSelector().Emit(S); - break; - - case DeclarationName::CXXConstructorName: - case DeclarationName::CXXDestructorName: - case DeclarationName::CXXConversionFunctionName: - Name.getCXXNameType().Emit(S); - break; - - case DeclarationName::CXXOperatorName: - S.EmitInt(Name.getCXXOverloadedOperator()); - break; - - case DeclarationName::CXXUsingDirective: - // No extra data to emit - break; - } -} - -void NamedDecl::ReadInRec(Deserializer& D, ASTContext& C) { - DeclarationName::NameKind Kind - = static_cast<DeclarationName::NameKind>(D.ReadInt()); - switch (Kind) { - case DeclarationName::Identifier: { - // Don't allow back-patching. The IdentifierInfo table must already - // be loaded. - Name = D.ReadPtr<IdentifierInfo>(); - break; - } - - case DeclarationName::ObjCZeroArgSelector: - case DeclarationName::ObjCOneArgSelector: - case DeclarationName::ObjCMultiArgSelector: - Name = Selector::ReadVal(D); - break; - - case DeclarationName::CXXConstructorName: - Name = C.DeclarationNames.getCXXConstructorName(QualType::ReadVal(D)); - break; - - case DeclarationName::CXXDestructorName: - Name = C.DeclarationNames.getCXXDestructorName(QualType::ReadVal(D)); - break; - - case DeclarationName::CXXConversionFunctionName: - Name - = C.DeclarationNames.getCXXConversionFunctionName(QualType::ReadVal(D)); - break; - - case DeclarationName::CXXOperatorName: { - OverloadedOperatorKind Op - = static_cast<OverloadedOperatorKind>(D.ReadInt()); - Name = C.DeclarationNames.getCXXOperatorName(Op); - break; - } - - case DeclarationName::CXXUsingDirective: - Name = DeclarationName::getUsingDirectiveName(); - break; - } -} - -//===----------------------------------------------------------------------===// -// Common serialization logic for subclasses of ValueDecl. -//===----------------------------------------------------------------------===// - -void ValueDecl::EmitInRec(Serializer& S) const { - NamedDecl::EmitInRec(S); - S.Emit(getType()); // From ValueDecl. -} - -void ValueDecl::ReadInRec(Deserializer& D, ASTContext& C) { - NamedDecl::ReadInRec(D, C); - DeclType = QualType::ReadVal(D); // From ValueDecl. -} - -//===----------------------------------------------------------------------===// -// Common serialization logic for subclasses of VarDecl. -//===----------------------------------------------------------------------===// - -void VarDecl::EmitInRec(Serializer& S) const { - ValueDecl::EmitInRec(S); - S.EmitInt(getStorageClass()); // From VarDecl. - S.EmitBool(ThreadSpecified); - S.EmitBool(HasCXXDirectInit); - S.EmitBool(DeclaredInCondition); - S.EmitPtr(PreviousDeclaration); - S.Emit(TypeSpecStartLoc); -} - -void VarDecl::ReadInRec(Deserializer& D, ASTContext& C) { - ValueDecl::ReadInRec(D, C); - SClass = static_cast<StorageClass>(D.ReadInt()); // From VarDecl. - ThreadSpecified = D.ReadBool(); - HasCXXDirectInit = D.ReadBool(); - DeclaredInCondition = D.ReadBool(); - D.ReadPtr(PreviousDeclaration); - TypeSpecStartLoc = SourceLocation::ReadVal(D); -} - -void VarDecl::EmitOutRec(Serializer& S) const { - // Emit this last because it will create a record of its own. - S.EmitOwnedPtr(getInit()); -} - -void VarDecl::ReadOutRec(Deserializer& D, ASTContext& C) { - Init = D.ReadOwnedPtr<Stmt>(C); -} - - -void VarDecl::EmitImpl(Serializer& S) const { - VarDecl::EmitInRec(S); - VarDecl::EmitOutRec(S); -} - -void VarDecl::ReadImpl(Deserializer& D, ASTContext& C) { - ReadInRec(D, C); - ReadOutRec(D, C); -} - -//===----------------------------------------------------------------------===// -// TranslationUnitDecl Serialization. -//===----------------------------------------------------------------------===// - -void TranslationUnitDecl::EmitImpl(llvm::Serializer& S) const -{ -} - -TranslationUnitDecl* TranslationUnitDecl::CreateImpl(Deserializer& D, - ASTContext& C) { - return new (C) TranslationUnitDecl(); -} - -//===----------------------------------------------------------------------===// -// NamespaceDecl Serialization. -//===----------------------------------------------------------------------===// - -void NamespaceDecl::EmitImpl(llvm::Serializer& S) const -{ - NamedDecl::EmitInRec(S); - S.Emit(getLBracLoc()); - S.Emit(getRBracLoc()); -} - -NamespaceDecl* NamespaceDecl::CreateImpl(Deserializer& D, ASTContext& C) { - NamespaceDecl* decl = new (C) NamespaceDecl(0, SourceLocation(), 0); - - decl->NamedDecl::ReadInRec(D, C); - decl->LBracLoc = SourceLocation::ReadVal(D); - decl->RBracLoc = SourceLocation::ReadVal(D); - - return decl; -} - -//===----------------------------------------------------------------------===// -// VarDecl Serialization. -//===----------------------------------------------------------------------===// - -VarDecl* VarDecl::CreateImpl(Deserializer& D, ASTContext& C) { - VarDecl* decl = - new (C) VarDecl(Var, 0, SourceLocation(), NULL, QualType(), None); - - decl->VarDecl::ReadImpl(D, C); - return decl; -} - -//===----------------------------------------------------------------------===// -// ParmVarDecl Serialization. -//===----------------------------------------------------------------------===// - -void ParmVarDecl::EmitImpl(llvm::Serializer& S) const { - VarDecl::EmitImpl(S); - S.EmitInt(getObjCDeclQualifier()); // From ParmVarDecl. - S.EmitOwnedPtr(getDefaultArg()); // From ParmVarDecl. -} - -ParmVarDecl* ParmVarDecl::CreateImpl(Deserializer& D, ASTContext& C) { - ParmVarDecl* decl = new (C) - ParmVarDecl(ParmVar, - 0, SourceLocation(), NULL, QualType(), None, NULL); - - decl->VarDecl::ReadImpl(D, C); - decl->objcDeclQualifier = static_cast<ObjCDeclQualifier>(D.ReadInt()); - decl->DefaultArg = D.ReadOwnedPtr<Expr>(C); - return decl; -} - -//===----------------------------------------------------------------------===// -// OriginalParmVarDecl Serialization. -//===----------------------------------------------------------------------===// - -void OriginalParmVarDecl::EmitImpl(llvm::Serializer& S) const { - ParmVarDecl::EmitImpl(S); - S.Emit(OriginalType); -} - -OriginalParmVarDecl* OriginalParmVarDecl::CreateImpl( - Deserializer& D, ASTContext& C) { - OriginalParmVarDecl* decl = new (C) - OriginalParmVarDecl(0, SourceLocation(), NULL, QualType(), - QualType(), None, NULL); - - decl->ParmVarDecl::ReadImpl(D, C); - decl->OriginalType = QualType::ReadVal(D); - return decl; -} -//===----------------------------------------------------------------------===// -// EnumDecl Serialization. -//===----------------------------------------------------------------------===// - -void EnumDecl::EmitImpl(Serializer& S) const { - NamedDecl::EmitInRec(S); - S.EmitBool(isDefinition()); - S.Emit(IntegerType); -} - -EnumDecl* EnumDecl::CreateImpl(Deserializer& D, ASTContext& C) { - EnumDecl* decl = new (C) EnumDecl(0, SourceLocation(), NULL); - - decl->NamedDecl::ReadInRec(D, C); - decl->setDefinition(D.ReadBool()); - decl->IntegerType = QualType::ReadVal(D); - - return decl; -} - -//===----------------------------------------------------------------------===// -// EnumConstantDecl Serialization. -//===----------------------------------------------------------------------===// - -void EnumConstantDecl::EmitImpl(Serializer& S) const { - S.Emit(Val); - ValueDecl::EmitInRec(S); - S.EmitOwnedPtr(Init); -} - -EnumConstantDecl* EnumConstantDecl::CreateImpl(Deserializer& D, ASTContext& C) { - llvm::APSInt val(1); - D.Read(val); - - EnumConstantDecl* decl = new (C) - EnumConstantDecl(0, SourceLocation(), NULL, QualType(), NULL, val); - - decl->ValueDecl::ReadInRec(D, C); - decl->Init = D.ReadOwnedPtr<Stmt>(C); - return decl; -} - -//===----------------------------------------------------------------------===// -// FieldDecl Serialization. -//===----------------------------------------------------------------------===// - -void FieldDecl::EmitImpl(Serializer& S) const { - S.EmitBool(Mutable); - S.Emit(getType()); - ValueDecl::EmitInRec(S); - S.EmitOwnedPtr(BitWidth); -} - -FieldDecl* FieldDecl::CreateImpl(Deserializer& D, ASTContext& C) { - FieldDecl* decl = new (C) FieldDecl(Field, 0, SourceLocation(), NULL, - QualType(), 0, false); - decl->Mutable = D.ReadBool(); - decl->ValueDecl::ReadInRec(D, C); - decl->BitWidth = D.ReadOwnedPtr<Expr>(C); - return decl; -} - -//===----------------------------------------------------------------------===// -// FunctionDecl Serialization. -//===----------------------------------------------------------------------===// - -void FunctionDecl::EmitImpl(Serializer& S) const { - S.EmitInt(SClass); // From FunctionDecl. - S.EmitBool(IsInline); // From FunctionDecl. - ValueDecl::EmitInRec(S); - S.EmitPtr(PreviousDeclaration); - - // NOTE: We do not need to serialize out the number of parameters, because - // that is encoded in the type (accessed via getNumParams()). - - if (ParamInfo != NULL) { - S.EmitBool(true); - S.EmitInt(getNumParams()); - // FIXME: S.BatchEmitOwnedPtrs(getNumParams(),&ParamInfo[0], Body); - } - else { - S.EmitBool(false); - // FIXME: S.EmitOwnedPtr(Body); - } -} - -FunctionDecl* FunctionDecl::CreateImpl(Deserializer& D, ASTContext& C) { - StorageClass SClass = static_cast<StorageClass>(D.ReadInt()); - bool IsInline = D.ReadBool(); - - FunctionDecl* decl = new (C) - FunctionDecl(Function, 0, SourceLocation(), DeclarationName(), - QualType(), SClass, IsInline); - - decl->ValueDecl::ReadInRec(D, C); - D.ReadPtr(decl->PreviousDeclaration); - - int numParams = 0; - bool hasParamDecls = D.ReadBool(); - if (hasParamDecls) - numParams = D.ReadInt(); - - decl->ParamInfo = hasParamDecls - ? new ParmVarDecl*[numParams] - : NULL; - - if (hasParamDecls) - D.BatchReadOwnedPtrs(numParams, - reinterpret_cast<Decl**>(&decl->ParamInfo[0]), - /*FIXME: decl->Body,*/ C); - else - decl->Body = D.ReadOwnedPtr<Stmt>(C); - - return decl; -} - -void BlockDecl::EmitImpl(Serializer& S) const { - // FIXME: what about arguments? - S.Emit(getCaretLocation()); - S.EmitOwnedPtr(Body); -} - -BlockDecl* BlockDecl::CreateImpl(Deserializer& D, ASTContext& C) { - QualType Q = QualType::ReadVal(D); - SourceLocation L = SourceLocation::ReadVal(D); - /*CompoundStmt* BodyStmt = cast<CompoundStmt>(*/D.ReadOwnedPtr<Stmt>(C)/*)*/; - assert(0 && "Cannot deserialize BlockBlockExpr yet"); - // FIXME: need to handle parameters. - //return new BlockBlockExpr(L, Q, BodyStmt); - return 0; -} - -//===----------------------------------------------------------------------===// -// OverloadedFunctionDecl Serialization. -//===----------------------------------------------------------------------===// - -void OverloadedFunctionDecl::EmitImpl(Serializer& S) const { - NamedDecl::EmitInRec(S); - - S.EmitInt(getNumFunctions()); - for (unsigned func = 0; func < getNumFunctions(); ++func) - S.EmitPtr(Functions[func]); -} - -OverloadedFunctionDecl * -OverloadedFunctionDecl::CreateImpl(Deserializer& D, ASTContext& C) { - OverloadedFunctionDecl* decl = new (C) - OverloadedFunctionDecl(0, DeclarationName()); - - decl->NamedDecl::ReadInRec(D, C); - - unsigned numFunctions = D.ReadInt(); - decl->Functions.reserve(numFunctions); - for (unsigned func = 0; func < numFunctions; ++func) - D.ReadPtr(decl->Functions[func]); - - return decl; -} - -//===----------------------------------------------------------------------===// -// RecordDecl Serialization. -//===----------------------------------------------------------------------===// - -void RecordDecl::EmitImpl(Serializer& S) const { - S.EmitInt(getTagKind()); - - NamedDecl::EmitInRec(S); - S.EmitBool(isDefinition()); - S.EmitBool(hasFlexibleArrayMember()); - S.EmitBool(isAnonymousStructOrUnion()); -} - -RecordDecl* RecordDecl::CreateImpl(Deserializer& D, ASTContext& C) { - TagKind TK = TagKind(D.ReadInt()); - - RecordDecl* decl = new (C) RecordDecl(Record, TK, 0, SourceLocation(), NULL); - - decl->NamedDecl::ReadInRec(D, C); - decl->setDefinition(D.ReadBool()); - decl->setHasFlexibleArrayMember(D.ReadBool()); - decl->setAnonymousStructOrUnion(D.ReadBool()); - - return decl; -} - -//===----------------------------------------------------------------------===// -// TypedefDecl Serialization. -//===----------------------------------------------------------------------===// - -void TypedefDecl::EmitImpl(Serializer& S) const { - S.Emit(UnderlyingType); - NamedDecl::EmitInRec(S); -} - -TypedefDecl* TypedefDecl::CreateImpl(Deserializer& D, ASTContext& C) { - QualType T = QualType::ReadVal(D); - - TypedefDecl* decl = new (C) TypedefDecl(0, SourceLocation(), NULL, T); - - decl->NamedDecl::ReadInRec(D, C); - - return decl; -} - -//===----------------------------------------------------------------------===// -// TemplateTypeParmDecl Serialization. -//===----------------------------------------------------------------------===// - -void TemplateTypeParmDecl::EmitImpl(Serializer& S) const { - S.EmitBool(Typename); - TypeDecl::EmitInRec(S); -} - -TemplateTypeParmDecl * -TemplateTypeParmDecl::CreateImpl(Deserializer& D, ASTContext& C) { - bool Typename = D.ReadBool(); - TemplateTypeParmDecl *decl - = new (C) TemplateTypeParmDecl(0, SourceLocation(), 0, Typename, - QualType()); - decl->TypeDecl::ReadInRec(D, C); - return decl; -} - -//===----------------------------------------------------------------------===// -// NonTypeTemplateParmDecl Serialization. -//===----------------------------------------------------------------------===// -void NonTypeTemplateParmDecl::EmitImpl(Serializer& S) const { - S.EmitInt(Depth); - S.EmitInt(Position); - NamedDecl::Emit(S); -} - -NonTypeTemplateParmDecl* -NonTypeTemplateParmDecl::CreateImpl(Deserializer& D, ASTContext& C) { - unsigned Depth = D.ReadInt(); - unsigned Position = D.ReadInt(); - NonTypeTemplateParmDecl *decl - = new (C) NonTypeTemplateParmDecl(0, SourceLocation(), Depth, Position, - 0, QualType(), SourceLocation()); - decl->NamedDecl::ReadInRec(D, C); - return decl; -} - -//===----------------------------------------------------------------------===// -// TemplateTemplateParmDecl Serialization. -//===----------------------------------------------------------------------===// -void TemplateTemplateParmDecl::EmitImpl(Serializer& S) const { - S.EmitInt(Depth); - S.EmitInt(Position); - NamedDecl::EmitInRec(S); -} - -TemplateTemplateParmDecl* -TemplateTemplateParmDecl::CreateImpl(Deserializer& D, ASTContext& C) { - unsigned Depth = D.ReadInt(); - unsigned Position = D.ReadInt(); - TemplateTemplateParmDecl *decl - = new (C) TemplateTemplateParmDecl(0, SourceLocation(), Depth, Position, - 0, 0); - decl->NamedDecl::ReadInRec(D, C); - return decl; -} - -//===----------------------------------------------------------------------===// -// LinkageSpec Serialization. -//===----------------------------------------------------------------------===// - -void LinkageSpecDecl::EmitInRec(Serializer& S) const { - S.EmitInt(getLanguage()); - S.EmitBool(HadBraces); -} - -void LinkageSpecDecl::ReadInRec(Deserializer& D, ASTContext& C) { - Language = static_cast<LanguageIDs>(D.ReadInt()); - HadBraces = D.ReadBool(); -} - -//===----------------------------------------------------------------------===// -// FileScopeAsm Serialization. -//===----------------------------------------------------------------------===// - -void FileScopeAsmDecl::EmitImpl(llvm::Serializer& S) const -{ - S.EmitOwnedPtr(AsmString); -} - -FileScopeAsmDecl* FileScopeAsmDecl::CreateImpl(Deserializer& D, ASTContext& C) { - FileScopeAsmDecl* decl = new (C) FileScopeAsmDecl(0, SourceLocation(), 0); - - decl->AsmString = cast<StringLiteral>(D.ReadOwnedPtr<Expr>(C)); -// D.ReadOwnedPtr(D.ReadOwnedPtr<StringLiteral>())<#T * * Ptr#>, <#bool AutoRegister#>)(decl->AsmString); - - return decl; -} diff --git a/clang/lib/AST/DeclarationName.cpp b/clang/lib/AST/DeclarationName.cpp index e2ed8925951..5cc0aab5ee3 100644 --- a/clang/lib/AST/DeclarationName.cpp +++ b/clang/lib/AST/DeclarationName.cpp @@ -15,9 +15,8 @@ #include "clang/AST/Type.h" #include "clang/AST/Decl.h" #include "clang/Basic/IdentifierTable.h" +#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/FoldingSet.h" -#include "llvm/Bitcode/Serialize.h" -#include "llvm/Bitcode/Deserialize.h" using namespace clang; namespace clang { diff --git a/clang/lib/AST/StmtSerialization.cpp b/clang/lib/AST/StmtSerialization.cpp deleted file mode 100644 index 7a37a16550d..00000000000 --- a/clang/lib/AST/StmtSerialization.cpp +++ /dev/null @@ -1,1602 +0,0 @@ -//===--- StmtSerialization.cpp - Serialization of Statements --------------===// -// -// 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 type-specific methods for serializing statements -// and expressions. -// -//===----------------------------------------------------------------------===// - -#include "clang/Basic/TypeTraits.h" -#include "clang/AST/DeclCXX.h" -#include "clang/AST/Expr.h" -#include "clang/AST/ExprCXX.h" -#include "clang/AST/ExprObjC.h" -#include "clang/AST/ASTContext.h" -#include "llvm/Bitcode/Serialize.h" -#include "llvm/Bitcode/Deserialize.h" - -using namespace clang; -using llvm::Serializer; -using llvm::Deserializer; - -void Stmt::Emit(Serializer& S) const { - S.FlushRecord(); - S.EmitInt(getStmtClass()); - EmitImpl(S); - S.FlushRecord(); -} - -Stmt* Stmt::Create(Deserializer& D, ASTContext& C) { - StmtClass SC = static_cast<StmtClass>(D.ReadInt()); - - switch (SC) { - default: - assert (false && "Not implemented."); - return NULL; - - case AddrLabelExprClass: - return AddrLabelExpr::CreateImpl(D, C); - - case ArraySubscriptExprClass: - return ArraySubscriptExpr::CreateImpl(D, C); - - case AsmStmtClass: - return AsmStmt::CreateImpl(D, C); - - case BinaryOperatorClass: - return BinaryOperator::CreateImpl(D, C); - - case BreakStmtClass: - return BreakStmt::CreateImpl(D, C); - - case CallExprClass: - return CallExpr::CreateImpl(D, C, CallExprClass); - - case CaseStmtClass: - return CaseStmt::CreateImpl(D, C); - - case CharacterLiteralClass: - return CharacterLiteral::CreateImpl(D, C); - - case ChooseExprClass: - return ChooseExpr::CreateImpl(D, C); - - case CompoundAssignOperatorClass: - return CompoundAssignOperator::CreateImpl(D, C); - - case CompoundLiteralExprClass: - return CompoundLiteralExpr::CreateImpl(D, C); - - case CompoundStmtClass: - return CompoundStmt::CreateImpl(D, C); - - case ConditionalOperatorClass: - return ConditionalOperator::CreateImpl(D, C); - - case ContinueStmtClass: - return ContinueStmt::CreateImpl(D, C); - - case DeclRefExprClass: - return DeclRefExpr::CreateImpl(D, C); - - case DeclStmtClass: - return DeclStmt::CreateImpl(D, C); - - case DefaultStmtClass: - return DefaultStmt::CreateImpl(D, C); - - case DoStmtClass: - return DoStmt::CreateImpl(D, C); - - case FloatingLiteralClass: - return FloatingLiteral::CreateImpl(D, C); - - case ForStmtClass: - return ForStmt::CreateImpl(D, C); - - case GNUNullExprClass: - return GNUNullExpr::CreateImpl(D, C); - - case GotoStmtClass: - return GotoStmt::CreateImpl(D, C); - - case IfStmtClass: - return IfStmt::CreateImpl(D, C); - - case ImaginaryLiteralClass: - return ImaginaryLiteral::CreateImpl(D, C); - - case ImplicitCastExprClass: - return ImplicitCastExpr::CreateImpl(D, C); - - case CStyleCastExprClass: - return CStyleCastExpr::CreateImpl(D, C); - - case IndirectGotoStmtClass: - return IndirectGotoStmt::CreateImpl(D, C); - - case InitListExprClass: - return InitListExpr::CreateImpl(D, C); - - case IntegerLiteralClass: - return IntegerLiteral::CreateImpl(D, C); - - case LabelStmtClass: - return LabelStmt::CreateImpl(D, C); - - case MemberExprClass: - return MemberExpr::CreateImpl(D, C); - - case NullStmtClass: - return NullStmt::CreateImpl(D, C); - - case ParenExprClass: - return ParenExpr::CreateImpl(D, C); - - case PredefinedExprClass: - return PredefinedExpr::CreateImpl(D, C); - - case ReturnStmtClass: - return ReturnStmt::CreateImpl(D, C); - - case SizeOfAlignOfExprClass: - return SizeOfAlignOfExpr::CreateImpl(D, C); - - case StmtExprClass: - return StmtExpr::CreateImpl(D, C); - - case StringLiteralClass: - return StringLiteral::CreateImpl(D, C); - - case SwitchStmtClass: - return SwitchStmt::CreateImpl(D, C); - - case UnaryOperatorClass: - return UnaryOperator::CreateImpl(D, C); - - case WhileStmtClass: - return WhileStmt::CreateImpl(D, C); - - //==--------------------------------------==// - // Objective C - //==--------------------------------------==// - - case ObjCAtCatchStmtClass: - return ObjCAtCatchStmt::CreateImpl(D, C); - - case ObjCAtFinallyStmtClass: - return ObjCAtFinallyStmt::CreateImpl(D, C); - - case ObjCAtSynchronizedStmtClass: - return ObjCAtSynchronizedStmt::CreateImpl(D, C); - - case ObjCAtThrowStmtClass: - return ObjCAtThrowStmt::CreateImpl(D, C); - - case ObjCAtTryStmtClass: - return ObjCAtTryStmt::CreateImpl(D, C); - - case ObjCEncodeExprClass: - return ObjCEncodeExpr::CreateImpl(D, C); - - case ObjCForCollectionStmtClass: - return ObjCForCollectionStmt::CreateImpl(D, C); - - case ObjCIvarRefExprClass: - return ObjCIvarRefExpr::CreateImpl(D, C); - - case ObjCMessageExprClass: - return ObjCMessageExpr::CreateImpl(D, C); - - case ObjCSelectorExprClass: - return ObjCSelectorExpr::CreateImpl(D, C); - - case ObjCStringLiteralClass: - return ObjCStringLiteral::CreateImpl(D, C); - - case ObjCSuperExprClass: - return ObjCSuperExpr::CreateImpl(D, C); - - //==--------------------------------------==// - // C++ - //==--------------------------------------==// - - case CXXOperatorCallExprClass: - return CXXOperatorCallExpr::CreateImpl(D, C, CXXOperatorCallExprClass); - - case CXXDefaultArgExprClass: - return CXXDefaultArgExpr::CreateImpl(D, C); - - case CXXFunctionalCastExprClass: - return CXXFunctionalCastExpr::CreateImpl(D, C); - - case CXXStaticCastExprClass: - return CXXStaticCastExpr::CreateImpl(D, C, SC); - - case CXXDynamicCastExprClass: - return CXXDynamicCastExpr::CreateImpl(D, C, SC); - - case CXXReinterpretCastExprClass: - return CXXReinterpretCastExpr::CreateImpl(D, C, SC); - - case CXXConstCastExprClass: - return CXXConstCastExpr::CreateImpl(D, C, SC); - - case CXXTypeidExprClass: - return CXXTypeidExpr::CreateImpl(D, C); - - case CXXThisExprClass: - return CXXThisExpr::CreateImpl(D, C); - - case CXXTemporaryObjectExprClass: - return CXXTemporaryObjectExpr::CreateImpl(D, C); - - case CXXZeroInitValueExprClass: - return CXXZeroInitValueExpr::CreateImpl(D, C); - - case CXXNewExprClass: - return CXXNewExpr::CreateImpl(D, C); - - case CXXDeleteExprClass: - return CXXDeleteExpr::CreateImpl(D, C); - - case UnresolvedFunctionNameExprClass: - return UnresolvedFunctionNameExpr::CreateImpl(D, C); - - case CXXCatchStmtClass: - return CXXCatchStmt::CreateImpl(D, C); - - case CXXTryStmtClass: - return CXXTryStmt::CreateImpl(D, C); - - case QualifiedDeclRefExprClass: - return QualifiedDeclRefExpr::CreateImpl(D, C); - } -} - -//===----------------------------------------------------------------------===// -// C Serialization -//===----------------------------------------------------------------------===// - -void AddrLabelExpr::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.Emit(AmpAmpLoc); - S.Emit(LabelLoc); - S.EmitPtr(Label); -} - -AddrLabelExpr* AddrLabelExpr::CreateImpl(Deserializer& D, ASTContext& C) { - QualType t = QualType::ReadVal(D); - SourceLocation AALoc = SourceLocation::ReadVal(D); - SourceLocation LLoc = SourceLocation::ReadVal(D); - AddrLabelExpr* expr = new (C, llvm::alignof<AddrLabelExpr>()) - AddrLabelExpr(AALoc,LLoc,NULL,t); - D.ReadPtr(expr->Label); // Pointer may be backpatched. - return expr; -} - -void ArraySubscriptExpr::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.Emit(RBracketLoc); - S.BatchEmitOwnedPtrs(getLHS(),getRHS()); -} - -ArraySubscriptExpr* ArraySubscriptExpr::CreateImpl(Deserializer& D, ASTContext& C) { - QualType t = QualType::ReadVal(D); - SourceLocation L = SourceLocation::ReadVal(D); - Expr *LHS, *RHS; - D.BatchReadOwnedPtrs(LHS, RHS, C); - return new (C, llvm::alignof<ArraySubscriptExpr>()) - ArraySubscriptExpr(LHS,RHS,t,L); -} - -void AsmStmt::EmitImpl(Serializer& S) const { - S.Emit(AsmLoc); - - getAsmString()->EmitImpl(S); - S.Emit(RParenLoc); - - S.EmitBool(IsVolatile); - S.EmitBool(IsSimple); - S.EmitInt(NumOutputs); - S.EmitInt(NumInputs); - - unsigned size = NumOutputs + NumInputs; - - for (unsigned i = 0; i < size; ++i) - S.EmitCStr(Names[i].c_str()); - - for (unsigned i = 0; i < size; ++i) - Constraints[i]->EmitImpl(S); - - for (unsigned i = 0; i < size; ++i) - S.EmitOwnedPtr(Exprs[i]); - - S.EmitInt(Clobbers.size()); - for (unsigned i = 0, e = Clobbers.size(); i != e; ++i) - Clobbers[i]->EmitImpl(S); -} - -AsmStmt* AsmStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation ALoc = SourceLocation::ReadVal(D); - StringLiteral *AsmStr = StringLiteral::CreateImpl(D, C); - SourceLocation PLoc = SourceLocation::ReadVal(D); - - bool IsVolatile = D.ReadBool(); - bool IsSimple = D.ReadBool(); - AsmStmt *Stmt = new (C, llvm::alignof<AsmStmt>()) - AsmStmt(ALoc, IsSimple, IsVolatile, 0, 0, 0, 0, 0, AsmStr, 0, 0, PLoc); - - Stmt->NumOutputs = D.ReadInt(); - Stmt->NumInputs = D.ReadInt(); - - unsigned size = Stmt->NumOutputs + Stmt->NumInputs; - - Stmt->Names.reserve(size); - for (unsigned i = 0; i < size; ++i) { - std::vector<char> data; - D.ReadCStr(data, false); - - Stmt->Names.push_back(std::string(data.begin(), data.end())); - } - - Stmt->Constraints.reserve(size); - for (unsigned i = 0; i < size; ++i) - Stmt->Constraints.push_back(StringLiteral::CreateImpl(D, C)); - - Stmt->Exprs.reserve(size); - for (unsigned i = 0; i < size; ++i) - Stmt->Exprs.push_back(D.ReadOwnedPtr<Expr>(C)); - - unsigned NumClobbers = D.ReadInt(); - Stmt->Clobbers.reserve(NumClobbers); - for (unsigned i = 0; i < NumClobbers; ++i) - Stmt->Clobbers.push_back(StringLiteral::CreateImpl(D, C)); - - return Stmt; -} - -void BinaryOperator::EmitImpl(Serializer& S) const { - S.EmitInt(Opc); - S.Emit(OpLoc);; - S.Emit(getType()); - S.BatchEmitOwnedPtrs(getLHS(),getRHS()); -} - -BinaryOperator* BinaryOperator::CreateImpl(Deserializer& D, ASTContext& C) { - Opcode Opc = static_cast<Opcode>(D.ReadInt()); - SourceLocation OpLoc = SourceLocation::ReadVal(D); - QualType Result = QualType::ReadVal(D); - Expr *LHS, *RHS; - D.BatchReadOwnedPtrs(LHS, RHS, C); - - return new (C, llvm::alignof<BinaryOperator>()) - BinaryOperator(LHS,RHS,Opc,Result,OpLoc); -} - -void BreakStmt::EmitImpl(Serializer& S) const { - S.Emit(BreakLoc); -} - -BreakStmt* BreakStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation Loc = SourceLocation::ReadVal(D); - return new (C, llvm::alignof<BreakStmt>()) BreakStmt(Loc); -} - -void CallExpr::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.Emit(RParenLoc); - S.EmitInt(NumArgs); - S.BatchEmitOwnedPtrs(NumArgs+1, SubExprs); -} - -CallExpr* CallExpr::CreateImpl(Deserializer& D, ASTContext& C, StmtClass SC) { - QualType t = QualType::ReadVal(D); - SourceLocation L = SourceLocation::ReadVal(D); - unsigned NumArgs = D.ReadInt(); - Stmt** SubExprs = new (C, llvm::alignof<Stmt*>()) Stmt*[NumArgs+1]; - D.BatchReadOwnedPtrs(NumArgs+1, SubExprs, C); - return new (C, llvm::alignof<CallExpr>()) CallExpr(SC, SubExprs,NumArgs,t,L); -} - -void CaseStmt::EmitImpl(Serializer& S) const { - S.Emit(CaseLoc); - S.EmitPtr(getNextSwitchCase()); - S.BatchEmitOwnedPtrs((unsigned) END_EXPR,&SubExprs[0]); -} - -CaseStmt* CaseStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation CaseLoc = SourceLocation::ReadVal(D); - CaseStmt* stmt = new (C, llvm::alignof<CaseStmt>()) - CaseStmt(NULL,NULL,CaseLoc); - D.ReadPtr(stmt->NextSwitchCase); - D.BatchReadOwnedPtrs((unsigned) END_EXPR, &stmt->SubExprs[0], C); - return stmt; -} - -void CStyleCastExpr::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.Emit(getTypeAsWritten()); - S.Emit(LPLoc); - S.Emit(RPLoc); - S.EmitOwnedPtr(getSubExpr()); -} - -CStyleCastExpr* CStyleCastExpr::CreateImpl(Deserializer& D, ASTContext& C) { - QualType t = QualType::ReadVal(D); - QualType writtenTy = QualType::ReadVal(D); - SourceLocation LPLoc = SourceLocation::ReadVal(D); - SourceLocation RPLoc = SourceLocation::ReadVal(D); - Expr* Op = D.ReadOwnedPtr<Expr>(C); - return new (C, llvm::alignof<CStyleCastExpr>()) - CStyleCastExpr(t,Op,writtenTy,LPLoc,RPLoc); -} - -void CharacterLiteral::EmitImpl(Serializer& S) const { - S.Emit(Value); - S.Emit(Loc); - S.EmitBool(IsWide); - S.Emit(getType()); -} - -CharacterLiteral* CharacterLiteral::CreateImpl(Deserializer& D, ASTContext& C) { - unsigned value = D.ReadInt(); - SourceLocation Loc = SourceLocation::ReadVal(D); - bool iswide = D.ReadBool(); - QualType T = QualType::ReadVal(D); - return new (C, llvm::alignof<CharacterLiteral>()) - CharacterLiteral(value,iswide,T,Loc); -} - -void CompoundAssignOperator::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.Emit(ComputationLHSType); - S.Emit(ComputationResultType); - S.Emit(getOperatorLoc()); - S.EmitInt(getOpcode()); - S.BatchEmitOwnedPtrs(getLHS(),getRHS()); -} - -CompoundAssignOperator* -CompoundAssignOperator::CreateImpl(Deserializer& D, ASTContext& C) { - QualType t = QualType::ReadVal(D); - QualType cl = QualType::ReadVal(D); - QualType cr = QualType::ReadVal(D); - SourceLocation L = SourceLocation::ReadVal(D); - Opcode Opc = static_cast<Opcode>(D.ReadInt()); - Expr* LHS, *RHS; - D.BatchReadOwnedPtrs(LHS, RHS, C); - - return new (C, llvm::alignof<CompoundAssignOperator>()) - CompoundAssignOperator(LHS,RHS,Opc,t,cl,cr,L); -} - -void CompoundLiteralExpr::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.Emit(getLParenLoc()); - S.EmitBool(isFileScope()); - S.EmitOwnedPtr(Init); -} - -CompoundLiteralExpr* CompoundLiteralExpr::CreateImpl(Deserializer& D, - ASTContext& C) { - QualType Q = QualType::ReadVal(D); - SourceLocation L = SourceLocation::ReadVal(D); - bool fileScope = D.ReadBool(); - Expr* Init = D.ReadOwnedPtr<Expr>(C); - return new (C, llvm::alignof<CompoundLiteralExpr>()) - CompoundLiteralExpr(L, Q, Init, fileScope); -} - -void CompoundStmt::EmitImpl(Serializer& S) const { - S.Emit(LBracLoc); - S.Emit(RBracLoc); - S.Emit(NumStmts); - if (NumStmts) S.BatchEmitOwnedPtrs(NumStmts, &Body[0]); -} - -CompoundStmt* CompoundStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation LB = SourceLocation::ReadVal(D); - SourceLocation RB = SourceLocation::ReadVal(D); - unsigned size = D.ReadInt(); - - CompoundStmt* stmt = new (C, llvm::alignof<CompoundStmt>()) - CompoundStmt(C, NULL, 0, LB, RB); - - stmt->NumStmts = size; - - if (size) { - stmt->Body = new (C) Stmt*[size]; - D.BatchReadOwnedPtrs(size, &stmt->Body[0], C); - } - - return stmt; -} - -void ConditionalOperator::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.BatchEmitOwnedPtrs((unsigned) END_EXPR, SubExprs); -} - -ConditionalOperator* ConditionalOperator::CreateImpl(Deserializer& D, - ASTContext& C) { - - QualType t = QualType::ReadVal(D); - ConditionalOperator* c = new (C, llvm::alignof<ConditionalOperator>()) - ConditionalOperator(NULL,NULL,NULL,t); - D.BatchReadOwnedPtrs((unsigned) END_EXPR, c->SubExprs, C); - return c; -} - -void ContinueStmt::EmitImpl(Serializer& S) const { - S.Emit(ContinueLoc); -} - -ContinueStmt* ContinueStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation Loc = SourceLocation::ReadVal(D); - return new ContinueStmt(Loc); -} - -void DeclStmt::EmitImpl(Serializer& S) const { - S.Emit(StartLoc); - S.Emit(EndLoc); - S.Emit(DG); -} - -DeclStmt* DeclStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation StartLoc = SourceLocation::ReadVal(D); - SourceLocation EndLoc = SourceLocation::ReadVal(D); - return new DeclStmt(DeclGroupRef::ReadVal(D), StartLoc, EndLoc); -} - -void DeclRefExpr::EmitImpl(Serializer& S) const { - S.Emit(Loc); - S.Emit(getType()); - S.EmitPtr(getDecl()); -} - -DeclRefExpr* DeclRefExpr::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation Loc = SourceLocation::ReadVal(D); - QualType T = QualType::ReadVal(D); - DeclRefExpr *DRE = new DeclRefExpr(0, T, Loc); - D.ReadPtr(DRE->D); - return DRE; -} - -void DefaultStmt::EmitImpl(Serializer& S) const { - S.Emit(DefaultLoc); - S.EmitOwnedPtr(getSubStmt()); - S.EmitPtr(getNextSwitchCase()); -} - -DefaultStmt* DefaultStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation Loc = SourceLocation::ReadVal(D); - Stmt* SubStmt = D.ReadOwnedPtr<Stmt>(C); - - DefaultStmt* stmt = new DefaultStmt(Loc,SubStmt); - stmt->setNextSwitchCase(D.ReadPtr<SwitchCase>()); - - return stmt; -} - -void DoStmt::EmitImpl(Serializer& S) const { - S.Emit(DoLoc); - S.EmitOwnedPtr(getCond()); - S.EmitOwnedPtr(getBody()); -} - -DoStmt* DoStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation DoLoc = SourceLocation::ReadVal(D); - Expr* Cond = D.ReadOwnedPtr<Expr>(C); - Stmt* Body = D.ReadOwnedPtr<Stmt>(C); - return new DoStmt(Body,Cond,DoLoc); -} - -void FloatingLiteral::EmitImpl(Serializer& S) const { - S.Emit(Loc); - S.Emit(getType()); - S.EmitBool(isExact()); - S.Emit(Value); -} - -FloatingLiteral* FloatingLiteral::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation Loc = SourceLocation::ReadVal(D); - QualType t = QualType::ReadVal(D); - bool isExact = D.ReadBool(); - llvm::APFloat Val = llvm::APFloat::ReadVal(D); - FloatingLiteral* expr = new FloatingLiteral(Val,&isExact,t,Loc); - return expr; -} - -void ForStmt::EmitImpl(Serializer& S) const { - S.Emit(ForLoc); - S.EmitOwnedPtr(getInit()); - S.EmitOwnedPtr(getCond()); - S.EmitOwnedPtr(getInc()); - S.EmitOwnedPtr(getBody()); -} - -ForStmt* ForStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation ForLoc = SourceLocation::ReadVal(D); - Stmt* Init = D.ReadOwnedPtr<Stmt>(C); - Expr* Cond = D.ReadOwnedPtr<Expr>(C); - Expr* Inc = D.ReadOwnedPtr<Expr>(C); - Stmt* Body = D.ReadOwnedPtr<Stmt>(C); - return new ForStmt(Init,Cond,Inc,Body,ForLoc); -} - -void GotoStmt::EmitImpl(Serializer& S) const { - S.Emit(GotoLoc); - S.Emit(LabelLoc); - S.EmitPtr(Label); -} - -GotoStmt* GotoStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation GotoLoc = SourceLocation::ReadVal(D); - SourceLocation LabelLoc = SourceLocation::ReadVal(D); - GotoStmt* stmt = new GotoStmt(NULL,GotoLoc,LabelLoc); - D.ReadPtr(stmt->Label); // This pointer may be backpatched later. - return stmt; -} - -void IfStmt::EmitImpl(Serializer& S) const { - S.Emit(IfLoc); - S.EmitOwnedPtr(getCond()); - S.EmitOwnedPtr(getThen()); - S.EmitOwnedPtr(getElse()); -} - -IfStmt* IfStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation L = SourceLocation::ReadVal(D); - Expr* Cond = D.ReadOwnedPtr<Expr>(C); - Stmt* Then = D.ReadOwnedPtr<Stmt>(C); - Stmt* Else = D.ReadOwnedPtr<Stmt>(C); - return new IfStmt(L,Cond,Then,Else); -} - -void ImaginaryLiteral::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.EmitOwnedPtr(Val); -} - -ImaginaryLiteral* ImaginaryLiteral::CreateImpl(Deserializer& D, ASTContext& C) { - QualType t = QualType::ReadVal(D); - Expr* expr = D.ReadOwnedPtr<Expr>(C); - assert (isa<FloatingLiteral>(expr) || isa<IntegerLiteral>(expr)); - return new ImaginaryLiteral(expr,t); -} - -void ImplicitCastExpr::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.EmitOwnedPtr(getSubExpr()); - S.Emit(LvalueCast); -} - -ImplicitCastExpr* ImplicitCastExpr::CreateImpl(Deserializer& D, ASTContext& C) { - QualType t = QualType::ReadVal(D); - Expr* Op = D.ReadOwnedPtr<Expr>(C); - bool isLvalue = D.ReadBool(); - return new ImplicitCastExpr(t,Op,isLvalue); -} - -void IndirectGotoStmt::EmitImpl(Serializer& S) const { - S.EmitOwnedPtr(Target); -} - -IndirectGotoStmt* IndirectGotoStmt::CreateImpl(Deserializer& D, ASTContext& C) { - Expr* Target = D.ReadOwnedPtr<Expr>(C); - return new IndirectGotoStmt(SourceLocation(), Target); -} - -void InitListExpr::EmitImpl(Serializer& S) const { - S.Emit(LBraceLoc); - S.Emit(RBraceLoc); - S.EmitInt(InitExprs.size()); - if (!InitExprs.empty()) S.BatchEmitOwnedPtrs(InitExprs.size(), &InitExprs[0]); -} - -InitListExpr* InitListExpr::CreateImpl(Deserializer& D, ASTContext& C) { - InitListExpr* expr = new InitListExpr(); - expr->LBraceLoc = SourceLocation::ReadVal(D); - expr->RBraceLoc = SourceLocation::ReadVal(D); - unsigned size = D.ReadInt(); - assert(size); - expr->InitExprs.reserve(size); - for (unsigned i = 0 ; i < size; ++i) expr->InitExprs.push_back(0); - - D.BatchReadOwnedPtrs(size, &expr->InitExprs[0], C); - return expr; -} - -void IntegerLiteral::EmitImpl(Serializer& S) const { - S.Emit(Loc); - S.Emit(getType()); - S.Emit(getValue()); -} - -IntegerLiteral* IntegerLiteral::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation Loc = SourceLocation::ReadVal(D); - QualType T = QualType::ReadVal(D); - - // Create a dummy APInt because it is more efficient to deserialize - // it in place with the deserialized IntegerLiteral. (fewer copies) - llvm::APInt temp; - IntegerLiteral* expr = new IntegerLiteral(temp,T,Loc); - D.Read(expr->Value); - - return expr; -} - -void LabelStmt::EmitImpl(Serializer& S) const { - S.EmitPtr(Label); - S.Emit(IdentLoc); - S.EmitOwnedPtr(SubStmt); -} - -LabelStmt* LabelStmt::CreateImpl(Deserializer& D, ASTContext& C) { - IdentifierInfo* Label = D.ReadPtr<IdentifierInfo>(); - SourceLocation IdentLoc = SourceLocation::ReadVal(D); - Stmt* SubStmt = D.ReadOwnedPtr<Stmt>(C); - return new LabelStmt(IdentLoc,Label,SubStmt); -} - -void MemberExpr::EmitImpl(Serializer& S) const { - S.Emit(MemberLoc); - S.EmitPtr(MemberDecl); - S.EmitBool(IsArrow); - S.Emit(getType()); - S.EmitOwnedPtr(Base); -} - -MemberExpr* MemberExpr::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation L = SourceLocation::ReadVal(D); - NamedDecl* MemberDecl = cast<NamedDecl>(D.ReadPtr<Decl>()); - bool IsArrow = D.ReadBool(); - QualType T = QualType::ReadVal(D); - Expr* base = D.ReadOwnedPtr<Expr>(C); - - return new MemberExpr(base,IsArrow,MemberDecl,L,T); -} - -void NullStmt::EmitImpl(Serializer& S) const { - S.Emit(SemiLoc); -} - -NullStmt* NullStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation SemiLoc = SourceLocation::ReadVal(D); - return new NullStmt(SemiLoc); -} - -void ParenExpr::EmitImpl(Serializer& S) const { - S.Emit(L); - S.Emit(R); - S.EmitOwnedPtr(Val); -} - -ParenExpr* ParenExpr::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation L = SourceLocation::ReadVal(D); - SourceLocation R = SourceLocation::ReadVal(D); - Expr* val = D.ReadOwnedPtr<Expr>(C); - return new ParenExpr(L,R,val); -} - -void PredefinedExpr::EmitImpl(Serializer& S) const { - S.Emit(Loc); - S.EmitInt(getIdentType()); - S.Emit(getType()); -} - -PredefinedExpr* PredefinedExpr::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation Loc = SourceLocation::ReadVal(D); - IdentType it = static_cast<IdentType>(D.ReadInt()); - QualType Q = QualType::ReadVal(D); - return new PredefinedExpr(Loc,Q,it); -} - -void ReturnStmt::EmitImpl(Serializer& S) const { - S.Emit(RetLoc); - S.EmitOwnedPtr(RetExpr); -} - -ReturnStmt* ReturnStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation RetLoc = SourceLocation::ReadVal(D); - Expr* RetExpr = D.ReadOwnedPtr<Expr>(C); - return new ReturnStmt(RetLoc,RetExpr); -} - -void SizeOfAlignOfExpr::EmitImpl(Serializer& S) const { - S.EmitBool(isSizeof); - S.EmitBool(isType); - if (isType) - S.Emit(getArgumentType()); - else - S.EmitOwnedPtr(getArgumentExpr()); - S.Emit(getType()); - S.Emit(OpLoc); - S.Emit(RParenLoc); -} - -SizeOfAlignOfExpr* -SizeOfAlignOfExpr::CreateImpl(Deserializer& D, ASTContext& C) { - bool isSizeof = D.ReadBool(); - bool isType = D.ReadBool(); - void *Argument; - if (isType) - Argument = QualType::ReadVal(D).getAsOpaquePtr(); - else - Argument = D.ReadOwnedPtr<Expr>(C); - QualType Res = QualType::ReadVal(D); - SourceLocation OpLoc = SourceLocation::ReadVal(D); - SourceLocation RParenLoc = SourceLocation::ReadVal(D); - - if (isType) - return new (C) SizeOfAlignOfExpr(isSizeof, - QualType::getFromOpaquePtr(Argument), - Res, OpLoc, RParenLoc); - - return new (C) SizeOfAlignOfExpr(isSizeof, (Expr *)Argument, - Res, OpLoc, RParenLoc); -} - -void StmtExpr::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.Emit(LParenLoc); - S.Emit(RParenLoc); - S.EmitOwnedPtr(SubStmt); -} - -StmtExpr* StmtExpr::CreateImpl(Deserializer& D, ASTContext& C) { - QualType t = QualType::ReadVal(D); - SourceLocation L = SourceLocation::ReadVal(D); - SourceLocation R = SourceLocation::ReadVal(D); - CompoundStmt* SubStmt = cast<CompoundStmt>(D.ReadOwnedPtr<Stmt>(C)); - return new StmtExpr(SubStmt,t,L,R); -} - -void TypesCompatibleExpr::EmitImpl(llvm::Serializer& S) const { - S.Emit(getType()); - S.Emit(BuiltinLoc); - S.Emit(RParenLoc); - S.Emit(Type1); - S.Emit(Type2); -} - -TypesCompatibleExpr* TypesCompatibleExpr::CreateImpl(llvm::Deserializer& D, - ASTContext& C) { - QualType RT = QualType::ReadVal(D); - SourceLocation BL = SourceLocation::ReadVal(D); - SourceLocation RP = SourceLocation::ReadVal(D); - QualType T1 = QualType::ReadVal(D); - QualType T2 = QualType::ReadVal(D); - return new TypesCompatibleExpr(RT, BL, T1, T2, RP); -} - -void ShuffleVectorExpr::EmitImpl(llvm::Serializer& S) const { - S.Emit(getType()); - S.Emit(BuiltinLoc); - S.Emit(RParenLoc); - S.EmitInt(NumExprs); - S.BatchEmitOwnedPtrs(NumExprs, &SubExprs[0]); -} - -ShuffleVectorExpr* ShuffleVectorExpr::CreateImpl(llvm::Deserializer& D, - ASTContext& C) { - QualType T = QualType::ReadVal(D); - SourceLocation BL = SourceLocation::ReadVal(D); - SourceLocation RP = SourceLocation::ReadVal(D); - unsigned NumExprs = D.ReadInt(); - // FIXME: Avoid extra allocation. - llvm::SmallVector<Expr*, 4> Exprs(NumExprs); - D.BatchReadOwnedPtrs(NumExprs, Exprs.begin(), C); - return new ShuffleVectorExpr(Exprs.begin(), NumExprs, T, BL, RP); -} - -void ChooseExpr::EmitImpl(llvm::Serializer& S) const { - S.Emit(getType()); - S.Emit(BuiltinLoc); - S.Emit(RParenLoc); - S.BatchEmitOwnedPtrs((unsigned) END_EXPR, &SubExprs[0]); -} - -ChooseExpr* ChooseExpr::CreateImpl(llvm::Deserializer& D, ASTContext& C) { - QualType T = QualType::ReadVal(D); - SourceLocation BL = SourceLocation::ReadVal(D); - SourceLocation RP = SourceLocation::ReadVal(D); - ChooseExpr *CE = new ChooseExpr(BL, 0, 0, 0, T, RP); - D.BatchReadOwnedPtrs((unsigned) END_EXPR, &CE->SubExprs[0], C); - return CE; -} - -void GNUNullExpr::EmitImpl(llvm::Serializer &S) const { - S.Emit(getType()); - S.Emit(TokenLoc); -} - -GNUNullExpr *GNUNullExpr::CreateImpl(llvm::Deserializer &D, ASTContext &C) { - QualType T = QualType::ReadVal(D); - SourceLocation TL = SourceLocation::ReadVal(D); - return new GNUNullExpr(T, TL); -} - -void VAArgExpr::EmitImpl(llvm::Serializer& S) const { - S.Emit(getType()); - S.Emit(BuiltinLoc); - S.Emit(RParenLoc); - S.EmitOwnedPtr(getSubExpr()); -} - -VAArgExpr* VAArgExpr::CreateImpl(llvm::Deserializer& D, ASTContext& C) { - QualType T = QualType::ReadVal(D); - SourceLocation BL = SourceLocation::ReadVal(D); - SourceLocation RP = SourceLocation::ReadVal(D); - Expr *E = D.ReadOwnedPtr<Expr>(C); - return new VAArgExpr(BL, E, T, RP); -} - -void StringLiteral::EmitImpl(Serializer& S) const { - S.Emit(getType()); - assert(0 && "Unimpl loc serialization"); - S.EmitBool(isWide()); - S.Emit(getByteLength()); - - for (unsigned i = 0 ; i < ByteLength; ++i) - S.EmitInt(StrData[i]); -} - -StringLiteral* StringLiteral::CreateImpl(Deserializer& D, ASTContext& C) { - QualType t = QualType::ReadVal(D); - assert(0 && "Unimpl loc serialization"); - //SourceLocation firstTokLoc = SourceLocation::ReadVal(D); - //SourceLocation lastTokLoc = SourceLocation::ReadVal(D); - bool isWide = D.ReadBool(); - unsigned ByteLength = D.ReadInt(); - - StringLiteral* sl = StringLiteral::Create(C, NULL, 0, isWide, t, - SourceLocation()); - - char* StrData = new (C, llvm::alignof<char>()) char[ByteLength]; - for (unsigned i = 0; i < ByteLength; ++i) - StrData[i] = (char) D.ReadInt(); - - sl->ByteLength = ByteLength; - sl->StrData = StrData; - - return sl; -} - -void SwitchStmt::EmitImpl(Serializer& S) const { - S.Emit(SwitchLoc); - S.EmitOwnedPtr(getCond()); - S.EmitOwnedPtr(getBody()); - S.EmitPtr(FirstCase); -} - -SwitchStmt* SwitchStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation Loc = SourceLocation::ReadVal(D); - Stmt* Cond = D.ReadOwnedPtr<Stmt>(C); - Stmt* Body = D.ReadOwnedPtr<Stmt>(C); - SwitchCase* FirstCase = cast<SwitchCase>(D.ReadPtr<Stmt>()); - - SwitchStmt* stmt = new SwitchStmt(cast<Expr>(Cond)); - stmt->setBody(Body,Loc); - stmt->FirstCase = FirstCase; - - return stmt; -} - -void UnaryOperator::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.Emit(Loc); - S.EmitInt(Opc); - S.EmitOwnedPtr(Val); -} - -UnaryOperator* UnaryOperator::CreateImpl(Deserializer& D, ASTContext& C) { - QualType t = QualType::ReadVal(D); - SourceLocation L = SourceLocation::ReadVal(D); - Opcode Opc = static_cast<Opcode>(D.ReadInt()); - Expr* Val = D.ReadOwnedPtr<Expr>(C); - return new UnaryOperator(Val,Opc,t,L); -} - -void WhileStmt::EmitImpl(Serializer& S) const { - S.Emit(WhileLoc); - S.EmitOwnedPtr(getCond()); - S.EmitOwnedPtr(getBody()); -} - -WhileStmt* WhileStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation WhileLoc = SourceLocation::ReadVal(D); - Expr* Cond = D.ReadOwnedPtr<Expr>(C); - Stmt* Body = D.ReadOwnedPtr<Stmt>(C); - return new WhileStmt(Cond,Body,WhileLoc); -} - -//===----------------------------------------------------------------------===// -// Objective C Serialization -//===----------------------------------------------------------------------===// - -void ObjCAtCatchStmt::EmitImpl(Serializer& S) const { - S.Emit(AtCatchLoc); - S.Emit(RParenLoc); - S.BatchEmitOwnedPtrs((unsigned) END_EXPR, &SubExprs[0]); -} - -ObjCAtCatchStmt* ObjCAtCatchStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation AtCatchLoc = SourceLocation::ReadVal(D); - SourceLocation RParenLoc = SourceLocation::ReadVal(D); - - ObjCAtCatchStmt* stmt = new ObjCAtCatchStmt(AtCatchLoc,RParenLoc); - D.BatchReadOwnedPtrs((unsigned) END_EXPR, &stmt->SubExprs[0], C); - - return stmt; -} - -void ObjCAtFinallyStmt::EmitImpl(Serializer& S) const { - S.Emit(AtFinallyLoc); - S.EmitOwnedPtr(AtFinallyStmt); -} - -ObjCAtFinallyStmt* ObjCAtFinallyStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation Loc = SourceLocation::ReadVal(D); - Stmt* AtFinallyStmt = D.ReadOwnedPtr<Stmt>(C); - return new ObjCAtFinallyStmt(Loc,AtFinallyStmt); -} - -void ObjCAtSynchronizedStmt::EmitImpl(Serializer& S) const { - S.Emit(AtSynchronizedLoc); - S.BatchEmitOwnedPtrs((unsigned) END_EXPR,&SubStmts[0]); - } - -ObjCAtSynchronizedStmt* ObjCAtSynchronizedStmt::CreateImpl(Deserializer& D, - ASTContext& C) { - - SourceLocation L = SourceLocation::ReadVal(D); - ObjCAtSynchronizedStmt* stmt = new ObjCAtSynchronizedStmt(L,0,0); - D.BatchReadOwnedPtrs((unsigned) END_EXPR, &stmt->SubStmts[0], C); - return stmt; -} - -void ObjCAtThrowStmt::EmitImpl(Serializer& S) const { - S.Emit(AtThrowLoc); - S.EmitOwnedPtr(Throw); -} - -ObjCAtThrowStmt* ObjCAtThrowStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation L = SourceLocation::ReadVal(D); - Stmt* Throw = D.ReadOwnedPtr<Stmt>(C); - return new ObjCAtThrowStmt(L,Throw); -} - -void ObjCAtTryStmt::EmitImpl(Serializer& S) const { - S.Emit(AtTryLoc); - S.BatchEmitOwnedPtrs((unsigned) END_EXPR, &SubStmts[0]); -} - -ObjCAtTryStmt* ObjCAtTryStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation L = SourceLocation::ReadVal(D); - ObjCAtTryStmt* stmt = new ObjCAtTryStmt(L,NULL,NULL,NULL); - D.BatchReadOwnedPtrs((unsigned) END_EXPR, &stmt->SubStmts[0], C); - return stmt; -} - -void ObjCEncodeExpr::EmitImpl(Serializer& S) const { - S.Emit(AtLoc); - S.Emit(RParenLoc); - S.Emit(getType()); - S.Emit(EncType); -} - -ObjCEncodeExpr* ObjCEncodeExpr::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation AtLoc = SourceLocation::ReadVal(D); - SourceLocation RParenLoc = SourceLocation::ReadVal(D); - QualType T = QualType::ReadVal(D); - QualType ET = QualType::ReadVal(D); - return new ObjCEncodeExpr(T,ET,AtLoc,RParenLoc); -} - -void ObjCForCollectionStmt::EmitImpl(Serializer& S) const { - S.Emit(ForLoc); - S.Emit(RParenLoc); - S.BatchEmitOwnedPtrs(getElement(),getCollection(),getBody()); -} - -ObjCForCollectionStmt* ObjCForCollectionStmt::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation ForLoc = SourceLocation::ReadVal(D); - SourceLocation RParenLoc = SourceLocation::ReadVal(D); - Stmt* Element; - Expr* Collection; - Stmt* Body; - D.BatchReadOwnedPtrs(Element, Collection, Body, C); - return new ObjCForCollectionStmt(Element,Collection,Body,ForLoc, RParenLoc); -} - -void ObjCProtocolExpr::EmitImpl(llvm::Serializer& S) const { - S.Emit(getType()); - S.EmitPtr(Protocol); - S.Emit(AtLoc); - S.Emit(RParenLoc); -} - -ObjCProtocolExpr* ObjCProtocolExpr::CreateImpl(llvm::Deserializer& D, - ASTContext& C) { - QualType T = QualType::ReadVal(D); - ObjCProtocolDecl *PD = D.ReadPtr<ObjCProtocolDecl>(); - SourceLocation AL = SourceLocation::ReadVal(D); - SourceLocation RP = SourceLocation::ReadVal(D); - return new ObjCProtocolExpr(T, PD, AL, RP); -} - -void ObjCIvarRefExpr::EmitImpl(Serializer& S) const { - S.Emit(Loc); - S.Emit(getType()); - S.EmitPtr(getDecl()); -} - -ObjCIvarRefExpr* ObjCIvarRefExpr::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation Loc = SourceLocation::ReadVal(D); - QualType T = QualType::ReadVal(D); - ObjCIvarRefExpr* dr = new ObjCIvarRefExpr(NULL,T,Loc); - D.ReadPtr(dr->D,false); - return dr; -} - -void ObjCPropertyRefExpr::EmitImpl(Serializer& S) const { - S.Emit(IdLoc); - S.Emit(getType()); - S.EmitPtr(getProperty()); -} - -void ObjCKVCRefExpr::EmitImpl(Serializer& S) const { - S.Emit(Loc); - S.Emit(getType()); - S.EmitPtr(getGetterMethod()); - S.EmitPtr(getSetterMethod()); -} - -ObjCPropertyRefExpr* ObjCPropertyRefExpr::CreateImpl(Deserializer& D, - ASTContext& C) { - SourceLocation Loc = SourceLocation::ReadVal(D); - QualType T = QualType::ReadVal(D); - ObjCPropertyRefExpr* dr = new ObjCPropertyRefExpr(NULL,T,Loc,0); - D.ReadPtr(dr->AsProperty,false); - return dr; -} - -ObjCKVCRefExpr* ObjCKVCRefExpr::CreateImpl(Deserializer& D, - ASTContext& C) { - SourceLocation Loc = SourceLocation::ReadVal(D); - QualType T = QualType::ReadVal(D); - ObjCKVCRefExpr* dr = new ObjCKVCRefExpr(NULL,T,NULL,Loc,0); - D.ReadPtr(dr->Setter,false); - D.ReadPtr(dr->Getter,false); - return dr; -} - -void ObjCMessageExpr::EmitImpl(Serializer& S) const { - S.EmitInt(getFlag()); - S.Emit(getType()); - S.Emit(SelName); - S.Emit(LBracloc); - S.Emit(RBracloc); - S.EmitInt(NumArgs); - S.EmitPtr(MethodProto); - - if (getReceiver()) - S.BatchEmitOwnedPtrs(NumArgs+1, SubExprs); - else { - ClassInfo Info = getClassInfo(); - - if (Info.first) S.EmitPtr(Info.first); - else S.EmitPtr(Info.second); - - S.BatchEmitOwnedPtrs(NumArgs, &SubExprs[ARGS_START]); - } -} - -ObjCMessageExpr* ObjCMessageExpr::CreateImpl(Deserializer& D, ASTContext& C) { - unsigned flags = D.ReadInt(); - QualType t = QualType::ReadVal(D); - Selector S = Selector::ReadVal(D); - SourceLocation L = SourceLocation::ReadVal(D); - SourceLocation R = SourceLocation::ReadVal(D); - - // Construct an array for the subexpressions. - unsigned NumArgs = D.ReadInt(); - Stmt** SubExprs = new Stmt*[NumArgs+1]; - - // Construct the ObjCMessageExpr object using the special ctor. - ObjCMessageExpr* ME = new ObjCMessageExpr(S, t, L, R, SubExprs, NumArgs); - - // Read in the MethodProto. Read the instance variable directly - // allows it to be backpatched. - D.ReadPtr(ME->MethodProto); - - // Now read in the arguments. - - if ((flags & Flags) == IsInstMeth) - D.BatchReadOwnedPtrs(NumArgs+1, SubExprs, C); - else { - // Read the pointer for Cls/ClassName. The Deserializer will handle the - // bit-mangling automatically. - SubExprs[RECEIVER] = (Stmt*) ((uintptr_t) flags); - D.ReadUIntPtr((uintptr_t&) SubExprs[RECEIVER]); - - // Read the arguments. - D.BatchReadOwnedPtrs(NumArgs, &SubExprs[ARGS_START], C); - } - - return ME; -} - -void ObjCSelectorExpr::EmitImpl(Serializer& S) const { - S.Emit(AtLoc); - S.Emit(RParenLoc); - S.Emit(getType()); - S.Emit(SelName); -} - -ObjCSelectorExpr* ObjCSelectorExpr::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation AtLoc = SourceLocation::ReadVal(D); - SourceLocation RParenLoc = SourceLocation::ReadVal(D); - QualType T = QualType::ReadVal(D); - Selector SelName = Selector::ReadVal(D); - - return new ObjCSelectorExpr(T,SelName,AtLoc,RParenLoc); -} - -void ObjCStringLiteral::EmitImpl(Serializer& S) const { - S.Emit(AtLoc); - S.Emit(getType()); - S.EmitOwnedPtr(String); -} - -ObjCStringLiteral* ObjCStringLiteral::CreateImpl(Deserializer& D, ASTContext& C) { - SourceLocation L = SourceLocation::ReadVal(D); - QualType T = QualType::ReadVal(D); - StringLiteral* String = cast<StringLiteral>(D.ReadOwnedPtr<Stmt>(C)); - return new ObjCStringLiteral(String,T,L); -} - -void ObjCSuperExpr::EmitImpl(llvm::Serializer& S) const { - S.Emit(getType()); - S.Emit(Loc); -} - -ObjCSuperExpr* ObjCSuperExpr::CreateImpl(llvm::Deserializer& D, ASTContext&) { - QualType Ty = QualType::ReadVal(D); - SourceLocation Loc = SourceLocation::ReadVal(D); - return new ObjCSuperExpr(Loc, Ty); -} - -//===----------------------------------------------------------------------===// -// Serialization for Clang Extensions. -//===----------------------------------------------------------------------===// - -void ExtVectorElementExpr::EmitImpl(llvm::Serializer& S) const { - S.Emit(getType()); - S.EmitOwnedPtr(getBase()); - S.EmitPtr(&Accessor); - S.Emit(AccessorLoc); -} - -ExtVectorElementExpr* CreateImpl(llvm::Deserializer& D, ASTContext& C) { - QualType T = QualType::ReadVal(D); - Expr *B = D.ReadOwnedPtr<Expr>(C); - IdentifierInfo *A = D.ReadPtr<IdentifierInfo>(); - SourceLocation AL = SourceLocation::ReadVal(D); - return new (C) ExtVectorElementExpr(T, B, *A, AL); -} - -void BlockExpr::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.EmitOwnedPtr(TheBlock); - S.EmitBool(HasBlockDeclRefExprs); -} - -BlockExpr* BlockExpr::CreateImpl(Deserializer& D, ASTContext& C) { - QualType T = QualType::ReadVal(D); - BlockDecl *B = cast<BlockDecl>(D.ReadOwnedPtr<Decl>(C)); - bool H = D.ReadBool(); - return new BlockExpr(B,T,H); -} - -void BlockDeclRefExpr::EmitImpl(Serializer& S) const { - S.Emit(Loc); - S.Emit(getType()); - S.EmitBool(false); - S.EmitPtr(getDecl()); -} - -BlockDeclRefExpr* BlockDeclRefExpr::CreateImpl(Deserializer& D, ASTContext& C) { - assert(0 && "Cannot deserialize BlockDeclRefExpr yet"); - return 0; -} - -//===----------------------------------------------------------------------===// -// C++ Serialization -//===----------------------------------------------------------------------===// -void CXXDefaultArgExpr::EmitImpl(Serializer& S) const { - S.EmitPtr(Param); -} - -CXXDefaultArgExpr *CXXDefaultArgExpr::CreateImpl(Deserializer& D, ASTContext& C) { - ParmVarDecl* Param = 0; - D.ReadPtr(Param, false); - return new CXXDefaultArgExpr(Param); -} - -void CXXFunctionalCastExpr::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.Emit(getTypeAsWritten()); - S.Emit(TyBeginLoc); - S.Emit(RParenLoc); - S.EmitOwnedPtr(getSubExpr()); -} - -CXXFunctionalCastExpr * -CXXFunctionalCastExpr::CreateImpl(Deserializer& D, ASTContext& C) { - QualType Ty = QualType::ReadVal(D); - QualType WrittenTy = QualType::ReadVal(D); - SourceLocation TyBeginLoc = SourceLocation::ReadVal(D); - SourceLocation RParenLoc = SourceLocation::ReadVal(D); - Expr* SubExpr = D.ReadOwnedPtr<Expr>(C); - return new CXXFunctionalCastExpr(Ty, WrittenTy, TyBeginLoc, SubExpr, RParenLoc); -} - -void CXXNamedCastExpr::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.Emit(getTypeAsWritten()); - S.Emit(Loc); - S.EmitOwnedPtr(getSubExpr()); -} - -CXXNamedCastExpr * -CXXNamedCastExpr::CreateImpl(Deserializer& D, ASTContext& C, StmtClass SC) { - QualType Ty = QualType::ReadVal(D); - QualType WrittenTy = QualType::ReadVal(D); - SourceLocation Loc = SourceLocation::ReadVal(D); - Expr* SubExpr = D.ReadOwnedPtr<Expr>(C); - switch (SC) { - case CXXStaticCastExprClass: - return new CXXStaticCastExpr(Ty, SubExpr, WrittenTy, Loc); - case CXXDynamicCastExprClass: - return new CXXDynamicCastExpr(Ty, SubExpr, WrittenTy, Loc); - case CXXReinterpretCastExprClass: - return new CXXReinterpretCastExpr(Ty, SubExpr, WrittenTy, Loc); - case CXXConstCastExprClass: - return new CXXConstCastExpr(Ty, SubExpr, WrittenTy, Loc); - default: - assert(false && "Unknown cast type!"); - return 0; - } -} - -void CXXTypeidExpr::EmitImpl(llvm::Serializer& S) const { - S.Emit(getType()); - S.EmitBool(isTypeOperand()); - if (isTypeOperand()) { - S.Emit(getTypeOperand()); - } else { - S.EmitOwnedPtr(getExprOperand()); - } - S.Emit(Range); -} - -CXXTypeidExpr* -CXXTypeidExpr::CreateImpl(llvm::Deserializer& D, ASTContext& C) { - QualType Ty = QualType::ReadVal(D); - bool isTypeOp = D.ReadBool(); - void *Operand; - if (isTypeOp) { - Operand = QualType::ReadVal(D).getAsOpaquePtr(); - } else { - Operand = D.ReadOwnedPtr<Expr>(C); - } - SourceRange Range = SourceRange::ReadVal(D); - return new CXXTypeidExpr(isTypeOp, Operand, Ty, Range); -} - -void CXXThisExpr::EmitImpl(llvm::Serializer& S) const { - S.Emit(getType()); - S.Emit(Loc); -} - -CXXThisExpr* CXXThisExpr::CreateImpl(llvm::Deserializer& D, ASTContext&) { - QualType Ty = QualType::ReadVal(D); - SourceLocation Loc = SourceLocation::ReadVal(D); - return new CXXThisExpr(Loc, Ty); -} - -void CXXTemporaryObjectExpr::EmitImpl(llvm::Serializer& S) const { - S.Emit(getType()); - S.Emit(TyBeginLoc); - S.Emit(RParenLoc); - S.EmitPtr(cast<Decl>(Constructor)); - S.EmitInt(NumArgs); - if (NumArgs > 0) - S.BatchEmitOwnedPtrs(NumArgs, Args); -} - -CXXTemporaryObjectExpr * -CXXTemporaryObjectExpr::CreateImpl(llvm::Deserializer& D, ASTContext& C) { - QualType writtenTy = QualType::ReadVal(D); - SourceLocation tyBeginLoc = SourceLocation::ReadVal(D); - SourceLocation rParenLoc = SourceLocation::ReadVal(D); - CXXConstructorDecl * Cons = cast_or_null<CXXConstructorDecl>(D.ReadPtr<Decl>()); - unsigned NumArgs = D.ReadInt(); - Stmt** Args = 0; - if (NumArgs > 0) { - Args = new Stmt*[NumArgs]; - D.BatchReadOwnedPtrs(NumArgs, Args, C); - } - - CXXTemporaryObjectExpr * Result - = new CXXTemporaryObjectExpr(Cons, writtenTy, tyBeginLoc, - (Expr**)Args, NumArgs, rParenLoc); - - if (NumArgs > 0) - delete [] Args; - - return Result; -} - - -void CXXZeroInitValueExpr::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.Emit(TyBeginLoc); - S.Emit(RParenLoc); -} - -CXXZeroInitValueExpr * -CXXZeroInitValueExpr::CreateImpl(Deserializer& D, ASTContext& C) { - QualType Ty = QualType::ReadVal(D); - SourceLocation TyBeginLoc = SourceLocation::ReadVal(D); - SourceLocation RParenLoc = SourceLocation::ReadVal(D); - return new CXXZeroInitValueExpr(Ty, TyBeginLoc, RParenLoc); -} - -void CXXNewExpr::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.EmitBool(GlobalNew); - S.EmitBool(ParenTypeId); - S.EmitBool(Initializer); - S.EmitBool(Array); - S.EmitInt(NumPlacementArgs); - S.EmitInt(NumConstructorArgs); - S.BatchEmitOwnedPtrs(NumPlacementArgs + NumConstructorArgs, SubExprs); - assert((OperatorNew == 0 || S.isRegistered(OperatorNew)) && - (OperatorDelete == 0 || S.isRegistered(OperatorDelete)) && - (Constructor == 0 || S.isRegistered(Constructor)) && - "CXXNewExpr cannot own declarations"); - S.EmitPtr(OperatorNew); - S.EmitPtr(OperatorDelete); - S.EmitPtr(Constructor); - S.Emit(StartLoc); - S.Emit(EndLoc); -} - -CXXNewExpr * -CXXNewExpr::CreateImpl(Deserializer& D, ASTContext& C) { - QualType T = QualType::ReadVal(D); - bool GlobalNew = D.ReadBool(); - bool ParenTypeId = D.ReadBool(); - bool Initializer = D.ReadBool(); - bool Array = D.ReadBool(); - unsigned NumPlacementArgs = D.ReadInt(); - unsigned NumConstructorArgs = D.ReadInt(); - unsigned TotalExprs = Array + NumPlacementArgs + NumConstructorArgs; - Stmt** SubExprs = new Stmt*[TotalExprs]; - D.BatchReadOwnedPtrs(TotalExprs, SubExprs, C); - FunctionDecl *OperatorNew = D.ReadPtr<FunctionDecl>(); - FunctionDecl *OperatorDelete = D.ReadPtr<FunctionDecl>(); - CXXConstructorDecl *Constructor = D.ReadPtr<CXXConstructorDecl>(); - SourceLocation StartLoc = SourceLocation::ReadVal(D); - SourceLocation EndLoc = SourceLocation::ReadVal(D); - - return new CXXNewExpr(T, GlobalNew, ParenTypeId, Initializer, Array, - NumPlacementArgs, NumConstructorArgs, SubExprs, - OperatorNew, OperatorDelete, Constructor, StartLoc, - EndLoc); -} - -void CXXDeleteExpr::EmitImpl(Serializer& S) const { - S.Emit(getType()); - S.EmitBool(GlobalDelete); - S.EmitBool(ArrayForm); - S.EmitPtr(OperatorDelete); - S.EmitOwnedPtr(Argument); - S.Emit(Loc); -} - -CXXDeleteExpr * -CXXDeleteExpr::CreateImpl(Deserializer& D, ASTContext& C) { - QualType Ty = QualType::ReadVal(D); - bool GlobalDelete = D.ReadBool(); - bool ArrayForm = D.ReadBool(); - FunctionDecl *OperatorDelete = D.ReadPtr<FunctionDecl>(); - Stmt *Argument = D.ReadOwnedPtr<Stmt>(C); - SourceLocation Loc = SourceLocation::ReadVal(D); - return new CXXDeleteExpr(Ty, GlobalDelete, ArrayForm, OperatorDelete, - cast<Expr>(Argument), Loc); -} - -void UnresolvedFunctionNameExpr::EmitImpl(llvm::Serializer& S) const { - S.Emit(getType()); - S.EmitPtr(Name.getAsIdentifierInfo()); // FIXME: WRONG! - S.Emit(Loc); -} - -UnresolvedFunctionNameExpr * -UnresolvedFunctionNameExpr::CreateImpl(llvm::Deserializer& D, ASTContext& C) { - QualType Ty = QualType::ReadVal(D); - IdentifierInfo *N = D.ReadPtr<IdentifierInfo>(); - SourceLocation L = SourceLocation::ReadVal(D); - return new UnresolvedFunctionNameExpr(N, Ty, L); -} - -void UnaryTypeTraitExpr::EmitImpl(llvm::Serializer& S) const { - S.EmitInt(UTT); - S.Emit(Loc); - S.Emit(RParen); - S.Emit(QueriedType); - S.Emit(getType()); -} - -UnaryTypeTraitExpr * -UnaryTypeTraitExpr::CreateImpl(llvm::Deserializer& D, ASTContext& C) { - UnaryTypeTrait UTT = static_cast<UnaryTypeTrait>(D.ReadInt()); - SourceLocation Loc = SourceLocation::ReadVal(D); - SourceLocation RParen = SourceLocation::ReadVal(D); - QualType QueriedType = QualType::ReadVal(D); - QualType Ty = QualType::ReadVal(D); - return new UnaryTypeTraitExpr(Loc, UTT, QueriedType, RParen, Ty); -} - -void CXXCatchStmt::EmitImpl(llvm::Serializer& S) const { - S.Emit(CatchLoc); - S.EmitOwnedPtr(ExceptionDecl); - S.EmitOwnedPtr(HandlerBlock); -} - -CXXCatchStmt * -CXXCatchStmt::CreateImpl(llvm::Deserializer& D, ASTContext& C) { - SourceLocation CatchLoc = SourceLocation::ReadVal(D); - Decl *ExDecl = D.ReadOwnedPtr<Decl>(C); - Stmt *HandlerBlock = D.ReadOwnedPtr<Stmt>(C); - return new CXXCatchStmt(CatchLoc, ExDecl, HandlerBlock); -} - -void CXXTryStmt::EmitImpl(llvm::Serializer& S) const { - S.Emit(TryLoc); - S.EmitInt(Stmts.size()); - S.BatchEmitOwnedPtrs(Stmts.size(), &Stmts[0]); -} - -CXXTryStmt * -CXXTryStmt::CreateImpl(llvm::Deserializer& D, ASTContext& C) { - SourceLocation TryLoc = SourceLocation::ReadVal(D); - unsigned size = D.ReadInt(); - llvm::SmallVector<Stmt*, 4> Stmts(size); - D.BatchReadOwnedPtrs<Stmt>(size, &Stmts[0], C); - - return new CXXTryStmt(TryLoc, Stmts[0], &Stmts[1], size - 1); -} - -void QualifiedDeclRefExpr::EmitImpl(llvm::Serializer& S) const { - DeclRefExpr::EmitImpl(S); - S.Emit(QualifierRange); - // FIXME: Serialize nested-name-specifiers -} - -QualifiedDeclRefExpr* -QualifiedDeclRefExpr::CreateImpl(llvm::Deserializer& D, ASTContext& C) { - assert(false && "Cannot deserialize qualified decl references"); - return 0; -} diff --git a/clang/lib/AST/TypeSerialization.cpp b/clang/lib/AST/TypeSerialization.cpp deleted file mode 100644 index 0562416da01..00000000000 --- a/clang/lib/AST/TypeSerialization.cpp +++ /dev/null @@ -1,490 +0,0 @@ -//===--- TypeSerialization.cpp - Serialization of Decls ---------*- 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 methods that implement bitcode serialization for Types. -// -//===----------------------------------------------------------------------===// - -#include "clang/AST/Type.h" -#include "clang/AST/Decl.h" -#include "clang/AST/DeclTemplate.h" -#include "clang/AST/Expr.h" -#include "clang/AST/ASTContext.h" -#include "llvm/Bitcode/Serialize.h" -#include "llvm/Bitcode/Deserialize.h" - -using namespace clang; -using llvm::Serializer; -using llvm::Deserializer; -using llvm::SerializedPtrID; - - -void QualType::Emit(Serializer& S) const { - S.EmitPtr(getTypePtr()); - S.EmitInt(getCVRQualifiers()); -} - -QualType QualType::ReadVal(Deserializer& D) { - uintptr_t Val; - D.ReadUIntPtr(Val, false); - return QualType(reinterpret_cast<Type*>(Val), D.ReadInt()); -} - -void QualType::ReadBackpatch(Deserializer& D) { - uintptr_t Val; - D.ReadUIntPtr(Val, false); - - Value.setPointer(reinterpret_cast<Type*>(Val)); - Value.setInt(D.ReadInt()); -} - -//===----------------------------------------------------------------------===// -// Type Serialization: Dispatch code to handle specific types. -//===----------------------------------------------------------------------===// - -void Type::Emit(Serializer& S) const { - S.EmitInt(getTypeClass()); - S.EmitPtr(this); - - if (!isa<BuiltinType>(this)) - EmitImpl(S); -} - -void Type::Create(ASTContext& Context, unsigned i, Deserializer& D) { - Type::TypeClass K = static_cast<Type::TypeClass>(D.ReadInt()); - SerializedPtrID PtrID = D.ReadPtrID(); - - switch (K) { - default: - assert (false && "Deserialization for type not supported."); - break; - - case Type::Builtin: - assert (i < Context.getTypes().size()); - assert (isa<BuiltinType>(Context.getTypes()[i])); - D.RegisterPtr(PtrID,Context.getTypes()[i]); - break; - - case Type::ExtQual: - D.RegisterPtr(PtrID,ExtQualType::CreateImpl(Context,D)); - break; - - case Type::Complex: - D.RegisterPtr(PtrID,ComplexType::CreateImpl(Context,D)); - break; - - case Type::ConstantArray: - D.RegisterPtr(PtrID,ConstantArrayType::CreateImpl(Context,D)); - break; - - case Type::FunctionNoProto: - D.RegisterPtr(PtrID,FunctionNoProtoType::CreateImpl(Context,D)); - break; - - case Type::FunctionProto: - D.RegisterPtr(PtrID,FunctionProtoType::CreateImpl(Context,D)); - break; - - case Type::IncompleteArray: - D.RegisterPtr(PtrID,IncompleteArrayType::CreateImpl(Context,D)); - break; - - case Type::MemberPointer: - D.RegisterPtr(PtrID, MemberPointerType::CreateImpl(Context, D)); - break; - - case Type::Pointer: - D.RegisterPtr(PtrID, PointerType::CreateImpl(Context, D)); - break; - - case Type::BlockPointer: - D.RegisterPtr(PtrID, BlockPointerType::CreateImpl(Context, D)); - break; - - case Type::LValueReference: - D.RegisterPtr(PtrID, LValueReferenceType::CreateImpl(Context, D)); - break; - - case Type::RValueReference: - D.RegisterPtr(PtrID, RValueReferenceType::CreateImpl(Context, D)); - break; - - case Type::Record: - case Type::Enum: - // FIXME: Implement this! - assert(false && "Can't deserialize tag types!"); - break; - - case Type::Typedef: - D.RegisterPtr(PtrID, TypedefType::CreateImpl(Context, D)); - break; - - case Type::TypeOfExpr: - D.RegisterPtr(PtrID, TypeOfExprType::CreateImpl(Context, D)); - break; - - case Type::TypeOf: - D.RegisterPtr(PtrID, TypeOfType::CreateImpl(Context, D)); - break; - - case Type::TemplateTypeParm: - D.RegisterPtr(PtrID, TemplateTypeParmType::CreateImpl(Context, D)); - break; - - case Type::VariableArray: - D.RegisterPtr(PtrID, VariableArrayType::CreateImpl(Context, D)); - break; - } -} - -//===----------------------------------------------------------------------===// -// ExtQualType -//===----------------------------------------------------------------------===// - -void ExtQualType::EmitImpl(Serializer& S) const { - S.EmitPtr(getBaseType()); - S.EmitInt(getAddressSpace()); -} - -Type* ExtQualType::CreateImpl(ASTContext& Context, Deserializer& D) { - QualType BaseTy = QualType::ReadVal(D); - unsigned AddressSpace = D.ReadInt(); - return Context.getAddrSpaceQualType(BaseTy, AddressSpace).getTypePtr(); -} - -//===----------------------------------------------------------------------===// -// BlockPointerType -//===----------------------------------------------------------------------===// - -void BlockPointerType::EmitImpl(Serializer& S) const { - S.Emit(getPointeeType()); -} - -Type* BlockPointerType::CreateImpl(ASTContext& Context, Deserializer& D) { - return Context.getBlockPointerType(QualType::ReadVal(D)).getTypePtr(); -} - -//===----------------------------------------------------------------------===// -// ComplexType -//===----------------------------------------------------------------------===// - -void ComplexType::EmitImpl(Serializer& S) const { - S.Emit(getElementType()); -} - -Type* ComplexType::CreateImpl(ASTContext& Context, Deserializer& D) { - return Context.getComplexType(QualType::ReadVal(D)).getTypePtr(); -} - -//===----------------------------------------------------------------------===// -// ConstantArray -//===----------------------------------------------------------------------===// - -void ConstantArrayType::EmitImpl(Serializer& S) const { - S.Emit(getElementType()); - S.EmitInt(getSizeModifier()); - S.EmitInt(getIndexTypeQualifier()); - S.Emit(Size); -} - -Type* ConstantArrayType::CreateImpl(ASTContext& Context, Deserializer& D) { - QualType ElTy = QualType::ReadVal(D); - ArraySizeModifier am = static_cast<ArraySizeModifier>(D.ReadInt()); - unsigned ITQ = D.ReadInt(); - - llvm::APInt Size; - D.Read(Size); - - return Context.getConstantArrayType(ElTy,Size,am,ITQ).getTypePtr(); -} - -//===----------------------------------------------------------------------===// -// FunctionNoProtoType -//===----------------------------------------------------------------------===// - -void FunctionNoProtoType::EmitImpl(Serializer& S) const { - S.Emit(getResultType()); -} - -Type* FunctionNoProtoType::CreateImpl(ASTContext& Context, Deserializer& D) { - return Context.getFunctionNoProtoType(QualType::ReadVal(D)).getTypePtr(); -} - -//===----------------------------------------------------------------------===// -// FunctionProtoType -//===----------------------------------------------------------------------===// - -void FunctionProtoType::EmitImpl(Serializer& S) const { - S.Emit(getResultType()); - S.EmitBool(isVariadic()); - S.EmitInt(getTypeQuals()); - S.EmitInt(getNumArgs()); - - for (arg_type_iterator I=arg_type_begin(), E=arg_type_end(); I!=E; ++I) - S.Emit(*I); -} - -Type* FunctionProtoType::CreateImpl(ASTContext& Context, Deserializer& D) { - QualType ResultType = QualType::ReadVal(D); - bool isVariadic = D.ReadBool(); - unsigned TypeQuals = D.ReadInt(); - unsigned NumArgs = D.ReadInt(); - - llvm::SmallVector<QualType,15> Args; - - for (unsigned j = 0; j < NumArgs; ++j) - Args.push_back(QualType::ReadVal(D)); - - return Context.getFunctionType(ResultType,&*Args.begin(), - NumArgs,isVariadic,TypeQuals).getTypePtr(); -} - -//===----------------------------------------------------------------------===// -// PointerType -//===----------------------------------------------------------------------===// - -void PointerType::EmitImpl(Serializer& S) const { - S.Emit(getPointeeType()); -} - -Type* PointerType::CreateImpl(ASTContext& Context, Deserializer& D) { - return Context.getPointerType(QualType::ReadVal(D)).getTypePtr(); -} - -//===----------------------------------------------------------------------===// -// ReferenceType -//===----------------------------------------------------------------------===// - -void ReferenceType::EmitImpl(Serializer& S) const { - S.Emit(getPointeeType()); -} - -Type* LValueReferenceType::CreateImpl(ASTContext& Context, Deserializer& D) { - return Context.getLValueReferenceType(QualType::ReadVal(D)).getTypePtr(); -} - -Type* RValueReferenceType::CreateImpl(ASTContext& Context, Deserializer& D) { - return Context.getRValueReferenceType(QualType::ReadVal(D)).getTypePtr(); -} - -//===----------------------------------------------------------------------===// -// MemberPointerType -//===----------------------------------------------------------------------===// - -void MemberPointerType::EmitImpl(Serializer& S) const { - S.Emit(getPointeeType()); - S.Emit(QualType(Class, 0)); -} - -Type* MemberPointerType::CreateImpl(ASTContext& Context, Deserializer& D) { - QualType Pointee = QualType::ReadVal(D); - QualType Class = QualType::ReadVal(D); - return Context.getMemberPointerType(Pointee, Class.getTypePtr()).getTypePtr(); -} - -//===----------------------------------------------------------------------===// -// TagType -//===----------------------------------------------------------------------===// - -void TagType::EmitImpl(Serializer& S) const { - S.EmitOwnedPtr(getDecl()); -} - -Type* TagType::CreateImpl(ASTContext& Context, Deserializer& D) { - std::vector<Type*>& Types = - const_cast<std::vector<Type*>&>(Context.getTypes()); - - // FIXME: This is wrong: we need the subclasses to do the - // (de-)serialization. - TagType* T = new TagType(Record, NULL,QualType()); - Types.push_back(T); - - // Deserialize the decl. - T->decl.setPointer(cast<TagDecl>(D.ReadOwnedPtr<Decl>(Context))); - T->decl.setInt(0); - - return T; -} - -//===----------------------------------------------------------------------===// -// TypedefType -//===----------------------------------------------------------------------===// - -void TypedefType::EmitImpl(Serializer& S) const { - S.Emit(getCanonicalTypeInternal()); - S.EmitPtr(Decl); -} - -Type* TypedefType::CreateImpl(ASTContext& Context, Deserializer& D) { - std::vector<Type*>& Types = - const_cast<std::vector<Type*>&>(Context.getTypes()); - - TypedefType* T = new TypedefType(Type::Typedef, NULL, QualType::ReadVal(D)); - Types.push_back(T); - - D.ReadPtr(T->Decl); // May be backpatched. - return T; -} - -//===----------------------------------------------------------------------===// -// TypeOfExprType -//===----------------------------------------------------------------------===// - -void TypeOfExprType::EmitImpl(llvm::Serializer& S) const { - S.EmitOwnedPtr(TOExpr); -} - -Type* TypeOfExprType::CreateImpl(ASTContext& Context, Deserializer& D) { - Expr* E = D.ReadOwnedPtr<Expr>(Context); - - std::vector<Type*>& Types = - const_cast<std::vector<Type*>&>(Context.getTypes()); - - TypeOfExprType* T - = new TypeOfExprType(E, Context.getCanonicalType(E->getType())); - Types.push_back(T); - - return T; -} - -//===----------------------------------------------------------------------===// -// TypeOfType -//===----------------------------------------------------------------------===// - -void TypeOfType::EmitImpl(llvm::Serializer& S) const { - S.Emit(TOType); -} - -Type* TypeOfType::CreateImpl(ASTContext& Context, Deserializer& D) { - QualType TOType = QualType::ReadVal(D); - - std::vector<Type*>& Types = - const_cast<std::vector<Type*>&>(Context.getTypes()); - - TypeOfType* T = new TypeOfType(TOType, Context.getCanonicalType(TOType)); - Types.push_back(T); - - return T; -} - -//===----------------------------------------------------------------------===// -// TemplateTypeParmType -//===----------------------------------------------------------------------===// - -void TemplateTypeParmType::EmitImpl(Serializer& S) const { - S.EmitInt(Depth); - S.EmitInt(Index); - S.EmitPtr(Name); -} - -Type* TemplateTypeParmType::CreateImpl(ASTContext& Context, Deserializer& D) { - unsigned Depth = D.ReadInt(); - unsigned Index = D.ReadInt(); - IdentifierInfo *Name = D.ReadPtr<IdentifierInfo>(); - return Context.getTemplateTypeParmType(Depth, Index, Name).getTypePtr(); -} - -//===----------------------------------------------------------------------===// -// TemplateSpecializationType -//===----------------------------------------------------------------------===// - -void TemplateSpecializationType::EmitImpl(Serializer& S) const { - // FIXME: Serialization support -} - -Type* -TemplateSpecializationType:: -CreateImpl(ASTContext& Context, Deserializer& D) { - // FIXME: Deserialization support - return 0; -} - -//===----------------------------------------------------------------------===// -// QualifiedNameType -//===----------------------------------------------------------------------===// -void QualifiedNameType::EmitImpl(llvm::Serializer& S) const { - // FIXME: Serialize the actual components -} - -Type* -QualifiedNameType::CreateImpl(ASTContext& Context, llvm::Deserializer& D) { - // FIXME: Implement de-serialization - return 0; -} - -//===----------------------------------------------------------------------===// -// TypenameType -//===----------------------------------------------------------------------===// -void TypenameType::EmitImpl(llvm::Serializer& S) const { - // FIXME: Serialize the actual components -} - -Type* -TypenameType::CreateImpl(ASTContext& Context, llvm::Deserializer& D) { - // FIXME: Implement de-serialization - return 0; -} - -//===----------------------------------------------------------------------===// -// VariableArrayType -//===----------------------------------------------------------------------===// - -void VariableArrayType::EmitImpl(Serializer& S) const { - S.Emit(getElementType()); - S.EmitInt(getSizeModifier()); - S.EmitInt(getIndexTypeQualifier()); - S.EmitOwnedPtr(SizeExpr); -} - -Type* VariableArrayType::CreateImpl(ASTContext& Context, Deserializer& D) { - QualType ElTy = QualType::ReadVal(D); - ArraySizeModifier am = static_cast<ArraySizeModifier>(D.ReadInt()); - unsigned ITQ = D.ReadInt(); - Expr* SizeExpr = D.ReadOwnedPtr<Expr>(Context); - - return Context.getVariableArrayType(ElTy,SizeExpr,am,ITQ).getTypePtr(); -} - -//===----------------------------------------------------------------------===// -// DependentSizedArrayType -//===----------------------------------------------------------------------===// - -void DependentSizedArrayType::EmitImpl(Serializer& S) const { - S.Emit(getElementType()); - S.EmitInt(getSizeModifier()); - S.EmitInt(getIndexTypeQualifier()); - S.EmitOwnedPtr(SizeExpr); -} - -Type* DependentSizedArrayType::CreateImpl(ASTContext& Context, Deserializer& D) { - QualType ElTy = QualType::ReadVal(D); - ArraySizeModifier am = static_cast<ArraySizeModifier>(D.ReadInt()); - unsigned ITQ = D.ReadInt(); - Expr* SizeExpr = D.ReadOwnedPtr<Expr>(Context); - - return Context.getDependentSizedArrayType(ElTy,SizeExpr,am,ITQ).getTypePtr(); -} - -//===----------------------------------------------------------------------===// -// IncompleteArrayType -//===----------------------------------------------------------------------===// - -void IncompleteArrayType::EmitImpl(Serializer& S) const { - S.Emit(getElementType()); - S.EmitInt(getSizeModifier()); - S.EmitInt(getIndexTypeQualifier()); -} - -Type* IncompleteArrayType::CreateImpl(ASTContext& Context, Deserializer& D) { - QualType ElTy = QualType::ReadVal(D); - ArraySizeModifier am = static_cast<ArraySizeModifier>(D.ReadInt()); - unsigned ITQ = D.ReadInt(); - - return Context.getIncompleteArrayType(ElTy,am,ITQ).getTypePtr(); -} diff --git a/clang/lib/Basic/CMakeLists.txt b/clang/lib/Basic/CMakeLists.txt index a3731cb4946..1cbf11c2bfb 100644 --- a/clang/lib/Basic/CMakeLists.txt +++ b/clang/lib/Basic/CMakeLists.txt @@ -5,7 +5,6 @@ add_clang_library(clangBasic Diagnostic.cpp FileManager.cpp IdentifierTable.cpp - LangOptions.cpp SourceLocation.cpp SourceManager.cpp TargetInfo.cpp diff --git a/clang/lib/Basic/FileManager.cpp b/clang/lib/Basic/FileManager.cpp index 773d3666756..2cd140d95ed 100644 --- a/clang/lib/Basic/FileManager.cpp +++ b/clang/lib/Basic/FileManager.cpp @@ -19,8 +19,6 @@ #include "clang/Basic/FileManager.h" #include "llvm/ADT/SmallString.h" -#include "llvm/Bitcode/Serialize.h" -#include "llvm/Bitcode/Deserialize.h" #include "llvm/Support/Streams.h" #include "llvm/Config/config.h" using namespace clang; diff --git a/clang/lib/Basic/IdentifierTable.cpp b/clang/lib/Basic/IdentifierTable.cpp index 78758d71888..344c4eb18dc 100644 --- a/clang/lib/Basic/IdentifierTable.cpp +++ b/clang/lib/Basic/IdentifierTable.cpp @@ -16,8 +16,6 @@ #include "clang/Basic/LangOptions.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/DenseMap.h" -#include "llvm/Bitcode/Serialize.h" -#include "llvm/Bitcode/Deserialize.h" #include <cstdio> using namespace clang; @@ -54,10 +52,6 @@ IdentifierTable::IdentifierTable(const LangOptions &LangOpts, AddKeywords(LangOpts); } -// This cstor is intended to be used only for serialization. -IdentifierTable::IdentifierTable() - : HashTable(8192), ExternalLookup(0) { } - //===----------------------------------------------------------------------===// // Language Keyword Implementation //===----------------------------------------------------------------------===// @@ -264,7 +258,6 @@ namespace clang { /// this class is provided strictly through Selector. class MultiKeywordSelector : public DeclarationNameExtra, public llvm::FoldingSetNode { - friend SelectorTable* SelectorTable::CreateAndRegister(llvm::Deserializer&); MultiKeywordSelector(unsigned nKeys) { ExtraKindOrNumArgs = NUM_EXTRA_KINDS + nKeys; } @@ -414,155 +407,3 @@ SelectorTable::~SelectorTable() { delete &getSelectorTableImpl(Impl); } -//===----------------------------------------------------------------------===// -// Serialization for IdentifierInfo and IdentifierTable. -//===----------------------------------------------------------------------===// - -void IdentifierInfo::Emit(llvm::Serializer& S) const { - S.EmitInt(getTokenID()); - S.EmitInt(getBuiltinID()); - S.EmitInt(getObjCKeywordID()); - S.EmitBool(hasMacroDefinition()); - S.EmitBool(isExtensionToken()); - S.EmitBool(isPoisoned()); - S.EmitBool(isCPlusPlusOperatorKeyword()); - // FIXME: FETokenInfo -} - -void IdentifierInfo::Read(llvm::Deserializer& D) { - setTokenID((tok::TokenKind) D.ReadInt()); - setBuiltinID(D.ReadInt()); - setObjCKeywordID((tok::ObjCKeywordKind) D.ReadInt()); - setHasMacroDefinition(D.ReadBool()); - setIsExtensionToken(D.ReadBool()); - setIsPoisoned(D.ReadBool()); - setIsCPlusPlusOperatorKeyword(D.ReadBool()); - // FIXME: FETokenInfo -} - -void IdentifierTable::Emit(llvm::Serializer& S) const { - S.EnterBlock(); - - S.EmitPtr(this); - - for (iterator I=begin(), E=end(); I != E; ++I) { - const char* Key = I->getKeyData(); - const IdentifierInfo* Info = I->getValue(); - - bool KeyRegistered = S.isRegistered(Key); - bool InfoRegistered = S.isRegistered(Info); - - if (KeyRegistered || InfoRegistered) { - // These acrobatics are so that we don't incur the cost of registering - // a pointer with the backpatcher during deserialization if nobody - // references the object. - S.EmitPtr(InfoRegistered ? Info : NULL); - S.EmitPtr(KeyRegistered ? Key : NULL); - S.EmitCStr(Key); - S.Emit(*Info); - } - } - - S.ExitBlock(); -} - -IdentifierTable* IdentifierTable::CreateAndRegister(llvm::Deserializer& D) { - llvm::Deserializer::Location BLoc = D.getCurrentBlockLocation(); - - std::vector<char> buff; - buff.reserve(200); - - IdentifierTable* t = new IdentifierTable(); - D.RegisterPtr(t); - - while (!D.FinishedBlock(BLoc)) { - llvm::SerializedPtrID InfoPtrID = D.ReadPtrID(); - llvm::SerializedPtrID KeyPtrID = D.ReadPtrID(); - - D.ReadCStr(buff); - IdentifierInfo *II = &t->get(&buff[0], &buff[0] + buff.size()); - II->Read(D); - - if (InfoPtrID) D.RegisterPtr(InfoPtrID, II); - if (KeyPtrID) D.RegisterPtr(KeyPtrID, II->getName()); - } - - return t; -} - -//===----------------------------------------------------------------------===// -// Serialization for Selector and SelectorTable. -//===----------------------------------------------------------------------===// - -void Selector::Emit(llvm::Serializer& S) const { - S.EmitInt(getIdentifierInfoFlag()); - S.EmitPtr(reinterpret_cast<void*>(InfoPtr & ~ArgFlags)); -} - -Selector Selector::ReadVal(llvm::Deserializer& D) { - unsigned flag = D.ReadInt(); - - uintptr_t ptr; - D.ReadUIntPtr(ptr,false); // No backpatching. - - return Selector(ptr | flag); -} - -void SelectorTable::Emit(llvm::Serializer& S) const { - typedef llvm::FoldingSet<MultiKeywordSelector>::iterator iterator; - llvm::FoldingSet<MultiKeywordSelector> *SelTab; - SelTab = static_cast<llvm::FoldingSet<MultiKeywordSelector> *>(Impl); - - S.EnterBlock(); - - S.EmitPtr(this); - - for (iterator I=SelTab->begin(), E=SelTab->end(); I != E; ++I) { - if (!S.isRegistered(&*I)) - continue; - - S.FlushRecord(); // Start a new record. - - S.EmitPtr(&*I); - S.EmitInt(I->getNumArgs()); - - for (MultiKeywordSelector::keyword_iterator KI = I->keyword_begin(), - KE = I->keyword_end(); KI != KE; ++KI) - S.EmitPtr(*KI); - } - - S.ExitBlock(); -} - -SelectorTable* SelectorTable::CreateAndRegister(llvm::Deserializer& D) { - llvm::Deserializer::Location BLoc = D.getCurrentBlockLocation(); - - SelectorTable* t = new SelectorTable(); - D.RegisterPtr(t); - - llvm::FoldingSet<MultiKeywordSelector>& SelTab = - *static_cast<llvm::FoldingSet<MultiKeywordSelector>*>(t->Impl); - - while (!D.FinishedBlock(BLoc)) { - - llvm::SerializedPtrID PtrID = D.ReadPtrID(); - unsigned nKeys = D.ReadInt(); - - MultiKeywordSelector *SI = - (MultiKeywordSelector*)malloc(sizeof(MultiKeywordSelector) + - nKeys*sizeof(IdentifierInfo *)); - - new (SI) MultiKeywordSelector(nKeys); - - D.RegisterPtr(PtrID,SI); - - IdentifierInfo **KeyInfo = reinterpret_cast<IdentifierInfo **>(SI+1); - - for (unsigned i = 0; i != nKeys; ++i) - D.ReadPtr(KeyInfo[i],false); - - SelTab.GetOrInsertNode(SI); - } - - return t; -} diff --git a/clang/lib/Basic/LangOptions.cpp b/clang/lib/Basic/LangOptions.cpp deleted file mode 100644 index 6119afc7906..00000000000 --- a/clang/lib/Basic/LangOptions.cpp +++ /dev/null @@ -1,60 +0,0 @@ -//===--- LangOptions.cpp - Language feature info --------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file implements the methods for LangOptions. -// -//===----------------------------------------------------------------------===// - -#include "clang/Basic/LangOptions.h" -#include "llvm/Bitcode/Serialize.h" -#include "llvm/Bitcode/Deserialize.h" - -using namespace clang; - -void LangOptions::Emit(llvm::Serializer& S) const { - S.EmitBool((bool) Trigraphs); - S.EmitBool((bool) BCPLComment); - S.EmitBool((bool) DollarIdents); - S.EmitBool((bool) Digraphs); - S.EmitBool((bool) HexFloats); - S.EmitBool((bool) C99); - S.EmitBool((bool) Microsoft); - S.EmitBool((bool) CPlusPlus); - S.EmitBool((bool) CPlusPlus0x); - S.EmitBool((bool) NoExtensions); - S.EmitBool((bool) CXXOperatorNames); - S.EmitBool((bool) ObjC1); - S.EmitBool((bool) ObjC2); - S.EmitBool((unsigned) GC); - S.EmitBool((bool) PascalStrings); - S.EmitBool((bool) Boolean); - S.EmitBool((bool) WritableStrings); - S.EmitBool((bool) LaxVectorConversions); -} - -void LangOptions::Read(llvm::Deserializer& D) { - Trigraphs = D.ReadBool() ? 1 : 0; - BCPLComment = D.ReadBool() ? 1 : 0; - DollarIdents = D.ReadBool() ? 1 : 0; - Digraphs = D.ReadBool() ? 1 : 0; - HexFloats = D.ReadBool() ? 1 : 0; - C99 = D.ReadBool() ? 1 : 0; - Microsoft = D.ReadBool() ? 1 : 0; - CPlusPlus = D.ReadBool() ? 1 : 0; - CPlusPlus0x = D.ReadBool() ? 1 : 0; - NoExtensions = D.ReadBool() ? 1 : 0; - CXXOperatorNames = D.ReadBool() ? 1 : 0; - ObjC1 = D.ReadBool() ? 1 : 0; - ObjC2 = D.ReadBool() ? 1 : 0; - GC = D.ReadInt(); - PascalStrings = D.ReadBool() ? 1 : 0; - Boolean = D.ReadBool() ? 1 : 0; - WritableStrings = D.ReadBool() ? 1 : 0; - LaxVectorConversions = D.ReadBool() ? 1 : 0; -} diff --git a/clang/lib/Basic/SourceLocation.cpp b/clang/lib/Basic/SourceLocation.cpp index 82e24d00a2a..f21ec8b1e9d 100644 --- a/clang/lib/Basic/SourceLocation.cpp +++ b/clang/lib/Basic/SourceLocation.cpp @@ -7,7 +7,6 @@ // //===----------------------------------------------------------------------===// // -// This file defines serialization methods for the SourceLocation class. // This file defines accessor methods for the FullSourceLoc class. // //===----------------------------------------------------------------------===// @@ -15,8 +14,6 @@ #include "clang/Basic/SourceLocation.h" #include "clang/Basic/PrettyStackTrace.h" #include "clang/Basic/SourceManager.h" -#include "llvm/Bitcode/Serialize.h" -#include "llvm/Bitcode/Deserialize.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/raw_ostream.h" #include <cstdio> @@ -38,14 +35,6 @@ void PrettyStackTraceLoc::print(llvm::raw_ostream &OS) const { // SourceLocation //===----------------------------------------------------------------------===// -void SourceLocation::Emit(llvm::Serializer& S) const { - S.EmitInt(getRawEncoding()); -} - -SourceLocation SourceLocation::ReadVal(llvm::Deserializer& D) { - return SourceLocation::getFromRawEncoding(D.ReadInt()); -} - void SourceLocation::print(llvm::raw_ostream &OS, const SourceManager &SM)const{ if (!isValid()) { OS << "<invalid loc>"; @@ -71,17 +60,6 @@ void SourceLocation::dump(const SourceManager &SM) const { print(llvm::errs(), SM); } -void SourceRange::Emit(llvm::Serializer& S) const { - B.Emit(S); - E.Emit(S); -} - -SourceRange SourceRange::ReadVal(llvm::Deserializer& D) { - SourceLocation A = SourceLocation::ReadVal(D); - SourceLocation B = SourceLocation::ReadVal(D); - return SourceRange(A,B); -} - //===----------------------------------------------------------------------===// // FullSourceLoc //===----------------------------------------------------------------------===// diff --git a/clang/lib/Basic/SourceManager.cpp b/clang/lib/Basic/SourceManager.cpp index ed541bfc6bc..9ed21635259 100644 --- a/clang/lib/Basic/SourceManager.cpp +++ b/clang/lib/Basic/SourceManager.cpp @@ -17,10 +17,9 @@ #include "llvm/Support/Compiler.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/System/Path.h" -#include "llvm/Bitcode/Serialize.h" -#include "llvm/Bitcode/Deserialize.h" #include "llvm/Support/Streams.h" #include <algorithm> +#include <iostream> using namespace clang; using namespace SrcMgr; using llvm::MemoryBuffer; @@ -866,134 +865,3 @@ void SourceManager::PrintStats() const { llvm::cerr << "FileID scans: " << NumLinearScans << " linear, " << NumBinaryProbes << " binary.\n"; } - -//===----------------------------------------------------------------------===// -// Serialization. -//===----------------------------------------------------------------------===// - -void ContentCache::Emit(llvm::Serializer& S) const { - S.FlushRecord(); - S.EmitPtr(this); - - if (Entry) { - llvm::sys::Path Fname(Buffer->getBufferIdentifier()); - - if (Fname.isAbsolute()) - S.EmitCStr(Fname.c_str()); - else { - // Create an absolute path. - // FIXME: This will potentially contain ".." and "." in the path. - llvm::sys::Path path = llvm::sys::Path::GetCurrentDirectory(); - path.appendComponent(Fname.c_str()); - S.EmitCStr(path.c_str()); - } - } - else { - const char* p = Buffer->getBufferStart(); - const char* e = Buffer->getBufferEnd(); - - S.EmitInt(e-p); - - for ( ; p != e; ++p) - S.EmitInt(*p); - } - - S.FlushRecord(); -} - -void ContentCache::ReadToSourceManager(llvm::Deserializer& D, - SourceManager& SMgr, - FileManager* FMgr, - std::vector<char>& Buf) { - if (FMgr) { - llvm::SerializedPtrID PtrID = D.ReadPtrID(); - D.ReadCStr(Buf,false); - - // Create/fetch the FileEntry. - const char* start = &Buf[0]; - const FileEntry* E = FMgr->getFile(start,start+Buf.size()); - - // FIXME: Ideally we want a lazy materialization of the ContentCache - // anyway, because we don't want to read in source files unless this - // is absolutely needed. - if (!E) - D.RegisterPtr(PtrID,NULL); - else - // Get the ContextCache object and register it with the deserializer. - D.RegisterPtr(PtrID, SMgr.getOrCreateContentCache(E)); - return; - } - - // Register the ContextCache object with the deserializer. - /* FIXME: - ContentCache *Entry - SMgr.MemBufferInfos.push_back(ContentCache()); - = const_cast<ContentCache&>(SMgr.MemBufferInfos.back()); - D.RegisterPtr(&Entry); - - // Create the buffer. - unsigned Size = D.ReadInt(); - Entry.Buffer = MemoryBuffer::getNewUninitMemBuffer(Size); - - // Read the contents of the buffer. - char* p = const_cast<char*>(Entry.Buffer->getBufferStart()); - for (unsigned i = 0; i < Size ; ++i) - p[i] = D.ReadInt(); - */ -} - -void SourceManager::Emit(llvm::Serializer& S) const { - S.EnterBlock(); - S.EmitPtr(this); - S.EmitInt(MainFileID.getOpaqueValue()); - - // Emit: FileInfos. Just emit the file name. - S.EnterBlock(); - - // FIXME: Emit FileInfos. - //std::for_each(FileInfos.begin(), FileInfos.end(), - // S.MakeEmitter<ContentCache>()); - - S.ExitBlock(); - - // Emit: MemBufferInfos - S.EnterBlock(); - - /* FIXME: EMIT. - std::for_each(MemBufferInfos.begin(), MemBufferInfos.end(), - S.MakeEmitter<ContentCache>()); - */ - - S.ExitBlock(); - - // FIXME: Emit SLocEntryTable. - - S.ExitBlock(); -} - -SourceManager* -SourceManager::CreateAndRegister(llvm::Deserializer &D, FileManager &FMgr) { - SourceManager *M = new SourceManager(); - D.RegisterPtr(M); - - // Read: the FileID of the main source file of the translation unit. - M->MainFileID = FileID::get(D.ReadInt()); - - std::vector<char> Buf; - - /*{ // FIXME Read: FileInfos. - llvm::Deserializer::Location BLoc = D.getCurrentBlockLocation(); - while (!D.FinishedBlock(BLoc)) - ContentCache::ReadToSourceManager(D,*M,&FMgr,Buf); - }*/ - - /*{ // FIXME Read: MemBufferInfos. - llvm::Deserializer::Location BLoc = D.getCurrentBlockLocation(); - while (!D.FinishedBlock(BLoc)) - ContentCache::ReadToSourceManager(D,*M,NULL,Buf); - }*/ - - // FIXME: Read SLocEntryTable. - - return M; -} |
