ce1d8e20a7
...<https://github.com/llvm/llvm-project/commit/ 777180a32b61070a10dd330b4f038bf24e916af1>. This is just a quick fix to get copmilerplugins buiding again with latest LLVM/Clang trunk. Ideally, we should get rid of as many of those (potentially expensive) conversions from llvm::StringRef to std::string as possible. Change-Id: I18e185e0022a06fd8e3b983a3c4f80e1f3b96746 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/87682 Tested-by: Jenkins Reviewed-by: Stephan Bergmann <sbergman@redhat.com>
576 lines
21 KiB
C++
576 lines
21 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 <cassert>
|
|
#include <string>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <set>
|
|
|
|
#include "config_clang.h"
|
|
|
|
#include "plugin.hxx"
|
|
|
|
#if CLANG_VERSION >= 110000
|
|
#include "clang/AST/ParentMapContext.h"
|
|
#endif
|
|
|
|
/**
|
|
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=1 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;
|
|
|
|
|
|
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" + 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(compat::getBeginLoc(s.fieldDecl)))
|
|
report(
|
|
DiagnosticsEngine::Warning,
|
|
"assign %0",
|
|
compat::getBeginLoc(s.fieldDecl))
|
|
<< 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( ignoreLocation( canonicalDecl )
|
|
|| 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( ignoreLocation( canonicalDecl )
|
|
|| 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 )
|
|
{
|
|
if( ignoreLocation( decl ) )
|
|
return true;
|
|
|
|
// 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;
|
|
if (ignoreLocation(memberExpr))
|
|
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;
|
|
if (ignoreLocation(declRefExpr))
|
|
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<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?",
|
|
compat::getBeginLoc(memberExpr))
|
|
<< 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 x1.toString(10);
|
|
if (isa<CXXNullPtrLiteralExpr>(arg))
|
|
return "0";
|
|
return "?";
|
|
}
|
|
|
|
loplugin::Plugin::Registration< SingleValFields > X("singlevalfields", false);
|
|
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|