8d8d25f5dd
Rename it to FORCE_COMPILE and it takes the --enable-symbols specification of what to include, for example FORCE_COMPILE="all -sw/ -Library_sc". Change-Id: I92afd8e0abc75d3566285c197d6640c26c03db36 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/122248 Tested-by: Jenkins Reviewed-by: Luboš Luňák <l.lunak@collabora.com>
261 lines
9.7 KiB
C++
261 lines
9.7 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/.
|
|
*/
|
|
|
|
#include <string>
|
|
#include <set>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
|
|
#include "clang/AST/Attr.h"
|
|
|
|
#include "plugin.hxx"
|
|
#include "compat.hxx"
|
|
|
|
/*
|
|
Count call sites that are actually using the defaulted values on params on methods that declare such.
|
|
|
|
The process goes something like this:
|
|
$ make check
|
|
$ make FORCE_COMPILE=all COMPILER_PLUGIN_TOOL='countusersofdefaultparams' check
|
|
$ ./compilerplugins/clang/countusersofdefaultparams.py
|
|
*/
|
|
|
|
namespace {
|
|
|
|
struct MyFuncInfo
|
|
{
|
|
std::string access;
|
|
std::string returnType;
|
|
std::string nameAndParams;
|
|
std::string sourceLocation;
|
|
};
|
|
bool operator < (const MyFuncInfo &lhs, const MyFuncInfo &rhs)
|
|
{
|
|
return std::tie(lhs.returnType, lhs.nameAndParams)
|
|
< std::tie(rhs.returnType, rhs.nameAndParams);
|
|
}
|
|
struct MyCallInfo : public MyFuncInfo
|
|
{
|
|
std::string sourceLocationOfCall;
|
|
};
|
|
bool operator < (const MyCallInfo &lhs, const MyCallInfo &rhs)
|
|
{
|
|
return std::tie(lhs.returnType, lhs.nameAndParams, lhs.sourceLocationOfCall)
|
|
< std::tie(rhs.returnType, rhs.nameAndParams, rhs.sourceLocationOfCall);
|
|
}
|
|
|
|
|
|
// try to limit the voluminous output a little
|
|
static std::set<MyCallInfo> callSet;
|
|
static std::set<MyFuncInfo> definitionSet;
|
|
|
|
class CountUsersOfDefaultParams:
|
|
public RecursiveASTVisitor<CountUsersOfDefaultParams>, public loplugin::Plugin
|
|
{
|
|
public:
|
|
explicit CountUsersOfDefaultParams(loplugin::InstantiationData const & data): Plugin(data) {}
|
|
|
|
virtual void run() override
|
|
{
|
|
TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
|
|
|
|
// 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 MyFuncInfo & s : definitionSet)
|
|
output += "defn:\t" + s.access + "\t" + s.returnType + "\t" + s.nameAndParams + "\t" + s.sourceLocation + "\n";
|
|
for (const MyCallInfo & s : callSet)
|
|
output += "call:\t" + s.returnType + "\t" + s.nameAndParams + "\t" + s.sourceLocationOfCall + "\n";
|
|
std::ofstream myfile;
|
|
myfile.open( WORKDIR "/loplugin.countusersofdefaultparams.log", std::ios::app | std::ios::out);
|
|
myfile << output;
|
|
myfile.close();
|
|
}
|
|
|
|
bool shouldVisitTemplateInstantiations () const { return true; }
|
|
|
|
bool VisitCallExpr( const CallExpr * );
|
|
bool VisitFunctionDecl( const FunctionDecl* );
|
|
bool VisitCXXConstructExpr( const CXXConstructExpr * );
|
|
private:
|
|
void niceName(const FunctionDecl* functionDecl, MyFuncInfo&);
|
|
std::string locationToString(const SourceLocation&);
|
|
};
|
|
|
|
void CountUsersOfDefaultParams::niceName(const FunctionDecl* functionDecl, MyFuncInfo& aInfo)
|
|
{
|
|
if (functionDecl->getInstantiatedFromMemberFunction())
|
|
functionDecl = functionDecl->getInstantiatedFromMemberFunction();
|
|
#if CLANG_VERSION < 90000
|
|
else if (functionDecl->getClassScopeSpecializationPattern())
|
|
functionDecl = functionDecl->getClassScopeSpecializationPattern();
|
|
#endif
|
|
else if (functionDecl->getTemplateInstantiationPattern())
|
|
functionDecl = functionDecl->getTemplateInstantiationPattern();
|
|
|
|
switch (functionDecl->getAccess())
|
|
{
|
|
case AS_public: aInfo.access = "public"; break;
|
|
case AS_private: aInfo.access = "private"; break;
|
|
case AS_protected: aInfo.access = "protected"; break;
|
|
default: aInfo.access = "unknown"; break;
|
|
}
|
|
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.sourceLocation = locationToString(functionDecl->getLocation());
|
|
loplugin::normalizeDotDotInFilePath(aInfo.sourceLocation);
|
|
}
|
|
|
|
bool CountUsersOfDefaultParams::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 == nullptr) {
|
|
return true;
|
|
}
|
|
functionDecl = functionDecl->getCanonicalDecl();
|
|
// 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();
|
|
#if CLANG_VERSION < 90000
|
|
else if (functionDecl->getClassScopeSpecializationPattern())
|
|
functionDecl = functionDecl->getClassScopeSpecializationPattern();
|
|
#endif
|
|
else if (functionDecl->getTemplateInstantiationPattern())
|
|
functionDecl = functionDecl->getTemplateInstantiationPattern();
|
|
int n = functionDecl->getNumParams() - 1;
|
|
if (n < 0 || !functionDecl->getParamDecl(n)->hasDefaultArg()) {
|
|
return true;
|
|
}
|
|
while (n > 0 && functionDecl->getParamDecl(n-1)->hasDefaultArg()) {
|
|
--n;
|
|
}
|
|
// look for callsites that are actually using the defaulted values
|
|
if ( n < (int)callExpr->getNumArgs() && callExpr->getArg(n)->isDefaultArgument()) {
|
|
MyCallInfo callInfo;
|
|
niceName(functionDecl, callInfo);
|
|
callInfo.sourceLocationOfCall = locationToString(compat::getBeginLoc(callExpr));
|
|
callSet.insert(callInfo);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CountUsersOfDefaultParams::VisitCXXConstructExpr(const CXXConstructExpr * constructExpr) {
|
|
if (ignoreLocation(constructExpr)) {
|
|
return true;
|
|
}
|
|
const CXXConstructorDecl* constructorDecl = constructExpr->getConstructor()->getCanonicalDecl();
|
|
// work our way back to the root definition for template methods
|
|
if (constructorDecl->getInstantiatedFromMemberFunction())
|
|
constructorDecl = dyn_cast<CXXConstructorDecl>(constructorDecl->getInstantiatedFromMemberFunction());
|
|
#if CLANG_VERSION < 90000
|
|
else if (constructorDecl->getClassScopeSpecializationPattern())
|
|
constructorDecl = dyn_cast<CXXConstructorDecl>(constructorDecl->getClassScopeSpecializationPattern());
|
|
#endif
|
|
else if (constructorDecl->getTemplateInstantiationPattern())
|
|
constructorDecl = dyn_cast<CXXConstructorDecl>(constructorDecl->getTemplateInstantiationPattern());
|
|
int n = constructorDecl->getNumParams() - 1;
|
|
if (n < 0 || !constructorDecl->getParamDecl(n)->hasDefaultArg()) {
|
|
return true;
|
|
}
|
|
while (n > 0 && constructorDecl->getParamDecl(n-1)->hasDefaultArg()) {
|
|
--n;
|
|
}
|
|
// look for callsites that are actually using the defaulted values
|
|
if ( n < (int)constructExpr->getNumArgs() && constructExpr->getArg(n)->isDefaultArgument()) {
|
|
MyCallInfo callInfo;
|
|
niceName(constructorDecl, callInfo);
|
|
callInfo.sourceLocationOfCall = locationToString(compat::getBeginLoc(constructExpr));
|
|
callSet.insert(callInfo);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::string CountUsersOfDefaultParams::locationToString(const SourceLocation& sourceLoc)
|
|
{
|
|
SourceLocation expansionLoc = compiler.getSourceManager().getExpansionLoc( sourceLoc );
|
|
StringRef name = getFilenameOfLocation(expansionLoc);
|
|
return std::string(name.substr(strlen(SRCDIR)+1)) + ":" + std::to_string(compiler.getSourceManager().getSpellingLineNumber(expansionLoc));
|
|
}
|
|
|
|
bool CountUsersOfDefaultParams::VisitFunctionDecl( const FunctionDecl* functionDecl )
|
|
{
|
|
functionDecl = functionDecl->getCanonicalDecl();
|
|
if( !functionDecl || !functionDecl->getLocation().isValid() || ignoreLocation( functionDecl )) {
|
|
return true;
|
|
}
|
|
const CXXMethodDecl* methodDecl = dyn_cast_or_null<CXXMethodDecl>(functionDecl);
|
|
|
|
// ignore method overrides, since the call will show up as being directed to the root method
|
|
if (methodDecl && (methodDecl->size_overridden_methods() != 0 || methodDecl->hasAttr<OverrideAttr>())) {
|
|
return true;
|
|
}
|
|
// ignore stuff that forms part of the stable URE interface
|
|
if (isInUnoIncludeFile(functionDecl)) {
|
|
return true;
|
|
}
|
|
if (isa<CXXDestructorDecl>(functionDecl)) {
|
|
return true;
|
|
}
|
|
if (functionDecl->isDeleted()) {
|
|
return true;
|
|
}
|
|
auto n = functionDecl->getNumParams();
|
|
if (n == 0 || !functionDecl->getParamDecl(n - 1)->hasDefaultArg()) {
|
|
return true;
|
|
}
|
|
|
|
if( functionDecl->getLocation().isValid() )
|
|
{
|
|
MyFuncInfo funcInfo;
|
|
niceName(functionDecl, funcInfo);
|
|
definitionSet.insert(funcInfo);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
loplugin::Plugin::Registration< CountUsersOfDefaultParams > X("countusersofdefaultparams", false);
|
|
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|