summaryrefslogtreecommitdiffstats
path: root/compilerplugins/clang/unusedenumconstants.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'compilerplugins/clang/unusedenumconstants.cxx')
-rw-r--r--compilerplugins/clang/unusedenumconstants.cxx303
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: */