[clang] 39a4b32 - [NFC] Move warning from CodeGen to Sema. (#107397)
via cfe-commits
cfe-commits at lists.llvm.org
Tue Sep 17 10:56:24 PDT 2024
Author: Zahira Ammarguellat
Date: 2024-09-17T13:56:20-04:00
New Revision: 39a4b3274de3283e5c5d12053678b7ecf947a2dc
URL: https://github.com/llvm/llvm-project/commit/39a4b3274de3283e5c5d12053678b7ecf947a2dc
DIFF: https://github.com/llvm/llvm-project/commit/39a4b3274de3283e5c5d12053678b7ecf947a2dc.diff
LOG: [NFC] Move warning from CodeGen to Sema. (#107397)
This is a warning that wasn't associated with the source location. Moved
it to Sema and changed the warning message to a more verbose one.
Added:
Modified:
clang/include/clang/AST/ASTContext.h
clang/include/clang/Basic/DiagnosticCommonKinds.td
clang/include/clang/Basic/DiagnosticSemaKinds.td
clang/include/clang/Sema/Sema.h
clang/lib/CodeGen/CGExprComplex.cpp
clang/lib/Sema/Sema.cpp
clang/lib/Sema/SemaAttr.cpp
clang/lib/Sema/SemaExpr.cpp
clang/test/Sema/complex-arithmetic.c
Removed:
################################################################################
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index 168bdca3c880b2..b65a1f7dff5bc1 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -782,6 +782,23 @@ class ASTContext : public RefCountedBase<ASTContext> {
const TargetInfo &getTargetInfo() const { return *Target; }
const TargetInfo *getAuxTargetInfo() const { return AuxTarget; }
+ const QualType GetHigherPrecisionFPType(QualType ElementType) const {
+ const auto *CurrentBT = cast<BuiltinType>(ElementType);
+ switch (CurrentBT->getKind()) {
+ case BuiltinType::Kind::Half:
+ case BuiltinType::Kind::Float16:
+ return FloatTy;
+ case BuiltinType::Kind::Float:
+ case BuiltinType::Kind::BFloat16:
+ return DoubleTy;
+ case BuiltinType::Kind::Double:
+ return LongDoubleTy;
+ default:
+ return ElementType;
+ }
+ return ElementType;
+ }
+
/// getIntTypeForBitwidth -
/// sets integer QualTy according to specified details:
/// bitwidth, signed/unsigned.
diff --git a/clang/include/clang/Basic/DiagnosticCommonKinds.td b/clang/include/clang/Basic/DiagnosticCommonKinds.td
index 33b1d58bb5b099..ae709e45a700a1 100644
--- a/clang/include/clang/Basic/DiagnosticCommonKinds.td
+++ b/clang/include/clang/Basic/DiagnosticCommonKinds.td
@@ -45,11 +45,6 @@ def note_using : Note<"using">;
def note_possibility : Note<"one possibility">;
def note_also_found : Note<"also found">;
-def warn_next_larger_fp_type_same_size_than_fp : Warning<
- "higher precision floating-point type size has the same size than "
- "floating-point type size">,
- InGroup<DiagGroup<"higher-precision-fp">>;
-
// Parse && Lex
let CategoryName = "Lexical or Preprocessor Issue" in {
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index d42558d2223aae..6fe87e92993a65 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -6800,6 +6800,12 @@ def warn_arc_lifetime_result_type : Warning<
"ARC %select{unused|__unsafe_unretained|__strong|__weak|__autoreleasing}0 "
"lifetime qualifier on return type is ignored">,
InGroup<IgnoredQualifiers>;
+def warn_excess_precision_not_supported : Warning<
+ "excess precision is requested but the target does not support excess "
+ "precision which may result in observable
diff erences in complex division "
+ "behavior%select{|, additional uses where the requested higher precision "
+ "cannot be honored were found but not diagnosed}0">,
+ InGroup<DiagGroup<"higher-precision-for-complex-division">>;
let CategoryName = "ARC Retain Cycle" in {
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 99eef472223a00..0809ac1b144ef6 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -7957,6 +7957,10 @@ class Sema final : public SemaBase {
/// Do an explicit extend of the given block pointer if we're in ARC.
void maybeExtendBlockObject(ExprResult &E);
+ std::vector<std::pair<QualType, unsigned>> ExcessPrecisionNotSatisfied;
+ SourceLocation LocationOfExcessPrecisionNotSatisfied;
+ void DiagnosePrecisionLossInComplexDivision();
+
private:
static BinaryOperatorKind ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind);
diff --git a/clang/lib/CodeGen/CGExprComplex.cpp b/clang/lib/CodeGen/CGExprComplex.cpp
index 828a09856099ac..fef26e7b4ccdbd 100644
--- a/clang/lib/CodeGen/CGExprComplex.cpp
+++ b/clang/lib/CodeGen/CGExprComplex.cpp
@@ -288,28 +288,15 @@ class ComplexExprEmitter
ComplexPairTy EmitComplexBinOpLibCall(StringRef LibCallName,
const BinOpInfo &Op);
- QualType GetHigherPrecisionFPType(QualType ElementType) {
- const auto *CurrentBT = cast<BuiltinType>(ElementType);
- switch (CurrentBT->getKind()) {
- case BuiltinType::Kind::Float16:
- return CGF.getContext().FloatTy;
- case BuiltinType::Kind::Float:
- case BuiltinType::Kind::BFloat16:
- return CGF.getContext().DoubleTy;
- case BuiltinType::Kind::Double:
- return CGF.getContext().LongDoubleTy;
- default:
- return ElementType;
- }
- }
-
QualType HigherPrecisionTypeForComplexArithmetic(QualType ElementType,
bool IsDivOpCode) {
- QualType HigherElementType = GetHigherPrecisionFPType(ElementType);
+ ASTContext &Ctx = CGF.getContext();
+ const QualType HigherElementType =
+ Ctx.GetHigherPrecisionFPType(ElementType);
const llvm::fltSemantics &ElementTypeSemantics =
- CGF.getContext().getFloatTypeSemantics(ElementType);
+ Ctx.getFloatTypeSemantics(ElementType);
const llvm::fltSemantics &HigherElementTypeSemantics =
- CGF.getContext().getFloatTypeSemantics(HigherElementType);
+ Ctx.getFloatTypeSemantics(HigherElementType);
// Check that the promoted type can handle the intermediate values without
// overflowing. This can be interpreted as:
// (SmallerType.LargestFiniteVal * SmallerType.LargestFiniteVal) * 2 <=
@@ -320,10 +307,10 @@ class ComplexExprEmitter
if (llvm::APFloat::semanticsMaxExponent(ElementTypeSemantics) * 2 + 1 <=
llvm::APFloat::semanticsMaxExponent(HigherElementTypeSemantics)) {
FPHasBeenPromoted = true;
- return CGF.getContext().getComplexType(HigherElementType);
+ return Ctx.getComplexType(HigherElementType);
} else {
- DiagnosticsEngine &Diags = CGF.CGM.getDiags();
- Diags.Report(diag::warn_next_larger_fp_type_same_size_than_fp);
+ // The intermediate values can't be represented in the promoted type
+ // without overflowing.
return QualType();
}
}
diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp
index d567de703903c9..85cbbe7750c2b3 100644
--- a/clang/lib/Sema/Sema.cpp
+++ b/clang/lib/Sema/Sema.cpp
@@ -1213,6 +1213,7 @@ void Sema::ActOnEndOfTranslationUnit() {
DiagnoseUnterminatedPragmaAlignPack();
DiagnoseUnterminatedPragmaAttribute();
OpenMP().DiagnoseUnterminatedOpenMPDeclareTarget();
+ DiagnosePrecisionLossInComplexDivision();
// All delayed member exception specs should be checked or we end up accepting
// incompatible declarations.
diff --git a/clang/lib/Sema/SemaAttr.cpp b/clang/lib/Sema/SemaAttr.cpp
index fb594e6f13c0b3..cf2a5a622a3a4d 100644
--- a/clang/lib/Sema/SemaAttr.cpp
+++ b/clang/lib/Sema/SemaAttr.cpp
@@ -1180,6 +1180,16 @@ void Sema::PrintPragmaAttributeInstantiationPoint() {
diag::note_pragma_attribute_applied_decl_here);
}
+void Sema::DiagnosePrecisionLossInComplexDivision() {
+ for (auto &[Type, Num] : ExcessPrecisionNotSatisfied) {
+ assert(LocationOfExcessPrecisionNotSatisfied.isValid() &&
+ "expected a valid source location");
+ Diag(LocationOfExcessPrecisionNotSatisfied,
+ diag::warn_excess_precision_not_supported)
+ << static_cast<bool>(Num);
+ }
+}
+
void Sema::DiagnoseUnterminatedPragmaAttribute() {
if (PragmaAttributeStack.empty())
return;
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 8f3e15cc9a9bb7..80c252c79e4d7a 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -15115,6 +15115,37 @@ static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc,
DiagnoseShiftCompare(Self, OpLoc, LHSExpr, RHSExpr);
}
+static void DetectPrecisionLossInComplexDivision(Sema &S, SourceLocation OpLoc,
+ Expr *Operand) {
+ if (auto *CT = Operand->getType()->getAs<ComplexType>()) {
+ QualType ElementType = CT->getElementType();
+ bool IsComplexRangePromoted = S.getLangOpts().getComplexRange() ==
+ LangOptions::ComplexRangeKind::CX_Promoted;
+ if (ElementType->isFloatingType() && IsComplexRangePromoted) {
+ ASTContext &Ctx = S.getASTContext();
+ QualType HigherElementType = Ctx.GetHigherPrecisionFPType(ElementType);
+ const llvm::fltSemantics &ElementTypeSemantics =
+ Ctx.getFloatTypeSemantics(ElementType);
+ const llvm::fltSemantics &HigherElementTypeSemantics =
+ Ctx.getFloatTypeSemantics(HigherElementType);
+ if (llvm::APFloat::semanticsMaxExponent(ElementTypeSemantics) * 2 + 1 >
+ llvm::APFloat::semanticsMaxExponent(HigherElementTypeSemantics)) {
+ // Retain the location of the first use of higher precision type.
+ if (!S.LocationOfExcessPrecisionNotSatisfied.isValid())
+ S.LocationOfExcessPrecisionNotSatisfied = OpLoc;
+ for (auto &[Type, Num] : S.ExcessPrecisionNotSatisfied) {
+ if (Type == HigherElementType) {
+ Num++;
+ return;
+ }
+ }
+ S.ExcessPrecisionNotSatisfied.push_back(std::make_pair(
+ HigherElementType, S.ExcessPrecisionNotSatisfied.size()));
+ }
+ }
+ }
+}
+
ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
tok::TokenKind Kind,
Expr *LHSExpr, Expr *RHSExpr) {
@@ -15125,6 +15156,11 @@ ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
// Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0"
DiagnoseBinOpPrecedence(*this, Opc, TokLoc, LHSExpr, RHSExpr);
+ // Emit warnings if the requested higher precision type equal to the current
+ // type precision.
+ if (Kind == tok::TokenKind::slash)
+ DetectPrecisionLossInComplexDivision(*this, TokLoc, LHSExpr);
+
return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr);
}
diff --git a/clang/test/Sema/complex-arithmetic.c b/clang/test/Sema/complex-arithmetic.c
index c9e84da6daa9dc..6cafbfb47ab74d 100644
--- a/clang/test/Sema/complex-arithmetic.c
+++ b/clang/test/Sema/complex-arithmetic.c
@@ -1,5 +1,9 @@
-// RUN: %clang_cc1 -verify %s
-// expected-no-diagnostics
+// RUN: %clang_cc1 -verify=no-diag %s
+// RUN: %clang_cc1 -complex-range=promoted -triple x86_64-unknown-linux \
+// RUN: -verify=no-diag %s
+// RUN: %clang_cc1 -complex-range=promoted -triple x86_64-unknown-windows \
+// RUN: -verify=div-precision %s
+// no-diag-no-diagnostics
// This tests evaluation of _Complex arithmetic at compile time.
@@ -21,6 +25,7 @@ void a() {
EVALF((2. + 3i) + (4. + 5i), 6. + 8i);
EVALF((2. + 3i) - (4. + 5i), -2. - 2i);
EVALF((2. + 3i) * (4. + 5i), -7. + 22i);
+ // div-precision-warning at +1 {{excess precision is requested but the target does not support excess precision which may result in observable
diff erences in complex division behavior, additional uses where the requested higher precision cannot be honored were found but not diagnosed}}
EVALF((2. + 3i) / (4. + 5i), .5609 + .0487i);
}
More information about the cfe-commits
mailing list