Index: clang/docs/UsersManual.rst =================================================================== --- clang/docs/UsersManual.rst +++ clang/docs/UsersManual.rst @@ -1226,10 +1226,10 @@ **-f[no-]trapping-math** - ``-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. + 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. .. option:: -ffp-contract= @@ -1314,6 +1314,52 @@ 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 different 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 different 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= + + 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= + + 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 Index: clang/include/clang/Basic/LangOptions.h =================================================================== --- clang/include/clang/Basic/LangOptions.h +++ clang/include/clang/Basic/LangOptions.h @@ -184,6 +184,34 @@ 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, @@ -317,6 +345,7 @@ /// Return the OpenCL C or C++ version as a VersionTuple. VersionTuple getOpenCLVersionTuple() const; + }; /// Floating point control options Index: clang/include/clang/Basic/LangOptions.def =================================================================== --- clang/include/clang/Basic/LangOptions.def +++ clang/include/clang/Basic/LangOptions.def @@ -254,6 +254,8 @@ 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") Index: clang/include/clang/Driver/Options.td =================================================================== --- clang/include/clang/Driver/Options.td +++ clang/include/clang/Driver/Options.td @@ -928,6 +928,10 @@ def : Flag<["-"], "fno-extended-identifiers">, Group, Flags<[Unsupported]>; def fhosted : Flag<["-"], "fhosted">, Group; def fdenormal_fp_math_EQ : Joined<["-"], "fdenormal-fp-math=">, Group, Flags<[CC1Option]>; +def ffp_model_EQ : Joined<["-"], "ffp-model=">, Group, Flags<[DriverOption]>, + HelpText<"Controls the semantics of floating-point calculations.">; +def ffp_exception_behavior_EQ : Joined<["-"], "ffp-exception-behavior=">, Group, Flags<[CC1Option]>, + HelpText<"Specifies the exception behavior of floating-point operations.">; def ffast_math : Flag<["-"], "ffast-math">, Group, Flags<[CC1Option]>, HelpText<"Allow aggressive, lossy floating-point optimizations">; def fno_fast_math : Flag<["-"], "fno-fast-math">, Group; @@ -1144,6 +1148,8 @@ // This option was originally misspelt "infinites" [sic]. def : Flag<["-"], "fhonor-infinites">, Alias; def : Flag<["-"], "fno-honor-infinites">, Alias; +def frounding_math : Flag<["-"], "frounding-math">, Group, Flags<[CC1Option]>; +def fno_rounding_math : Flag<["-"], "fno-rounding-math">, Group, Flags<[CC1Option]>; def ftrapping_math : Flag<["-"], "ftrapping-math">, Group, Flags<[CC1Option]>; def fno_trapping_math : Flag<["-"], "fno-trapping-math">, Group, Flags<[CC1Option]>; def ffp_contract : Joined<["-"], "ffp-contract=">, Group, @@ -3211,7 +3217,6 @@ defm regs_graph : BooleanFFlag<"regs-graph">, Group; defm rename_registers : BooleanFFlag<"rename-registers">, Group; defm ripa : BooleanFFlag<"ripa">, Group; -defm rounding_math : BooleanFFlag<"rounding-math">, Group; defm schedule_insns : BooleanFFlag<"schedule-insns">, Group; defm schedule_insns2 : BooleanFFlag<"schedule-insns2">, Group; defm see : BooleanFFlag<"see">, Group; Index: clang/lib/CodeGen/CodeGenFunction.h =================================================================== --- clang/lib/CodeGen/CodeGenFunction.h +++ clang/lib/CodeGen/CodeGenFunction.h @@ -4154,6 +4154,9 @@ /// 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); Index: clang/lib/CodeGen/CodeGenFunction.cpp =================================================================== --- clang/lib/CodeGen/CodeGenFunction.cpp +++ clang/lib/CodeGen/CodeGenFunction.cpp @@ -33,6 +33,7 @@ #include "clang/Frontend/FrontendDiagnostic.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/Dominators.h" +#include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/Intrinsics.h" #include "llvm/IR/MDBuilder.h" #include "llvm/IR/Operator.h" @@ -87,6 +88,7 @@ FMF.setAllowReassoc(); } Builder.setFastMathFlags(FMF); + SetFPModel(); } CodeGenFunction::~CodeGenFunction() { @@ -102,6 +104,60 @@ CGM.getOpenMPRuntime().functionFinished(*this); } +void CodeGenFunction::SetFPModel() { + auto fpRoundingMode = getLangOpts().getFPRoundingMode(); + auto fpExceptionBehavior = getLangOpts().getFPExceptionMode(); + + // Translate the compiler options into + // the settings that are transmitted to the IR Builder + llvm::ConstrainedFPIntrinsic::RoundingMode ConstrainedRoundingMD; + llvm::ConstrainedFPIntrinsic::ExceptionBehavior ConstrainedExceptMD; + + switch (fpRoundingMode) { + case LangOptions::FPR_ToNearest: + ConstrainedRoundingMD = llvm::ConstrainedFPIntrinsic::rmToNearest; + break; + case LangOptions::FPR_Downward: + ConstrainedRoundingMD = llvm::ConstrainedFPIntrinsic::rmDownward; + break; + case LangOptions::FPR_Upward: + ConstrainedRoundingMD = llvm::ConstrainedFPIntrinsic::rmUpward; + break; + case LangOptions::FPR_TowardZero: + ConstrainedRoundingMD = llvm::ConstrainedFPIntrinsic::rmTowardZero; + break; + case LangOptions::FPR_Dynamic: + ConstrainedRoundingMD = llvm::ConstrainedFPIntrinsic::rmDynamic; + break; + default: + llvm_unreachable("Unsupported FP RoundingMode"); + } + + switch (fpExceptionBehavior) { + case LangOptions::FPE_Ignore: + ConstrainedExceptMD = llvm::ConstrainedFPIntrinsic::ebIgnore; + break; + case LangOptions::FPE_MayTrap: + ConstrainedExceptMD = llvm::ConstrainedFPIntrinsic::ebMayTrap; + break; + case LangOptions::FPE_Strict: + ConstrainedExceptMD = llvm::ConstrainedFPIntrinsic::ebStrict; + break; + default: + llvm_unreachable("Unsupported FP Exception Behavior"); + } + + if (fpExceptionBehavior == LangOptions::FPE_Ignore && + fpRoundingMode == LangOptions::FPR_ToNearest) + // Constrained intrinsics are not used. + ; + else { + Builder.setIsFPConstrained(true); + Builder.setDefaultConstrainedRounding(ConstrainedRoundingMD); + Builder.setDefaultConstrainedExcept(ConstrainedExceptMD); + } +} + CharUnits CodeGenFunction::getNaturalPointeeTypeAlignment(QualType T, LValueBaseInfo *BaseInfo, TBAAAccessInfo *TBAAInfo) { Index: clang/lib/Driver/ToolChains/Clang.cpp =================================================================== --- clang/lib/Driver/ToolChains/Clang.cpp +++ clang/lib/Driver/ToolChains/Clang.cpp @@ -2229,9 +2229,18 @@ bool AssociativeMath = false; bool ReciprocalMath = false; bool SignedZeros = true; - bool TrappingMath = 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 = ""; StringRef DenormalFPMath = ""; StringRef FPContract = ""; + bool StrictFPModel = false; if (const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) { CmdArgs.push_back("-mlimit-float-precision"); @@ -2239,7 +2248,82 @@ } for (const Arg *A : Args) { - switch (A->getOption().getID()) { + 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; + // fp-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) { // If this isn't an FP option skip the claim below default: continue; @@ -2256,8 +2340,27 @@ 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; break; - case options::OPT_fno_trapping_math: TrappingMath = 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_fdenormal_fp_math_EQ: DenormalFPMath = A->getValue(); @@ -2266,10 +2369,43 @@ // Validate and pass through -fp-contract option. case options::OPT_ffp_contract: { StringRef Val = A->getValue(); - if (Val == "fast" || Val == "on" || Val == "off") + if (PreciseFPModel) { + // -fp-model=precise enables fp-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")) 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; } @@ -2311,6 +2447,7 @@ ReciprocalMath = true; SignedZeros = false; TrappingMath = false; + RoundingFPMath = false; // If fast-math is set then set the fp-contract mode to fast. FPContract = "fast"; break; @@ -2325,11 +2462,30 @@ ReciprocalMath = false; SignedZeros = true; TrappingMath = true; + RoundingFPMath = true; // -fno_fast_math restores default denormal and fpcontract handling DenormalFPMath = ""; FPContract = ""; break; } + if (StrictFPModel) { + // If fp-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 fp-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(); @@ -2357,7 +2513,11 @@ if (ReciprocalMath) CmdArgs.push_back("-freciprocal-math"); - if (!TrappingMath) + if (TrappingMath) { + // FP Exception Behavior is also set to strict + assert(FPExceptionBehavior.equals("strict")); + CmdArgs.push_back("-ftrapping-math"); + } else if (TrappingMathPresent) CmdArgs.push_back("-fno-trapping-math"); if (!DenormalFPMath.empty()) @@ -2367,14 +2527,37 @@ 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) + ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath) { CmdArgs.push_back("-ffast-math"); + if (FPModel.equals("fast")) { + if (FPContract.equals("fast")) + // All set, do nothing. + ; + else if (FPContract.empty()) + // Enable fp-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) Index: clang/lib/Frontend/CompilerInvocation.cpp =================================================================== --- clang/lib/Frontend/CompilerInvocation.cpp +++ clang/lib/Frontend/CompilerInvocation.cpp @@ -3124,6 +3124,36 @@ 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); Index: clang/test/CodeGen/fpconstrained.c =================================================================== --- /dev/null +++ clang/test/CodeGen/fpconstrained.c @@ -0,0 +1,23 @@ +// 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 +} Index: clang/test/Driver/clang_f_opts.c =================================================================== --- clang/test/Driver/clang_f_opts.c +++ clang/test/Driver/clang_f_opts.c @@ -320,7 +320,6 @@ // RUN: -fprefetch-loop-arrays \ // RUN: -fprofile-correction \ // RUN: -fprofile-values \ -// RUN: -frounding-math \ // RUN: -fschedule-insns \ // RUN: -fsignaling-nans \ // RUN: -fstrength-reduce \ @@ -385,7 +384,6 @@ // 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 Index: clang/test/Driver/fast-math.c =================================================================== --- clang/test/Driver/fast-math.c +++ 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 -c %s 2>&1 \ +// RUN: -fno-math-errno -ffp-contract=fast -fno-rounding-math -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 -c %s 2>&1 \ +// RUN: -fno-trapping-math -ffp-contract=fast -fno-rounding-math -c %s 2>&1 \ // RUN: | FileCheck --check-prefix=CHECK-FAST-MATH %s // CHECK-FAST-MATH: "-cc1" // CHECK-FAST-MATH: "-ffast-math" Index: clang/test/Driver/fp-model.c =================================================================== --- /dev/null +++ clang/test/Driver/fp-model.c @@ -0,0 +1,130 @@ +// 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" + Index: llvm/include/llvm/Target/TargetOptions.h =================================================================== --- llvm/include/llvm/Target/TargetOptions.h +++ llvm/include/llvm/Target/TargetOptions.h @@ -107,7 +107,7 @@ public: TargetOptions() : PrintMachineCode(false), UnsafeFPMath(false), NoInfsFPMath(false), - NoNaNsFPMath(false), NoTrappingFPMath(false), + NoNaNsFPMath(false), NoTrappingFPMath(true), NoSignedZerosFPMath(false), HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false), GuaranteedTailCallOpt(false), StackSymbolOrdering(true),