summaryrefslogtreecommitdiffstats
path: root/compilerplugins/clang/singlevalfields.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'compilerplugins/clang/singlevalfields.cxx')
-rw-r--r--compilerplugins/clang/singlevalfields.cxx577
1 files changed, 577 insertions, 0 deletions
diff --git a/compilerplugins/clang/singlevalfields.cxx b/compilerplugins/clang/singlevalfields.cxx
new file mode 100644
index 000000000..df5abcc00
--- /dev/null
+++ b/compilerplugins/clang/singlevalfields.cxx
@@ -0,0 +1,577 @@
+/* -*- 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 "config_clang.h"
+
+#include "compat.hxx"
+#include "plugin.hxx"
+
+#include "clang/AST/ParentMapContext.h"
+
+/**
+Look for fields that are only ever assigned a single constant value.
+
+We dmp a list of values assigned to fields, and a list of field definitions.
+Then we will post-process the 2 lists and find the set of interesting fields.
+
+Be warned that it produces around 5G of log file.
+
+The process goes something like this:
+ $ make check
+ $ make FORCE_COMPILE=all COMPILER_PLUGIN_TOOL='singlevalfields' check
+ $ ./compilerplugins/clang/singlevalfields.py
+
+Note that the actual process may involve a fair amount of undoing, hand editing, and general messing around
+to get it to work :-)
+
+@TODO we don't spot fields that have been zero-initialised via calloc or rtl_allocateZeroMemory or memset
+@TODO calls to lambdas where a reference to the field is taken
+
+*/
+
+namespace {
+
+struct MyFieldInfo
+{
+ FieldDecl const * fieldDecl;
+ std::string parentClass;
+ std::string fieldName;
+ std::string fieldType;
+ std::string sourceLocation;
+};
+bool operator < (const MyFieldInfo &lhs, const MyFieldInfo &rhs)
+{
+ return std::tie(lhs.parentClass, lhs.fieldName)
+ < std::tie(rhs.parentClass, rhs.fieldName);
+}
+
+struct MyFieldAssignmentInfo : public MyFieldInfo
+{
+ std::string value;
+};
+
+bool operator < (const MyFieldAssignmentInfo &lhs, const MyFieldAssignmentInfo &rhs)
+{
+ return std::tie(lhs.parentClass, lhs.fieldName, lhs.value)
+ < std::tie(rhs.parentClass, rhs.fieldName, rhs.value);
+}
+
+
+// try to limit the voluminous output a little
+static std::set<MyFieldAssignmentInfo> assignedSet;
+static std::set<MyFieldInfo> definitionSet;
+
+/** escape the value string to make it easier to parse the output file in python */
+std::string escape(std::string s)
+{
+ std::string out;
+ for (size_t i=0; i<s.length(); ++i)
+ if (int(s[i]) >= 32)
+ out += s[i];
+ else
+ out += "\\" + std::to_string((int)s[i]);
+ return out;
+}
+
+class SingleValFields:
+ public RecursiveASTVisitor<SingleValFields>, public loplugin::Plugin
+{
+public:
+ explicit SingleValFields(loplugin::InstantiationData const & data):
+ Plugin(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 MyFieldAssignmentInfo & s : assignedSet)
+ output += "asgn:\t" + s.parentClass + "\t" + s.fieldName + "\t" + escape(s.value) + "\n";
+ for (const MyFieldInfo & s : definitionSet)
+ output += "defn:\t" + s.parentClass + "\t" + s.fieldName + "\t" + s.fieldType + "\t" + s.sourceLocation + "\n";
+ std::ofstream myfile;
+ myfile.open( WORKDIR "/loplugin.singlevalfields.log", std::ios::app | std::ios::out);
+ myfile << output;
+ myfile.close();
+ }
+ else
+ {
+ for (const MyFieldAssignmentInfo & s : assignedSet)
+ if (s.fieldDecl && compiler.getSourceManager().isInMainFile(s.fieldDecl->getBeginLoc()))
+ report(
+ DiagnosticsEngine::Warning,
+ "assign %0",
+ s.fieldDecl->getBeginLoc())
+ << s.value;
+ }
+ }
+
+ bool shouldVisitTemplateInstantiations () const { return true; }
+ // to catch compiler-generated constructors
+ bool shouldVisitImplicitCode() const { return true; }
+
+ bool VisitFieldDecl( const FieldDecl* );
+ bool VisitVarDecl( const VarDecl* );
+ bool VisitMemberExpr( const MemberExpr* );
+ bool VisitDeclRefExpr( const DeclRefExpr* );
+ bool VisitCXXConstructorDecl( const CXXConstructorDecl* );
+// bool VisitUnaryExprOrTypeTraitExpr( const UnaryExprOrTypeTraitExpr* );
+private:
+ void niceName(const DeclaratorDecl*, MyFieldInfo&);
+ void walkPotentialAssign( const DeclaratorDecl* fieldOrVarDecl, const Stmt* stmt );
+ std::string getExprValue(const Expr*);
+ const FunctionDecl* get_top_FunctionDecl_from_Stmt(const Stmt&);
+ void checkCallExpr(const Stmt* child, const CallExpr* callExpr, std::string& assignValue, bool& bPotentiallyAssignedTo);
+};
+
+void SingleValFields::niceName(const DeclaratorDecl* fieldOrVarDecl, MyFieldInfo& aInfo)
+{
+ const VarDecl* varDecl = dyn_cast<VarDecl>(fieldOrVarDecl);
+ const FieldDecl* fieldDecl = dyn_cast<FieldDecl>(fieldOrVarDecl);
+ aInfo.fieldDecl = fieldDecl;
+ if (fieldDecl)
+ aInfo.parentClass = fieldDecl->getParent()->getQualifiedNameAsString();
+ else
+ {
+ if (auto parentRecordDecl = dyn_cast<CXXRecordDecl>(varDecl->getDeclContext()))
+ aInfo.parentClass = parentRecordDecl->getQualifiedNameAsString();
+ else if (auto parentMethodDecl = dyn_cast<CXXMethodDecl>(varDecl->getDeclContext()))
+ aInfo.parentClass = parentMethodDecl->getQualifiedNameAsString();
+ else if (auto parentFunctionDecl = dyn_cast<FunctionDecl>(varDecl->getDeclContext()))
+ aInfo.parentClass = parentFunctionDecl->getQualifiedNameAsString();
+ else if (isa<TranslationUnitDecl>(varDecl->getDeclContext()))
+ aInfo.parentClass = handler.getMainFileName().str();
+ else if (auto parentNamespaceDecl = dyn_cast<NamespaceDecl>(varDecl->getDeclContext()))
+ aInfo.parentClass = parentNamespaceDecl->getQualifiedNameAsString();
+ else if (isa<LinkageSpecDecl>(varDecl->getDeclContext()))
+ aInfo.parentClass = "extern"; // what to do here?
+ else
+ {
+ std::cout << "what is this? " << varDecl->getDeclContext()->getDeclKindName() << std::endl;
+ exit(1);
+ }
+ }
+ aInfo.fieldName = fieldOrVarDecl->getNameAsString();
+ aInfo.fieldType = fieldOrVarDecl->getType().getAsString();
+
+ SourceLocation expansionLoc = compiler.getSourceManager().getExpansionLoc( fieldOrVarDecl->getLocation() );
+ StringRef name = getFilenameOfLocation(expansionLoc);
+ aInfo.sourceLocation = std::string(name.substr(strlen(SRCDIR)+1)) + ":" + std::to_string(compiler.getSourceManager().getSpellingLineNumber(expansionLoc));
+ loplugin::normalizeDotDotInFilePath(aInfo.sourceLocation);
+}
+
+bool SingleValFields::VisitFieldDecl( const FieldDecl* fieldDecl )
+{
+ auto canonicalDecl = fieldDecl->getCanonicalDecl();
+
+ if( isInUnoIncludeFile( compiler.getSourceManager().getSpellingLoc(canonicalDecl->getLocation())) )
+ return true;
+
+ MyFieldInfo aInfo;
+ niceName(canonicalDecl, aInfo);
+ definitionSet.insert(aInfo);
+
+ if (fieldDecl->getInClassInitializer())
+ {
+ MyFieldAssignmentInfo aInfo;
+ niceName(canonicalDecl, aInfo);
+ aInfo.value = getExprValue(fieldDecl->getInClassInitializer());
+ assignedSet.insert(aInfo);
+ }
+
+ return true;
+}
+
+bool SingleValFields::VisitVarDecl( const VarDecl* varDecl )
+{
+ if (isa<ParmVarDecl>(varDecl))
+ return true;
+ if (varDecl->getType().isConstQualified())
+ return true;
+ if (!(varDecl->isStaticLocal() || varDecl->isStaticDataMember() || varDecl->hasGlobalStorage()))
+ return true;
+
+ auto canonicalDecl = varDecl->getCanonicalDecl();
+ if (!canonicalDecl->getLocation().isValid())
+ return true;
+
+ if( isInUnoIncludeFile( compiler.getSourceManager().getSpellingLoc(canonicalDecl->getLocation())) )
+ return true;
+
+ MyFieldInfo aInfo;
+ niceName(canonicalDecl, aInfo);
+ definitionSet.insert(aInfo);
+
+ if (varDecl->getInit())
+ {
+ MyFieldAssignmentInfo aInfo;
+ niceName(canonicalDecl, aInfo);
+ aInfo.value = getExprValue(varDecl->getInit());
+ assignedSet.insert(aInfo);
+ }
+
+ return true;
+}
+
+bool SingleValFields::VisitCXXConstructorDecl( const CXXConstructorDecl* decl )
+{
+ // doesn't count as a write to fields because it's self->self
+ if (decl->isCopyOrMoveConstructor())
+ return true;
+
+ for(auto it = decl->init_begin(); it != decl->init_end(); ++it)
+ {
+ const CXXCtorInitializer* init = *it;
+ const FieldDecl* fieldDecl = init->getMember();
+ if( !fieldDecl )
+ continue;
+ MyFieldAssignmentInfo aInfo;
+ niceName(fieldDecl, aInfo);
+ const Expr * expr = init->getInit();
+ // unwrap any single-arg constructors, this helps to find smart pointers
+ // that are only assigned nullptr
+ if (auto cxxConstructExpr = dyn_cast<CXXConstructExpr>(expr))
+ if (cxxConstructExpr->getNumArgs() == 1)
+ expr = cxxConstructExpr->getArg(0);
+ aInfo.value = getExprValue(expr);
+ assignedSet.insert(aInfo);
+ }
+ return true;
+}
+
+bool SingleValFields::VisitMemberExpr( const MemberExpr* memberExpr )
+{
+ const ValueDecl* decl = memberExpr->getMemberDecl();
+ const FieldDecl* fieldDecl = dyn_cast<FieldDecl>(decl);
+ if (!fieldDecl)
+ return true;
+ walkPotentialAssign(fieldDecl, memberExpr);
+ return true;
+}
+
+bool SingleValFields::VisitDeclRefExpr( const DeclRefExpr* declRefExpr )
+{
+ const VarDecl* varDecl = dyn_cast_or_null<VarDecl>(declRefExpr->getDecl());
+ if (!varDecl)
+ return true;
+ if (isa<ParmVarDecl>(varDecl))
+ return true;
+ if (varDecl->getType().isConstQualified())
+ return true;
+ if (!(varDecl->isStaticLocal() || varDecl->isStaticDataMember() || varDecl->hasGlobalStorage()))
+ return true;
+ walkPotentialAssign(varDecl, declRefExpr);
+ return true;
+}
+
+void SingleValFields::walkPotentialAssign( const DeclaratorDecl* fieldOrVarDecl, const Stmt* memberExpr )
+{
+ const FunctionDecl* parentFunction = getParentFunctionDecl(memberExpr);
+ if (parentFunction)
+ {
+ auto methodDecl = dyn_cast<CXXMethodDecl>(parentFunction);
+ if (methodDecl && (methodDecl->isCopyAssignmentOperator() || methodDecl->isMoveAssignmentOperator()))
+ return;
+ if (methodDecl && methodDecl->getIdentifier()
+ && (methodDecl->getName().startswith("Clone") || methodDecl->getName().startswith("clone")))
+ return;
+ auto cxxConstructorDecl = dyn_cast<CXXConstructorDecl>(parentFunction);
+ if (cxxConstructorDecl && cxxConstructorDecl->isCopyOrMoveConstructor())
+ return;
+ }
+
+ // walk up the tree until we find something interesting
+ const Stmt* child = memberExpr;
+ const Stmt* parent = getParentStmt(memberExpr);
+ bool bPotentiallyAssignedTo = false;
+ bool bDump = false;
+ std::string assignValue = "?";
+
+ // check for field being returned by non-const ref eg. Foo& getFoo() { return f; }
+ if (parentFunction && parent && isa<ReturnStmt>(parent)) {
+ const Stmt* parent2 = getParentStmt(parent);
+ if (parent2 && isa<CompoundStmt>(parent2)) {
+ QualType qt = parentFunction->getReturnType().getDesugaredType(compiler.getASTContext());
+ if (!qt.isConstQualified() && qt->isReferenceType()) {
+ bPotentiallyAssignedTo = true;
+ }
+ }
+ }
+
+ while (!bPotentiallyAssignedTo) {
+ // check for field being accessed by a reference variable e.g. Foo& f = m.foo;
+ auto parentsList = compiler.getASTContext().getParents(*child);
+ auto it = parentsList.begin();
+ if (it != parentsList.end()) {
+ const VarDecl *varDecl = it->get<VarDecl>();
+ if (varDecl) {
+ QualType qt = varDecl->getType().getDesugaredType(compiler.getASTContext());
+ if (!qt.isConstQualified() && qt->isReferenceType()) {
+ bPotentiallyAssignedTo = true;
+ break;
+ }
+ }
+ }
+
+ if (!parent) {
+ return;
+ }
+ if (isa<CastExpr>(parent) || isa<MemberExpr>(parent) || isa<ParenExpr>(parent) || isa<ParenListExpr>(parent)
+ || isa<ExprWithCleanups>(parent))
+ {
+ child = parent;
+ parent = getParentStmt(parent);
+ }
+ else if (isa<UnaryOperator>(parent))
+ {
+ const UnaryOperator* unaryOperator = dyn_cast<UnaryOperator>(parent);
+ int x = unaryOperator->getOpcode();
+ if (x == UO_AddrOf || x == UO_PostInc || x == UO_PostDec || x == UO_PreInc || x == UO_PreDec) {
+ assignValue = "?";
+ bPotentiallyAssignedTo = true;
+ break;
+ }
+ // cannot be assigned to anymore
+ break;
+ }
+ else if (auto callExpr = dyn_cast<CallExpr>(parent))
+ {
+ checkCallExpr(child, callExpr, assignValue, bPotentiallyAssignedTo);
+ break;
+ }
+ else if (isa<CXXConstructExpr>(parent))
+ {
+ const CXXConstructExpr* consExpr = dyn_cast<CXXConstructExpr>(parent);
+ const CXXConstructorDecl* consDecl = consExpr->getConstructor();
+ for (unsigned i = 0; i < consExpr->getNumArgs(); ++i) {
+ if (i >= consDecl->getNumParams()) // can happen in template code
+ break;
+ if (consExpr->getArg(i) == child) {
+ const ParmVarDecl* parmVarDecl = consDecl->getParamDecl(i);
+ QualType qt = parmVarDecl->getType().getDesugaredType(compiler.getASTContext());
+ if (!qt.isConstQualified() && qt->isReferenceType()) {
+ bPotentiallyAssignedTo = true;
+ }
+ break;
+ }
+ }
+ break;
+ }
+ else if (isa<BinaryOperator>(parent))
+ {
+ const BinaryOperator* binaryOp = dyn_cast<BinaryOperator>(parent);
+ auto op = binaryOp->getOpcode();
+ if ( binaryOp->getLHS() != child ) {
+ // if the expr is on the RHS, do nothing
+ }
+ else if ( op == BO_Assign ) {
+ assignValue = getExprValue(binaryOp->getRHS());
+ bPotentiallyAssignedTo = true;
+ } else if ( op == BO_MulAssign || op == BO_DivAssign
+ || op == BO_RemAssign || op == BO_AddAssign
+ || op == BO_SubAssign || op == BO_ShlAssign
+ || op == BO_ShrAssign || op == BO_AndAssign
+ || op == BO_XorAssign || op == BO_OrAssign )
+ {
+ bPotentiallyAssignedTo = true;
+ }
+ break;
+ }
+ else if ( isa<CompoundStmt>(parent)
+ || isa<SwitchStmt>(parent) || isa<CaseStmt>(parent) || isa<DefaultStmt>(parent)
+ || isa<DoStmt>(parent) || isa<WhileStmt>(parent)
+ || isa<IfStmt>(parent)
+ || isa<ForStmt>(parent)
+ || isa<ReturnStmt>(parent)
+ || isa<CXXNewExpr>(parent)
+ || isa<CXXDeleteExpr>(parent)
+ || isa<ConditionalOperator>(parent)
+ || isa<CXXTypeidExpr>(parent)
+ || isa<ArraySubscriptExpr>(parent)
+ || isa<CXXDependentScopeMemberExpr>(parent)
+ || isa<DeclStmt>(parent)
+ || isa<UnaryExprOrTypeTraitExpr>(parent)
+ || isa<UnresolvedMemberExpr>(parent)
+ || isa<MaterializeTemporaryExpr>(parent) //???
+ || isa<InitListExpr>(parent)
+ || isa<CXXUnresolvedConstructExpr>(parent)
+ || isa<LambdaExpr>(parent)
+ || isa<PackExpansionExpr>(parent)
+ || isa<CXXPseudoDestructorExpr>(parent)
+ )
+ {
+ break;
+ }
+ else if ( isa<ArrayInitLoopExpr>(parent) || isa<AtomicExpr>(parent) || isa<GCCAsmStmt>(parent) || isa<VAArgExpr>(parent))
+ {
+ bPotentiallyAssignedTo = true;
+ break;
+ }
+ else {
+ bPotentiallyAssignedTo = true;
+ bDump = true;
+ break;
+ }
+ }
+ if (bDump)
+ {
+ report(
+ DiagnosticsEngine::Warning,
+ "oh dear, what can the matter be?",
+ memberExpr->getBeginLoc())
+ << memberExpr->getSourceRange();
+ parent->dump();
+ }
+ if (bPotentiallyAssignedTo)
+ {
+ MyFieldAssignmentInfo aInfo;
+ niceName(fieldOrVarDecl, aInfo);
+ aInfo.value = assignValue;
+ assignedSet.insert(aInfo);
+ }
+}
+
+void SingleValFields::checkCallExpr(const Stmt* child, const CallExpr* callExpr, std::string& assignValue, bool& bPotentiallyAssignedTo)
+{
+ if (callExpr->getCallee() == child) {
+ return;
+ }
+ const FunctionDecl* functionDecl;
+ if (auto memberCallExpr = dyn_cast<CXXMemberCallExpr>(callExpr)) {
+ functionDecl = memberCallExpr->getMethodDecl();
+ } else {
+ functionDecl = callExpr->getDirectCallee();
+ }
+ if (functionDecl) {
+ if (auto operatorCallExpr = dyn_cast<CXXOperatorCallExpr>(callExpr)) {
+ if (operatorCallExpr->getArg(0) == child) {
+ const CXXMethodDecl* calleeMethodDecl = dyn_cast_or_null<CXXMethodDecl>(operatorCallExpr->getDirectCallee());
+ if (calleeMethodDecl) {
+ if (operatorCallExpr->getOperator() == OO_Equal) {
+ assignValue = getExprValue(operatorCallExpr->getArg(1));
+ bPotentiallyAssignedTo = true;
+ return;
+ }
+ }
+ }
+ }
+ for (unsigned i = 0; i < callExpr->getNumArgs(); ++i) {
+ if (i >= functionDecl->getNumParams()) // can happen in template code
+ break;
+ if (callExpr->getArg(i) == child) {
+ const ParmVarDecl* parmVarDecl = functionDecl->getParamDecl(i);
+ QualType qt = parmVarDecl->getType().getDesugaredType(compiler.getASTContext());
+ if (!qt.isConstQualified() && qt->isReferenceType()) {
+ assignValue = "?";
+ bPotentiallyAssignedTo = true;
+ }
+ break;
+ }
+ }
+ return;
+ }
+ // check for function pointers
+ const FieldDecl* calleeFieldDecl = dyn_cast_or_null<FieldDecl>(callExpr->getCalleeDecl());
+ if (!calleeFieldDecl) {
+ return;
+ }
+ QualType qt = calleeFieldDecl->getType().getDesugaredType(compiler.getASTContext());
+ if (!qt->isPointerType()) {
+ return;
+ }
+ qt = qt->getPointeeType().getDesugaredType(compiler.getASTContext());
+ const FunctionProtoType* proto = qt->getAs<FunctionProtoType>();
+ if (!proto) {
+ return;
+ }
+ for (unsigned i = 0; i < callExpr->getNumArgs(); ++i) {
+ if (i >= proto->getNumParams()) // can happen in template code
+ break;
+ if (callExpr->getArg(i) == child) {
+ QualType qt = proto->getParamType(i).getDesugaredType(compiler.getASTContext());
+ if (!qt.isConstQualified() && qt->isReferenceType()) {
+ assignValue = "?";
+ bPotentiallyAssignedTo = true;
+ }
+ break;
+ }
+ }
+}
+
+
+std::string SingleValFields::getExprValue(const Expr* arg)
+{
+ if (!arg)
+ return "?";
+ arg = arg->IgnoreParenCasts();
+ arg = arg->IgnoreImplicit();
+ // ignore this, it seems to trigger an infinite recursion
+ if (isa<UnaryExprOrTypeTraitExpr>(arg))
+ return "?";
+ if (arg->isValueDependent())
+ return "?";
+ // for stuff like: OUString foo = "xxx";
+ if (auto stringLiteral = dyn_cast<clang::StringLiteral>(arg))
+ {
+ if (stringLiteral->getCharByteWidth() == 1)
+ return stringLiteral->getString().str();
+ return "?";
+ }
+ // ParenListExpr containing a CXXNullPtrLiteralExpr and has a NULL type pointer
+ if (auto parenListExpr = dyn_cast<ParenListExpr>(arg))
+ {
+ if (parenListExpr->getNumExprs() == 1)
+ return getExprValue(parenListExpr->getExpr(0));
+ return "?";
+ }
+ if (auto constructExpr = dyn_cast<CXXConstructExpr>(arg))
+ {
+ if (constructExpr->getNumArgs() >= 1
+ && isa<clang::StringLiteral>(constructExpr->getArg(0)))
+ {
+ auto stringLiteral = dyn_cast<clang::StringLiteral>(constructExpr->getArg(0));
+ if (stringLiteral->getCharByteWidth() == 1)
+ return stringLiteral->getString().str();
+ return "?";
+ }
+ }
+ if (arg->getType()->isFloatingType())
+ {
+ APFloat x1(0.0f);
+ if (arg->EvaluateAsFloat(x1, compiler.getASTContext()))
+ {
+ std::string s;
+ llvm::raw_string_ostream os(s);
+ x1.print(os);
+ return os.str();
+ }
+ }
+ APSInt x1;
+ if (compat::EvaluateAsInt(arg, x1, compiler.getASTContext()))
+ return compat::toString(x1, 10);
+ if (isa<CXXNullPtrLiteralExpr>(arg))
+ return "0";
+ return "?";
+}
+
+loplugin::Plugin::Registration< SingleValFields > X("singlevalfields", false);
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */