[clang] 30e7ee3 - Temporarily Revert "Add support for options -frounding-math, ftrapping-math, -ffp-model=, and -ffp-exception-behavior="
Eric Christopher via cfe-commits
cfe-commits at lists.llvm.org
Mon Nov 18 10:47:01 PST 2019
Author: Eric Christopher
Date: 2019-11-18T10:46:48-08:00
New Revision: 30e7ee3c4bac4a12ea584a879aa320bd4e035cc2
URL: https://github.com/llvm/llvm-project/commit/30e7ee3c4bac4a12ea584a879aa320bd4e035cc2
DIFF: https://github.com/llvm/llvm-project/commit/30e7ee3c4bac4a12ea584a879aa320bd4e035cc2.diff
LOG: Temporarily Revert "Add support for options -frounding-math, ftrapping-math, -ffp-model=, and -ffp-exception-behavior="
and a follow-up NFC rearrangement as it's causing a crash on valid. Testcase is on the original review thread.
This reverts commits af57dbf12e54f3a8ff48534bf1078f4de104c1cd and e6584b2b7b2de06f1e59aac41971760cac1e1b79
Added:
Modified:
clang/docs/UsersManual.rst
clang/include/clang/Basic/LangOptions.def
clang/include/clang/Basic/LangOptions.h
clang/include/clang/Driver/Options.td
clang/lib/CodeGen/CodeGenFunction.cpp
clang/lib/CodeGen/CodeGenFunction.h
clang/lib/Driver/ToolChains/Clang.cpp
clang/lib/Frontend/CompilerInvocation.cpp
clang/test/Driver/clang_f_opts.c
clang/test/Driver/fast-math.c
llvm/include/llvm/IR/IRBuilder.h
llvm/include/llvm/IR/IntrinsicInst.h
llvm/include/llvm/Target/TargetOptions.h
llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
llvm/lib/IR/CMakeLists.txt
llvm/lib/IR/IntrinsicInst.cpp
llvm/unittests/IR/IRBuilderTest.cpp
Removed:
clang/test/CodeGen/fpconstrained.c
clang/test/Driver/fp-model.c
llvm/include/llvm/IR/FPEnv.h
llvm/lib/IR/FPEnv.cpp
################################################################################
diff --git a/clang/docs/UsersManual.rst b/clang/docs/UsersManual.rst
index 62e2575c6b26..714681d7f4ce 100644
--- a/clang/docs/UsersManual.rst
+++ b/clang/docs/UsersManual.rst
@@ -1231,10 +1231,10 @@ are listed below.
**-f[no-]trapping-math**
- Control floating point exception behavior. ``-fno-trapping-math`` allows optimizations that assume that floating point operations cannot generate traps such as divide-by-zero, overflow and underflow.
-
-- The option ``-ftrapping-math`` behaves identically to ``-ffp-exception-behavior=strict``.
-- The option ``-fno-trapping-math`` behaves identically to ``-ffp-exception-behavior=ignore``. This is the default.
+ ``-fno-trapping-math`` allows optimizations that assume that
+ floating point operations cannot generate traps such as divide-by-zero,
+ overflow and underflow. Defaults to ``-ftrapping-math``.
+ Currently this option has no effect.
.. option:: -ffp-contract=<value>
@@ -1319,52 +1319,6 @@ are listed below.
Defaults to ``-fno-finite-math``.
-.. _opt_frounding-math:
-
-**-f[no-]rounding-math**
-
-Force floating-point operations to honor the dynamically-set rounding mode by default.
-
-The result of a floating-point operation often cannot be exactly represented in the result type and therefore must be rounded. IEEE 754 describes
diff erent rounding modes that control how to perform this rounding, not all of which are supported by all implementations. C provides interfaces (``fesetround`` and ``fesetenv``) for dynamically controlling the rounding mode, and while it also recommends certain conventions for changing the rounding mode, these conventions are not typically enforced in the ABI. Since the rounding mode changes the numerical result of operations, the compiler must understand something about it in order to optimize floating point operations.
-
-Note that floating-point operations performed as part of constant initialization are formally performed prior to the start of the program and are therefore not subject to the current rounding mode. This includes the initialization of global variables and local ``static`` variables. Floating-point operations in these contexts will be rounded using ``FE_TONEAREST``.
-
-- The option ``-fno-rounding-math`` allows the compiler to assume that the rounding mode is set to ``FE_TONEAREST``. This is the default.
-- The option ``-frounding-math`` forces the compiler to honor the dynamically-set rounding mode. This prevents optimizations which might affect results if the rounding mode changes or is
diff erent from the default; for example, it prevents floating-point operations from being reordered across most calls and prevents constant-folding when the result is not exactly representable.
-
-.. option:: -ffp-model=<value>
-
- Specify floating point behavior. ``-ffp-model`` is an umbrella
- option that encompasses functionality provided by other, single
- purpose, floating point options. Valid values are: ``precise``, ``strict``,
- and ``fast``.
- Details:
-
- * ``precise`` Disables optimizations that are not value-safe on floating-point data, although FP contraction (FMA) is enabled (``-ffp-contract=fast``). This is the default behavior.
- * ``strict`` Enables ``-frounding-math`` and ``-ffp-exception-behavior=strict``, and disables contractions (FMA). All of the ``-ffast-math`` enablements are disabled.
- * ``fast`` Behaves identically to specifying both ``-ffast-math`` and ``ffp-contract=fast``
-
- Note: If your command line specifies multiple instances
- of the ``-ffp-model`` option, or if your command line option specifies
- ``-ffp-model`` and later on the command line selects a floating point
- option that has the effect of negating part of the ``ffp-model`` that
- has been selected, then the compiler will issue a diagnostic warning
- that the override has occurred.
-
-.. option:: -ffp-exception-behavior=<value>
-
- Specify the floating-point exception behavior.
-
- Valid values are: ``ignore``, ``maytrap``, and ``strict``.
- The default value is ``ignore``. Details:
-
- * ``ignore`` The compiler assumes that the exception status flags will not be read and that floating point exceptions will be masked.
- * ``maytrap`` The compiler avoids transformations that may raise exceptions that would not have been raised by the original code. Constant folding performed by the compiler is exempt from this option.
- * ``strict`` The compiler ensures that all transformations strictly preserve the floating point exception semantics of the original code.
-
-
-
-
.. _controlling-code-generation:
Controlling Code Generation
diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def
index bfd0cd53e488..eba4f835d661 100644
--- a/clang/include/clang/Basic/LangOptions.def
+++ b/clang/include/clang/Basic/LangOptions.def
@@ -254,8 +254,6 @@ LANGOPT(SinglePrecisionConstants , 1, 0, "treating double-precision floating poi
LANGOPT(FastRelaxedMath , 1, 0, "OpenCL fast relaxed math")
/// FP_CONTRACT mode (on/off/fast).
ENUM_LANGOPT(DefaultFPContractMode, FPContractModeKind, 2, FPC_Off, "FP contraction type")
-ENUM_LANGOPT(FPRoundingMode, FPRoundingModeKind, 3, FPR_ToNearest, "FP Rounding Mode type")
-ENUM_LANGOPT(FPExceptionMode, FPExceptionModeKind, 2, FPE_Ignore, "FP Exception Behavior Mode type")
LANGOPT(NoBitFieldTypeAlign , 1, 0, "bit-field type alignment")
LANGOPT(HexagonQdsp6Compat , 1, 0, "hexagon-qdsp6 backward compatibility")
LANGOPT(ObjCAutoRefCount , 1, 0, "Objective-C automated reference counting")
diff --git a/clang/include/clang/Basic/LangOptions.h b/clang/include/clang/Basic/LangOptions.h
index 3614f584f29a..5f808f04e9ae 100644
--- a/clang/include/clang/Basic/LangOptions.h
+++ b/clang/include/clang/Basic/LangOptions.h
@@ -184,34 +184,6 @@ class LangOptions : public LangOptionsBase {
FEA_On
};
- // Values of the following enumerations correspond to metadata arguments
- // specified for constrained floating-point intrinsics:
- // http://llvm.org/docs/LangRef.html#constrained-floating-point-intrinsics.
-
- /// Possible rounding modes.
- enum FPRoundingModeKind {
- /// Rounding to nearest, corresponds to "round.tonearest".
- FPR_ToNearest,
- /// Rounding toward -Inf, corresponds to "round.downward".
- FPR_Downward,
- /// Rounding toward +Inf, corresponds to "round.upward".
- FPR_Upward,
- /// Rounding toward zero, corresponds to "round.towardzero".
- FPR_TowardZero,
- /// Is determined by runtime environment, corresponds to "round.dynamic".
- FPR_Dynamic
- };
-
- /// Possible floating point exception behavior.
- enum FPExceptionModeKind {
- /// Assume that floating-point exceptions are masked.
- FPE_Ignore,
- /// Transformations do not cause new exceptions but may hide some.
- FPE_MayTrap,
- /// Strictly preserve the floating-point exception semantics.
- FPE_Strict
- };
-
enum class LaxVectorConversionKind {
/// Permit no implicit vector bitcasts.
None,
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 3fca181b8784..ab629598eab9 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -928,10 +928,6 @@ def : Flag<["-"], "fextended-identifiers">, Group<clang_ignored_f_Group>;
def : Flag<["-"], "fno-extended-identifiers">, Group<f_Group>, Flags<[Unsupported]>;
def fhosted : Flag<["-"], "fhosted">, Group<f_Group>;
def fdenormal_fp_math_EQ : Joined<["-"], "fdenormal-fp-math=">, Group<f_Group>, Flags<[CC1Option]>;
-def ffp_model_EQ : Joined<["-"], "ffp-model=">, Group<f_Group>, Flags<[DriverOption]>,
- HelpText<"Controls the semantics of floating-point calculations.">;
-def ffp_exception_behavior_EQ : Joined<["-"], "ffp-exception-behavior=">, Group<f_Group>, Flags<[CC1Option]>,
- HelpText<"Specifies the exception behavior of floating-point operations.">;
def ffast_math : Flag<["-"], "ffast-math">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Allow aggressive, lossy floating-point optimizations">;
def fno_fast_math : Flag<["-"], "fno-fast-math">, Group<f_Group>;
@@ -1157,8 +1153,6 @@ def fno_honor_infinities : Flag<["-"], "fno-honor-infinities">, Group<f_Group>;
// This option was originally misspelt "infinites" [sic].
def : Flag<["-"], "fhonor-infinites">, Alias<fhonor_infinities>;
def : Flag<["-"], "fno-honor-infinites">, Alias<fno_honor_infinities>;
-def frounding_math : Flag<["-"], "frounding-math">, Group<f_Group>, Flags<[CC1Option]>;
-def fno_rounding_math : Flag<["-"], "fno-rounding-math">, Group<f_Group>, Flags<[CC1Option]>;
def ftrapping_math : Flag<["-"], "ftrapping-math">, Group<f_Group>, Flags<[CC1Option]>;
def fno_trapping_math : Flag<["-"], "fno-trapping-math">, Group<f_Group>, Flags<[CC1Option]>;
def ffp_contract : Joined<["-"], "ffp-contract=">, Group<f_Group>,
@@ -3242,6 +3236,7 @@ defm profile_values : BooleanFFlag<"profile-values">, Group<clang_ignored_gcc_op
defm regs_graph : BooleanFFlag<"regs-graph">, Group<clang_ignored_f_Group>;
defm rename_registers : BooleanFFlag<"rename-registers">, Group<clang_ignored_gcc_optimization_f_Group>;
defm ripa : BooleanFFlag<"ripa">, Group<clang_ignored_f_Group>;
+defm rounding_math : BooleanFFlag<"rounding-math">, Group<clang_ignored_gcc_optimization_f_Group>;
defm schedule_insns : BooleanFFlag<"schedule-insns">, Group<clang_ignored_gcc_optimization_f_Group>;
defm schedule_insns2 : BooleanFFlag<"schedule-insns2">, Group<clang_ignored_gcc_optimization_f_Group>;
defm see : BooleanFFlag<"see">, Group<clang_ignored_f_Group>;
diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
index b853401ebdc3..6f2bd8c16b3b 100644
--- a/clang/lib/CodeGen/CodeGenFunction.cpp
+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -33,8 +33,6 @@
#include "clang/Frontend/FrontendDiagnostic.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Dominators.h"
-#include "llvm/IR/FPEnv.h"
-#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/MDBuilder.h"
#include "llvm/IR/Operator.h"
@@ -89,7 +87,6 @@ CodeGenFunction::CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext)
FMF.setAllowReassoc();
}
Builder.setFastMathFlags(FMF);
- SetFPModel();
}
CodeGenFunction::~CodeGenFunction() {
@@ -105,51 +102,6 @@ CodeGenFunction::~CodeGenFunction() {
CGM.getOpenMPRuntime().functionFinished(*this);
}
-// Map the LangOption for rounding mode into
-// the corresponding enum in the IR.
-static llvm::fp::RoundingMode ToConstrainedRoundingMD(
- LangOptions::FPRoundingModeKind Kind) {
-
- switch (Kind) {
- case LangOptions::FPR_ToNearest: return llvm::fp::rmToNearest;
- case LangOptions::FPR_Downward: return llvm::fp::rmDownward;
- case LangOptions::FPR_Upward: return llvm::fp::rmUpward;
- case LangOptions::FPR_TowardZero: return llvm::fp::rmTowardZero;
- case LangOptions::FPR_Dynamic: return llvm::fp::rmDynamic;
- }
- llvm_unreachable("Unsupported FP RoundingMode");
-}
-
-// Map the LangOption for exception behavior into
-// the corresponding enum in the IR.
-static llvm::fp::ExceptionBehavior ToConstrainedExceptMD(
- LangOptions::FPExceptionModeKind Kind) {
-
- switch (Kind) {
- case LangOptions::FPE_Ignore: return llvm::fp::ebIgnore;
- case LangOptions::FPE_MayTrap: return llvm::fp::ebMayTrap;
- case LangOptions::FPE_Strict: return llvm::fp::ebStrict;
- }
- llvm_unreachable("Unsupported FP Exception Behavior");
-}
-
-void CodeGenFunction::SetFPModel() {
- auto fpRoundingMode = ToConstrainedRoundingMD(
- getLangOpts().getFPRoundingMode());
- auto fpExceptionBehavior = ToConstrainedExceptMD(
- getLangOpts().getFPExceptionMode());
-
- if (fpExceptionBehavior == llvm::fp::ebIgnore &&
- fpRoundingMode == llvm::fp::rmToNearest)
- // Constrained intrinsics are not used.
- ;
- else {
- Builder.setIsFPConstrained(true);
- Builder.setDefaultConstrainedRounding(fpRoundingMode);
- Builder.setDefaultConstrainedExcept(fpExceptionBehavior);
- }
-}
-
CharUnits CodeGenFunction::getNaturalPointeeTypeAlignment(QualType T,
LValueBaseInfo *BaseInfo,
TBAAAccessInfo *TBAAInfo) {
diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h
index b05475a30002..5c3d1764fad7 100644
--- a/clang/lib/CodeGen/CodeGenFunction.h
+++ b/clang/lib/CodeGen/CodeGenFunction.h
@@ -4156,9 +4156,6 @@ class CodeGenFunction : public CodeGenTypeCache {
/// point operation, expressed as the maximum relative error in ulp.
void SetFPAccuracy(llvm::Value *Val, float Accuracy);
- /// SetFPModel - Control floating point behavior via fp-model settings.
- void SetFPModel();
-
private:
llvm::MDNode *getRangeForLoadFromType(QualType Ty);
void EmitReturnOfRValue(RValue RV, QualType Ty);
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index f5591c48d4e0..2e3624e6cd24 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -2283,18 +2283,9 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
bool AssociativeMath = false;
bool ReciprocalMath = false;
bool SignedZeros = true;
- bool TrappingMath = false; // Implemented via -ffp-exception-behavior
- bool TrappingMathPresent = false; // Is trapping-math in args, and not
- // overriden by ffp-exception-behavior?
- bool RoundingFPMath = false;
- bool RoundingMathPresent = false; // Is rounding-math in args?
- // -ffp-model values: strict, fast, precise
- StringRef FPModel = "";
- // -ffp-exception-behavior options: strict, maytrap, ignore
- StringRef FPExceptionBehavior = "";
+ bool TrappingMath = true;
StringRef DenormalFPMath = "";
StringRef FPContract = "";
- bool StrictFPModel = false;
if (const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
CmdArgs.push_back("-mlimit-float-precision");
@@ -2302,82 +2293,7 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
}
for (const Arg *A : Args) {
- auto optID = A->getOption().getID();
- bool PreciseFPModel = false;
- switch (optID) {
- default:
- break;
- case options::OPT_ffp_model_EQ: {
- StringRef Val = A->getValue();
- if (OFastEnabled && !Val.equals("fast")) {
- // Only -ffp-model=fast is compatible with OFast, ignore.
- D.Diag(clang::diag::warn_drv_overriding_flag_option)
- << Args.MakeArgString("-ffp-model=" + Val)
- << "-Ofast";
- break;
- }
- StrictFPModel = false;
- PreciseFPModel = true;
- // ffp-model= is a Driver option, it is entirely rewritten into more
- // granular options before being passed into cc1.
- // Use the gcc option in the switch below.
- if (!FPModel.empty() && !FPModel.equals(Val)) {
- D.Diag(clang::diag::warn_drv_overriding_flag_option)
- << Args.MakeArgString("-ffp-model=" + FPModel)
- << Args.MakeArgString("-ffp-model=" + Val);
- FPContract = "";
- }
- if (Val.equals("fast")) {
- if (!FPContract.empty() && !FPContract.equals("fast"))
- // FPContract has already been set to something else
- // so warn about the override.
- D.Diag(clang::diag::warn_drv_overriding_flag_option)
- << Args.MakeArgString("-ffp-contract=" + FPContract)
- << "-ffp-contract=fast";
- optID = options::OPT_ffast_math;
- FPModel = Val;
- FPContract = "fast";
- } else if (Val.equals("precise")) {
- if (!FPContract.empty() && !FPContract.equals("fast"))
- D.Diag(clang::diag::warn_drv_overriding_flag_option)
- << Args.MakeArgString("-ffp-contract=" + FPContract)
- << "-ffp-contract=fast";
- optID = options::OPT_ffp_contract;
- FPModel = Val;
- FPContract = "fast";
- PreciseFPModel = true;
- } else if (Val.equals("strict")) {
- StrictFPModel = true;
- if (!FPContract.empty() && !FPContract.equals("strict"))
- D.Diag(clang::diag::warn_drv_overriding_flag_option)
- << Args.MakeArgString("-ffp-contract=" + FPContract)
- << "-ffp-contract=strict";
- optID = options::OPT_frounding_math;
- FPExceptionBehavior = "strict";
- FPModel = Val;
- // -ffp-model=strict also enables fno-fast-math
- HonorINFs = true;
- HonorNaNs = true;
- // Turning on -ffast-math (with either flag) removes the need for
- // MathErrno. However, turning *off* -ffast-math merely restores the
- // toolchain default (which may be false).
- MathErrno = TC.IsMathErrnoDefault();
- AssociativeMath = false;
- ReciprocalMath = false;
- SignedZeros = true;
- TrappingMath = true;
- RoundingFPMath = true;
- // -fno_fast_math restores default denormal and fpcontract handling
- DenormalFPMath = "";
- FPContract = "";
- } else
- D.Diag(diag::err_drv_unsupported_option_argument)
- << A->getOption().getName() << Val;
- break;
- }
- }
-
- switch (optID) {
+ switch (A->getOption().getID()) {
// If this isn't an FP option skip the claim below
default: continue;
@@ -2394,71 +2310,19 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
case options::OPT_fno_reciprocal_math: ReciprocalMath = false; break;
case options::OPT_fsigned_zeros: SignedZeros = true; break;
case options::OPT_fno_signed_zeros: SignedZeros = false; break;
- case options::OPT_ftrapping_math:
- TrappingMath = true;
- TrappingMathPresent = true;
- FPExceptionBehavior = "strict";
- break;
- case options::OPT_fno_trapping_math:
- TrappingMath = false;
- TrappingMathPresent = true;
- FPExceptionBehavior = "ignore";
- break;
- case options::OPT_frounding_math:
- // The default setting for frounding-math is True and ffast-math
- // sets fno-rounding-math, but we only want to use constrained
- // floating point intrinsics if the option is specifically requested.
- RoundingFPMath = true;
- RoundingMathPresent = true;
- break;
- case options::OPT_fno_rounding_math:
- RoundingFPMath = false;
- RoundingMathPresent = false;
- break;
+ case options::OPT_ftrapping_math: TrappingMath = true; break;
+ case options::OPT_fno_trapping_math: TrappingMath = false; break;
case options::OPT_fdenormal_fp_math_EQ:
DenormalFPMath = A->getValue();
break;
- // Validate and pass through -ffp-contract option.
+ // Validate and pass through -fp-contract option.
case options::OPT_ffp_contract: {
StringRef Val = A->getValue();
- if (PreciseFPModel) {
- // -ffp-model=precise enables ffp-contract=fast as a side effect
- // the FPContract value has already been set to a string literal
- // and the Val string isn't a pertinent value.
- ;
- } else if (Val.equals("fast") || Val.equals("on") || Val.equals("off"))
+ if (Val == "fast" || Val == "on" || Val == "off")
FPContract = Val;
else
- D.Diag(diag::err_drv_unsupported_option_argument)
- << A->getOption().getName() << Val;
- break;
- }
-
- // Validate and pass through -ffp-model option.
- case options::OPT_ffp_model_EQ:
- // This should only occur in the error case
- // since the optID has been replaced by a more granular
- // floating point option.
- break;
-
- // Validate and pass through -ffp-exception-behavior option.
- case options::OPT_ffp_exception_behavior_EQ: {
- StringRef Val = A->getValue();
- if (!TrappingMathPresent && !FPExceptionBehavior.empty() &&
- !FPExceptionBehavior.equals(Val))
- // Warn that previous value of option is overridden.
- D.Diag(clang::diag::warn_drv_overriding_flag_option)
- << Args.MakeArgString("-ffp-exception-behavior=" + FPExceptionBehavior)
- << Args.MakeArgString("-ffp-exception-behavior=" + Val);
- TrappingMathPresent = false;
- if (Val.equals("ignore") || Val.equals("maytrap"))
- FPExceptionBehavior = Val;
- else if (Val.equals("strict")) {
- FPExceptionBehavior = Val;
- TrappingMath = TrappingMathPresent = true;
- } else
D.Diag(diag::err_drv_unsupported_option_argument)
<< A->getOption().getName() << Val;
break;
@@ -2478,14 +2342,12 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
ReciprocalMath = true;
SignedZeros = false;
TrappingMath = false;
- FPExceptionBehavior = "";
break;
case options::OPT_fno_unsafe_math_optimizations:
AssociativeMath = false;
ReciprocalMath = false;
SignedZeros = true;
TrappingMath = true;
- FPExceptionBehavior = "strict";
// -fno_unsafe_math_optimizations restores default denormal handling
DenormalFPMath = "";
break;
@@ -2503,7 +2365,6 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
ReciprocalMath = true;
SignedZeros = false;
TrappingMath = false;
- RoundingFPMath = false;
// If fast-math is set then set the fp-contract mode to fast.
FPContract = "fast";
break;
@@ -2517,31 +2378,12 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
AssociativeMath = false;
ReciprocalMath = false;
SignedZeros = true;
- TrappingMath = false;
- RoundingFPMath = false;
+ TrappingMath = true;
// -fno_fast_math restores default denormal and fpcontract handling
DenormalFPMath = "";
FPContract = "";
break;
}
- if (StrictFPModel) {
- // If -ffp-model=strict has been specified on command line but
- // subsequent options conflict then emit warning diagnostic.
- if (HonorINFs && HonorNaNs &&
- !AssociativeMath && !ReciprocalMath &&
- SignedZeros && TrappingMath && RoundingFPMath &&
- DenormalFPMath.empty() && FPContract.empty())
- // OK: Current Arg doesn't conflict with -ffp-model=strict
- ;
- else {
- StrictFPModel = false;
- FPModel = "";
- D.Diag(clang::diag::warn_drv_overriding_flag_option)
- << "-ffp-model=strict" <<
- ((A->getNumValues() == 0) ? A->getSpelling()
- : Args.MakeArgString(A->getSpelling() + A->getValue()));
- }
- }
// If we handled this option claim it
A->claim();
@@ -2569,11 +2411,7 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
if (ReciprocalMath)
CmdArgs.push_back("-freciprocal-math");
- if (TrappingMath) {
- // FP Exception Behavior is also set to strict
- assert(FPExceptionBehavior.equals("strict"));
- CmdArgs.push_back("-ftrapping-math");
- } else if (TrappingMathPresent)
+ if (!TrappingMath)
CmdArgs.push_back("-fno-trapping-math");
if (!DenormalFPMath.empty())
@@ -2583,37 +2421,14 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
if (!FPContract.empty())
CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + FPContract));
- if (!RoundingFPMath)
- CmdArgs.push_back(Args.MakeArgString("-fno-rounding-math"));
-
- if (RoundingFPMath && RoundingMathPresent)
- CmdArgs.push_back(Args.MakeArgString("-frounding-math"));
-
- if (!FPExceptionBehavior.empty())
- CmdArgs.push_back(Args.MakeArgString("-ffp-exception-behavior=" +
- FPExceptionBehavior));
-
ParseMRecip(D, Args, CmdArgs);
// -ffast-math enables the __FAST_MATH__ preprocessor macro, but check for the
// individual features enabled by -ffast-math instead of the option itself as
// that's consistent with gcc's behaviour.
if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath &&
- ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath) {
+ ReciprocalMath && !SignedZeros && !TrappingMath)
CmdArgs.push_back("-ffast-math");
- if (FPModel.equals("fast")) {
- if (FPContract.equals("fast"))
- // All set, do nothing.
- ;
- else if (FPContract.empty())
- // Enable -ffp-contract=fast
- CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
- else
- D.Diag(clang::diag::warn_drv_overriding_flag_option)
- << "-ffp-model=fast"
- << Args.MakeArgString("-ffp-contract=" + FPContract);
- }
- }
// Handle __FINITE_MATH_ONLY__ similarly.
if (!HonorINFs && !HonorNaNs)
diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
index 26221a898185..79975722a475 100644
--- a/clang/lib/Frontend/CompilerInvocation.cpp
+++ b/clang/lib/Frontend/CompilerInvocation.cpp
@@ -3148,36 +3148,6 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
}
- if (Args.hasArg(OPT_frounding_math)) {
- Opts.setFPRoundingMode(LangOptions::FPR_Dynamic);
- }
-
- if (Args.hasArg(OPT_fno_rounding_math)) {
- Opts.setFPRoundingMode(LangOptions::FPR_ToNearest);
- }
-
- if (Args.hasArg(OPT_ftrapping_math)) {
- Opts.setFPExceptionMode(LangOptions::FPE_Strict);
- }
-
- if (Args.hasArg(OPT_fno_trapping_math)) {
- Opts.setFPExceptionMode(LangOptions::FPE_Ignore);
- }
-
- LangOptions::FPExceptionModeKind FPEB = LangOptions::FPE_Ignore;
- if (Arg *A = Args.getLastArg(OPT_ffp_exception_behavior_EQ)) {
- StringRef Val = A->getValue();
- if (Val.equals("ignore"))
- FPEB = LangOptions::FPE_Ignore;
- else if (Val.equals("maytrap"))
- FPEB = LangOptions::FPE_MayTrap;
- else if (Val.equals("strict"))
- FPEB = LangOptions::FPE_Strict;
- else
- Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
- Opts.setFPExceptionMode(FPEB);
- }
-
Opts.RetainCommentsFromSystemHeaders =
Args.hasArg(OPT_fretain_comments_from_system_headers);
diff --git a/clang/test/CodeGen/fpconstrained.c b/clang/test/CodeGen/fpconstrained.c
deleted file mode 100644
index b99e49fcfc6b..000000000000
--- a/clang/test/CodeGen/fpconstrained.c
+++ /dev/null
@@ -1,23 +0,0 @@
-// RUN: %clang_cc1 -ftrapping-math -frounding-math -ffp-exception-behavior=strict -emit-llvm -o - %s | FileCheck %s -check-prefix=FPMODELSTRICT
-// RUN: %clang_cc1 -ffp-contract=fast -emit-llvm -o - %s | FileCheck %s -check-prefix=PRECISE
-// RUN: %clang_cc1 -ffast-math -ffp-contract=fast -emit-llvm -o - %s | FileCheck %s -check-prefix=FAST
-// RUN: %clang_cc1 -ffast-math -emit-llvm -o - %s | FileCheck %s -check-prefix=FAST
-// RUN: %clang_cc1 -ffast-math -ffp-contract=fast -ffp-exception-behavior=ignore -emit-llvm -o - %s | FileCheck %s -check-prefix=FAST
-// RUN: %clang_cc1 -ffast-math -ffp-contract=fast -ffp-exception-behavior=strict -emit-llvm -o - %s | FileCheck %s -check-prefix=EXCEPT
-// RUN: %clang_cc1 -ffast-math -ffp-contract=fast -ffp-exception-behavior=maytrap -emit-llvm -o - %s | FileCheck %s -check-prefix=MAYTRAP
-float f0, f1, f2;
-
-void foo() {
- // CHECK-LABEL: define {{.*}}void @foo()
-
- // MAYTRAP: llvm.experimental.constrained.fadd.f32(float %0, float %1, metadata !"round.tonearest", metadata !"fpexcept.maytrap")
- // EXCEPT: llvm.experimental.constrained.fadd.f32(float %0, float %1, metadata !"round.tonearest", metadata !"fpexcept.strict")
- // FPMODELSTRICT: llvm.experimental.constrained.fadd.f32(float %0, float %1, metadata !"round.dynamic", metadata !"fpexcept.strict")
- // STRICTEXCEPT: llvm.experimental.constrained.fadd.f32(float %0, float %1, metadata !"round.dynamic", metadata !"fpexcept.strict")
- // STRICTNOEXCEPT: llvm.experimental.constrained.fadd.f32(float %0, float %1, metadata !"round.dynamic", metadata !"fpexcept.ignore")
- // PRECISE: fadd contract float %0, %1
- // FAST: fadd fast
- f0 = f1 + f2;
-
- // CHECK: ret
-}
diff --git a/clang/test/Driver/clang_f_opts.c b/clang/test/Driver/clang_f_opts.c
index fef9cbfb115e..17feaab26ab7 100644
--- a/clang/test/Driver/clang_f_opts.c
+++ b/clang/test/Driver/clang_f_opts.c
@@ -198,22 +198,6 @@
// CHECK-EXTENDED-IDENTIFIERS-NOT: "-fextended-identifiers"
// CHECK-NO-EXTENDED-IDENTIFIERS: error: unsupported option '-fno-extended-identifiers'
-// RUN: %clang -### -S -frounding-math %s 2>&1 | FileCheck -check-prefix=CHECK-ROUNDING-MATH %s
-// CHECK-ROUNDING-MATH: "-cc1"
-// CHECK-ROUNDING-MATH: "-frounding-math"
-// CHECK-ROUNDING-MATH-NOT: "-fno-rounding-math"
-// RUN: %clang -### -S %s 2>&1 | FileCheck -check-prefix=CHECK-ROUNDING-MATH-NOT %s
-// RUN: %clang -### -S -ffp-model=imprecise %s 2>&1 | FileCheck -check-prefix=CHECK-FPMODEL %s
-// CHECK-FPMODEL: unsupported argument 'imprecise' to option 'ffp-model='
-// RUN: %clang -### -S -ffp-model=precise %s 2>&1 | FileCheck -check-prefix=IGNORE %s
-// RUN: %clang -### -S -ffp-model=strict %s 2>&1 | FileCheck -check-prefix=IGNORE %s
-// RUN: %clang -### -S -ffp-model=fast %s 2>&1 | FileCheck -check-prefix=IGNORE %s
-// RUN: %clang -### -S -ffp-exception-behavior=trap %s 2>&1 | FileCheck -check-prefix=CHECK-FPEB %s
-// CHECK-FPEB: unsupported argument 'trap' to option 'ffp-exception-behavior='
-// RUN: %clang -### -S -ffp-exception-behavior=maytrap %s 2>&1 | FileCheck -check-prefix=IGNORE %s
-// RUN: %clang -### -S -ffp-exception-behavior=ignore %s 2>&1 | FileCheck -check-prefix=IGNORE %s
-// RUN: %clang -### -S -ffp-exception-behavior=strict %s 2>&1 | FileCheck -check-prefix=IGNORE %s
-
// RUN: %clang -### -S -fno-pascal-strings -mpascal-strings %s 2>&1 | FileCheck -check-prefix=CHECK-M-PASCAL-STRINGS %s
// CHECK-M-PASCAL-STRINGS: "-fpascal-strings"
@@ -336,6 +320,7 @@
// RUN: -fprefetch-loop-arrays \
// RUN: -fprofile-correction \
// RUN: -fprofile-values \
+// RUN: -frounding-math \
// RUN: -fschedule-insns \
// RUN: -fsignaling-nans \
// RUN: -fstrength-reduce \
@@ -400,6 +385,7 @@
// CHECK-WARNING-DAG: optimization flag '-fprefetch-loop-arrays' is not supported
// CHECK-WARNING-DAG: optimization flag '-fprofile-correction' is not supported
// CHECK-WARNING-DAG: optimization flag '-fprofile-values' is not supported
+// CHECK-WARNING-DAG: optimization flag '-frounding-math' is not supported
// CHECK-WARNING-DAG: optimization flag '-fschedule-insns' is not supported
// CHECK-WARNING-DAG: optimization flag '-fsignaling-nans' is not supported
// CHECK-WARNING-DAG: optimization flag '-fstrength-reduce' is not supported
diff --git a/clang/test/Driver/fast-math.c b/clang/test/Driver/fast-math.c
index da47de260dc9..916384216d8c 100644
--- a/clang/test/Driver/fast-math.c
+++ b/clang/test/Driver/fast-math.c
@@ -170,11 +170,11 @@
// RUN: %clang -### -fno-fast-math -ffast-math -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-FAST-MATH %s
// RUN: %clang -### -funsafe-math-optimizations -ffinite-math-only \
-// RUN: -fno-math-errno -ffp-contract=fast -fno-rounding-math -c %s 2>&1 \
+// RUN: -fno-math-errno -ffp-contract=fast -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-FAST-MATH %s
// RUN: %clang -### -fno-honor-infinities -fno-honor-nans -fno-math-errno \
// RUN: -fassociative-math -freciprocal-math -fno-signed-zeros \
-// RUN: -fno-trapping-math -ffp-contract=fast -fno-rounding-math -c %s 2>&1 \
+// RUN: -fno-trapping-math -ffp-contract=fast -c %s 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-FAST-MATH %s
// CHECK-FAST-MATH: "-cc1"
// CHECK-FAST-MATH: "-ffast-math"
diff --git a/clang/test/Driver/fp-model.c b/clang/test/Driver/fp-model.c
deleted file mode 100644
index 4956ff7fca9b..000000000000
--- a/clang/test/Driver/fp-model.c
+++ /dev/null
@@ -1,130 +0,0 @@
-// Test that incompatible combinations of -ffp-model= options
-// and other floating point options get a warning diagnostic.
-//
-// REQUIRES: clang-driver
-
-// RUN: %clang -### -ffp-model=fast -ffp-contract=off -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARN %s
-// WARN: warning: overriding '-ffp-model=fast' option with '-ffp-contract=off' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=fast -ffp-contract=on -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARN1 %s
-// WARN1: warning: overriding '-ffp-model=fast' option with '-ffp-contract=on' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -fassociative-math -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARN2 %s
-// WARN2: warning: overriding '-ffp-model=strict' option with '-fassociative-math' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -ffast-math -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARN3 %s
-// WARN3: warning: overriding '-ffp-model=strict' option with '-ffast-math' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -ffinite-math-only -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARN4 %s
-// WARN4: warning: overriding '-ffp-model=strict' option with '-ffinite-math-only' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -ffp-contract=fast -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARN5 %s
-// WARN5: warning: overriding '-ffp-model=strict' option with '-ffp-contract=fast' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -ffp-contract=off -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARN6 %s
-// WARN6: warning: overriding '-ffp-model=strict' option with '-ffp-contract=off' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -ffp-contract=on -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARN7 %s
-// WARN7: warning: overriding '-ffp-model=strict' option with '-ffp-contract=on' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -fno-honor-infinities -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARN8 %s
-// WARN8: warning: overriding '-ffp-model=strict' option with '-fno-honor-infinities' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -fno-honor-nans -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARN9 %s
-// WARN9: warning: overriding '-ffp-model=strict' option with '-fno-honor-nans' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -fno-rounding-math -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARNa %s
-// WARNa: warning: overriding '-ffp-model=strict' option with '-fno-rounding-math' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -fno-signed-zeros -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARNb %s
-// WARNb: warning: overriding '-ffp-model=strict' option with '-fno-signed-zeros' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -fno-trapping-math -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARNc %s
-// WARNc: warning: overriding '-ffp-model=strict' option with '-fno-trapping-math' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -freciprocal-math -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARNd %s
-// WARNd: warning: overriding '-ffp-model=strict' option with '-freciprocal-math' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -funsafe-math-optimizations -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARNe %s
-// WARNe: warning: overriding '-ffp-model=strict' option with '-funsafe-math-optimizations' [-Woverriding-t-option]
-
-// RUN: %clang -### -ffp-model=strict -Ofast -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=WARNf %s
-// WARNf: warning: overriding '-ffp-model=strict' option with '-Ofast' [-Woverriding-t-option]
-
-// RUN: %clang -### -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=CHECK-NOROUND %s
-// CHECK-NOROUND: "-cc1"
-// CHECK-NOROUND: "-fno-rounding-math"
-
-// RUN: %clang -### -frounding-math -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=CHECK-ROUND --implicit-check-not ffp-exception-behavior=strict %s
-// CHECK-ROUND: "-cc1"
-// CHECK-ROUND: "-frounding-math"
-
-// RUN: %clang -### -ftrapping-math -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=CHECK-TRAP %s
-// CHECK-TRAP: "-cc1"
-// CHECK-TRAP: "-ftrapping-math"
-// CHECK-TRAP: "-ffp-exception-behavior=strict"
-
-// RUN: %clang -### -nostdinc -ffp-model=fast -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=CHECK-FPM-FAST %s
-// CHECK-FPM-FAST: "-cc1"
-// CHECK-FPM-FAST: "-menable-no-infs"
-// CHECK-FPM-FAST: "-menable-no-nans"
-// CHECK-FPM-FAST: "-menable-unsafe-fp-math"
-// CHECK-FPM-FAST: "-fno-signed-zeros"
-// CHECK-FPM-FAST: "-mreassociate"
-// CHECK-FPM-FAST: "-freciprocal-math"
-// CHECK-FPM-FAST: "-ffp-contract=fast"
-// CHECK-FPM-FAST: "-fno-rounding-math"
-// CHECK-FPM-FAST: "-ffast-math"
-// CHECK-FPM-FAST: "-ffinite-math-only"
-
-// RUN: %clang -### -nostdinc -ffp-model=precise -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=CHECK-FPM-PRECISE %s
-// CHECK-FPM-PRECISE: "-cc1"
-// CHECK-FPM-PRECISE: "-ffp-contract=fast"
-// CHECK-FPM-PRECISE: "-fno-rounding-math"
-
-// RUN: %clang -### -nostdinc -ffp-model=strict -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=CHECK-FPM-STRICT %s
-// CHECK-FPM-STRICT: "-cc1"
-// CHECK-FPM-STRICT: "-ftrapping-math"
-// CHECK-FPM-STRICT: "-frounding-math"
-// CHECK-FPM-STRICT: "-ffp-exception-behavior=strict"
-
-// RUN: %clang -### -nostdinc -ffp-exception-behavior=strict -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=CHECK-FEB-STRICT %s
-// CHECK-FEB-STRICT: "-cc1"
-// CHECK-FEB-STRICT: "-fno-rounding-math"
-// CHECK-FEB-STRICT: "-ffp-exception-behavior=strict"
-
-// RUN: %clang -### -nostdinc -ffp-exception-behavior=maytrap -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=CHECK-FEB-MAYTRAP %s
-// CHECK-FEB-MAYTRAP: "-cc1"
-// CHECK-FEB-MAYTRAP: "-fno-rounding-math"
-// CHECK-FEB-MAYTRAP: "-ffp-exception-behavior=maytrap"
-
-// RUN: %clang -### -nostdinc -ffp-exception-behavior=ignore -c %s 2>&1 \
-// RUN: | FileCheck --check-prefix=CHECK-FEB-IGNORE %s
-// CHECK-FEB-IGNORE: "-cc1"
-// CHECK-FEB-IGNORE: "-fno-rounding-math"
-// CHECK-FEB-IGNORE: "-ffp-exception-behavior=ignore"
-
diff --git a/llvm/include/llvm/IR/FPEnv.h b/llvm/include/llvm/IR/FPEnv.h
deleted file mode 100644
index a1e0665d4112..000000000000
--- a/llvm/include/llvm/IR/FPEnv.h
+++ /dev/null
@@ -1,70 +0,0 @@
-//===- FPEnv.h ---- FP Environment ------------------------------*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-/// @file
-/// This file contains the declarations of entities that describe floating
-/// point environment and related functions.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_IR_FLOATINGPOINT_H
-#define LLVM_IR_FLOATINGPOINT_H
-
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/StringRef.h"
-#include <stdint.h>
-
-namespace llvm {
-
-namespace fp {
-
-/// Rounding mode used for floating point operations.
-///
-/// Each of these values correspond to some metadata argument value of a
-/// constrained floating point intrinsic. See the LLVM Language Reference Manual
-/// for details.
-enum RoundingMode : uint8_t {
- rmDynamic, ///< This corresponds to "fpround.dynamic".
- rmToNearest, ///< This corresponds to "fpround.tonearest".
- rmDownward, ///< This corresponds to "fpround.downward".
- rmUpward, ///< This corresponds to "fpround.upward".
- rmTowardZero ///< This corresponds to "fpround.tozero".
-};
-
-/// Exception behavior used for floating point operations.
-///
-/// Each of these values correspond to some metadata argument value of a
-/// constrained floating point intrinsic. See the LLVM Language Reference Manual
-/// for details.
-enum ExceptionBehavior : uint8_t {
- ebIgnore, ///< This corresponds to "fpexcept.ignore".
- ebMayTrap, ///< This corresponds to "fpexcept.maytrap".
- ebStrict ///< This corresponds to "fpexcept.strict".
-};
-
-}
-
-/// Returns a valid RoundingMode enumerator when given a string
-/// that is valid as input in constrained intrinsic rounding mode
-/// metadata.
-Optional<fp::RoundingMode> StrToRoundingMode(StringRef);
-
-/// For any RoundingMode enumerator, returns a string valid as input in
-/// constrained intrinsic rounding mode metadata.
-Optional<StringRef> RoundingModeToStr(fp::RoundingMode);
-
-/// Returns a valid ExceptionBehavior enumerator when given a string
-/// valid as input in constrained intrinsic exception behavior metadata.
-Optional<fp::ExceptionBehavior> StrToExceptionBehavior(StringRef);
-
-/// For any ExceptionBehavior enumerator, returns a string valid as
-/// input in constrained intrinsic exception behavior metadata.
-Optional<StringRef> ExceptionBehaviorToStr(fp::ExceptionBehavior);
-
-}
-#endif
diff --git a/llvm/include/llvm/IR/IRBuilder.h b/llvm/include/llvm/IR/IRBuilder.h
index 2d9c72108d3d..841e05b9c13b 100644
--- a/llvm/include/llvm/IR/IRBuilder.h
+++ b/llvm/include/llvm/IR/IRBuilder.h
@@ -97,8 +97,8 @@ class IRBuilderBase {
FastMathFlags FMF;
bool IsFPConstrained;
- fp::ExceptionBehavior DefaultConstrainedExcept;
- fp::RoundingMode DefaultConstrainedRounding;
+ ConstrainedFPIntrinsic::ExceptionBehavior DefaultConstrainedExcept;
+ ConstrainedFPIntrinsic::RoundingMode DefaultConstrainedRounding;
ArrayRef<OperandBundleDef> DefaultOperandBundles;
@@ -106,8 +106,8 @@ class IRBuilderBase {
IRBuilderBase(LLVMContext &context, MDNode *FPMathTag = nullptr,
ArrayRef<OperandBundleDef> OpBundles = None)
: Context(context), DefaultFPMathTag(FPMathTag), IsFPConstrained(false),
- DefaultConstrainedExcept(fp::ebStrict),
- DefaultConstrainedRounding(fp::rmDynamic),
+ DefaultConstrainedExcept(ConstrainedFPIntrinsic::ebStrict),
+ DefaultConstrainedRounding(ConstrainedFPIntrinsic::rmDynamic),
DefaultOperandBundles(OpBundles) {
ClearInsertionPoint();
}
@@ -234,22 +234,24 @@ class IRBuilderBase {
bool getIsFPConstrained() { return IsFPConstrained; }
/// Set the exception handling to be used with constrained floating point
- void setDefaultConstrainedExcept(fp::ExceptionBehavior NewExcept) {
+ void setDefaultConstrainedExcept(
+ ConstrainedFPIntrinsic::ExceptionBehavior NewExcept) {
DefaultConstrainedExcept = NewExcept;
}
/// Set the rounding mode handling to be used with constrained floating point
- void setDefaultConstrainedRounding(fp::RoundingMode NewRounding) {
+ void setDefaultConstrainedRounding(
+ ConstrainedFPIntrinsic::RoundingMode NewRounding) {
DefaultConstrainedRounding = NewRounding;
}
/// Get the exception handling used with constrained floating point
- fp::ExceptionBehavior getDefaultConstrainedExcept() {
+ ConstrainedFPIntrinsic::ExceptionBehavior getDefaultConstrainedExcept() {
return DefaultConstrainedExcept;
}
/// Get the rounding mode handling used with constrained floating point
- fp::RoundingMode getDefaultConstrainedRounding() {
+ ConstrainedFPIntrinsic::RoundingMode getDefaultConstrainedRounding() {
return DefaultConstrainedRounding;
}
@@ -1095,26 +1097,32 @@ class IRBuilder : public IRBuilderBase, public Inserter {
return (LC && RC) ? Insert(Folder.CreateBinOp(Opc, LC, RC), Name) : nullptr;
}
- Value *getConstrainedFPRounding(Optional<fp::RoundingMode> Rounding) {
- fp::RoundingMode UseRounding = DefaultConstrainedRounding;
+ Value *getConstrainedFPRounding(
+ Optional<ConstrainedFPIntrinsic::RoundingMode> Rounding) {
+ ConstrainedFPIntrinsic::RoundingMode UseRounding =
+ DefaultConstrainedRounding;
if (Rounding.hasValue())
UseRounding = Rounding.getValue();
- Optional<StringRef> RoundingStr = RoundingModeToStr(UseRounding);
+ Optional<StringRef> RoundingStr =
+ ConstrainedFPIntrinsic::RoundingModeToStr(UseRounding);
assert(RoundingStr.hasValue() && "Garbage strict rounding mode!");
auto *RoundingMDS = MDString::get(Context, RoundingStr.getValue());
return MetadataAsValue::get(Context, RoundingMDS);
}
- Value *getConstrainedFPExcept(Optional<fp::ExceptionBehavior> Except) {
- fp::ExceptionBehavior UseExcept = DefaultConstrainedExcept;
+ Value *getConstrainedFPExcept(
+ Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except) {
+ ConstrainedFPIntrinsic::ExceptionBehavior UseExcept =
+ DefaultConstrainedExcept;
if (Except.hasValue())
UseExcept = Except.getValue();
- Optional<StringRef> ExceptStr = ExceptionBehaviorToStr(UseExcept);
+ Optional<StringRef> ExceptStr =
+ ConstrainedFPIntrinsic::ExceptionBehaviorToStr(UseExcept);
assert(ExceptStr.hasValue() && "Garbage strict exception behavior!");
auto *ExceptMDS = MDString::get(Context, ExceptStr.getValue());
@@ -1475,8 +1483,8 @@ class IRBuilder : public IRBuilderBase, public Inserter {
CallInst *CreateConstrainedFPBinOp(
Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr,
const Twine &Name = "", MDNode *FPMathTag = nullptr,
- Optional<fp::RoundingMode> Rounding = None,
- Optional<fp::ExceptionBehavior> Except = None) {
+ Optional<ConstrainedFPIntrinsic::RoundingMode> Rounding = None,
+ Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except = None) {
Value *RoundingV = getConstrainedFPRounding(Rounding);
Value *ExceptV = getConstrainedFPExcept(Except);
@@ -2070,8 +2078,8 @@ class IRBuilder : public IRBuilderBase, public Inserter {
Intrinsic::ID ID, Value *V, Type *DestTy,
Instruction *FMFSource = nullptr, const Twine &Name = "",
MDNode *FPMathTag = nullptr,
- Optional<fp::RoundingMode> Rounding = None,
- Optional<fp::ExceptionBehavior> Except = None) {
+ Optional<ConstrainedFPIntrinsic::RoundingMode> Rounding = None,
+ Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except = None) {
Value *ExceptV = getConstrainedFPExcept(Except);
FastMathFlags UseFMF = FMF;
diff --git a/llvm/include/llvm/IR/IntrinsicInst.h b/llvm/include/llvm/IR/IntrinsicInst.h
index 18ab39b3413f..c989b4a2e72a 100644
--- a/llvm/include/llvm/IR/IntrinsicInst.h
+++ b/llvm/include/llvm/IR/IntrinsicInst.h
@@ -25,7 +25,6 @@
#include "llvm/IR/Constants.h"
#include "llvm/IR/DerivedTypes.h"
-#include "llvm/IR/FPEnv.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/GlobalVariable.h"
#include "llvm/IR/Instructions.h"
@@ -209,10 +208,47 @@ namespace llvm {
/// This is the common base class for constrained floating point intrinsics.
class ConstrainedFPIntrinsic : public IntrinsicInst {
public:
+ /// Specifies the rounding mode to be assumed. This is only used when
+ /// when constrained floating point is enabled. See the LLVM Language
+ /// Reference Manual for details.
+ enum RoundingMode : uint8_t {
+ rmDynamic, ///< This corresponds to "fpround.dynamic".
+ rmToNearest, ///< This corresponds to "fpround.tonearest".
+ rmDownward, ///< This corresponds to "fpround.downward".
+ rmUpward, ///< This corresponds to "fpround.upward".
+ rmTowardZero ///< This corresponds to "fpround.tozero".
+ };
+
+ /// Specifies the required exception behavior. This is only used when
+ /// when constrained floating point is used. See the LLVM Language
+ /// Reference Manual for details.
+ enum ExceptionBehavior : uint8_t {
+ ebIgnore, ///< This corresponds to "fpexcept.ignore".
+ ebMayTrap, ///< This corresponds to "fpexcept.maytrap".
+ ebStrict ///< This corresponds to "fpexcept.strict".
+ };
+
bool isUnaryOp() const;
bool isTernaryOp() const;
- Optional<fp::RoundingMode> getRoundingMode() const;
- Optional<fp::ExceptionBehavior> getExceptionBehavior() const;
+ Optional<RoundingMode> getRoundingMode() const;
+ Optional<ExceptionBehavior> getExceptionBehavior() const;
+
+ /// Returns a valid RoundingMode enumerator when given a string
+ /// that is valid as input in constrained intrinsic rounding mode
+ /// metadata.
+ static Optional<RoundingMode> StrToRoundingMode(StringRef);
+
+ /// For any RoundingMode enumerator, returns a string valid as input in
+ /// constrained intrinsic rounding mode metadata.
+ static Optional<StringRef> RoundingModeToStr(RoundingMode);
+
+ /// Returns a valid ExceptionBehavior enumerator when given a string
+ /// valid as input in constrained intrinsic exception behavior metadata.
+ static Optional<ExceptionBehavior> StrToExceptionBehavior(StringRef);
+
+ /// For any ExceptionBehavior enumerator, returns a string valid as
+ /// input in constrained intrinsic exception behavior metadata.
+ static Optional<StringRef> ExceptionBehaviorToStr(ExceptionBehavior);
// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const IntrinsicInst *I) {
diff --git a/llvm/include/llvm/Target/TargetOptions.h b/llvm/include/llvm/Target/TargetOptions.h
index d1db4eceabb8..c395e5bcecf1 100644
--- a/llvm/include/llvm/Target/TargetOptions.h
+++ b/llvm/include/llvm/Target/TargetOptions.h
@@ -107,7 +107,7 @@ namespace llvm {
public:
TargetOptions()
: PrintMachineCode(false), UnsafeFPMath(false), NoInfsFPMath(false),
- NoNaNsFPMath(false), NoTrappingFPMath(true),
+ NoNaNsFPMath(false), NoTrappingFPMath(false),
NoSignedZerosFPMath(false),
HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
GuaranteedTailCallOpt(false), StackSymbolOrdering(true),
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
index 54a31424b202..1a42150b3e54 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
@@ -7032,7 +7032,8 @@ void SelectionDAGBuilder::visitConstrainedFPIntrinsic(
SDVTList VTs = DAG.getVTList(ValueVTs);
SDValue Result = DAG.getNode(Opcode, sdl, VTs, Opers);
- if (FPI.getExceptionBehavior() != fp::ExceptionBehavior::ebIgnore) {
+ if (FPI.getExceptionBehavior() !=
+ ConstrainedFPIntrinsic::ExceptionBehavior::ebIgnore) {
SDNodeFlags Flags;
Flags.setFPExcept(true);
Result->setFlags(Flags);
diff --git a/llvm/lib/IR/CMakeLists.txt b/llvm/lib/IR/CMakeLists.txt
index f53d536ca8e1..a9012637277b 100644
--- a/llvm/lib/IR/CMakeLists.txt
+++ b/llvm/lib/IR/CMakeLists.txt
@@ -22,7 +22,6 @@ add_llvm_library(LLVMCore
DiagnosticInfo.cpp
DiagnosticPrinter.cpp
Dominators.cpp
- FPEnv.cpp
Function.cpp
GVMaterializer.cpp
Globals.cpp
diff --git a/llvm/lib/IR/FPEnv.cpp b/llvm/lib/IR/FPEnv.cpp
deleted file mode 100644
index 008852658232..000000000000
--- a/llvm/lib/IR/FPEnv.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-//===-- FPEnv.cpp ---- FP Environment -------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-/// @file
-/// This file contains the implementations of entities that describe floating
-/// point environment.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/StringSwitch.h"
-#include "llvm/IR/FPEnv.h"
-
-namespace llvm {
-
-Optional<fp::RoundingMode> StrToRoundingMode(StringRef RoundingArg) {
- // For dynamic rounding mode, we use round to nearest but we will set the
- // 'exact' SDNodeFlag so that the value will not be rounded.
- return StringSwitch<Optional<fp::RoundingMode>>(RoundingArg)
- .Case("round.dynamic", fp::rmDynamic)
- .Case("round.tonearest", fp::rmToNearest)
- .Case("round.downward", fp::rmDownward)
- .Case("round.upward", fp::rmUpward)
- .Case("round.towardzero", fp::rmTowardZero)
- .Default(None);
-}
-
-Optional<StringRef> RoundingModeToStr(fp::RoundingMode UseRounding) {
- Optional<StringRef> RoundingStr = None;
- switch (UseRounding) {
- case fp::rmDynamic:
- RoundingStr = "round.dynamic";
- break;
- case fp::rmToNearest:
- RoundingStr = "round.tonearest";
- break;
- case fp::rmDownward:
- RoundingStr = "round.downward";
- break;
- case fp::rmUpward:
- RoundingStr = "round.upward";
- break;
- case fp::rmTowardZero:
- RoundingStr = "round.towardzero";
- break;
- }
- return RoundingStr;
-}
-
-Optional<fp::ExceptionBehavior> StrToExceptionBehavior(StringRef ExceptionArg) {
- return StringSwitch<Optional<fp::ExceptionBehavior>>(ExceptionArg)
- .Case("fpexcept.ignore", fp::ebIgnore)
- .Case("fpexcept.maytrap", fp::ebMayTrap)
- .Case("fpexcept.strict", fp::ebStrict)
- .Default(None);
-}
-
-Optional<StringRef> ExceptionBehaviorToStr(fp::ExceptionBehavior UseExcept) {
- Optional<StringRef> ExceptStr = None;
- switch (UseExcept) {
- case fp::ebStrict:
- ExceptStr = "fpexcept.strict";
- break;
- case fp::ebIgnore:
- ExceptStr = "fpexcept.ignore";
- break;
- case fp::ebMayTrap:
- ExceptStr = "fpexcept.maytrap";
- break;
- }
- return ExceptStr;
-}
-
-}
\ No newline at end of file
diff --git a/llvm/lib/IR/IntrinsicInst.cpp b/llvm/lib/IR/IntrinsicInst.cpp
index 8b80d294a250..26ed46a9cd91 100644
--- a/llvm/lib/IR/IntrinsicInst.cpp
+++ b/llvm/lib/IR/IntrinsicInst.cpp
@@ -102,7 +102,8 @@ Value *InstrProfIncrementInst::getStep() const {
return ConstantInt::get(Type::getInt64Ty(Context), 1);
}
-Optional<fp::RoundingMode> ConstrainedFPIntrinsic::getRoundingMode() const {
+Optional<ConstrainedFPIntrinsic::RoundingMode>
+ConstrainedFPIntrinsic::getRoundingMode() const {
unsigned NumOperands = getNumArgOperands();
Metadata *MD =
cast<MetadataAsValue>(getArgOperand(NumOperands - 2))->getMetadata();
@@ -111,7 +112,43 @@ Optional<fp::RoundingMode> ConstrainedFPIntrinsic::getRoundingMode() const {
return StrToRoundingMode(cast<MDString>(MD)->getString());
}
-Optional<fp::ExceptionBehavior>
+Optional<ConstrainedFPIntrinsic::RoundingMode>
+ConstrainedFPIntrinsic::StrToRoundingMode(StringRef RoundingArg) {
+ // For dynamic rounding mode, we use round to nearest but we will set the
+ // 'exact' SDNodeFlag so that the value will not be rounded.
+ return StringSwitch<Optional<RoundingMode>>(RoundingArg)
+ .Case("round.dynamic", rmDynamic)
+ .Case("round.tonearest", rmToNearest)
+ .Case("round.downward", rmDownward)
+ .Case("round.upward", rmUpward)
+ .Case("round.towardzero", rmTowardZero)
+ .Default(None);
+}
+
+Optional<StringRef>
+ConstrainedFPIntrinsic::RoundingModeToStr(RoundingMode UseRounding) {
+ Optional<StringRef> RoundingStr = None;
+ switch (UseRounding) {
+ case ConstrainedFPIntrinsic::rmDynamic:
+ RoundingStr = "round.dynamic";
+ break;
+ case ConstrainedFPIntrinsic::rmToNearest:
+ RoundingStr = "round.tonearest";
+ break;
+ case ConstrainedFPIntrinsic::rmDownward:
+ RoundingStr = "round.downward";
+ break;
+ case ConstrainedFPIntrinsic::rmUpward:
+ RoundingStr = "round.upward";
+ break;
+ case ConstrainedFPIntrinsic::rmTowardZero:
+ RoundingStr = "round.towardzero";
+ break;
+ }
+ return RoundingStr;
+}
+
+Optional<ConstrainedFPIntrinsic::ExceptionBehavior>
ConstrainedFPIntrinsic::getExceptionBehavior() const {
unsigned NumOperands = getNumArgOperands();
Metadata *MD =
@@ -121,6 +158,32 @@ ConstrainedFPIntrinsic::getExceptionBehavior() const {
return StrToExceptionBehavior(cast<MDString>(MD)->getString());
}
+Optional<ConstrainedFPIntrinsic::ExceptionBehavior>
+ConstrainedFPIntrinsic::StrToExceptionBehavior(StringRef ExceptionArg) {
+ return StringSwitch<Optional<ExceptionBehavior>>(ExceptionArg)
+ .Case("fpexcept.ignore", ebIgnore)
+ .Case("fpexcept.maytrap", ebMayTrap)
+ .Case("fpexcept.strict", ebStrict)
+ .Default(None);
+}
+
+Optional<StringRef>
+ConstrainedFPIntrinsic::ExceptionBehaviorToStr(ExceptionBehavior UseExcept) {
+ Optional<StringRef> ExceptStr = None;
+ switch (UseExcept) {
+ case ConstrainedFPIntrinsic::ebStrict:
+ ExceptStr = "fpexcept.strict";
+ break;
+ case ConstrainedFPIntrinsic::ebIgnore:
+ ExceptStr = "fpexcept.ignore";
+ break;
+ case ConstrainedFPIntrinsic::ebMayTrap:
+ ExceptStr = "fpexcept.maytrap";
+ break;
+ }
+ return ExceptStr;
+}
+
bool ConstrainedFPIntrinsic::isUnaryOp() const {
switch (getIntrinsicID()) {
default:
diff --git a/llvm/unittests/IR/IRBuilderTest.cpp b/llvm/unittests/IR/IRBuilderTest.cpp
index d7712fda1270..c74f63014d29 100644
--- a/llvm/unittests/IR/IRBuilderTest.cpp
+++ b/llvm/unittests/IR/IRBuilderTest.cpp
@@ -242,52 +242,52 @@ TEST_F(IRBuilderTest, ConstrainedFP) {
V = Builder.CreateFAdd(V, V);
ASSERT_TRUE(isa<ConstrainedFPIntrinsic>(V));
auto *CII = cast<ConstrainedFPIntrinsic>(V);
- EXPECT_EQ(fp::ebStrict, CII->getExceptionBehavior());
- EXPECT_EQ(fp::rmDynamic, CII->getRoundingMode());
+ ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebStrict);
+ ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDynamic);
- Builder.setDefaultConstrainedExcept(fp::ebIgnore);
- Builder.setDefaultConstrainedRounding(fp::rmUpward);
+ Builder.setDefaultConstrainedExcept(ConstrainedFPIntrinsic::ebIgnore);
+ Builder.setDefaultConstrainedRounding(ConstrainedFPIntrinsic::rmUpward);
V = Builder.CreateFAdd(V, V);
CII = cast<ConstrainedFPIntrinsic>(V);
- EXPECT_EQ(fp::ebIgnore, CII->getExceptionBehavior());
- EXPECT_EQ(CII->getRoundingMode(), fp::rmUpward);
+ ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebIgnore);
+ ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmUpward);
- Builder.setDefaultConstrainedExcept(fp::ebIgnore);
- Builder.setDefaultConstrainedRounding(fp::rmToNearest);
+ Builder.setDefaultConstrainedExcept(ConstrainedFPIntrinsic::ebIgnore);
+ Builder.setDefaultConstrainedRounding(ConstrainedFPIntrinsic::rmToNearest);
V = Builder.CreateFAdd(V, V);
CII = cast<ConstrainedFPIntrinsic>(V);
- EXPECT_EQ(fp::ebIgnore, CII->getExceptionBehavior());
- EXPECT_EQ(fp::rmToNearest, CII->getRoundingMode());
+ ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebIgnore);
+ ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmToNearest);
- Builder.setDefaultConstrainedExcept(fp::ebMayTrap);
- Builder.setDefaultConstrainedRounding(fp::rmDownward);
+ Builder.setDefaultConstrainedExcept(ConstrainedFPIntrinsic::ebMayTrap);
+ Builder.setDefaultConstrainedRounding(ConstrainedFPIntrinsic::rmDownward);
V = Builder.CreateFAdd(V, V);
CII = cast<ConstrainedFPIntrinsic>(V);
- EXPECT_EQ(fp::ebMayTrap, CII->getExceptionBehavior());
- EXPECT_EQ(fp::rmDownward, CII->getRoundingMode());
+ ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebMayTrap);
+ ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDownward);
- Builder.setDefaultConstrainedExcept(fp::ebStrict);
- Builder.setDefaultConstrainedRounding(fp::rmTowardZero);
+ Builder.setDefaultConstrainedExcept(ConstrainedFPIntrinsic::ebStrict);
+ Builder.setDefaultConstrainedRounding(ConstrainedFPIntrinsic::rmTowardZero);
V = Builder.CreateFAdd(V, V);
CII = cast<ConstrainedFPIntrinsic>(V);
- EXPECT_EQ(fp::ebStrict, CII->getExceptionBehavior());
- EXPECT_EQ(fp::rmTowardZero, CII->getRoundingMode());
+ ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebStrict);
+ ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmTowardZero);
- Builder.setDefaultConstrainedExcept(fp::ebIgnore);
- Builder.setDefaultConstrainedRounding(fp::rmDynamic);
+ Builder.setDefaultConstrainedExcept(ConstrainedFPIntrinsic::ebIgnore);
+ Builder.setDefaultConstrainedRounding(ConstrainedFPIntrinsic::rmDynamic);
V = Builder.CreateFAdd(V, V);
CII = cast<ConstrainedFPIntrinsic>(V);
- EXPECT_EQ(fp::ebIgnore, CII->getExceptionBehavior());
- EXPECT_EQ(fp::rmDynamic, CII->getRoundingMode());
+ ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebIgnore);
+ ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDynamic);
// Now override the defaults.
Call = Builder.CreateConstrainedFPBinOp(
Intrinsic::experimental_constrained_fadd, V, V, nullptr, "", nullptr,
- fp::rmDownward, fp::ebMayTrap);
+ ConstrainedFPIntrinsic::rmDownward, ConstrainedFPIntrinsic::ebMayTrap);
CII = cast<ConstrainedFPIntrinsic>(Call);
EXPECT_EQ(CII->getIntrinsicID(), Intrinsic::experimental_constrained_fadd);
- EXPECT_EQ(fp::ebMayTrap, CII->getExceptionBehavior());
- EXPECT_EQ(fp::rmDownward, CII->getRoundingMode());
+ ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebMayTrap);
+ ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDownward);
Builder.CreateRetVoid();
EXPECT_FALSE(verifyModule(*M));
More information about the cfe-commits
mailing list