From c0279a9826b1628934083b02276e505c19dcb703 Mon Sep 17 00:00:00 2001 From: Argyrios Kyrtzidis Date: Tue, 27 Jul 2010 22:37:14 +0000 Subject: [PATCH] Revert r109546, it broke linux build. llvm-svn: 109550 --- clang/include/clang/CodeGen/BackendUtil.h | 9 --- clang/lib/CodeGen/CodeGenModule.cpp | 98 +++++++++-------------- clang/lib/Frontend/PCHWriterDecl.cpp | 54 ++++++++++++- clang/test/PCH/cxx-required-decls.cpp | 1 - clang/test/PCH/cxx-required-decls.h | 3 - clang/tools/libclang/Makefile | 2 +- 6 files changed, 91 insertions(+), 76 deletions(-) diff --git a/clang/include/clang/CodeGen/BackendUtil.h b/clang/include/clang/CodeGen/BackendUtil.h index 193a0fb4d943..abcef8130dbc 100644 --- a/clang/include/clang/CodeGen/BackendUtil.h +++ b/clang/include/clang/CodeGen/BackendUtil.h @@ -19,7 +19,6 @@ namespace clang { class Diagnostic; class CodeGenOptions; class TargetOptions; - class Decl; enum BackendAction { Backend_EmitAssembly, ///< Emit native assembly files @@ -33,14 +32,6 @@ namespace clang { void EmitBackendOutput(Diagnostic &Diags, const CodeGenOptions &CGOpts, const TargetOptions &TOpts, llvm::Module *M, BackendAction Action, llvm::raw_ostream *OS); - - /// \brief Determines if the decl can be CodeGen'ed or deserialized from PCH - /// lazily, only when used; this is only relevant for function or file scoped - /// var definitions. - /// - /// \returns true if the function/var must be CodeGen'ed/deserialized even if - /// it is not used. - bool DeclIsRequiredFunctionOrFileScopedVar(const Decl *D); } #endif diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp index a574bb6a98be..057182d0392b 100644 --- a/clang/lib/CodeGen/CodeGenModule.cpp +++ b/clang/lib/CodeGen/CodeGenModule.cpp @@ -18,7 +18,6 @@ #include "CGObjCRuntime.h" #include "Mangle.h" #include "TargetInfo.h" -#include "clang/CodeGen/BackendUtil.h" #include "clang/Frontend/CodeGenOptions.h" #include "clang/AST/ASTContext.h" #include "clang/AST/CharUnits.h" @@ -324,11 +323,12 @@ void CodeGenModule::EmitAnnotations() { } static CodeGenModule::GVALinkage -GetLinkageForFunction(const FunctionDecl *FD, const LangOptions &Features) { +GetLinkageForFunction(ASTContext &Context, const FunctionDecl *FD, + const LangOptions &Features) { CodeGenModule::GVALinkage External = CodeGenModule::GVA_StrongExternal; Linkage L = FD->getLinkage(); - if (L == ExternalLinkage && Features.CPlusPlus && + if (L == ExternalLinkage && Context.getLangOptions().CPlusPlus && FD->getType()->getLinkage() == UniqueExternalLinkage) L = UniqueExternalLinkage; @@ -383,7 +383,7 @@ GetLinkageForFunction(const FunctionDecl *FD, const LangOptions &Features) { llvm::GlobalValue::LinkageTypes CodeGenModule::getFunctionLinkage(const FunctionDecl *D) { - GVALinkage Linkage = GetLinkageForFunction(D, Features); + GVALinkage Linkage = GetLinkageForFunction(getContext(), D, Features); if (Linkage == GVA_Internal) return llvm::Function::InternalLinkage; @@ -642,7 +642,7 @@ llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, } static CodeGenModule::GVALinkage -GetLinkageForVariable(const VarDecl *VD, const LangOptions &Features) { +GetLinkageForVariable(ASTContext &Context, const VarDecl *VD) { // If this is a static data member, compute the kind of template // specialization. Otherwise, this variable is not part of a // template. @@ -651,7 +651,7 @@ GetLinkageForVariable(const VarDecl *VD, const LangOptions &Features) { TSK = VD->getTemplateSpecializationKind(); Linkage L = VD->getLinkage(); - if (L == ExternalLinkage && Features.CPlusPlus && + if (L == ExternalLinkage && Context.getLangOptions().CPlusPlus && VD->getType()->getLinkage() == UniqueExternalLinkage) L = UniqueExternalLinkage; @@ -682,83 +682,61 @@ GetLinkageForVariable(const VarDecl *VD, const LangOptions &Features) { return CodeGenModule::GVA_StrongExternal; } -bool clang::DeclIsRequiredFunctionOrFileScopedVar(const Decl *D) { - if (const VarDecl *VD = dyn_cast(D)) { - if (!VD->isFileVarDecl()) - return false; - } else if (!isa(D)) +bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) { + // Never defer when EmitAllDecls is specified or the decl has + // attribute used. + if (Features.EmitAllDecls || Global->hasAttr()) return false; - // Aliases and used decls are required. - if (D->hasAttr() || D->hasAttr()) - return true; - - if (const FunctionDecl *FD = dyn_cast(D)) { - // Forward declarations aren't required. - if (!FD->isThisDeclarationADefinition()) + if (const FunctionDecl *FD = dyn_cast(Global)) { + // Constructors and destructors should never be deferred. + if (FD->hasAttr() || + FD->hasAttr()) return false; - // Constructors and destructors are required. - if (FD->hasAttr() || FD->hasAttr()) - return true; - - ASTContext &Ctx = FD->getASTContext(); - - // The key function for a class is required. - if (const CXXMethodDecl *MD = dyn_cast(FD)) { + // The key function for a class must never be deferred. + if (const CXXMethodDecl *MD = dyn_cast(Global)) { const CXXRecordDecl *RD = MD->getParent(); if (MD->isOutOfLine() && RD->isDynamicClass()) { - const CXXMethodDecl *KeyFunc = Ctx.getKeyFunction(RD); - if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl()) - return true; + const CXXMethodDecl *KeyFunction = getContext().getKeyFunction(RD); + if (KeyFunction && + KeyFunction->getCanonicalDecl() == MD->getCanonicalDecl()) + return false; } } - CodeGenModule::GVALinkage Linkage - = GetLinkageForFunction(FD, Ctx.getLangOptions()); + GVALinkage Linkage = GetLinkageForFunction(getContext(), FD, Features); // static, static inline, always_inline, and extern inline functions can // always be deferred. Normal inline functions can be deferred in C99/C++. // Implicit template instantiations can also be deferred in C++. - if (Linkage == CodeGenModule::GVA_Internal || - Linkage == CodeGenModule::GVA_C99Inline || - Linkage == CodeGenModule::GVA_CXXInline || - Linkage == CodeGenModule::GVA_TemplateInstantiation) - return false; - return true; + if (Linkage == GVA_Internal || Linkage == GVA_C99Inline || + Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) + return true; + return false; } - const VarDecl *VD = cast(D); - assert(VD->isFileVarDecl() && "Expected file scoped var"); - - // Structs that have non-trivial constructors or destructors are required. + const VarDecl *VD = cast(Global); + assert(VD->isFileVarDecl() && "Invalid decl"); + // We never want to defer structs that have non-trivial constructors or + // destructors. + // FIXME: Handle references. if (const RecordType *RT = VD->getType()->getAs()) { if (const CXXRecordDecl *RD = dyn_cast(RT->getDecl())) { if (!RD->hasTrivialConstructor() || !RD->hasTrivialDestructor()) - return true; + return false; } } - - ASTContext &Ctx = VD->getASTContext(); - - CodeGenModule::GVALinkage L = GetLinkageForVariable(VD, Ctx.getLangOptions()); - if (L == CodeGenModule::GVA_Internal || - L == CodeGenModule::GVA_TemplateInstantiation) { - if (!(VD->getInit() && VD->getInit()->HasSideEffects(Ctx))) - return false; + + GVALinkage L = GetLinkageForVariable(getContext(), VD); + if (L == GVA_Internal || L == GVA_TemplateInstantiation) { + if (!(VD->getInit() && VD->getInit()->HasSideEffects(Context))) + return true; } - return true; -} - -bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) { - // Never defer when EmitAllDecls is specified. - if (Features.EmitAllDecls) - return false; - - return !DeclIsRequiredFunctionOrFileScopedVar(Global); + return false; } llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) { @@ -1293,7 +1271,7 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { GV->setAlignment(getContext().getDeclAlign(D).getQuantity()); // Set the llvm linkage type as appropriate. - GVALinkage Linkage = GetLinkageForVariable(D, Features); + GVALinkage Linkage = GetLinkageForVariable(getContext(), D); if (Linkage == GVA_Internal) GV->setLinkage(llvm::Function::InternalLinkage); else if (D->hasAttr()) diff --git a/clang/lib/Frontend/PCHWriterDecl.cpp b/clang/lib/Frontend/PCHWriterDecl.cpp index f0d563297bbd..06266d2282d5 100644 --- a/clang/lib/Frontend/PCHWriterDecl.cpp +++ b/clang/lib/Frontend/PCHWriterDecl.cpp @@ -16,7 +16,6 @@ #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/Expr.h" -#include "clang/CodeGen/BackendUtil.h" #include "llvm/ADT/Twine.h" #include "llvm/Bitcode/BitstreamWriter.h" #include "llvm/Support/ErrorHandling.h" @@ -1079,12 +1078,63 @@ void PCHWriter::WriteDeclsBlockAbbrevs() { /// clients to use a separate API call to "realize" the decl. This should be /// relatively painless since they would presumably only do it for top-level /// decls. +// +// FIXME: This predicate is essentially IRgen's predicate to determine whether a +// declaration can be deferred. Merge them somehow. static bool isRequiredDecl(const Decl *D, ASTContext &Context) { // File scoped assembly must be seen. if (isa(D)) return true; - return DeclIsRequiredFunctionOrFileScopedVar(D); + // Otherwise if this isn't a function or a file scoped variable it doesn't + // need to be seen. + if (const VarDecl *VD = dyn_cast(D)) { + if (!VD->isFileVarDecl()) + return false; + } else if (!isa(D)) + return false; + + // Aliases and used decls must be seen. + if (D->hasAttr() || D->hasAttr()) + return true; + + if (const FunctionDecl *FD = dyn_cast(D)) { + // Forward declarations don't need to be seen. + if (!FD->isThisDeclarationADefinition()) + return false; + + // Constructors and destructors must be seen. + if (FD->hasAttr() || FD->hasAttr()) + return true; + + // Otherwise, this is required unless it is static. + // + // FIXME: Inlines. + return FD->getStorageClass() != FunctionDecl::Static; + } else { + const VarDecl *VD = cast(D); + + // Structs that have non-trivial constructors or destructors must be seen. + if (const RecordType *RT = VD->getType()->getAs()) { + if (const CXXRecordDecl *RD = dyn_cast(RT->getDecl())) { + if (!RD->hasTrivialConstructor() || !RD->hasTrivialDestructor()) + return true; + } + } + + // In C++, this doesn't need to be seen if it is marked "extern". + if (Context.getLangOptions().CPlusPlus && !VD->getInit() && + (VD->getStorageClass() == VarDecl::Extern || + VD->isExternC())) + return false; + + // In C, this doesn't need to be seen unless it is a definition. + if (!Context.getLangOptions().CPlusPlus && !VD->getInit()) + return false; + + // Otherwise, this is required unless it is static. + return VD->getStorageClass() != VarDecl::Static; + } } void PCHWriter::WriteDecl(ASTContext &Context, Decl *D) { diff --git a/clang/test/PCH/cxx-required-decls.cpp b/clang/test/PCH/cxx-required-decls.cpp index 818958ea1e9f..0e39ce36fe92 100644 --- a/clang/test/PCH/cxx-required-decls.cpp +++ b/clang/test/PCH/cxx-required-decls.cpp @@ -6,4 +6,3 @@ // RUN: %clang_cc1 -include-pch %t %s -emit-llvm -o - | FileCheck %s // CHECK: @_ZL5globS = internal global %struct.S zeroinitializer -// CHECK: @_ZL3bar = internal global i32 0, align 4 diff --git a/clang/test/PCH/cxx-required-decls.h b/clang/test/PCH/cxx-required-decls.h index df28ad6c2f8d..f4fa79e4eeba 100644 --- a/clang/test/PCH/cxx-required-decls.h +++ b/clang/test/PCH/cxx-required-decls.h @@ -5,6 +5,3 @@ struct S { }; static S globS; - -extern int ext_foo; -static int bar = ++ext_foo; diff --git a/clang/tools/libclang/Makefile b/clang/tools/libclang/Makefile index 0f362cd26e72..253ea38c7b94 100644 --- a/clang/tools/libclang/Makefile +++ b/clang/tools/libclang/Makefile @@ -17,7 +17,7 @@ SHARED_LIBRARY = 1 LINK_COMPONENTS := bitreader mc core USEDLIBS = clangFrontend.a clangDriver.a clangSema.a \ - clangAnalysis.a clangAST.a clangCodeGen.a clangParse.a clangLex.a clangBasic.a + clangAnalysis.a clangAST.a clangParse.a clangLex.a clangBasic.a include $(CLANG_LEVEL)/Makefile