summaryrefslogtreecommitdiffstats
path: root/compilerplugins/clang/constantparam.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'compilerplugins/clang/constantparam.cxx')
-rw-r--r--compilerplugins/clang/constantparam.cxx296
1 files changed, 296 insertions, 0 deletions
diff --git a/compilerplugins/clang/constantparam.cxx b/compilerplugins/clang/constantparam.cxx
new file mode 100644
index 000000000..5fd472954
--- /dev/null
+++ b/compilerplugins/clang/constantparam.cxx
@@ -0,0 +1,296 @@
+/* -*- 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 <string>
+#include <set>
+#include <iostream>
+#include <fstream>
+
+#include "plugin.hxx"
+#include "compat.hxx"
+#include "check.hxx"
+#include "functionaddress.hxx"
+
+/*
+ Find params on methods where the param is only ever passed as a single constant value.
+
+ The process goes something like this:
+ $ make check
+ $ make FORCE_COMPILE=all COMPILER_PLUGIN_TOOL='constantparam' check
+ $ ./compilerplugins/clang/constantparam.py
+
+ TODO look for OUString and OString params and check for call-params that are always either "" or default constructed
+
+ FIXME this plugin manages to trigger crashes inside clang, when calling EvaluateAsInt, so I end up disabling it for a handful of files
+ here and there.
+*/
+
+namespace {
+
+struct MyCallSiteInfo
+{
+ std::string returnType;
+ std::string nameAndParams;
+ std::string paramName;
+ std::string paramType;
+ int paramIndex; // because in some declarations the names are empty
+ std::string callValue;
+ std::string sourceLocation;
+};
+bool operator < (const MyCallSiteInfo &lhs, const MyCallSiteInfo &rhs)
+{
+ return std::tie(lhs.sourceLocation, lhs.paramIndex, lhs.callValue)
+ < std::tie(rhs.sourceLocation, rhs.paramIndex, rhs.callValue);
+}
+
+
+// try to limit the voluminous output a little
+static std::set<MyCallSiteInfo> callSet;
+
+class ConstantParam:
+ public loplugin::FunctionAddress<loplugin::FilteringPlugin<ConstantParam>>
+{
+public:
+ explicit ConstantParam(loplugin::InstantiationData const & data): FunctionAddress(data) {}
+
+ virtual void run() override
+ {
+ // ignore some files that make clang crash inside EvaluateAsInt
+ std::string fn(handler.getMainFileName());
+ loplugin::normalizeDotDotInFilePath(fn);
+ if (loplugin::isSamePathname(fn, SRCDIR "/basegfx/source/matrix/b2dhommatrix.cxx")
+ || loplugin::isSamePathname(fn, SRCDIR "/basegfx/source/matrix/b3dhommatrix.cxx"))
+ return;
+
+ TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
+
+ // this catches places that take the address of a method
+ for (auto functionDecl : getFunctionsWithAddressTaken())
+ {
+ for (unsigned i = 0; i < functionDecl->getNumParams(); ++i)
+ addToCallSet(functionDecl, i, functionDecl->getParamDecl(i)->getName(), "unknown3");
+ }
+
+ // 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 MyCallSiteInfo & s : callSet)
+ output += s.returnType + "\t" + s.nameAndParams + "\t" + s.sourceLocation + "\t"
+ + s.paramName + "\t" + s.paramType + "\t" + s.callValue + "\n";
+ std::ofstream myfile;
+ myfile.open( WORKDIR "/loplugin.constantparam.log", std::ios::app | std::ios::out);
+ myfile << output;
+ myfile.close();
+ }
+
+ bool shouldVisitTemplateInstantiations () const { return true; }
+ bool shouldVisitImplicitCode () const { return true; }
+
+ bool VisitCallExpr( const CallExpr* );
+ bool VisitCXXConstructExpr( const CXXConstructExpr* );
+private:
+ void addToCallSet(const FunctionDecl* functionDecl, int paramIndex, llvm::StringRef paramName, const std::string& callValue);
+ std::string getCallValue(const Expr* arg);
+};
+
+void ConstantParam::addToCallSet(const FunctionDecl* functionDecl, int paramIndex, llvm::StringRef paramName, const std::string& callValue)
+{
+ if (functionDecl->getInstantiatedFromMemberFunction())
+ functionDecl = functionDecl->getInstantiatedFromMemberFunction();
+ else if (functionDecl->getTemplateInstantiationPattern())
+ functionDecl = functionDecl->getTemplateInstantiationPattern();
+
+ if (!functionDecl->getNameInfo().getLoc().isValid())
+ return;
+ if (functionDecl->isVariadic())
+ return;
+ // ignore stuff that forms part of the stable URE interface
+ if (isInUnoIncludeFile(functionDecl))
+ return;
+ SourceLocation expansionLoc = compiler.getSourceManager().getExpansionLoc( functionDecl->getLocation() );
+ StringRef filename = getFilenameOfLocation(expansionLoc);
+ if (!loplugin::hasPathnamePrefix(filename, SRCDIR "/"))
+ return;
+ filename = filename.substr(strlen(SRCDIR)+1);
+
+ MyCallSiteInfo aInfo;
+ aInfo.returnType = functionDecl->getReturnType().getCanonicalType().getAsString();
+
+ if (isa<CXXMethodDecl>(functionDecl)) {
+ const CXXRecordDecl* recordDecl = dyn_cast<CXXMethodDecl>(functionDecl)->getParent();
+ aInfo.nameAndParams += recordDecl->getQualifiedNameAsString();
+ aInfo.nameAndParams += "::";
+ }
+ aInfo.nameAndParams += functionDecl->getNameAsString() + "(";
+ bool bFirst = true;
+ for (const ParmVarDecl *pParmVarDecl : functionDecl->parameters()) {
+ if (bFirst)
+ bFirst = false;
+ else
+ aInfo.nameAndParams += ",";
+ aInfo.nameAndParams += pParmVarDecl->getType().getCanonicalType().getAsString();
+ }
+ aInfo.nameAndParams += ")";
+ if (isa<CXXMethodDecl>(functionDecl) && dyn_cast<CXXMethodDecl>(functionDecl)->isConst()) {
+ aInfo.nameAndParams += " const";
+ }
+ aInfo.paramName = paramName.str();
+ aInfo.paramIndex = paramIndex;
+ if (paramIndex < (int)functionDecl->getNumParams())
+ aInfo.paramType = functionDecl->getParamDecl(paramIndex)->getType().getCanonicalType().getAsString();
+
+ aInfo.callValue = callValue;
+ aInfo.sourceLocation = filename.str() + ":" + std::to_string(compiler.getSourceManager().getSpellingLineNumber(expansionLoc));
+ loplugin::normalizeDotDotInFilePath(aInfo.sourceLocation);
+
+ callSet.insert(aInfo);
+}
+
+std::string ConstantParam::getCallValue(const Expr* arg)
+{
+ arg = arg->IgnoreParenCasts();
+ 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 "unknown1";
+ if (arg->isValueDependent())
+ return "unknown2";
+ APSInt x1;
+ if (compat::EvaluateAsInt(arg, x1, compiler.getASTContext()))
+ {
+ return compat::toString(x1, 10);
+ }
+ if (isa<CXXNullPtrLiteralExpr>(arg)) {
+ return "0";
+ }
+ 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 "\"\"";
+ }
+ if (loplugin::TypeCheck(temp->getType()).Class("OString").Namespace("rtl").GlobalNamespace()) {
+ return "\"\"";
+ }
+ return "defaultConstruct";
+ }
+ }
+ }
+
+ // 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 "unknown";
+ }
+ unsigned n = Lexer::MeasureTokenLength( endLoc, SM, compiler.getLangOpts());
+ std::string s( p1, p2 - p1 + n);
+ // sanitize call value, makes using command line tools (and python) much less error prone
+ for (auto const & ch : s)
+ if (ch < 32)
+ return "sanitised";
+
+ // 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()")
+ s = "\"\"";
+ else if (s == "OString()")
+ s = "\"\"";
+ return s;
+}
+
+bool ConstantParam::VisitCallExpr(const CallExpr * callExpr) {
+ if (ignoreLocation(callExpr)) {
+ return true;
+ }
+ const FunctionDecl* functionDecl;
+ if (isa<CXXMemberCallExpr>(callExpr)) {
+ functionDecl = dyn_cast<CXXMemberCallExpr>(callExpr)->getMethodDecl();
+ }
+ else {
+ functionDecl = callExpr->getDirectCallee();
+ }
+ if (!functionDecl)
+ return true;
+ functionDecl = functionDecl->getCanonicalDecl();
+ // method overrides don't always specify the same default params (although they probably should)
+ // so we need to work our way up to the root method
+ while (isa<CXXMethodDecl>(functionDecl)) {
+ const CXXMethodDecl* methodDecl = dyn_cast<CXXMethodDecl>(functionDecl);
+ if (methodDecl->size_overridden_methods()==0)
+ break;
+ functionDecl = *methodDecl->begin_overridden_methods();
+ }
+ // work our way back to the root definition for template methods
+ if (functionDecl->getInstantiatedFromMemberFunction())
+ functionDecl = functionDecl->getInstantiatedFromMemberFunction();
+ else if (functionDecl->getTemplateInstantiationPattern())
+ functionDecl = functionDecl->getTemplateInstantiationPattern();
+
+ unsigned len = std::max(callExpr->getNumArgs(), functionDecl->getNumParams());
+ for (unsigned i = 0; i < len; ++i) {
+ const Expr* valExpr;
+ if (i < callExpr->getNumArgs())
+ valExpr = callExpr->getArg(i);
+ else if (i < functionDecl->getNumParams() && functionDecl->getParamDecl(i)->hasDefaultArg())
+ valExpr = functionDecl->getParamDecl(i)->getDefaultArg();
+ else
+ // can happen in template code
+ continue;
+ std::string callValue = getCallValue(valExpr);
+ std::string paramName = i < functionDecl->getNumParams()
+ ? functionDecl->getParamDecl(i)->getName().str()
+ : "###" + std::to_string(i);
+ addToCallSet(functionDecl, i, paramName, callValue);
+ }
+ return true;
+}
+
+bool ConstantParam::VisitCXXConstructExpr( const CXXConstructExpr* constructExpr )
+{
+ const CXXConstructorDecl* constructorDecl = constructExpr->getConstructor();
+ constructorDecl = constructorDecl->getCanonicalDecl();
+
+ unsigned len = std::max(constructExpr->getNumArgs(), constructorDecl->getNumParams());
+ for (unsigned i = 0; i < len; ++i) {
+ const Expr* valExpr;
+ if (i < constructExpr->getNumArgs())
+ valExpr = constructExpr->getArg(i);
+ else if (i < constructorDecl->getNumParams() && constructorDecl->getParamDecl(i)->hasDefaultArg())
+ valExpr = constructorDecl->getParamDecl(i)->getDefaultArg();
+ else
+ // can happen in template code
+ continue;
+ std::string callValue = getCallValue(valExpr);
+ std::string paramName = i < constructorDecl->getNumParams()
+ ? constructorDecl->getParamDecl(i)->getName().str()
+ : "###" + std::to_string(i);
+ addToCallSet(constructorDecl, i, paramName, callValue);
+ }
+ return true;
+}
+
+
+loplugin::Plugin::Registration< ConstantParam > X("constantparam", false);
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */