mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-20 03:55:48 -04:00
2946cd7010
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
447 lines
18 KiB
C++
447 lines
18 KiB
C++
//===--- NarrowingConversionsCheck.cpp - clang-tidy------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "NarrowingConversionsCheck.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/Type.h"
|
|
#include "clang/ASTMatchers/ASTMatchFinder.h"
|
|
#include "llvm/ADT/APSInt.h"
|
|
#include "llvm/ADT/SmallString.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
|
|
#include <cstdint>
|
|
|
|
using namespace clang::ast_matchers;
|
|
|
|
namespace clang {
|
|
namespace tidy {
|
|
namespace cppcoreguidelines {
|
|
|
|
NarrowingConversionsCheck::NarrowingConversionsCheck(StringRef Name,
|
|
ClangTidyContext *Context)
|
|
: ClangTidyCheck(Name, Context),
|
|
WarnOnFloatingPointNarrowingConversion(
|
|
Options.get("WarnOnFloatingPointNarrowingConversion", 1)),
|
|
PedanticMode(Options.get("PedanticMode", 0)) {}
|
|
|
|
void NarrowingConversionsCheck::registerMatchers(MatchFinder *Finder) {
|
|
// ceil() and floor() are guaranteed to return integers, even though the type
|
|
// is not integral.
|
|
const auto IsCeilFloorCallExpr = expr(callExpr(callee(functionDecl(
|
|
hasAnyName("::ceil", "::std::ceil", "::floor", "::std::floor")))));
|
|
|
|
// Casts:
|
|
// i = 0.5;
|
|
// void f(int); f(0.5);
|
|
Finder->addMatcher(
|
|
implicitCastExpr(hasImplicitDestinationType(builtinType()),
|
|
hasSourceExpression(hasType(builtinType())),
|
|
unless(hasSourceExpression(IsCeilFloorCallExpr)),
|
|
unless(hasParent(castExpr())),
|
|
unless(isInTemplateInstantiation()))
|
|
.bind("cast"),
|
|
this);
|
|
|
|
// Binary operators:
|
|
// i += 0.5;
|
|
Finder->addMatcher(binaryOperator(isAssignmentOperator(),
|
|
hasLHS(expr(hasType(builtinType()))),
|
|
hasRHS(expr(hasType(builtinType()))),
|
|
unless(hasRHS(IsCeilFloorCallExpr)),
|
|
unless(isInTemplateInstantiation()),
|
|
// The `=` case generates an implicit cast
|
|
// which is covered by the previous matcher.
|
|
unless(hasOperatorName("=")))
|
|
.bind("binary_op"),
|
|
this);
|
|
}
|
|
|
|
static const BuiltinType *getBuiltinType(const Expr &E) {
|
|
return E.getType().getCanonicalType().getTypePtr()->getAs<BuiltinType>();
|
|
}
|
|
|
|
static QualType getUnqualifiedType(const Expr &E) {
|
|
return E.getType().getUnqualifiedType();
|
|
}
|
|
|
|
static APValue getConstantExprValue(const ASTContext &Ctx, const Expr &E) {
|
|
llvm::APSInt IntegerConstant;
|
|
if (E.isIntegerConstantExpr(IntegerConstant, Ctx))
|
|
return APValue(IntegerConstant);
|
|
APValue Constant;
|
|
if (Ctx.getLangOpts().CPlusPlus && E.isCXX11ConstantExpr(Ctx, &Constant))
|
|
return Constant;
|
|
return {};
|
|
}
|
|
|
|
static bool getIntegerConstantExprValue(const ASTContext &Context,
|
|
const Expr &E, llvm::APSInt &Value) {
|
|
APValue Constant = getConstantExprValue(Context, E);
|
|
if (!Constant.isInt())
|
|
return false;
|
|
Value = Constant.getInt();
|
|
return true;
|
|
}
|
|
|
|
static bool getFloatingConstantExprValue(const ASTContext &Context,
|
|
const Expr &E, llvm::APFloat &Value) {
|
|
APValue Constant = getConstantExprValue(Context, E);
|
|
if (!Constant.isFloat())
|
|
return false;
|
|
Value = Constant.getFloat();
|
|
return true;
|
|
}
|
|
|
|
namespace {
|
|
|
|
struct IntegerRange {
|
|
bool Contains(const IntegerRange &From) const {
|
|
return llvm::APSInt::compareValues(Lower, From.Lower) <= 0 &&
|
|
llvm::APSInt::compareValues(Upper, From.Upper) >= 0;
|
|
}
|
|
|
|
bool Contains(const llvm::APSInt &Value) const {
|
|
return llvm::APSInt::compareValues(Lower, Value) <= 0 &&
|
|
llvm::APSInt::compareValues(Upper, Value) >= 0;
|
|
}
|
|
|
|
llvm::APSInt Lower;
|
|
llvm::APSInt Upper;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
static IntegerRange createFromType(const ASTContext &Context,
|
|
const BuiltinType &T) {
|
|
if (T.isFloatingPoint()) {
|
|
unsigned PrecisionBits = llvm::APFloatBase::semanticsPrecision(
|
|
Context.getFloatTypeSemantics(T.desugar()));
|
|
// Contrary to two's complement integer, floating point values are
|
|
// symmetric and have the same number of positive and negative values.
|
|
// The range of valid integers for a floating point value is:
|
|
// [-2^PrecisionBits, 2^PrecisionBits]
|
|
|
|
// Values are created with PrecisionBits plus two bits:
|
|
// - One to express the missing negative value of 2's complement
|
|
// representation.
|
|
// - One for the sign.
|
|
llvm::APSInt UpperValue(PrecisionBits + 2, /*isUnsigned*/ false);
|
|
UpperValue.setBit(PrecisionBits);
|
|
llvm::APSInt LowerValue(PrecisionBits + 2, /*isUnsigned*/ false);
|
|
LowerValue.setBit(PrecisionBits);
|
|
LowerValue.setSignBit();
|
|
return {LowerValue, UpperValue};
|
|
}
|
|
assert(T.isInteger() && "Unexpected builtin type");
|
|
uint64_t TypeSize = Context.getTypeSize(&T);
|
|
bool IsUnsignedInteger = T.isUnsignedInteger();
|
|
return {llvm::APSInt::getMinValue(TypeSize, IsUnsignedInteger),
|
|
llvm::APSInt::getMaxValue(TypeSize, IsUnsignedInteger)};
|
|
}
|
|
|
|
static bool isWideEnoughToHold(const ASTContext &Context,
|
|
const BuiltinType &FromType,
|
|
const BuiltinType &ToType) {
|
|
IntegerRange FromIntegerRange = createFromType(Context, FromType);
|
|
IntegerRange ToIntegerRange = createFromType(Context, ToType);
|
|
return ToIntegerRange.Contains(FromIntegerRange);
|
|
}
|
|
|
|
static bool isWideEnoughToHold(const ASTContext &Context,
|
|
const llvm::APSInt &IntegerConstant,
|
|
const BuiltinType &ToType) {
|
|
IntegerRange ToIntegerRange = createFromType(Context, ToType);
|
|
return ToIntegerRange.Contains(IntegerConstant);
|
|
}
|
|
|
|
static llvm::SmallString<64> getValueAsString(const llvm::APSInt &Value,
|
|
uint64_t HexBits) {
|
|
llvm::SmallString<64> Str;
|
|
Value.toString(Str, 10);
|
|
if (HexBits > 0) {
|
|
Str.append(" (0x");
|
|
llvm::SmallString<32> HexValue;
|
|
Value.toStringUnsigned(HexValue, 16);
|
|
for (size_t I = HexValue.size(); I < (HexBits / 4); ++I)
|
|
Str.append("0");
|
|
Str.append(HexValue);
|
|
Str.append(")");
|
|
}
|
|
return Str;
|
|
}
|
|
|
|
void NarrowingConversionsCheck::diagNarrowType(SourceLocation SourceLoc,
|
|
const Expr &Lhs,
|
|
const Expr &Rhs) {
|
|
diag(SourceLoc, "narrowing conversion from %0 to %1")
|
|
<< getUnqualifiedType(Rhs) << getUnqualifiedType(Lhs);
|
|
}
|
|
|
|
void NarrowingConversionsCheck::diagNarrowTypeToSignedInt(
|
|
SourceLocation SourceLoc, const Expr &Lhs, const Expr &Rhs) {
|
|
diag(SourceLoc, "narrowing conversion from %0 to signed type %1 is "
|
|
"implementation-defined")
|
|
<< getUnqualifiedType(Rhs) << getUnqualifiedType(Lhs);
|
|
}
|
|
|
|
void NarrowingConversionsCheck::diagNarrowIntegerConstant(
|
|
SourceLocation SourceLoc, const Expr &Lhs, const Expr &Rhs,
|
|
const llvm::APSInt &Value) {
|
|
diag(SourceLoc,
|
|
"narrowing conversion from constant value %0 of type %1 to %2")
|
|
<< getValueAsString(Value, /*NoHex*/ 0) << getUnqualifiedType(Rhs)
|
|
<< getUnqualifiedType(Lhs);
|
|
}
|
|
|
|
void NarrowingConversionsCheck::diagNarrowIntegerConstantToSignedInt(
|
|
SourceLocation SourceLoc, const Expr &Lhs, const Expr &Rhs,
|
|
const llvm::APSInt &Value, const uint64_t HexBits) {
|
|
diag(SourceLoc, "narrowing conversion from constant value %0 of type %1 "
|
|
"to signed type %2 is implementation-defined")
|
|
<< getValueAsString(Value, HexBits) << getUnqualifiedType(Rhs)
|
|
<< getUnqualifiedType(Lhs);
|
|
}
|
|
|
|
void NarrowingConversionsCheck::diagNarrowConstant(SourceLocation SourceLoc,
|
|
const Expr &Lhs,
|
|
const Expr &Rhs) {
|
|
diag(SourceLoc, "narrowing conversion from constant %0 to %1")
|
|
<< getUnqualifiedType(Rhs) << getUnqualifiedType(Lhs);
|
|
}
|
|
|
|
void NarrowingConversionsCheck::diagConstantCast(SourceLocation SourceLoc,
|
|
const Expr &Lhs,
|
|
const Expr &Rhs) {
|
|
diag(SourceLoc, "constant value should be of type of type %0 instead of %1")
|
|
<< getUnqualifiedType(Lhs) << getUnqualifiedType(Rhs);
|
|
}
|
|
|
|
void NarrowingConversionsCheck::diagNarrowTypeOrConstant(
|
|
const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
|
|
const Expr &Rhs) {
|
|
APValue Constant = getConstantExprValue(Context, Rhs);
|
|
if (Constant.isInt())
|
|
return diagNarrowIntegerConstant(SourceLoc, Lhs, Rhs, Constant.getInt());
|
|
if (Constant.isFloat())
|
|
return diagNarrowConstant(SourceLoc, Lhs, Rhs);
|
|
return diagNarrowType(SourceLoc, Lhs, Rhs);
|
|
}
|
|
|
|
void NarrowingConversionsCheck::handleIntegralCast(const ASTContext &Context,
|
|
SourceLocation SourceLoc,
|
|
const Expr &Lhs,
|
|
const Expr &Rhs) {
|
|
const BuiltinType *ToType = getBuiltinType(Lhs);
|
|
// From [conv.integral]p7.3.8:
|
|
// Conversions to unsigned integer is well defined so no warning is issued.
|
|
// "The resulting value is the smallest unsigned value equal to the source
|
|
// value modulo 2^n where n is the number of bits used to represent the
|
|
// destination type."
|
|
if (ToType->isUnsignedInteger())
|
|
return;
|
|
const BuiltinType *FromType = getBuiltinType(Rhs);
|
|
llvm::APSInt IntegerConstant;
|
|
if (getIntegerConstantExprValue(Context, Rhs, IntegerConstant)) {
|
|
if (!isWideEnoughToHold(Context, IntegerConstant, *ToType))
|
|
diagNarrowIntegerConstantToSignedInt(SourceLoc, Lhs, Rhs, IntegerConstant,
|
|
Context.getTypeSize(FromType));
|
|
return;
|
|
}
|
|
if (!isWideEnoughToHold(Context, *FromType, *ToType))
|
|
diagNarrowTypeToSignedInt(SourceLoc, Lhs, Rhs);
|
|
}
|
|
|
|
void NarrowingConversionsCheck::handleIntegralToBoolean(
|
|
const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
|
|
const Expr &Rhs) {
|
|
// Conversion from Integral to Bool value is well defined.
|
|
|
|
// We keep this function (even if it is empty) to make sure that
|
|
// handleImplicitCast and handleBinaryOperator are symmetric in their behavior
|
|
// and handle the same cases.
|
|
}
|
|
|
|
void NarrowingConversionsCheck::handleIntegralToFloating(
|
|
const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
|
|
const Expr &Rhs) {
|
|
const BuiltinType *ToType = getBuiltinType(Lhs);
|
|
llvm::APSInt IntegerConstant;
|
|
if (getIntegerConstantExprValue(Context, Rhs, IntegerConstant)) {
|
|
if (!isWideEnoughToHold(Context, IntegerConstant, *ToType))
|
|
diagNarrowIntegerConstant(SourceLoc, Lhs, Rhs, IntegerConstant);
|
|
return;
|
|
}
|
|
const BuiltinType *FromType = getBuiltinType(Rhs);
|
|
if (!isWideEnoughToHold(Context, *FromType, *ToType))
|
|
diagNarrowType(SourceLoc, Lhs, Rhs);
|
|
}
|
|
|
|
void NarrowingConversionsCheck::handleFloatingToIntegral(
|
|
const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
|
|
const Expr &Rhs) {
|
|
llvm::APFloat FloatConstant(0.0);
|
|
|
|
// We always warn when Rhs is non-constexpr.
|
|
if (!getFloatingConstantExprValue(Context, Rhs, FloatConstant))
|
|
return diagNarrowType(SourceLoc, Lhs, Rhs);
|
|
|
|
QualType DestType = Lhs.getType();
|
|
unsigned DestWidth = Context.getIntWidth(DestType);
|
|
bool DestSigned = DestType->isSignedIntegerOrEnumerationType();
|
|
llvm::APSInt Result = llvm::APSInt(DestWidth, !DestSigned);
|
|
bool IsExact = false;
|
|
bool Overflows = FloatConstant.convertToInteger(
|
|
Result, llvm::APFloat::rmTowardZero, &IsExact) &
|
|
llvm::APFloat::opInvalidOp;
|
|
// We warn iff the constant floating point value is not exactly representable.
|
|
if (Overflows || !IsExact)
|
|
return diagNarrowConstant(SourceLoc, Lhs, Rhs);
|
|
|
|
if (PedanticMode)
|
|
return diagConstantCast(SourceLoc, Lhs, Rhs);
|
|
}
|
|
|
|
void NarrowingConversionsCheck::handleFloatingToBoolean(
|
|
const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
|
|
const Expr &Rhs) {
|
|
return diagNarrowTypeOrConstant(Context, SourceLoc, Lhs, Rhs);
|
|
}
|
|
|
|
void NarrowingConversionsCheck::handleBooleanToSignedIntegral(
|
|
const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
|
|
const Expr &Rhs) {
|
|
// Conversion from Bool to SignedIntegral value is well defined.
|
|
|
|
// We keep this function (even if it is empty) to make sure that
|
|
// handleImplicitCast and handleBinaryOperator are symmetric in their behavior
|
|
// and handle the same cases.
|
|
}
|
|
|
|
void NarrowingConversionsCheck::handleFloatingCast(const ASTContext &Context,
|
|
SourceLocation SourceLoc,
|
|
const Expr &Lhs,
|
|
const Expr &Rhs) {
|
|
if (WarnOnFloatingPointNarrowingConversion) {
|
|
const BuiltinType *ToType = getBuiltinType(Lhs);
|
|
APValue Constant = getConstantExprValue(Context, Rhs);
|
|
if (Constant.isFloat()) {
|
|
// From [dcl.init.list]p7.2:
|
|
// Floating point constant narrowing only takes place when the value is
|
|
// not within destination range. We convert the value to the destination
|
|
// type and check if the resulting value is infinity.
|
|
llvm::APFloat Tmp = Constant.getFloat();
|
|
bool UnusedLosesInfo;
|
|
Tmp.convert(Context.getFloatTypeSemantics(ToType->desugar()),
|
|
llvm::APFloatBase::rmNearestTiesToEven, &UnusedLosesInfo);
|
|
if (Tmp.isInfinity())
|
|
diagNarrowConstant(SourceLoc, Lhs, Rhs);
|
|
return;
|
|
}
|
|
const BuiltinType *FromType = getBuiltinType(Rhs);
|
|
if (ToType->getKind() < FromType->getKind())
|
|
diagNarrowType(SourceLoc, Lhs, Rhs);
|
|
}
|
|
}
|
|
|
|
void NarrowingConversionsCheck::handleBinaryOperator(const ASTContext &Context,
|
|
SourceLocation SourceLoc,
|
|
const Expr &Lhs,
|
|
const Expr &Rhs) {
|
|
assert(!Lhs.isInstantiationDependent() && !Rhs.isInstantiationDependent() &&
|
|
"Dependent types must be check before calling this function");
|
|
const BuiltinType *LhsType = getBuiltinType(Lhs);
|
|
const BuiltinType *RhsType = getBuiltinType(Rhs);
|
|
if (RhsType == nullptr || LhsType == nullptr)
|
|
return;
|
|
if (RhsType->getKind() == BuiltinType::Bool && LhsType->isSignedInteger())
|
|
return handleBooleanToSignedIntegral(Context, SourceLoc, Lhs, Rhs);
|
|
if (RhsType->isInteger() && LhsType->getKind() == BuiltinType::Bool)
|
|
return handleIntegralToBoolean(Context, SourceLoc, Lhs, Rhs);
|
|
if (RhsType->isInteger() && LhsType->isFloatingPoint())
|
|
return handleIntegralToFloating(Context, SourceLoc, Lhs, Rhs);
|
|
if (RhsType->isInteger() && LhsType->isInteger())
|
|
return handleIntegralCast(Context, SourceLoc, Lhs, Rhs);
|
|
if (RhsType->isFloatingPoint() && LhsType->getKind() == BuiltinType::Bool)
|
|
return handleFloatingToBoolean(Context, SourceLoc, Lhs, Rhs);
|
|
if (RhsType->isFloatingPoint() && LhsType->isInteger())
|
|
return handleFloatingToIntegral(Context, SourceLoc, Lhs, Rhs);
|
|
if (RhsType->isFloatingPoint() && LhsType->isFloatingPoint())
|
|
return handleFloatingCast(Context, SourceLoc, Lhs, Rhs);
|
|
}
|
|
|
|
bool NarrowingConversionsCheck::handleConditionalOperator(
|
|
const ASTContext &Context, const Expr &Lhs, const Expr &Rhs) {
|
|
if (const auto *CO = llvm::dyn_cast<ConditionalOperator>(&Rhs)) {
|
|
// We have an expression like so: `output = cond ? lhs : rhs`
|
|
// From the point of view of narrowing conversion we treat it as two
|
|
// expressions `output = lhs` and `output = rhs`.
|
|
handleBinaryOperator(Context, CO->getLHS()->getExprLoc(), Lhs,
|
|
*CO->getLHS());
|
|
handleBinaryOperator(Context, CO->getRHS()->getExprLoc(), Lhs,
|
|
*CO->getRHS());
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void NarrowingConversionsCheck::handleImplicitCast(
|
|
const ASTContext &Context, const ImplicitCastExpr &Cast) {
|
|
if (Cast.getExprLoc().isMacroID())
|
|
return;
|
|
const Expr &Lhs = Cast;
|
|
const Expr &Rhs = *Cast.getSubExpr();
|
|
if (Lhs.isInstantiationDependent() || Rhs.isInstantiationDependent())
|
|
return;
|
|
if (handleConditionalOperator(Context, Lhs, Rhs))
|
|
return;
|
|
SourceLocation SourceLoc = Lhs.getExprLoc();
|
|
switch (Cast.getCastKind()) {
|
|
case CK_BooleanToSignedIntegral:
|
|
return handleBooleanToSignedIntegral(Context, SourceLoc, Lhs, Rhs);
|
|
case CK_IntegralToBoolean:
|
|
return handleIntegralToBoolean(Context, SourceLoc, Lhs, Rhs);
|
|
case CK_IntegralToFloating:
|
|
return handleIntegralToFloating(Context, SourceLoc, Lhs, Rhs);
|
|
case CK_IntegralCast:
|
|
return handleIntegralCast(Context, SourceLoc, Lhs, Rhs);
|
|
case CK_FloatingToBoolean:
|
|
return handleFloatingToBoolean(Context, SourceLoc, Lhs, Rhs);
|
|
case CK_FloatingToIntegral:
|
|
return handleFloatingToIntegral(Context, SourceLoc, Lhs, Rhs);
|
|
case CK_FloatingCast:
|
|
return handleFloatingCast(Context, SourceLoc, Lhs, Rhs);
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void NarrowingConversionsCheck::handleBinaryOperator(const ASTContext &Context,
|
|
const BinaryOperator &Op) {
|
|
if (Op.getBeginLoc().isMacroID())
|
|
return;
|
|
const Expr &Lhs = *Op.getLHS();
|
|
const Expr &Rhs = *Op.getRHS();
|
|
if (Lhs.isInstantiationDependent() || Rhs.isInstantiationDependent())
|
|
return;
|
|
if (handleConditionalOperator(Context, Lhs, Rhs))
|
|
return;
|
|
handleBinaryOperator(Context, Rhs.getBeginLoc(), Lhs, Rhs);
|
|
}
|
|
|
|
void NarrowingConversionsCheck::check(const MatchFinder::MatchResult &Result) {
|
|
if (const auto *Op = Result.Nodes.getNodeAs<BinaryOperator>("binary_op"))
|
|
return handleBinaryOperator(*Result.Context, *Op);
|
|
if (const auto *Cast = Result.Nodes.getNodeAs<ImplicitCastExpr>("cast"))
|
|
return handleImplicitCast(*Result.Context, *Cast);
|
|
llvm_unreachable("must be binary operator or cast expression");
|
|
}
|
|
|
|
} // namespace cppcoreguidelines
|
|
} // namespace tidy
|
|
} // namespace clang
|