| 1 |
//===--- TypePromotionInMathFnCheck.cpp - clang-tidy-----------------------===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
|
| 9 |
#include "TypePromotionInMathFnCheck.h" |
| 10 |
#include "clang/AST/ASTContext.h" |
| 11 |
#include "clang/ASTMatchers/ASTMatchFinder.h" |
| 12 |
#include "clang/Frontend/CompilerInstance.h" |
| 13 |
#include "clang/Lex/Preprocessor.h" |
| 14 |
#include "llvm/ADT/StringSet.h" |
| 15 |
|
| 16 |
using namespace clang::ast_matchers; |
| 17 |
|
| 18 |
namespace clang::tidy::performance { |
| 19 |
|
| 20 |
namespace { |
| 21 |
AST_MATCHER_P(Type, isBuiltinType, BuiltinType::Kind, Kind) { |
| 22 |
if (const auto *BT = dyn_cast<BuiltinType>(&Node)) { |
| 23 |
return BT->getKind() == Kind; |
| 24 |
} |
| 25 |
return false; |
| 26 |
} |
| 27 |
} // anonymous namespace |
| 28 |
|
| 29 |
TypePromotionInMathFnCheck::TypePromotionInMathFnCheck( |
| 30 |
StringRef Name, ClangTidyContext *Context) |
| 31 |
: ClangTidyCheck(Name, Context), |
| 32 |
IncludeInserter(Options.getLocalOrGlobal("IncludeStyle", |
| 33 |
utils::IncludeSorter::IS_LLVM), |
| 34 |
areDiagsSelfContained()) {} |
| 35 |
|
| 36 |
void TypePromotionInMathFnCheck::registerPPCallbacks( |
| 37 |
const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) { |
| 38 |
IncludeInserter.registerPreprocessor(PP); |
| 39 |
} |
| 40 |
|
| 41 |
void TypePromotionInMathFnCheck::storeOptions( |
| 42 |
ClangTidyOptions::OptionMap &Opts) { |
| 43 |
Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle()); |
| 44 |
} |
| 45 |
|
| 46 |
void TypePromotionInMathFnCheck::registerMatchers(MatchFinder *Finder) { |
| 47 |
constexpr BuiltinType::Kind IntTy = BuiltinType::Int; |
| 48 |
constexpr BuiltinType::Kind LongTy = BuiltinType::Long; |
| 49 |
constexpr BuiltinType::Kind FloatTy = BuiltinType::Float; |
| 50 |
constexpr BuiltinType::Kind DoubleTy = BuiltinType::Double; |
| 51 |
constexpr BuiltinType::Kind LongDoubleTy = BuiltinType::LongDouble; |
| 52 |
|
| 53 |
auto HasBuiltinTyParam = [](int Pos, BuiltinType::Kind Kind) { |
| 54 |
return hasParameter(Pos, hasType(isBuiltinType(Kind))); |
| 55 |
}; |
| 56 |
auto HasBuiltinTyArg = [](int Pos, BuiltinType::Kind Kind) { |
| 57 |
return hasArgument(Pos, hasType(isBuiltinType(Kind))); |
| 58 |
}; |
| 59 |
|
| 60 |
// Match calls to foo(double) with a float argument. |
| 61 |
auto OneDoubleArgFns = hasAnyName( |
| 62 |
"::acos", "::acosh", "::asin", "::asinh", "::atan", "::atanh", "::cbrt", |
| 63 |
"::ceil", "::cos", "::cosh", "::erf", "::erfc", "::exp", "::exp2", |
| 64 |
"::expm1", "::fabs", "::floor", "::ilogb", "::lgamma", "::llrint", |
| 65 |
"::log", "::log10", "::log1p", "::log2", "::logb", "::lrint", "::modf", |
| 66 |
"::nearbyint", "::rint", "::round", "::sin", "::sinh", "::sqrt", "::tan", |
| 67 |
"::tanh", "::tgamma", "::trunc", "::llround", "::lround"); |
| 68 |
Finder->addMatcher( |
| 69 |
callExpr(callee(functionDecl(OneDoubleArgFns, parameterCountIs(1), |
| 70 |
HasBuiltinTyParam(0, DoubleTy))), |
| 71 |
HasBuiltinTyArg(0, FloatTy)) |
| 72 |
.bind("call"), |
| 73 |
this); |
| 74 |
|
| 75 |
// Match calls to foo(double, double) where both args are floats. |
| 76 |
auto TwoDoubleArgFns = hasAnyName("::atan2", "::copysign", "::fdim", "::fmax", |
| 77 |
"::fmin", "::fmod", "::hypot", "::ldexp", |
| 78 |
"::nextafter", "::pow", "::remainder"); |
| 79 |
Finder->addMatcher( |
| 80 |
callExpr(callee(functionDecl(TwoDoubleArgFns, parameterCountIs(2), |
| 81 |
HasBuiltinTyParam(0, DoubleTy), |
| 82 |
HasBuiltinTyParam(1, DoubleTy))), |
| 83 |
HasBuiltinTyArg(0, FloatTy), HasBuiltinTyArg(1, FloatTy)) |
| 84 |
.bind("call"), |
| 85 |
this); |
| 86 |
|
| 87 |
// Match calls to fma(double, double, double) where all args are floats. |
| 88 |
Finder->addMatcher( |
| 89 |
callExpr(callee(functionDecl(hasName("::fma"), parameterCountIs(3), |
| 90 |
HasBuiltinTyParam(0, DoubleTy), |
| 91 |
HasBuiltinTyParam(1, DoubleTy), |
| 92 |
HasBuiltinTyParam(2, DoubleTy))), |
| 93 |
HasBuiltinTyArg(0, FloatTy), HasBuiltinTyArg(1, FloatTy), |
| 94 |
HasBuiltinTyArg(2, FloatTy)) |
| 95 |
.bind("call"), |
| 96 |
this); |
| 97 |
|
| 98 |
// Match calls to frexp(double, int*) where the first arg is a float. |
| 99 |
Finder->addMatcher( |
| 100 |
callExpr(callee(functionDecl( |
| 101 |
hasName("::frexp"), parameterCountIs(2), |
| 102 |
HasBuiltinTyParam(0, DoubleTy), |
| 103 |
hasParameter(1, parmVarDecl(hasType(pointerType( |
| 104 |
pointee(isBuiltinType(IntTy)))))))), |
| 105 |
HasBuiltinTyArg(0, FloatTy)) |
| 106 |
.bind("call"), |
| 107 |
this); |
| 108 |
|
| 109 |
// Match calls to nexttoward(double, long double) where the first arg is a |
| 110 |
// float. |
| 111 |
Finder->addMatcher( |
| 112 |
callExpr(callee(functionDecl(hasName("::nexttoward"), parameterCountIs(2), |
| 113 |
HasBuiltinTyParam(0, DoubleTy), |
| 114 |
HasBuiltinTyParam(1, LongDoubleTy))), |
| 115 |
HasBuiltinTyArg(0, FloatTy)) |
| 116 |
.bind("call"), |
| 117 |
this); |
| 118 |
|
| 119 |
// Match calls to remquo(double, double, int*) where the first two args are |
| 120 |
// floats. |
| 121 |
Finder->addMatcher( |
| 122 |
callExpr( |
| 123 |
callee(functionDecl( |
| 124 |
hasName("::remquo"), parameterCountIs(3), |
| 125 |
HasBuiltinTyParam(0, DoubleTy), HasBuiltinTyParam(1, DoubleTy), |
| 126 |
hasParameter(2, parmVarDecl(hasType(pointerType( |
| 127 |
pointee(isBuiltinType(IntTy)))))))), |
| 128 |
HasBuiltinTyArg(0, FloatTy), HasBuiltinTyArg(1, FloatTy)) |
| 129 |
.bind("call"), |
| 130 |
this); |
| 131 |
|
| 132 |
// Match calls to scalbln(double, long) where the first arg is a float. |
| 133 |
Finder->addMatcher( |
| 134 |
callExpr(callee(functionDecl(hasName("::scalbln"), parameterCountIs(2), |
| 135 |
HasBuiltinTyParam(0, DoubleTy), |
| 136 |
HasBuiltinTyParam(1, LongTy))), |
| 137 |
HasBuiltinTyArg(0, FloatTy)) |
| 138 |
.bind("call"), |
| 139 |
this); |
| 140 |
|
| 141 |
// Match calls to scalbn(double, int) where the first arg is a float. |
| 142 |
Finder->addMatcher( |
| 143 |
callExpr(callee(functionDecl(hasName("::scalbn"), parameterCountIs(2), |
| 144 |
HasBuiltinTyParam(0, DoubleTy), |
| 145 |
HasBuiltinTyParam(1, IntTy))), |
| 146 |
HasBuiltinTyArg(0, FloatTy)) |
| 147 |
.bind("call"), |
| 148 |
this); |
| 149 |
|
| 150 |
// modf(double, double*) is omitted because the second parameter forces the |
| 151 |
// type -- there's no conversion from float* to double*. |
| 152 |
} |
| 153 |
|
| 154 |
void TypePromotionInMathFnCheck::check(const MatchFinder::MatchResult &Result) { |
| 155 |
const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call"); |
| 156 |
assert(Call != nullptr); |
| 157 |
|
| 158 |
StringRef OldFnName = Call->getDirectCallee()->getName(); |
| 159 |
|
| 160 |
// In C++ mode, we prefer std::foo to ::foof. But some of these suggestions |
| 161 |
// are only valid in C++11 and newer. |
| 162 |
static llvm::StringSet<> Cpp11OnlyFns = { |
| 163 |
"acosh", "asinh", "atanh", "cbrt", "copysign", "erf", |
| 164 |
"erfc", "exp2", "expm1", "fdim", "fma", "fmax", |
| 165 |
"fmin", "hypot", "ilogb", "lgamma", "llrint", "llround", |
| 166 |
"log1p", "log2", "logb", "lrint", "lround", "nearbyint", |
| 167 |
"nextafter", "nexttoward", "remainder", "remquo", "rint", "round", |
| 168 |
"scalbln", "scalbn", "tgamma", "trunc"}; |
| 169 |
bool StdFnRequiresCpp11 = Cpp11OnlyFns.count(OldFnName); |
| 170 |
|
| 171 |
std::string NewFnName; |
| 172 |
bool FnInCmath = false; |
| 173 |
if (getLangOpts().CPlusPlus && |
| 174 |
(!StdFnRequiresCpp11 || getLangOpts().CPlusPlus11)) { |
| 175 |
NewFnName = ("std::" + OldFnName).str(); |
| 176 |
FnInCmath = true; |
| 177 |
} else { |
| 178 |
NewFnName = (OldFnName + "f").str(); |
| 179 |
} |
| 180 |
|
| 181 |
auto Diag = diag(Call->getExprLoc(), "call to '%0' promotes float to double") |
| 182 |
<< OldFnName |
| 183 |
<< FixItHint::CreateReplacement( |
| 184 |
Call->getCallee()->getSourceRange(), NewFnName); |
| 185 |
|
| 186 |
// Suggest including <cmath> if the function we're suggesting is declared in |
| 187 |
// <cmath> and it's not already included. We never have to suggest including |
| 188 |
// <math.h>, because the functions we're suggesting moving away from are all |
| 189 |
// declared in <math.h>. |
| 190 |
if (FnInCmath) |
| 191 |
Diag << IncludeInserter.createIncludeInsertion( |
| 192 |
Result.Context->getSourceManager().getFileID(Call->getBeginLoc()), |
| 193 |
"<cmath>"); |
| 194 |
} |
| 195 |
|
| 196 |
} // namespace clang::tidy::performance |