diff options
Diffstat (limited to 'compilerplugins/clang/unusedenumconstants.cxx')
| -rw-r--r-- | compilerplugins/clang/unusedenumconstants.cxx | 303 |
1 files changed, 303 insertions, 0 deletions
diff --git a/compilerplugins/clang/unusedenumconstants.cxx b/compilerplugins/clang/unusedenumconstants.cxx new file mode 100644 index 000000000..4ae1f52f2 --- /dev/null +++ b/compilerplugins/clang/unusedenumconstants.cxx @@ -0,0 +1,303 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#include <cassert> +#include <string> +#include <iostream> +#include <fstream> +#include <set> +#include "plugin.hxx" +#include "compat.hxx" + +/** +This looks for unused enum constants + +We search for 3 things +(a) constants that are declared but never used +(b) constants only used in a "read" fashion i.e. we compare stuff against them, but we never store a value anywhere +(c) constants only used in a "write" fashion i.e. we store a value, but never check for that value + +(a) is fairly reliable but (b) and (c) will need some checking before acting on. + +Be warned that it produces around 5G of log file. + +The process goes something like this: + $ make check + $ make FORCE_COMPILE_ALL=1 COMPILER_PLUGIN_TOOL='unusedenumconstants' check + $ ./compilerplugins/clang/unusedenumconstants.py + +Note that the actual process may involve a fair amount of undoing, hand editing, and general messing around +to get it to work :-) + +*/ + +namespace { + +struct MyFieldInfo +{ + std::string parentClass; + std::string fieldName; + std::string sourceLocation; + SourceLocation loc; +}; +bool operator < (const MyFieldInfo &lhs, const MyFieldInfo &rhs) +{ + return std::tie(lhs.parentClass, lhs.fieldName) + < std::tie(rhs.parentClass, rhs.fieldName); +} + + +// try to limit the voluminous output a little +static std::set<MyFieldInfo> definitionSet; +static std::set<MyFieldInfo> writeSet; +static std::set<MyFieldInfo> readSet; + + +class UnusedEnumConstants: + public loplugin::FilteringPlugin<UnusedEnumConstants> +{ +public: + explicit UnusedEnumConstants(loplugin::InstantiationData const & data): FilteringPlugin(data) {} + + virtual void run() override + { + TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()); + + if (!isUnitTestMode()) + { + // dump all our output in one write call - this is to try and limit IO "crosstalk" between multiple processes + // writing to the same logfile + std::string output; + for (const MyFieldInfo & s : definitionSet) + output += "definition:\t" + s.parentClass + "\t" + s.fieldName + "\t" + s.sourceLocation + "\n"; + for (const MyFieldInfo & s : writeSet) + output += "write:\t" + s.parentClass + "\t" + s.fieldName + "\n"; + for (const MyFieldInfo & s : readSet) + output += "read:\t" + s.parentClass + "\t" + s.fieldName + "\n"; + std::ofstream myfile; + myfile.open( WORKDIR "/loplugin.unusedenumconstants.log", std::ios::app | std::ios::out); + myfile << output; + myfile.close(); + } + else + { + for (const MyFieldInfo& s : writeSet) + report(DiagnosticsEngine::Warning, "write %0", s.loc) + << s.fieldName; + for (const MyFieldInfo& s : readSet) + report(DiagnosticsEngine::Warning, "read %0", s.loc) + << s.fieldName; + } + } + + bool shouldVisitTemplateInstantiations () const { return true; } + bool shouldVisitImplicitCode() const { return true; } + + bool VisitEnumConstantDecl( const EnumConstantDecl * ); + bool VisitDeclRefExpr( const DeclRefExpr * ); +private: + MyFieldInfo niceName(const EnumConstantDecl*); +}; + +MyFieldInfo UnusedEnumConstants::niceName(const EnumConstantDecl* enumConstantDecl) +{ + MyFieldInfo aInfo; + + aInfo.parentClass = enumConstantDecl->getType().getAsString(); + aInfo.fieldName = enumConstantDecl->getNameAsString(); + // sometimes the name (if it's anonymous thing) contains the full path of the build folder, which we don't need + size_t idx = aInfo.fieldName.find(SRCDIR); + if (idx != std::string::npos) { + aInfo.fieldName = aInfo.fieldName.replace(idx, strlen(SRCDIR), ""); + } + + SourceLocation expansionLoc = compiler.getSourceManager().getExpansionLoc( enumConstantDecl->getLocation() ); + StringRef name = getFilenameOfLocation(expansionLoc); + aInfo.loc = expansionLoc; + aInfo.sourceLocation = std::string(name.substr(strlen(SRCDIR)+1)) + ":" + std::to_string(compiler.getSourceManager().getSpellingLineNumber(expansionLoc)); + loplugin::normalizeDotDotInFilePath(aInfo.sourceLocation); + + return aInfo; +} + +bool UnusedEnumConstants::VisitEnumConstantDecl( const EnumConstantDecl* enumConstantDecl ) +{ + enumConstantDecl = enumConstantDecl->getCanonicalDecl(); + if (ignoreLocation( enumConstantDecl )) { + return true; + } + // ignore stuff that forms part of the stable URE interface + if (isInUnoIncludeFile(compiler.getSourceManager().getSpellingLoc(enumConstantDecl->getLocation()))) { + return true; + } + + definitionSet.insert(niceName(enumConstantDecl)); + return true; +} + +bool UnusedEnumConstants::VisitDeclRefExpr( const DeclRefExpr* declRefExpr ) +{ + auto enumConstantDecl = dyn_cast<EnumConstantDecl>(declRefExpr->getDecl()); + if (!enumConstantDecl) { + return true; + } + enumConstantDecl = enumConstantDecl->getCanonicalDecl(); + if (ignoreLocation(enumConstantDecl)) { + return true; + } + // ignore stuff that forms part of the stable URE interface + if (isInUnoIncludeFile(compiler.getSourceManager().getSpellingLoc(enumConstantDecl->getLocation()))) { + return true; + } + + const Stmt * parent = declRefExpr; + const Stmt * child = nullptr; + +walk_up: + child = parent; + parent = getParentStmt(parent); + bool bWrite = false; + bool bRead = false; + bool bDump = false; + if (!parent) + { + // Could probably do better here. + // Sometimes this is a constructor-initialiser-expression, so just make a pessimistic assumption. + bWrite = true; + } + else if (const CXXOperatorCallExpr * operatorCall = dyn_cast<CXXOperatorCallExpr>(parent)) + { + auto oo = operatorCall->getOperator(); + if (oo == OO_AmpEqual) + { + // Ignore a common pattern that does not introduce any new information, merely removes + // information: foo &= ~Enum6::Top + bool found = false; + if (auto innerOperatorCall = dyn_cast<CXXOperatorCallExpr>(operatorCall->getArg(1)->IgnoreImplicit()->IgnoreParens()->IgnoreImplicit())) + { + found = innerOperatorCall->getOperator() == OO_Tilde; + } + if (!found) + bWrite = true; + } + // if assignment op + else if (oo == OO_Equal || oo == OO_StarEqual || oo == OO_SlashEqual || oo == OO_PercentEqual + || oo == OO_PlusEqual || oo == OO_MinusEqual || oo == OO_LessLessEqual + || oo == OO_CaretEqual || oo == OO_PipeEqual) + bWrite = true; + // else if comparison op + else if (oo == OO_AmpAmp || oo == OO_PipePipe || oo == OO_Subscript + || oo == OO_Less || oo == OO_Greater || oo == OO_LessEqual || oo == OO_GreaterEqual || oo == OO_EqualEqual || oo == OO_ExclaimEqual) + bRead = true; + else + goto walk_up; + } + else if (const CXXMemberCallExpr * memberCall = dyn_cast<CXXMemberCallExpr>(parent)) + { + // happens a lot with o3tl::typed_flags + if (*memberCall->child_begin() == child) + { + if (auto conversionDecl = dyn_cast<CXXConversionDecl>(memberCall->getMethodDecl())) + { + if (conversionDecl->getConversionType()->isSpecificBuiltinType(clang::BuiltinType::Bool)) + bRead = true; + else + goto walk_up; + } + else + goto walk_up; + } + else + bWrite = true; + } + else if (isa<CallExpr>(parent) || isa<InitListExpr>(parent) || isa<ArraySubscriptExpr>(parent) + || isa<ReturnStmt>(parent) || isa<DeclStmt>(parent) + || isa<CXXConstructExpr>(parent) + || isa<CXXThrowExpr>(parent)) + { + bWrite = true; + } + else if (isa<CaseStmt>(parent) || isa<SwitchStmt>(parent) || isa<IfStmt>(parent) + || isa<WhileStmt>(parent) || isa<DoStmt>(parent) || isa<ForStmt>(parent) || isa<DefaultStmt>(parent)) + { + bRead = true; + } + else if (const BinaryOperator * binaryOp = dyn_cast<BinaryOperator>(parent)) + { + if (BinaryOperator::isAssignmentOp(binaryOp->getOpcode())) { + bWrite = true; + } else if (BinaryOperator::isComparisonOp(binaryOp->getOpcode())) { + bRead = true; + } else { + goto walk_up; + } + } + else if (isa<ConditionalOperator>(parent)) + { + goto walk_up; + } + else if (isa<CastExpr>(parent) || isa<UnaryOperator>(parent) + || isa<ParenExpr>(parent) + || isa<MaterializeTemporaryExpr>(parent) + || isa<ExprWithCleanups>(parent) +#if CLANG_VERSION >= 80000 + || isa<ConstantExpr>(parent) +#endif + || isa<CXXBindTemporaryExpr>(parent)) + { + goto walk_up; + } + else if (isa<CXXDefaultArgExpr>(parent)) + { + // TODO this could be improved + bWrite = true; + } + else if (isa<DeclRefExpr>(parent)) + { + // slightly weird case I saw in basegfx where the enum is being used as a template param + bWrite = true; + } + else if (isa<MemberExpr>(parent)) + { + goto walk_up; + } + else if (isa<UnresolvedLookupExpr>(parent) + || isa<CompoundStmt>(parent)) + { + bRead = true; + bWrite = true; + } + else + { + bDump = true; + } + + // to let me know if I missed something + if (bDump) { + parent->dump(); + declRefExpr->dump(); + report( DiagnosticsEngine::Warning, + "unhandled clang AST node type", + compat::getBeginLoc(parent)); + } + + if (bWrite) { + writeSet.insert(niceName(enumConstantDecl)); + } + if (bRead) { + readSet.insert(niceName(enumConstantDecl)); + } + return true; +} + +loplugin::Plugin::Registration< UnusedEnumConstants > X("unusedenumconstants", false); + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |