From: Argyrios Kyrtzidis Date: Sun, 15 Aug 2010 01:15:20 +0000 (+0000) Subject: Commit improved version of 111026 & 111027. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=bbc6454bb98d6a6ecbaafa715222c5db834307f2;p=clang Commit improved version of 111026 & 111027. Unused warnings for functions: -static functions -functions in anonymous namespace -class methods in anonymous namespace -class method specializations in anonymous namespace -function specializations in anonymous namespace Unused warnings for variables: -static variables -variables in anonymous namespace -static data members in anonymous namespace -static data members specializations in anonymous namespace Reveals lots of opportunities for dead code removal in llvm codebase that will interest my esteemed colleagues. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@111086 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h index 5ab6d827e1..5ef8e5f070 100644 --- a/include/clang/Sema/Sema.h +++ b/include/clang/Sema/Sema.h @@ -349,7 +349,7 @@ public: std::vector TentativeDefinitions; /// \brief The set of file scoped decls seen so far that have not been used - /// and must warn if not used. + /// and must warn if not used. Only contains the first declaration. std::vector UnusedFileScopedDecls; class AccessedEntity { @@ -1877,6 +1877,10 @@ public: MultiStmtArg Handlers); void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock); + bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const; + + /// \brief If it's a file scoped decl that must warn if not used, keep track + /// of it. void MarkUnusedFileScopedDecl(const DeclaratorDecl *D); /// DiagnoseUnusedExprResult - If the statement passed in is an expression diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp index 988bedb1c0..3ec4ae7dc1 100644 --- a/lib/AST/ASTContext.cpp +++ b/lib/AST/ASTContext.cpp @@ -5640,7 +5640,8 @@ bool ASTContext::DeclMustBeEmitted(const Decl *D) { // FIXME: Handle references. if (const RecordType *RT = VD->getType()->getAs()) { if (const CXXRecordDecl *RD = dyn_cast(RT->getDecl())) { - if (!RD->hasTrivialConstructor() || !RD->hasTrivialDestructor()) + if (RD->hasDefinition() && + (!RD->hasTrivialConstructor() || !RD->hasTrivialDestructor())) return true; } } diff --git a/lib/Sema/Sema.cpp b/lib/Sema/Sema.cpp index 95f08bdf01..0a85252ab1 100644 --- a/lib/Sema/Sema.cpp +++ b/lib/Sema/Sema.cpp @@ -235,6 +235,42 @@ void Sema::DeleteExpr(ExprTy *E) { void Sema::DeleteStmt(StmtTy *S) { } +/// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector. +static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) { + if (D->isUsed()) + return true; + + if (const FunctionDecl *FD = dyn_cast(D)) { + // UnusedFileScopedDecls stores the first declaration. + // The declaration may have become definition so check again. + const FunctionDecl *DeclToCheck; + if (FD->hasBody(DeclToCheck)) + return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); + + // Later redecls may add new information resulting in not having to warn, + // so check again. + DeclToCheck = FD->getMostRecentDeclaration(); + if (DeclToCheck != FD) + return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); + } + + if (const VarDecl *VD = dyn_cast(D)) { + // UnusedFileScopedDecls stores the first declaration. + // The declaration may have become definition so check again. + const VarDecl *DeclToCheck = VD->getDefinition(); + if (DeclToCheck) + return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); + + // Later redecls may add new information resulting in not having to warn, + // so check again. + DeclToCheck = VD->getMostRecentDeclaration(); + if (DeclToCheck != VD) + return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); + } + + return false; +} + /// ActOnEndOfTranslationUnit - This is called at the very end of the /// translation unit when EOF is reached and all but the top-level scope is /// popped. @@ -263,10 +299,10 @@ void Sema::ActOnEndOfTranslationUnit() { } // Remove file scoped decls that turned out to be used. - UnusedFileScopedDecls.erase(std::remove_if(UnusedFileScopedDecls.begin(), - UnusedFileScopedDecls.end(), - std::bind2nd(std::mem_fun(&DeclaratorDecl::isUsed), - true)), + UnusedFileScopedDecls.erase(std::remove_if(UnusedFileScopedDecls.begin(), + UnusedFileScopedDecls.end(), + std::bind1st(std::ptr_fun(ShouldRemoveFromUnused), + this)), UnusedFileScopedDecls.end()); if (!CompleteTranslationUnit) { @@ -336,11 +372,19 @@ void Sema::ActOnEndOfTranslationUnit() { for (std::vector::iterator I = UnusedFileScopedDecls.begin(), E = UnusedFileScopedDecls.end(); I != E; ++I) { - if (const FunctionDecl *FD = dyn_cast(*I)) - Diag(FD->getLocation(), diag::warn_unused_function) << FD->getDeclName(); - else - Diag((*I)->getLocation(), diag::warn_unused_variable) - << cast(*I)->getDeclName(); + if (const FunctionDecl *FD = dyn_cast(*I)) { + const FunctionDecl *DiagD; + if (!FD->hasBody(DiagD)) + DiagD = FD; + Diag(DiagD->getLocation(), diag::warn_unused_function) + << DiagD->getDeclName(); + } else { + const VarDecl *DiagD = cast(*I)->getDefinition(); + if (!DiagD) + DiagD = cast(*I); + Diag(DiagD->getLocation(), diag::warn_unused_variable) + << DiagD->getDeclName(); + } } TUScope = 0; diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp index e1f9c82fec..ea65c8cf30 100644 --- a/lib/Sema/SemaDecl.cpp +++ b/lib/Sema/SemaDecl.cpp @@ -521,25 +521,71 @@ static void RemoveUsingDecls(LookupResult &R) { F.done(); } -static bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) { +bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const { + assert(D); + + if (D->isInvalidDecl() || D->isUsed() || D->hasAttr()) + return false; + + // Ignore class templates. + if (D->getDeclContext()->isDependentContext()) + return false; + + // We warn for unused decls internal to the translation unit. + if (D->getLinkage() == ExternalLinkage) + return false; + + if (const FunctionDecl *FD = dyn_cast(D)) { + if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) + return false; + + if (const CXXMethodDecl *MD = dyn_cast(FD)) { + if (MD->isVirtual()) + return false; + } else { + // 'static inline' functions are used in headers; don't warn. + if (FD->getStorageClass() == FunctionDecl::Static && + FD->isInlineSpecified()) + return false; + } + + if (FD->isThisDeclarationADefinition()) + return !Context.DeclMustBeEmitted(FD); + return true; + } + + if (const VarDecl *VD = dyn_cast(D)) { + if (VD->isStaticDataMember() && + VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) + return false; + + if ( VD->isFileVarDecl() && + !VD->getType().isConstant(Context)) + return !Context.DeclMustBeEmitted(VD); + } + + return false; + } + + void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) { + if (!D) + return; + if (const FunctionDecl *FD = dyn_cast(D)) { - // Warn for static, non-inlined function definitions that - // have not been used. - // FIXME: Also include static functions declared but not defined. - return (!FD->isInvalidDecl() - && !FD->isInlined() && FD->getLinkage() == InternalLinkage - && !FD->isUsed() && !FD->hasAttr() - && !FD->hasAttr() - && !FD->hasAttr()); + const FunctionDecl *First = FD->getFirstDeclaration(); + if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First)) + return; // First should already be in the vector. } - - return false; -} -void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) { - if (ShouldWarnIfUnusedFileScopedDecl(D)) - UnusedFileScopedDecls.push_back(D); -} + if (const VarDecl *VD = dyn_cast(D)) { + const VarDecl *First = VD->getFirstDeclaration(); + if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First)) + return; // First should already be in the vector. + } + + if (ShouldWarnIfUnusedFileScopedDecl(D)) + UnusedFileScopedDecls.push_back(D); + } static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) { if (D->isInvalidDecl()) @@ -2743,6 +2789,8 @@ Sema::ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC, if (NewVD->getLinkage() == ExternalLinkage && !DC->isRecord()) AddPushedVisibilityAttribute(NewVD); + MarkUnusedFileScopedDecl(NewVD); + return NewVD; } @@ -3638,8 +3686,7 @@ Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC, if (FunctionTemplate) return FunctionTemplate; - if (IsFunctionDefinition) - MarkUnusedFileScopedDecl(NewFD); + MarkUnusedFileScopedDecl(NewFD); return NewFD; } diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp index 378c789273..24ecb47110 100644 --- a/lib/Sema/SemaTemplate.cpp +++ b/lib/Sema/SemaTemplate.cpp @@ -4360,8 +4360,10 @@ Sema::CheckFunctionTemplateSpecialization(FunctionDecl *FD, // Mark the prior declaration as an explicit specialization, so that later // clients know that this is an explicit specialization. - if (!isFriend) + if (!isFriend) { SpecInfo->setTemplateSpecializationKind(TSK_ExplicitSpecialization); + MarkUnusedFileScopedDecl(Specialization); + } // Turn the given function declaration into a function template // specialization, with the template arguments from the previous @@ -4514,6 +4516,7 @@ Sema::CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous) { cast(Member)->setInstantiationOfMemberFunction( cast(InstantiatedFrom), TSK_ExplicitSpecialization); + MarkUnusedFileScopedDecl(InstantiationFunction); } else if (isa(Member)) { VarDecl *InstantiationVar = cast(Instantiation); if (InstantiationVar->getTemplateSpecializationKind() == @@ -4526,6 +4529,7 @@ Sema::CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous) { Context.setInstantiatedFromStaticDataMember(cast(Member), cast(InstantiatedFrom), TSK_ExplicitSpecialization); + MarkUnusedFileScopedDecl(InstantiationVar); } else { assert(isa(Member) && "Only member classes remain"); CXXRecordDecl *InstantiationClass = cast(Instantiation); diff --git a/lib/Sema/SemaTemplateInstantiateDecl.cpp b/lib/Sema/SemaTemplateInstantiateDecl.cpp index fd630f2ef3..feedc2cbd0 100644 --- a/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -449,7 +449,7 @@ Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) { // Diagnose unused local variables. if (!Var->isInvalidDecl() && Owner->isFunctionOrMethod() && !Var->isUsed()) SemaRef.DiagnoseUnusedDecl(Var); - + return Var; } @@ -1415,7 +1415,7 @@ TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D, else Owner->addDecl(DeclToAdd); } - + return Method; } diff --git a/test/Sema/warn-unused-function.c b/test/Sema/warn-unused-function.c index d5e676b116..5ae0cce079 100644 --- a/test/Sema/warn-unused-function.c +++ b/test/Sema/warn-unused-function.c @@ -35,3 +35,12 @@ void bar2(void) { } __attribute__((destructor)) static void bar3(void); void bar3(void) { } + +static void f10(void); // expected-warning{{unused}} +static void f10(void); + +static void f11(void); +static void f11(void) { } // expected-warning{{unused}} + +static void f12(void) { } // expected-warning{{unused}} +static void f12(void); diff --git a/test/SemaCXX/warn-unused-filescoped.cpp b/test/SemaCXX/warn-unused-filescoped.cpp new file mode 100644 index 0000000000..b51aedc54a --- /dev/null +++ b/test/SemaCXX/warn-unused-filescoped.cpp @@ -0,0 +1,54 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wunused %s + +static void f1(); // expected-warning{{unused}} + +namespace { + void f2(); // expected-warning{{unused}} + + void f3() { } // expected-warning{{unused}} + + struct S { + void m1() { } // expected-warning{{unused}} + void m2(); // expected-warning{{unused}} + void m3(); + }; + + template + struct TS { + void m(); + }; + template <> void TS::m() { } // expected-warning{{unused}} + + template + void tf() { } + template <> void tf() { } // expected-warning{{unused}} + + struct VS { + virtual void vm() { } + }; + + struct SVS : public VS { + void vm() { } + }; +} + +void S::m3() { } // expected-warning{{unused}} + +static inline void f4() { } +const unsigned int cx = 0; + +static int x1; // expected-warning{{unused}} + +namespace { + int x2; // expected-warning{{unused}} + + struct S2 { + static int x; // expected-warning{{unused}} + }; + + template + struct TS2 { + static int x; + }; + template <> int TS2::x; // expected-warning{{unused}} +}