Use FPContractModeKind universally

[anemet]

Summary

FPContractModeKind is the codegen option flag which is already ternary (off,
on, fast). This makes it universally the type for the contractable info
across the front-end:

• In FPOptions (i.e. in the Sema + in the expression nodes).
• In LangOpts::DefaultFPContractMode which is the option that initializes

FPOptions in the Sema.

Another way to look at this change is that before fp-contractable on/off were
the only states handled to the front-end:

• For "on", FMA folding was performed by the front-end
• For "fast", we simply forwarded the flag to TargetOptions to handle it in LLVM

Now off/on/fast are all exposed because for fast we will generate
fast-math-flags during CodeGen.

This is toward moving fp-contraction=fast from an LLVM TargetOption to a
FastMathFlag in order to fix PR25721.

[aaron.ballman]

Aside from a minor comment nit, LGTM

include/clang/Basic/LangOptions.h

92 ↗

(On Diff #92423)

I think you mean effected rather than affected.

[anemet]

include/clang/Basic/LangOptions.h

92 ↗

(On Diff #92423)

I think the verb is affect; effect is the noun. Quick grep confirms:

/org/llvm$ git grep affected | wc -l

109

/org/llvm$ git grep effected | wc -l

2

[aaron.ballman]

include/clang/Basic/LangOptions.h

92 ↗

(On Diff #92423)

I think I was thrown by "form" being the verb in that sentence, but you are correct. :-)

[rnk]

cfe/trunk/include/clang/Basic/LangOptions.h

217

Please do not use bitfields with enum types, it's a good way to break the build on Windows. This change triggered this clang-cl warning:

C:\src\llvm-project\clang\include\clang/Basic/LangOptions.h(208,17):  warning: implicit truncation from 'clang::LangOptions::FPContractModeKind' to bit-field changes value from 2 to -2 [-Wbitfield-constant-conversion]
    fp_contract = LangOptions::FPC_Fast;
                ^ ~~~~~~~~~~~~~~~~~~~~~

[anemet]

cfe/trunk/include/clang/Basic/LangOptions.h

217

Noted and thanks for the fix! Unfortunately the warning wasn't showing up on my host. I'll take a look why.

[rnk]

cfe/trunk/include/clang/Basic/LangOptions.h

217

Clang doesn't emit that warning on Posix because it wouldn't be true. The implicit underlying type of the enum on non-Windows is 'unsigned', not 'int'. We could issue a portability warning, but we wouldn't be able to turn it on by default because many users don't care about Windows portability.

Anyway, sorry about the bother. This is one of the reasons we just use 'unsigned' for all our bitfields. =/

[yaxunl]

cfe/trunk/include/clang/Basic/LangOptions.def

220

This change seemed to cause some performance degradations in some OpenCL applications.

This option used to be on by default. Now it is off by default.

There are applications do separated compile/link/codegen stages. In the codegen stage, clang is invoked with .bc as input, therefore this option is off by default, whereas it was on by default before this change.

Is there any reason not to keep the original behavior?

Thanks.

[anemet]

cfe/trunk/include/clang/Basic/LangOptions.def

220

This change seemed to cause some performance degradations in some OpenCL applications.

This option used to be on by default. Now it is off by default.

It's always been off. It was set to fast for CUDA which should still be the case. See the changes further down on the patch.

There are applications do separated compile/link/codegen stages. In the codegen stage, clang is invoked with .bc as input, therefore this option is off by default, whereas it was on by default before this change.

Is there any reason not to keep the original behavior?

Sorry but I am not sure what changed, can you elaborate on what you're doing and how things used to work for you?

[hfinkel]

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

1638

Looks like the intent is certainly to have kept the OpenCL default the same here.

[yaxunl]

cfe/trunk/include/clang/Basic/LangOptions.def

220

Before your change, -ffp-contract was a codegen option defined as

ENUM_CODEGENOPT(FPContractMode, FPContractModeKind, 2, FPC_On)

therefore the default value as on. After your change, it becomes off by default.

[yaxunl]

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

1638

Well we also use clang to compile LLVM IR to ISA. Before this change, fp-contract was on so that backend did fp contract. However, now clang does not turn on fp-contract when compiling LLVM IRs.

[hfinkel]

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

1638

That's the equivalent of 'Fast'. Maybe this should also be set to Fast then.

[yaxunl]

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

1638

Agree. That should fix this issue.

[anemet]

cfe/trunk/include/clang/Basic/LangOptions.def

220

No. -ffp-contract=on was a FE option and -ffp-contract=fast was a backend option. I still don't understand your use-case. Can you include a small testcase how this used to work before?

[yaxunl]

cfe/trunk/include/clang/Basic/LangOptions.def

220

-ffp-contract=on used to be a codegen option before this change. In CodeGen/BackendUtil.cpp, before this change:

switch (CodeGenOpts.getFPContractMode()) {
  switch (LangOpts.getDefaultFPContractMode()) {
  case LangOptions::FPC_Off:
    Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
    break;
  case LangOptions::FPC_On:
    Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
    break;
  case LangOptions::FPC_Fast:
    Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
    break;
  }

By default, -fp-contract=on, which results in llvm::FPOpFusion::Standard in the backend. This options allows backend to translate llvm.fmuladd to FMA machine instructions.

After this change, it becomes:

switch (LangOpts.getDefaultFPContractMode()) {
  case LangOptions::FPC_Off:
    Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
    break;
  case LangOptions::FPC_On:
    Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
    break;
  case LangOptions::FPC_Fast:
    Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
    break;
  }

now by default -ffp-contract=off, which results in llvm::FPOpFusion::Strict in the backend. This option disables backend translating llvm.fmuladd to FMA machine instructions in certain situations.

A simple lit test is as follows:

; RUN: %clang_cc1 -triple amdgcn -S -o - %s| FileCheck %s

define amdgpu_kernel void @f(double addrspace(1)* nocapture %out, double %a, double %b, double %c) local_unnamed_addr #0 {
entry:
  ; CHECK: v_fma_f64
  %0 = tail call double @llvm.fmuladd.f64(double %b, double %c, double %a)
  store double %0, double addrspace(1)* %out, align 8, !tbaa !6
  ret void
}

declare double @llvm.fmuladd.f64(double, double, double) #1

attributes #0 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-features"="+fp64-fp16-denormals,-fp32-denormals" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind readnone }

The test passes before this change and fails after this change.

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

1638

Actually, the option on may be working too, which corresponds to llvm::FPOpFusion::Standard. At least it allows llvm.fmuladd to be translated to FMA machine instructions. However, off will disable such translation in certain cases.

Quoting TargetOptions.h:

/// Fast mode - allows formation of fused FP ops whenever they're
/// profitable.
/// Standard mode - allow fusion only for 'blessed' FP ops. At present the
/// only blessed op is the fmuladd intrinsic. In the future more blessed ops
/// may be added.
/// Strict mode - allow fusion only if/when it can be proven that the excess
/// precision won't effect the result.

[hfinkel]

cfe/trunk/include/clang/Basic/LangOptions.def

220

I'm missing something here. We're calling for OpenCL:

Opts.setDefaultFPContractMode(LangOptions::FPC_On);

which seems like it should change the result returned by getDefaultFPContractMode(). Why does it not?

[yaxunl]

cfe/trunk/include/clang/Basic/LangOptions.def

220

The input to this test is LLVM IR, so Opts.setDefaultFPContractMode(LangOptions::FPC_On) is not executed.

[hfinkel]

cfe/trunk/include/clang/Basic/LangOptions.def

220

Seems like this is another aspect of the LTO problem. All of these things need to be function attributes. This is also true to make LTO work.

[anemet]

cfe/trunk/include/clang/Basic/LangOptions.def

220

@hfinkel, what is the actual point of un-fusing the intrinsic in the BE with FPOpFusion::Strict?

I don't know if targets use the target-independent intrinsic to implement builtin support but if yes this would override the user choosing of FMA by directly specifying the builtin.

[hfinkel]

cfe/trunk/include/clang/Basic/LangOptions.def

220

@hfinkel, what is the actual point of un-fusing the intrinsic in the BE with FPOpFusion::Strict?

I think this was added based on a different conception of how frontends would use the intrinsic: that they'd always add it where the language-semantics allow, and then the backend would either never use FMAs (strict), use FMAs where profitable (standard), etc.

I don't know if targets use the target-independent intrinsic to implement builtin support but if yes this would override the user choosing of FMA by directly specifying the builtin.

No target should use fmuladd to implement the builtin support for a target-specific intrinsic. It should use the fma intrinsic would always maps to an fma.

[anemet]

cfe/trunk/include/clang/Basic/LangOptions.def

220

I think this was added based on a different conception of how frontends would use the intrinsic: that they'd always add it where the language-semantics allow, and then the backend would either never use FMAs (strict), use FMAs where profitable (standard), etc.

So would you support disabling un-fusion on Strict? That should solve Yaxun's problem.

Also my mid-term goal is to completely remove the FPOpFusion target option in favor of the explicit representation in the IR: either the FMF or the direct use of the intrinsic. At that point the behavior would have to change anyway.

No target should use fmuladd to implement the builtin support for a target-specific intrinsic. It should use the fma intrinsic would always maps to an fma.

Could you please rephrase this, I am not sure I understand?

[mehdi_amini]

I believe considering the goal of moving to using per-instruction FMF and kills the global backend option, this leads to a bitcode upgrade issue: OpenCL (or other) bitcode that were generated bitcode don't have the right FMF and will be upgraded conservatively.
Performance regression when upgrading bitcode are to be expected in general, so it is not a bug.
To recover, an option for an OpenCL backend would be to add a pass that set the expected FMF everywhere after bitcode upgrade.

[yaxunl]

In D31167#725705, @mehdi_amini wrote:

I believe considering the goal of moving to using per-instruction FMF and kills the global backend option, this leads to a bitcode upgrade issue: OpenCL (or other) bitcode that were generated bitcode don't have the right FMF and will be upgraded conservatively.
Performance regression when upgrading bitcode are to be expected in general, so it is not a bug.
To recover, an option for an OpenCL backend would be to add a pass that set the expected FMF everywhere after bitcode upgrade.

Actually we are not concerned about old bitcodes. We are doing separate compile/link/codegen, but the bitcode we use in codegen is fresh from the same revision of llvm/clang. As long as the FMF carries the correct info from Clang we should be OK.

[hfinkel]

cfe/trunk/include/clang/Basic/LangOptions.def

220

So would you support disabling un-fusion on Strict? That should solve Yaxun's problem.

Why don't you just have the frontend never set 'Strict' and always set' Standard' (or 'Fast')? That seems like a reasonable option to me given how Clang generates IR.

Also my mid-term goal is to completely remove the FPOpFusion target option in favor of the explicit representation in the IR: either the FMF or the direct use of the intrinsic.

Sounds good.

Could you please rephrase this, I am not sure I understand?

Hrmm, maybe I misunderstood the question. Were you asking whether any target intrinsics, __builtin_<my target prefix>_<some fma thing>(a, b, c) would be lowered in terms of fmuladd instead of fma?

cfe/trunk/include/clang/AST/Expr.h

 public:
   typedef BinaryOperatorKind Opcode;
 
 private:
   unsigned Opc : 6;
 
   // This is only meaningful for operations on floating point types and 0
   // otherwise.
-  unsigned FPFeatures : 1;
+  unsigned FPFeatures : 2;
   SourceLocation OpLoc;
 
   enum { LHS, RHS, END_EXPR };
   Stmt* SubExprs[END_EXPR];
 public:
 
   BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
                  ExprValueKind VK, ExprObjectKind OK,
public:
   // Set the FP contractability status of this operator. Only meaningful for
   // operations on floating point types.
   void setFPFeatures(FPOptions F) { FPFeatures = F.getInt(); }
 
   FPOptions getFPFeatures() const { return FPOptions(FPFeatures); }
 
   // Get the FP contractability status of this operator. Only meaningful for
   // operations on floating point types.
-  bool isFPContractable() const {
-    return FPOptions(FPFeatures).isFPContractable();
+  bool isFPContractableWithinStatement() const {
+    return FPOptions(FPFeatures).allowFPContractWithinStatement();
   }
 
 protected:
   BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
                  ExprValueKind VK, ExprObjectKind OK,
                  SourceLocation opLoc, FPOptions FPFeatures, bool dead2)
     : Expr(CompoundAssignOperatorClass, ResTy, VK, OK,
            lhs->isTypeDependent() || rhs->isTypeDependent(),

cfe/trunk/include/clang/AST/ExprCXX.h

public:
   // Set the FP contractability status of this operator. Only meaningful for
   // operations on floating point types.
   void setFPFeatures(FPOptions F) { FPFeatures = F; }
 
   FPOptions getFPFeatures() const { return FPFeatures; }
 
   // Get the FP contractability status of this operator. Only meaningful for
   // operations on floating point types.
-  bool isFPContractable() const { return FPFeatures.isFPContractable(); }
+  bool isFPContractableWithinStatement() const {
+    return FPFeatures.allowFPContractWithinStatement();
+  }
 
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 };
 
 /// Represents a call to a member function that
 /// may be written either with member call syntax (e.g., "obj.func()"
 /// or "objptr->func()") or with normal function-call syntax

cfe/trunk/include/clang/Basic/LangOptions.h

public:
 
   enum MSVCMajorVersion {
     MSVC2010 = 16,
     MSVC2012 = 17,
     MSVC2013 = 18,
     MSVC2015 = 19
   };
 
+  enum FPContractModeKind {
+    FPC_Off,        // Form fused FP ops only where result will not be affected.
+    FPC_On,         // Form fused FP ops according to FP_CONTRACT rules.
+    FPC_Fast        // Aggressively fuse FP ops (E.g. FMA).
+  };
+
 public:
   /// \brief Set of enabled sanitizers.
   SanitizerSet Sanitize;
 
   /// \brief Paths to blacklist files specifying which objects
   /// (files, functions, variables) should not be instrumented.
   std::vector<std::string> SanitizerBlacklistFiles;
 
#include "clang/Basic/LangOptions.def"
   bool allowsNonTrivialObjCLifetimeQualifiers() const {
     return ObjCAutoRefCount || ObjCWeak;
   }
 };
 
 /// \brief Floating point control options
 class FPOptions {
 public:
-  FPOptions() : fp_contract(0) {}
+  FPOptions() : fp_contract(LangOptions::FPC_Off) {}
 
-  explicit FPOptions(unsigned I) : fp_contract(I) {}
+  // Used for serializing.
+  explicit FPOptions(unsigned I)
+      : fp_contract(static_cast<LangOptions::FPContractModeKind>(I)) {}
 
   explicit FPOptions(const LangOptions &LangOpts)
-      : fp_contract(LangOpts.DefaultFPContract) {}
+      : fp_contract(LangOpts.getDefaultFPContractMode()) {}
 
-  void setFPContractable(bool V) { fp_contract = V; }
-  bool isFPContractable() const { return fp_contract; }
+  bool allowFPContractWithinStatement() const {
+    return fp_contract == LangOptions::FPC_On;
+  }
+  bool allowFPContractAcrossStatement() const {
+    return fp_contract == LangOptions::FPC_Fast;
+  }
+  void setAllowFPContractWithinStatement() {
+    fp_contract = LangOptions::FPC_On;
+  }
+  void setAllowFPContractAcrossStatement() {
+    fp_contract = LangOptions::FPC_Fast;
+  }
+  void setDisallowFPContract() { fp_contract = LangOptions::FPC_Off; }
 
   /// Used to serialize this.
   unsigned getInt() const { return fp_contract; }
 
 private:
   /// Adjust BinaryOperator::FPFeatures to match the bit-field size of this.
-  unsigned fp_contract : 1;
+  LangOptions::FPContractModeKind fp_contract : 2;
 };
 
 /// \brief Describes the kind of translation unit being processed.
 enum TranslationUnitKind {
   /// \brief The translation unit is a complete translation unit.
   TU_Complete,
   /// \brief The translation unit is a prefix to a translation unit, and is
   /// not complete.
   TU_Prefix,
   /// \brief The translation unit is a module.
   TU_Module
 };
   
 }  // end namespace clang
 
 #endif

cfe/trunk/include/clang/Basic/LangOptions.def

 BENIGN_LANGOPT(ParseUnknownAnytype, 1, 0, "__unknown_anytype")
 BENIGN_LANGOPT(DebuggerSupport , 1, 0, "debugger support")
 BENIGN_LANGOPT(DebuggerCastResultToId, 1, 0, "for 'po' in the debugger, cast the result to id if it is of unknown type")
 BENIGN_LANGOPT(DebuggerObjCLiteral , 1, 0, "debugger Objective-C literals and subscripting support")
 
 BENIGN_LANGOPT(SpellChecking , 1, 1, "spell-checking")
 LANGOPT(SinglePrecisionConstants , 1, 0, "treating double-precision floating point constants as single precision constants")
 LANGOPT(FastRelaxedMath , 1, 0, "OpenCL fast relaxed math")
-LANGOPT(DefaultFPContract , 1, 0, "FP_CONTRACT")
+/// \brief FP_CONTRACT mode (on/off/fast).
+ENUM_LANGOPT(DefaultFPContractMode, FPContractModeKind, 2, FPC_Off, "FP contraction 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")
 LANGOPT(ObjCWeakRuntime     , 1, 0, "__weak support in the ARC runtime")
 LANGOPT(ObjCWeak            , 1, 0, "Objective-C __weak in ARC and MRC files")
 LANGOPT(ObjCSubscriptingLegacyRuntime         , 1, 0, "Subscripting support in legacy ObjectiveC runtime")
 LANGOPT(FakeAddressSpaceMap , 1, 0, "OpenCL fake address space map")
 ENUM_LANGOPT(AddressSpaceMapMangling , AddrSpaceMapMangling, 2, ASMM_Target, "OpenCL address space map mangling mode")

cfe/trunk/include/clang/Frontend/CodeGenOptions.h

public:
 
   enum TLSModel {
     GeneralDynamicTLSModel,
     LocalDynamicTLSModel,
     InitialExecTLSModel,
     LocalExecTLSModel
   };
 
-  enum FPContractModeKind {
-    FPC_Off,        // Form fused FP ops only where result will not be affected.
-    FPC_On,         // Form fused FP ops according to FP_CONTRACT rules.
-    FPC_Fast        // Aggressively fuse FP ops (E.g. FMA).
-  };
-
   enum StructReturnConventionKind {
     SRCK_Default,  // No special option was passed.
     SRCK_OnStack,  // Small structs on the stack (-fpcc-struct-return).
     SRCK_InRegs    // Small structs in registers (-freg-struct-return).
   };
 
   enum ProfileInstrKind {
     ProfileNone,       // Profile instrumentation is turned off.

cfe/trunk/include/clang/Frontend/CodeGenOptions.def

 CODEGENOPT(EmitDeclMetadata  , 1, 0) ///< Emit special metadata indicating what
                                      ///< Decl* various IR entities came from.
                                      ///< Only useful when running CodeGen as a
                                      ///< subroutine.
 CODEGENOPT(EmitGcovArcs      , 1, 0) ///< Emit coverage data files, aka. GCDA.
 CODEGENOPT(EmitGcovNotes     , 1, 0) ///< Emit coverage "notes" files, aka GCNO.
 CODEGENOPT(EmitOpenCLArgMetadata , 1, 0) ///< Emit OpenCL kernel arg metadata.
 CODEGENOPT(EmulatedTLS       , 1, 0) ///< Set when -femulated-tls is enabled.
-/// \brief FP_CONTRACT mode (on/off/fast).
-ENUM_CODEGENOPT(FPContractMode, FPContractModeKind, 2, FPC_On)
 /// \brief Embed Bitcode mode (off/all/bitcode/marker).
 ENUM_CODEGENOPT(EmbedBitcode, EmbedBitcodeKind, 2, Embed_Off)
 CODEGENOPT(ForbidGuardVariables , 1, 0) ///< Issue errors if C++ guard variables
                                         ///< are required.
 CODEGENOPT(FunctionSections  , 1, 0) ///< Set when -ffunction-sections is enabled.
 CODEGENOPT(InstrumentFunctions , 1, 0) ///< Set when -finstrument-functions is
                                        ///< enabled.
 

cfe/trunk/lib/CodeGen/BackendUtil.cpp

void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
   Options.FloatABIType =
       llvm::StringSwitch<llvm::FloatABI::ABIType>(CodeGenOpts.FloatABI)
           .Case("soft", llvm::FloatABI::Soft)
           .Case("softfp", llvm::FloatABI::Soft)
           .Case("hard", llvm::FloatABI::Hard)
           .Default(llvm::FloatABI::Default);
 
   // Set FP fusion mode.
-  switch (CodeGenOpts.getFPContractMode()) {
-  case CodeGenOptions::FPC_Off:
+  switch (LangOpts.getDefaultFPContractMode()) {
+  case LangOptions::FPC_Off:
     Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
     break;
-  case CodeGenOptions::FPC_On:
+  case LangOptions::FPC_On:
     Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
     break;
-  case CodeGenOptions::FPC_Fast:
+  case LangOptions::FPC_Fast:
     Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
     break;
   }
 
   Options.UseInitArray = CodeGenOpts.UseInitArray;
   Options.DisableIntegratedAS = CodeGenOpts.DisableIntegratedAS;
   Options.CompressDebugSections = CodeGenOpts.CompressDebugSections;
   Options.RelaxELFRelocations = CodeGenOpts.RelaxELFRelocations;

cfe/trunk/lib/CodeGen/CGExprScalar.cpp

static Value* tryEmitFMulAdd(const BinOpInfo &op,
                          const CodeGenFunction &CGF, CGBuilderTy &Builder,
                          bool isSub=false) {
 
   assert((op.Opcode == BO_Add || op.Opcode == BO_AddAssign ||
           op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) &&
          "Only fadd/fsub can be the root of an fmuladd.");
 
   // Check whether this op is marked as fusable.
-  if (!op.FPFeatures.isFPContractable())
-    return nullptr;
-
-  // Check whether -ffp-contract=on. (If -ffp-contract=off/fast, fusing is
-  // either disabled, or handled entirely by the LLVM backend).
-  if (CGF.CGM.getCodeGenOpts().getFPContractMode() != CodeGenOptions::FPC_On)
+  if (!op.FPFeatures.allowFPContractWithinStatement())
     return nullptr;
 
   // We have a potentially fusable op. Look for a mul on one of the operands.
   // Also, make sure that the mul result isn't used directly. In that case,
   // there's no point creating a muladd operation.
   if (auto *LHSBinOp = dyn_cast<llvm::BinaryOperator>(op.LHS)) {
     if (LHSBinOp->getOpcode() == llvm::Instruction::FMul &&
         LHSBinOp->use_empty())

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
     if (Model == ~0U) {
       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
       Success = false;
     } else {
       Opts.setDefaultTLSModel(static_cast<CodeGenOptions::TLSModel>(Model));
     }
   }
 
-  if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
-    StringRef Val = A->getValue();
-    if (Val == "fast")
-      Opts.setFPContractMode(CodeGenOptions::FPC_Fast);
-    else if (Val == "on")
-      Opts.setFPContractMode(CodeGenOptions::FPC_On);
-    else if (Val == "off")
-      Opts.setFPContractMode(CodeGenOptions::FPC_Off);
-    else
-      Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
-  }
-
   if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
     StringRef Val = A->getValue();
     if (Val == "ieee")
       Opts.FPDenormalMode = "ieee";
     else if (Val == "preserve-sign")
       Opts.FPDenormalMode = "preserve-sign";
     else if (Val == "positive-zero")
       Opts.FPDenormalMode = "positive-zero";
void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
   else if (LangStd == LangStandard::lang_opencl20)
     Opts.OpenCLVersion = 200;
 
   // OpenCL has some additional defaults.
   if (Opts.OpenCL) {
     Opts.AltiVec = 0;
     Opts.ZVector = 0;
     Opts.LaxVectorConversions = 0;
-    Opts.DefaultFPContract = 1;
+    Opts.setDefaultFPContractMode(LangOptions::FPC_On);
     Opts.NativeHalfType = 1;
     Opts.NativeHalfArgsAndReturns = 1;
     // Include default header file for OpenCL.
     if (Opts.IncludeDefaultHeader) {
       PPOpts.Includes.push_back("opencl-c.h");
     }
   }
 
   Opts.CUDA = IK == IK_CUDA || IK == IK_PreprocessedCuda ||
               LangStd == LangStandard::lang_cuda;
+  if (Opts.CUDA)
+    // Set default FP_CONTRACT to FAST.
+    Opts.setDefaultFPContractMode(LangOptions::FPC_Fast);
 
   Opts.RenderScript = IK == IK_RenderScript;
   if (Opts.RenderScript) {
     Opts.NativeHalfType = 1;
     Opts.NativeHalfArgsAndReturns = 1;
   }
 
   // OpenCL and C++ both have bool, true, false keywords.
Opts.FastMath = Args.hasArg(OPT_ffast_math) ||
       Args.hasArg(OPT_cl_fast_relaxed_math);
   Opts.FiniteMathOnly = Args.hasArg(OPT_ffinite_math_only) ||
       Args.hasArg(OPT_cl_finite_math_only) ||
       Args.hasArg(OPT_cl_fast_relaxed_math);
   Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
                       Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
                       Args.hasArg(OPT_cl_fast_relaxed_math);
 
+  if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
+    StringRef Val = A->getValue();
+    if (Val == "fast")
+      Opts.setDefaultFPContractMode(LangOptions::FPC_Fast);
+    else if (Val == "on")
+      Opts.setDefaultFPContractMode(LangOptions::FPC_On);
+    else if (Val == "off")
+      Opts.setDefaultFPContractMode(LangOptions::FPC_Off);
+    else
+      Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
+  }
+
   Opts.RetainCommentsFromSystemHeaders =
       Args.hasArg(OPT_fretain_comments_from_system_headers);
 
   unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
   switch (SSP) {
   default:
     Diags.Report(diag::err_drv_invalid_value)
       << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC)
       LangOpts.ObjCExceptions = 1;
   }
 
   if (LangOpts.CUDA) {
     // During CUDA device-side compilation, the aux triple is the
     // triple used for host compilation.
     if (LangOpts.CUDAIsDevice)
       Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple;
-
-    // Set default FP_CONTRACT to FAST.
-    if (!Args.hasArg(OPT_ffp_contract))
-      Res.getCodeGenOpts().setFPContractMode(CodeGenOptions::FPC_Fast);
   }
 
   // FIXME: Override value name discarding when asan or msan is used because the
   // backend passes depend on the name of the alloca in order to print out
   // names.
   Res.getCodeGenOpts().DiscardValueNames &=
       !LangOpts.Sanitize.has(SanitizerKind::Address) &&
       !LangOpts.Sanitize.has(SanitizerKind::Memory);

cfe/trunk/lib/Sema/SemaAttr.cpp

void Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType,
   } else {
     PopPragmaVisibility(false, PragmaLoc);
   }
 }
 
 void Sema::ActOnPragmaFPContract(tok::OnOffSwitch OOS) {
   switch (OOS) {
   case tok::OOS_ON:
-    FPFeatures.setFPContractable(true);
+    FPFeatures.setAllowFPContractWithinStatement();
     break;
   case tok::OOS_OFF:
-    FPFeatures.setFPContractable(false);
+    FPFeatures.setDisallowFPContract();
     break;
   case tok::OOS_DEFAULT:
-    FPFeatures.setFPContractable(getLangOpts().DefaultFPContract);
+    if (getLangOpts().getDefaultFPContractMode() == LangOptions::FPC_On)
+      FPFeatures.setAllowFPContractWithinStatement();
+    else
+      FPFeatures.setDisallowFPContract();
     break;
   }
 }
 
 void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
                                        SourceLocation Loc) {
   // Visibility calculations will consider the namespace's visibility.
   // Here we just want to note that we're in a visibility context