6f33d21fdd
(<397f2e9ebe
>)
Change-Id: I51acda5951f8250d1a1b47e1c2612199ae7338a2
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/152618
Tested-by: Jenkins
Reviewed-by: Stephan Bergmann <sbergman@redhat.com>
961 lines
37 KiB
C++
961 lines
37 KiB
C++
/* -*- 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/.
|
|
*/
|
|
|
|
#if !defined _WIN32 //TODO, #include <sys/file.h>
|
|
|
|
#include <cassert>
|
|
#include <string>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
#include <algorithm>
|
|
#include <sys/file.h>
|
|
#include <unistd.h>
|
|
|
|
#include "config_clang.h"
|
|
|
|
#include "plugin.hxx"
|
|
#include "compat.hxx"
|
|
#include "check.hxx"
|
|
|
|
#include "clang/AST/ParentMapContext.h"
|
|
|
|
/**
|
|
This performs two analyses:
|
|
(1) look for unused global vars
|
|
(2) look for global vars that are write-only
|
|
*/
|
|
|
|
namespace
|
|
{
|
|
struct MyVarInfo
|
|
{
|
|
const VarDecl* varDecl;
|
|
std::string fieldName;
|
|
std::string fieldType;
|
|
std::string sourceLocation;
|
|
};
|
|
bool operator<(const MyVarInfo& lhs, const MyVarInfo& rhs)
|
|
{
|
|
return std::tie(lhs.sourceLocation, lhs.fieldName)
|
|
< std::tie(rhs.sourceLocation, rhs.fieldName);
|
|
}
|
|
|
|
// try to limit the voluminous output a little
|
|
static std::set<MyVarInfo> readFromSet;
|
|
static std::set<MyVarInfo> writeToSet;
|
|
static std::set<MyVarInfo> definitionSet;
|
|
|
|
/**
|
|
* Wrap the different kinds of callable and callee objects in the clang AST so I can define methods that handle everything.
|
|
*/
|
|
class CallerWrapper
|
|
{
|
|
const CallExpr* m_callExpr;
|
|
const CXXConstructExpr* m_cxxConstructExpr;
|
|
|
|
public:
|
|
CallerWrapper(const CallExpr* callExpr)
|
|
: m_callExpr(callExpr)
|
|
, m_cxxConstructExpr(nullptr)
|
|
{
|
|
}
|
|
CallerWrapper(const CXXConstructExpr* cxxConstructExpr)
|
|
: m_callExpr(nullptr)
|
|
, m_cxxConstructExpr(cxxConstructExpr)
|
|
{
|
|
}
|
|
unsigned getNumArgs() const
|
|
{
|
|
return m_callExpr ? m_callExpr->getNumArgs() : m_cxxConstructExpr->getNumArgs();
|
|
}
|
|
const Expr* getArg(unsigned i) const
|
|
{
|
|
return m_callExpr ? m_callExpr->getArg(i) : m_cxxConstructExpr->getArg(i);
|
|
}
|
|
};
|
|
class CalleeWrapper
|
|
{
|
|
const FunctionDecl* m_calleeFunctionDecl = nullptr;
|
|
const CXXConstructorDecl* m_cxxConstructorDecl = nullptr;
|
|
const FunctionProtoType* m_functionPrototype = nullptr;
|
|
|
|
public:
|
|
explicit CalleeWrapper(const FunctionDecl* calleeFunctionDecl)
|
|
: m_calleeFunctionDecl(calleeFunctionDecl)
|
|
{
|
|
}
|
|
explicit CalleeWrapper(const CXXConstructExpr* cxxConstructExpr)
|
|
: m_cxxConstructorDecl(cxxConstructExpr->getConstructor())
|
|
{
|
|
}
|
|
explicit CalleeWrapper(const FunctionProtoType* functionPrototype)
|
|
: m_functionPrototype(functionPrototype)
|
|
{
|
|
}
|
|
unsigned getNumParams() const
|
|
{
|
|
if (m_calleeFunctionDecl)
|
|
return m_calleeFunctionDecl->getNumParams();
|
|
else if (m_cxxConstructorDecl)
|
|
return m_cxxConstructorDecl->getNumParams();
|
|
else if (m_functionPrototype->param_type_begin() == m_functionPrototype->param_type_end())
|
|
// FunctionProtoType will assert if we call getParamTypes() and it has no params
|
|
return 0;
|
|
else
|
|
return m_functionPrototype->getParamTypes().size();
|
|
}
|
|
const QualType getParamType(unsigned i) const
|
|
{
|
|
if (m_calleeFunctionDecl)
|
|
return m_calleeFunctionDecl->getParamDecl(i)->getType();
|
|
else if (m_cxxConstructorDecl)
|
|
return m_cxxConstructorDecl->getParamDecl(i)->getType();
|
|
else
|
|
return m_functionPrototype->getParamTypes()[i];
|
|
}
|
|
std::string getNameAsString() const
|
|
{
|
|
if (m_calleeFunctionDecl)
|
|
return m_calleeFunctionDecl->getNameAsString();
|
|
else if (m_cxxConstructorDecl)
|
|
return m_cxxConstructorDecl->getNameAsString();
|
|
else
|
|
return "";
|
|
}
|
|
CXXMethodDecl const* getAsCXXMethodDecl() const
|
|
{
|
|
if (m_calleeFunctionDecl)
|
|
return dyn_cast<CXXMethodDecl>(m_calleeFunctionDecl);
|
|
return nullptr;
|
|
}
|
|
};
|
|
|
|
class UnusedVarsGlobal : public loplugin::FilteringPlugin<UnusedVarsGlobal>
|
|
{
|
|
public:
|
|
explicit UnusedVarsGlobal(loplugin::InstantiationData const& data)
|
|
: FilteringPlugin(data)
|
|
{
|
|
}
|
|
|
|
virtual void run() override;
|
|
|
|
bool shouldVisitTemplateInstantiations() const { return true; }
|
|
bool shouldVisitImplicitCode() const { return true; }
|
|
|
|
bool VisitVarDecl(const VarDecl*);
|
|
bool VisitDeclRefExpr(const DeclRefExpr*);
|
|
bool TraverseCXXMethodDecl(CXXMethodDecl*);
|
|
bool TraverseFunctionDecl(FunctionDecl*);
|
|
bool TraverseIfStmt(IfStmt*);
|
|
|
|
private:
|
|
MyVarInfo niceName(const VarDecl*);
|
|
void checkIfReadFrom(const VarDecl* fieldDecl, const DeclRefExpr* declRefExpr);
|
|
void checkIfWrittenTo(const VarDecl* fieldDecl, const DeclRefExpr* declRefExpr);
|
|
bool isSomeKindOfZero(const Expr* arg);
|
|
bool checkForWriteWhenUsingCollectionType(const CXXMethodDecl* calleeMethodDecl);
|
|
bool IsPassedByNonConst(const VarDecl* fieldDecl, const Stmt* child, CallerWrapper callExpr,
|
|
CalleeWrapper calleeFunctionDecl);
|
|
compat::optional<CalleeWrapper> getCallee(CallExpr const*);
|
|
|
|
// For reasons I do not understand, parentFunctionDecl() is not reliable, so
|
|
// we store the parent function on the way down the AST.
|
|
FunctionDecl* insideFunctionDecl = nullptr;
|
|
std::vector<VarDecl const*> insideConditionalCheckOfVarSet;
|
|
};
|
|
|
|
void UnusedVarsGlobal::run()
|
|
{
|
|
handler.enableTreeWideAnalysisMode();
|
|
|
|
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 MyVarInfo& s : readFromSet)
|
|
output += "read:\t" + s.sourceLocation + "\t" + s.fieldName + "\n";
|
|
for (const MyVarInfo& s : writeToSet)
|
|
output += "write:\t" + s.sourceLocation + "\t" + s.fieldName + "\n";
|
|
for (const MyVarInfo& s : definitionSet)
|
|
output += "definition:\t" + s.fieldName + "\t" + s.fieldType + "\t" + s.sourceLocation
|
|
+ "\n";
|
|
std::ofstream myfile;
|
|
myfile.open(WORKDIR "/loplugin.unusedvarsglobal.log", std::ios::app | std::ios::out);
|
|
myfile << output;
|
|
myfile.close();
|
|
}
|
|
else
|
|
{
|
|
for (const MyVarInfo& s : readFromSet)
|
|
report(DiagnosticsEngine::Warning, "read", s.varDecl->getBeginLoc());
|
|
for (const MyVarInfo& s : writeToSet)
|
|
report(DiagnosticsEngine::Warning, "write", s.varDecl->getBeginLoc());
|
|
}
|
|
}
|
|
|
|
MyVarInfo UnusedVarsGlobal::niceName(const VarDecl* varDecl)
|
|
{
|
|
MyVarInfo aInfo;
|
|
aInfo.varDecl = varDecl;
|
|
|
|
aInfo.fieldName = varDecl->getNameAsString();
|
|
// sometimes the name (if it's an 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), "");
|
|
}
|
|
aInfo.fieldType = varDecl->getType().getAsString();
|
|
|
|
SourceLocation expansionLoc
|
|
= compiler.getSourceManager().getExpansionLoc(varDecl->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);
|
|
|
|
return aInfo;
|
|
}
|
|
|
|
bool UnusedVarsGlobal::VisitVarDecl(const VarDecl* varDecl)
|
|
{
|
|
varDecl = varDecl->getCanonicalDecl();
|
|
if (isa<ParmVarDecl>(varDecl))
|
|
return true;
|
|
if (!varDecl->hasGlobalStorage())
|
|
return true;
|
|
if (!varDecl->getLocation().isValid() || ignoreLocation(varDecl))
|
|
return true;
|
|
// ignore stuff that forms part of the stable URE interface
|
|
if (isInUnoIncludeFile(compiler.getSourceManager().getSpellingLoc(varDecl->getLocation())))
|
|
return true;
|
|
|
|
/**
|
|
If we have
|
|
const size_t NB_PRODUCTS = 3;
|
|
int DefaultProductDir[NB_PRODUCTS] = { 3, 3, 3 };
|
|
clang will inline the constant "3" and never tell us that we are reading from NB_PRODUCTS,
|
|
so just ignore integer constants.
|
|
*/
|
|
auto varType = varDecl->getType();
|
|
if (varType.isConstQualified() && varType->isIntegerType())
|
|
return true;
|
|
|
|
auto initExpr = varDecl->getAnyInitializer();
|
|
if (initExpr && !isSomeKindOfZero(initExpr))
|
|
writeToSet.insert(niceName(varDecl));
|
|
|
|
definitionSet.insert(niceName(varDecl));
|
|
return true;
|
|
}
|
|
|
|
bool UnusedVarsGlobal::VisitDeclRefExpr(const DeclRefExpr* declRefExpr)
|
|
{
|
|
const Decl* decl = declRefExpr->getDecl();
|
|
const VarDecl* varDecl = dyn_cast<VarDecl>(decl);
|
|
if (!varDecl)
|
|
return true;
|
|
if (isa<ParmVarDecl>(varDecl))
|
|
return true;
|
|
if (!varDecl->hasGlobalStorage())
|
|
return true;
|
|
varDecl = varDecl->getCanonicalDecl();
|
|
if (!varDecl->getLocation().isValid() || ignoreLocation(varDecl))
|
|
return true;
|
|
// ignore stuff that forms part of the stable URE interface
|
|
if (isInUnoIncludeFile(compiler.getSourceManager().getSpellingLoc(varDecl->getLocation())))
|
|
return true;
|
|
checkIfReadFrom(varDecl, declRefExpr);
|
|
checkIfWrittenTo(varDecl, declRefExpr);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
Does the expression being used to initialise a field value evaluate to
|
|
the same as a default value?
|
|
*/
|
|
bool UnusedVarsGlobal::isSomeKindOfZero(const Expr* arg)
|
|
{
|
|
assert(arg);
|
|
if (arg->isValueDependent())
|
|
return false;
|
|
if (arg->getType().isNull())
|
|
return false;
|
|
if (isa<CXXDefaultArgExpr>(arg))
|
|
arg = dyn_cast<CXXDefaultArgExpr>(arg)->getExpr();
|
|
arg = arg->IgnoreParenCasts();
|
|
// ignore this, it seems to trigger an infinite recursion
|
|
if (isa<UnaryExprOrTypeTraitExpr>(arg))
|
|
return false;
|
|
if (auto cxxConstructExpr = dyn_cast<CXXConstructExpr>(arg))
|
|
return cxxConstructExpr->getConstructor()->isDefaultConstructor();
|
|
APSInt x1;
|
|
if (compat::EvaluateAsInt(arg, x1, compiler.getASTContext()))
|
|
return x1 == 0;
|
|
if (isa<CXXNullPtrLiteralExpr>(arg))
|
|
return true;
|
|
if (isa<MaterializeTemporaryExpr>(arg))
|
|
{
|
|
const CXXBindTemporaryExpr* strippedArg
|
|
= dyn_cast_or_null<CXXBindTemporaryExpr>(arg->IgnoreParenCasts());
|
|
if (strippedArg)
|
|
{
|
|
auto temp = dyn_cast<CXXTemporaryObjectExpr>(strippedArg->getSubExpr());
|
|
if (temp->getNumArgs() == 0)
|
|
{
|
|
if (loplugin::TypeCheck(temp->getType())
|
|
.Class("OUString")
|
|
.Namespace("rtl")
|
|
.GlobalNamespace())
|
|
return true;
|
|
if (loplugin::TypeCheck(temp->getType())
|
|
.Class("OString")
|
|
.Namespace("rtl")
|
|
.GlobalNamespace())
|
|
return true;
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get the expression contents.
|
|
// This helps us find params which are always initialised with something like "OUString()".
|
|
SourceManager& SM = compiler.getSourceManager();
|
|
SourceLocation startLoc = arg->getBeginLoc();
|
|
SourceLocation endLoc = arg->getEndLoc();
|
|
const char* p1 = SM.getCharacterData(startLoc);
|
|
const char* p2 = SM.getCharacterData(endLoc);
|
|
if (!p1 || !p2 || (p2 - p1) < 0 || (p2 - p1) > 40)
|
|
return false;
|
|
unsigned n = Lexer::MeasureTokenLength(endLoc, SM, compiler.getLangOpts());
|
|
std::string s(p1, p2 - p1 + n);
|
|
// strip linefeed and tab characters so they don't interfere with the parsing of the log file
|
|
std::replace(s.begin(), s.end(), '\r', ' ');
|
|
std::replace(s.begin(), s.end(), '\n', ' ');
|
|
std::replace(s.begin(), s.end(), '\t', ' ');
|
|
|
|
// now normalize the value. For some params, like OUString, we can pass it as OUString() or "" and they are the same thing
|
|
if (s == "OUString()")
|
|
return true;
|
|
else if (s == "OString()")
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
static char easytolower(char in)
|
|
{
|
|
if (in <= 'Z' && in >= 'A')
|
|
return in - ('Z' - 'z');
|
|
return in;
|
|
}
|
|
|
|
bool startswith(const std::string& rStr, const char* pSubStr)
|
|
{
|
|
return rStr.compare(0, strlen(pSubStr), pSubStr) == 0;
|
|
}
|
|
|
|
bool UnusedVarsGlobal::TraverseCXXMethodDecl(CXXMethodDecl* cxxMethodDecl)
|
|
{
|
|
auto copy2 = insideFunctionDecl;
|
|
insideFunctionDecl = cxxMethodDecl;
|
|
bool ret = RecursiveASTVisitor::TraverseCXXMethodDecl(cxxMethodDecl);
|
|
insideFunctionDecl = copy2;
|
|
return ret;
|
|
}
|
|
|
|
bool UnusedVarsGlobal::TraverseFunctionDecl(FunctionDecl* functionDecl)
|
|
{
|
|
auto copy2 = insideFunctionDecl;
|
|
insideFunctionDecl = functionDecl;
|
|
bool ret = RecursiveASTVisitor::TraverseFunctionDecl(functionDecl);
|
|
insideFunctionDecl = copy2;
|
|
return ret;
|
|
}
|
|
|
|
bool UnusedVarsGlobal::TraverseIfStmt(IfStmt* ifStmt)
|
|
{
|
|
VarDecl const* varDecl = nullptr;
|
|
Expr const* cond = ifStmt->getCond()->IgnoreParenImpCasts();
|
|
|
|
if (auto memberCallExpr = dyn_cast<CXXMemberCallExpr>(cond))
|
|
{
|
|
if (auto cxxConvert = dyn_cast_or_null<CXXConversionDecl>(memberCallExpr->getMethodDecl()))
|
|
{
|
|
if (cxxConvert->getConversionType()->isBooleanType())
|
|
if (auto declRefExpr = dyn_cast<DeclRefExpr>(
|
|
memberCallExpr->getImplicitObjectArgument()->IgnoreParenImpCasts()))
|
|
if ((varDecl = dyn_cast<VarDecl>(declRefExpr->getDecl())))
|
|
insideConditionalCheckOfVarSet.push_back(varDecl);
|
|
}
|
|
}
|
|
else if (auto declRefExpr = dyn_cast<DeclRefExpr>(cond))
|
|
{
|
|
if ((varDecl = dyn_cast<VarDecl>(declRefExpr->getDecl())))
|
|
insideConditionalCheckOfVarSet.push_back(varDecl);
|
|
}
|
|
|
|
bool ret = RecursiveASTVisitor::TraverseIfStmt(ifStmt);
|
|
if (varDecl)
|
|
insideConditionalCheckOfVarSet.pop_back();
|
|
return ret;
|
|
}
|
|
|
|
void UnusedVarsGlobal::checkIfReadFrom(const VarDecl* varDecl, const DeclRefExpr* declRefExpr)
|
|
{
|
|
auto parentsRange = compiler.getASTContext().getParents(*declRefExpr);
|
|
const Stmt* child = declRefExpr;
|
|
const Stmt* parent
|
|
= parentsRange.begin() == parentsRange.end() ? nullptr : parentsRange.begin()->get<Stmt>();
|
|
// walk up the tree until we find something interesting
|
|
bool bPotentiallyReadFrom = false;
|
|
bool bDump = false;
|
|
auto walkUp = [&]() {
|
|
child = parent;
|
|
auto parentsRange = compiler.getASTContext().getParents(*parent);
|
|
parent = parentsRange.begin() == parentsRange.end() ? nullptr
|
|
: parentsRange.begin()->get<Stmt>();
|
|
};
|
|
do
|
|
{
|
|
if (!parent)
|
|
{
|
|
// check if we're inside a CXXCtorInitializer or a VarDecl
|
|
auto parentsRange = compiler.getASTContext().getParents(*child);
|
|
if (parentsRange.begin() != parentsRange.end())
|
|
{
|
|
const Decl* decl = parentsRange.begin()->get<Decl>();
|
|
if (decl && (isa<CXXConstructorDecl>(decl) || isa<VarDecl>(decl)))
|
|
bPotentiallyReadFrom = true;
|
|
}
|
|
if (!bPotentiallyReadFrom)
|
|
return;
|
|
break;
|
|
}
|
|
if (isa<CXXReinterpretCastExpr>(parent))
|
|
{
|
|
// once we see one of these, there is not much useful we can know
|
|
bPotentiallyReadFrom = true;
|
|
break;
|
|
}
|
|
else if (isa<CastExpr>(parent) || isa<MemberExpr>(parent) || isa<ParenExpr>(parent)
|
|
|| isa<ParenListExpr>(parent) || isa<ArrayInitLoopExpr>(parent)
|
|
|| isa<ExprWithCleanups>(parent))
|
|
{
|
|
walkUp();
|
|
}
|
|
else if (auto unaryOperator = dyn_cast<UnaryOperator>(parent))
|
|
{
|
|
UnaryOperator::Opcode op = unaryOperator->getOpcode();
|
|
if (declRefExpr->getType()->isArrayType() && op == UO_Deref)
|
|
{
|
|
// ignore, deref'ing an array does not count as a read
|
|
}
|
|
else if (op == UO_AddrOf || op == UO_Deref || op == UO_Plus || op == UO_Minus
|
|
|| op == UO_Not || op == UO_LNot)
|
|
{
|
|
bPotentiallyReadFrom = true;
|
|
break;
|
|
}
|
|
/* The following are technically reads, but from a code-sense they're more of a write/modify, so
|
|
ignore them to find interesting fields that only modified, not usefully read:
|
|
UO_PreInc / UO_PostInc / UO_PreDec / UO_PostDec
|
|
But we still walk up in case the result of the expression is used in a read sense.
|
|
*/
|
|
walkUp();
|
|
}
|
|
else if (auto caseStmt = dyn_cast<CaseStmt>(parent))
|
|
{
|
|
bPotentiallyReadFrom = caseStmt->getLHS() == child || caseStmt->getRHS() == child;
|
|
break;
|
|
}
|
|
else if (auto ifStmt = dyn_cast<IfStmt>(parent))
|
|
{
|
|
bPotentiallyReadFrom = ifStmt->getCond() == child;
|
|
break;
|
|
}
|
|
else if (auto doStmt = dyn_cast<DoStmt>(parent))
|
|
{
|
|
bPotentiallyReadFrom = doStmt->getCond() == child;
|
|
break;
|
|
}
|
|
else if (auto arraySubscriptExpr = dyn_cast<ArraySubscriptExpr>(parent))
|
|
{
|
|
if (arraySubscriptExpr->getIdx() == child)
|
|
{
|
|
bPotentiallyReadFrom = true;
|
|
break;
|
|
}
|
|
walkUp();
|
|
}
|
|
else if (auto binaryOp = dyn_cast<BinaryOperator>(parent))
|
|
{
|
|
BinaryOperator::Opcode op = binaryOp->getOpcode();
|
|
const bool assignmentOp = op == BO_Assign || 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;
|
|
if (binaryOp->getLHS() == child && assignmentOp)
|
|
break;
|
|
else
|
|
{
|
|
bPotentiallyReadFrom = true;
|
|
break;
|
|
}
|
|
}
|
|
else if (auto operatorCallExpr = dyn_cast<CXXOperatorCallExpr>(parent))
|
|
{
|
|
auto op = operatorCallExpr->getOperator();
|
|
const bool assignmentOp = op == OO_Equal || op == OO_StarEqual || op == OO_SlashEqual
|
|
|| op == OO_PercentEqual || op == OO_PlusEqual
|
|
|| op == OO_MinusEqual || op == OO_LessLessEqual
|
|
|| op == OO_AmpEqual || op == OO_CaretEqual
|
|
|| op == OO_PipeEqual;
|
|
if (operatorCallExpr->getArg(0) == child && assignmentOp)
|
|
break;
|
|
else if (op == OO_GreaterGreaterEqual && operatorCallExpr->getArg(1) == child)
|
|
break; // this is a write-only call
|
|
else
|
|
{
|
|
bPotentiallyReadFrom = true;
|
|
break;
|
|
}
|
|
}
|
|
else if (auto cxxMemberCallExpr = dyn_cast<CXXMemberCallExpr>(parent))
|
|
{
|
|
bool bWriteOnlyCall = false;
|
|
const CXXMethodDecl* callee = cxxMemberCallExpr->getMethodDecl();
|
|
if (callee)
|
|
{
|
|
const Expr* tmp = dyn_cast<Expr>(child);
|
|
if (tmp->isBoundMemberFunction(compiler.getASTContext()))
|
|
{
|
|
tmp = dyn_cast<MemberExpr>(tmp)->getBase();
|
|
}
|
|
if (cxxMemberCallExpr->getImplicitObjectArgument() == tmp)
|
|
{
|
|
// FIXME perhaps a better solution here would be some kind of SAL_PARAM_WRITEONLY attribute
|
|
// which we could scatter around.
|
|
std::string name = callee->getNameAsString();
|
|
std::transform(name.begin(), name.end(), name.begin(), easytolower);
|
|
if (startswith(name, "emplace") || name == "insert" || name == "erase"
|
|
|| name == "remove" || name == "remove_if" || name == "sort"
|
|
|| name == "push_back" || name == "pop_back" || name == "push_front"
|
|
|| name == "pop_front" || name == "reserve" || name == "resize"
|
|
|| name == "reset" || name == "clear" || name == "fill")
|
|
// write-only modifications to collections
|
|
bWriteOnlyCall = true;
|
|
else if (name == "dispose" || name == "disposeAndClear" || name == "swap")
|
|
// we're abusing the write-only analysis here to look for fields which don't have anything useful
|
|
// being done to them, so we're ignoring things like std::vector::clear, std::vector::swap,
|
|
// and VclPtr::disposeAndClear
|
|
bWriteOnlyCall = true;
|
|
}
|
|
}
|
|
if (!bWriteOnlyCall)
|
|
bPotentiallyReadFrom = true;
|
|
break;
|
|
}
|
|
else if (auto callExpr = dyn_cast<CallExpr>(parent))
|
|
{
|
|
bool bWriteOnlyCall = false;
|
|
// check for calls to ReadXXX(foo) type methods, where foo is write-only
|
|
auto callee = getCallee(callExpr);
|
|
if (callee)
|
|
{
|
|
// FIXME perhaps a better solution here would be some kind of SAL_PARAM_WRITEONLY attribute
|
|
// which we could scatter around.
|
|
std::string name = callee->getNameAsString();
|
|
std::transform(name.begin(), name.end(), name.begin(), easytolower);
|
|
if (startswith(name, "read"))
|
|
// this is a write-only call
|
|
bWriteOnlyCall = true;
|
|
}
|
|
if (!bWriteOnlyCall)
|
|
bPotentiallyReadFrom = true;
|
|
break;
|
|
}
|
|
else if (isa<ReturnStmt>(parent) || isa<CXXConstructExpr>(parent)
|
|
|| isa<ConditionalOperator>(parent) || isa<SwitchStmt>(parent)
|
|
|| isa<DeclStmt>(parent) || isa<WhileStmt>(parent) || isa<CXXNewExpr>(parent)
|
|
|| isa<ForStmt>(parent) || isa<InitListExpr>(parent)
|
|
|| isa<CXXDependentScopeMemberExpr>(parent) || isa<UnresolvedMemberExpr>(parent)
|
|
|| isa<MaterializeTemporaryExpr>(parent))
|
|
{
|
|
bPotentiallyReadFrom = true;
|
|
break;
|
|
}
|
|
else if (isa<CXXDeleteExpr>(parent) || isa<UnaryExprOrTypeTraitExpr>(parent)
|
|
|| isa<CXXUnresolvedConstructExpr>(parent) || isa<CompoundStmt>(parent)
|
|
|| isa<LabelStmt>(parent) || isa<CXXForRangeStmt>(parent)
|
|
|| isa<CXXTypeidExpr>(parent) || isa<DefaultStmt>(parent)
|
|
|| isa<GCCAsmStmt>(parent) || isa<LambdaExpr>(parent) // TODO
|
|
|| isa<CXXDefaultArgExpr>(parent) || isa<AtomicExpr>(parent)
|
|
|| isa<VAArgExpr>(parent) || isa<DeclRefExpr>(parent) || isa<ConstantExpr>(parent)
|
|
|| isa<SubstNonTypeTemplateParmExpr>(parent))
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
bPotentiallyReadFrom = true;
|
|
bDump = true;
|
|
break;
|
|
}
|
|
} while (true);
|
|
|
|
if (bDump)
|
|
{
|
|
report(DiagnosticsEngine::Warning, "oh dear, what can the matter be?",
|
|
declRefExpr->getBeginLoc())
|
|
<< declRefExpr->getSourceRange();
|
|
report(DiagnosticsEngine::Note, "parent over here", parent->getBeginLoc())
|
|
<< parent->getSourceRange();
|
|
parent->dump();
|
|
declRefExpr->dump();
|
|
}
|
|
|
|
if (bPotentiallyReadFrom)
|
|
readFromSet.insert(niceName(varDecl));
|
|
}
|
|
|
|
void UnusedVarsGlobal::checkIfWrittenTo(const VarDecl* varDecl, const DeclRefExpr* declRefExpr)
|
|
{
|
|
// if we're inside a block that looks like
|
|
// if (varDecl)
|
|
// ...
|
|
// then writes to this field don't matter, because unless we find another write to this field, this field is dead
|
|
if (std::find(insideConditionalCheckOfVarSet.begin(), insideConditionalCheckOfVarSet.end(),
|
|
varDecl)
|
|
!= insideConditionalCheckOfVarSet.end())
|
|
return;
|
|
|
|
auto parentsRange = compiler.getASTContext().getParents(*declRefExpr);
|
|
const Stmt* child = declRefExpr;
|
|
const Stmt* parent
|
|
= parentsRange.begin() == parentsRange.end() ? nullptr : parentsRange.begin()->get<Stmt>();
|
|
// walk up the tree until we find something interesting
|
|
bool bPotentiallyWrittenTo = false;
|
|
bool bDump = false;
|
|
auto walkUp = [&]() {
|
|
child = parent;
|
|
auto parentsRange = compiler.getASTContext().getParents(*parent);
|
|
parent = parentsRange.begin() == parentsRange.end() ? nullptr
|
|
: parentsRange.begin()->get<Stmt>();
|
|
};
|
|
do
|
|
{
|
|
if (!parent)
|
|
{
|
|
// check if we have an expression like
|
|
// int& r = m_field;
|
|
auto parentsRange = compiler.getASTContext().getParents(*child);
|
|
if (parentsRange.begin() != parentsRange.end())
|
|
{
|
|
auto varDecl = dyn_cast_or_null<VarDecl>(parentsRange.begin()->get<Decl>());
|
|
// The isImplicit() call is to avoid triggering when we see the vardecl which is part of a for-range statement,
|
|
// which is of type 'T&&' and also an l-value-ref ?
|
|
if (varDecl && !varDecl->isImplicit()
|
|
&& loplugin::TypeCheck(varDecl->getType()).LvalueReference().NonConst())
|
|
{
|
|
bPotentiallyWrittenTo = true;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (isa<CXXReinterpretCastExpr>(parent))
|
|
{
|
|
// once we see one of these, there is not much useful we can know
|
|
bPotentiallyWrittenTo = true;
|
|
break;
|
|
}
|
|
else if (isa<CastExpr>(parent) || isa<MemberExpr>(parent) || isa<ParenExpr>(parent)
|
|
|| isa<ParenListExpr>(parent) || isa<ArrayInitLoopExpr>(parent)
|
|
|| isa<ExprWithCleanups>(parent))
|
|
{
|
|
walkUp();
|
|
}
|
|
else if (auto unaryOperator = dyn_cast<UnaryOperator>(parent))
|
|
{
|
|
UnaryOperator::Opcode op = unaryOperator->getOpcode();
|
|
if (op == UO_AddrOf || op == UO_PostInc || op == UO_PostDec || op == UO_PreInc
|
|
|| op == UO_PreDec)
|
|
{
|
|
bPotentiallyWrittenTo = true;
|
|
}
|
|
break;
|
|
}
|
|
else if (auto arraySubscriptExpr = dyn_cast<ArraySubscriptExpr>(parent))
|
|
{
|
|
if (arraySubscriptExpr->getIdx() == child)
|
|
break;
|
|
walkUp();
|
|
}
|
|
else if (auto operatorCallExpr = dyn_cast<CXXOperatorCallExpr>(parent))
|
|
{
|
|
auto callee = getCallee(operatorCallExpr);
|
|
if (callee)
|
|
{
|
|
// if calling a non-const operator on the field
|
|
auto calleeMethodDecl = callee->getAsCXXMethodDecl();
|
|
if (calleeMethodDecl && operatorCallExpr->getArg(0) == child)
|
|
{
|
|
if (!calleeMethodDecl->isConst())
|
|
bPotentiallyWrittenTo
|
|
= checkForWriteWhenUsingCollectionType(calleeMethodDecl);
|
|
}
|
|
else if (IsPassedByNonConst(varDecl, child, operatorCallExpr, *callee))
|
|
{
|
|
bPotentiallyWrittenTo = true;
|
|
}
|
|
}
|
|
else
|
|
bPotentiallyWrittenTo = true; // conservative, could improve
|
|
break;
|
|
}
|
|
else if (auto cxxMemberCallExpr = dyn_cast<CXXMemberCallExpr>(parent))
|
|
{
|
|
const CXXMethodDecl* calleeMethodDecl = cxxMemberCallExpr->getMethodDecl();
|
|
if (calleeMethodDecl)
|
|
{
|
|
// if calling a non-const method on the field
|
|
const Expr* tmp = dyn_cast<Expr>(child);
|
|
if (tmp->isBoundMemberFunction(compiler.getASTContext()))
|
|
{
|
|
tmp = dyn_cast<MemberExpr>(tmp)->getBase();
|
|
}
|
|
if (cxxMemberCallExpr->getImplicitObjectArgument() == tmp)
|
|
{
|
|
if (!calleeMethodDecl->isConst())
|
|
bPotentiallyWrittenTo
|
|
= checkForWriteWhenUsingCollectionType(calleeMethodDecl);
|
|
break;
|
|
}
|
|
else if (IsPassedByNonConst(varDecl, child, cxxMemberCallExpr,
|
|
CalleeWrapper(calleeMethodDecl)))
|
|
bPotentiallyWrittenTo = true;
|
|
}
|
|
else
|
|
bPotentiallyWrittenTo = true; // can happen in templates
|
|
break;
|
|
}
|
|
else if (auto cxxConstructExpr = dyn_cast<CXXConstructExpr>(parent))
|
|
{
|
|
if (IsPassedByNonConst(varDecl, child, cxxConstructExpr,
|
|
CalleeWrapper(cxxConstructExpr)))
|
|
bPotentiallyWrittenTo = true;
|
|
break;
|
|
}
|
|
else if (auto callExpr = dyn_cast<CallExpr>(parent))
|
|
{
|
|
auto callee = getCallee(callExpr);
|
|
if (callee)
|
|
{
|
|
if (IsPassedByNonConst(varDecl, child, callExpr, *callee))
|
|
bPotentiallyWrittenTo = true;
|
|
}
|
|
else
|
|
bPotentiallyWrittenTo = true; // conservative, could improve
|
|
break;
|
|
}
|
|
else if (auto binaryOp = dyn_cast<BinaryOperator>(parent))
|
|
{
|
|
BinaryOperator::Opcode op = binaryOp->getOpcode();
|
|
const bool assignmentOp = op == BO_Assign || 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;
|
|
if (assignmentOp)
|
|
{
|
|
if (binaryOp->getLHS() == child)
|
|
bPotentiallyWrittenTo = true;
|
|
else if (loplugin::TypeCheck(binaryOp->getLHS()->getType())
|
|
.LvalueReference()
|
|
.NonConst())
|
|
// if the LHS is a non-const reference, we could write to the field later on
|
|
bPotentiallyWrittenTo = true;
|
|
}
|
|
break;
|
|
}
|
|
else if (isa<ReturnStmt>(parent))
|
|
{
|
|
if (insideFunctionDecl)
|
|
{
|
|
auto tc = loplugin::TypeCheck(insideFunctionDecl->getReturnType());
|
|
if (tc.LvalueReference().NonConst())
|
|
bPotentiallyWrittenTo = true;
|
|
}
|
|
break;
|
|
}
|
|
else if (isa<ConditionalOperator>(parent) || isa<SwitchStmt>(parent)
|
|
|| isa<DeclStmt>(parent) || isa<WhileStmt>(parent) || isa<CXXNewExpr>(parent)
|
|
|| isa<ForStmt>(parent) || isa<InitListExpr>(parent)
|
|
|| isa<CXXDependentScopeMemberExpr>(parent) || isa<UnresolvedMemberExpr>(parent)
|
|
|| isa<MaterializeTemporaryExpr>(parent) || isa<IfStmt>(parent)
|
|
|| isa<DoStmt>(parent) || isa<CXXDeleteExpr>(parent)
|
|
|| isa<UnaryExprOrTypeTraitExpr>(parent) || isa<CXXUnresolvedConstructExpr>(parent)
|
|
|| isa<CompoundStmt>(parent) || isa<LabelStmt>(parent)
|
|
|| isa<CXXForRangeStmt>(parent) || isa<CXXTypeidExpr>(parent)
|
|
|| isa<DefaultStmt>(parent) || isa<GCCAsmStmt>(parent) || isa<ConstantExpr>(parent)
|
|
|| isa<AtomicExpr>(parent) || isa<CXXDefaultArgExpr>(parent)
|
|
|| isa<VAArgExpr>(parent) || isa<DeclRefExpr>(parent)
|
|
|| isa<SubstNonTypeTemplateParmExpr>(parent) || isa<LambdaExpr>(parent)) // TODO
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
bPotentiallyWrittenTo = true;
|
|
bDump = true;
|
|
break;
|
|
}
|
|
} while (true);
|
|
|
|
if (bDump)
|
|
{
|
|
report(DiagnosticsEngine::Warning, "oh dear, what can the matter be? writtenTo=%0",
|
|
declRefExpr->getBeginLoc())
|
|
<< bPotentiallyWrittenTo << declRefExpr->getSourceRange();
|
|
if (parent)
|
|
{
|
|
report(DiagnosticsEngine::Note, "parent over here", parent->getBeginLoc())
|
|
<< parent->getSourceRange();
|
|
parent->dump();
|
|
}
|
|
declRefExpr->dump();
|
|
varDecl->getType()->dump();
|
|
}
|
|
|
|
if (bPotentiallyWrittenTo)
|
|
writeToSet.insert(niceName(varDecl));
|
|
}
|
|
|
|
// return true if this not a collection type, or if it is a collection type, and we might be writing to it
|
|
bool UnusedVarsGlobal::checkForWriteWhenUsingCollectionType(const CXXMethodDecl* calleeMethodDecl)
|
|
{
|
|
auto const tc = loplugin::TypeCheck(calleeMethodDecl->getParent());
|
|
bool listLike = false, setLike = false, mapLike = false, cssSequence = false;
|
|
if (tc.Class("deque").StdNamespace() || tc.Class("list").StdNamespace()
|
|
|| tc.Class("queue").StdNamespace() || tc.Class("vector").StdNamespace())
|
|
{
|
|
listLike = true;
|
|
}
|
|
else if (tc.Class("set").StdNamespace() || tc.Class("unordered_set").StdNamespace())
|
|
{
|
|
setLike = true;
|
|
}
|
|
else if (tc.Class("map").StdNamespace() || tc.Class("unordered_map").StdNamespace())
|
|
{
|
|
mapLike = true;
|
|
}
|
|
else if (tc.Class("Sequence")
|
|
.Namespace("uno")
|
|
.Namespace("star")
|
|
.Namespace("sun")
|
|
.Namespace("com")
|
|
.GlobalNamespace())
|
|
{
|
|
cssSequence = true;
|
|
}
|
|
else
|
|
return true;
|
|
|
|
if (calleeMethodDecl->isOverloadedOperator())
|
|
{
|
|
auto oo = calleeMethodDecl->getOverloadedOperator();
|
|
if (oo == OO_Equal)
|
|
return true;
|
|
// This is operator[]. We only care about things that add elements to the collection.
|
|
// if nothing modifies the size of the collection, then nothing useful
|
|
// is stored in it.
|
|
if (listLike)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
auto name = calleeMethodDecl->getName();
|
|
if (listLike || setLike || mapLike)
|
|
{
|
|
if (name == "reserve" || name == "shrink_to_fit" || name == "clear" || name == "erase"
|
|
|| name == "pop_back" || name == "pop_front" || name == "front" || name == "back"
|
|
|| name == "data" || name == "remove" || name == "remove_if" || name == "unique"
|
|
|| name == "sort" || name == "begin" || name == "end" || name == "rbegin"
|
|
|| name == "rend" || name == "at" || name == "find" || name == "equal_range"
|
|
|| name == "lower_bound" || name == "upper_bound")
|
|
return false;
|
|
}
|
|
if (cssSequence)
|
|
{
|
|
if (name == "getArray" || name == "begin" || name == "end")
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool UnusedVarsGlobal::IsPassedByNonConst(const VarDecl* varDecl, const Stmt* child,
|
|
CallerWrapper callExpr, CalleeWrapper calleeFunctionDecl)
|
|
{
|
|
unsigned len = std::min(callExpr.getNumArgs(), calleeFunctionDecl.getNumParams());
|
|
// if it's an array, passing it by value to a method typically means the
|
|
// callee takes a pointer and can modify the array
|
|
if (varDecl->getType()->isConstantArrayType())
|
|
{
|
|
for (unsigned i = 0; i < len; ++i)
|
|
if (callExpr.getArg(i) == child)
|
|
if (loplugin::TypeCheck(calleeFunctionDecl.getParamType(i)).Pointer().NonConst())
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
for (unsigned i = 0; i < len; ++i)
|
|
if (callExpr.getArg(i) == child)
|
|
if (loplugin::TypeCheck(calleeFunctionDecl.getParamType(i))
|
|
.LvalueReference()
|
|
.NonConst())
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
compat::optional<CalleeWrapper> UnusedVarsGlobal::getCallee(CallExpr const* callExpr)
|
|
{
|
|
FunctionDecl const* functionDecl = callExpr->getDirectCallee();
|
|
if (functionDecl)
|
|
return CalleeWrapper(functionDecl);
|
|
|
|
// Extract the functionprototype from a type
|
|
clang::Type const* calleeType = callExpr->getCallee()->getType().getTypePtr();
|
|
if (auto pointerType = calleeType->getUnqualifiedDesugaredType()->getAs<clang::PointerType>())
|
|
{
|
|
if (auto prototype = pointerType->getPointeeType()
|
|
->getUnqualifiedDesugaredType()
|
|
->getAs<FunctionProtoType>())
|
|
{
|
|
return CalleeWrapper(prototype);
|
|
}
|
|
}
|
|
|
|
return compat::optional<CalleeWrapper>();
|
|
}
|
|
|
|
loplugin::Plugin::Registration<UnusedVarsGlobal> X("unusedvarsglobal", false);
|
|
}
|
|
|
|
#endif
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|