[Clang] Interaction of FP pragmas and function template instantiation

[sepavloff]

Summary

C standard defines set of pragmas that modify code generation for
operations on floating point values. In C++ code may be obtained using
template instantiation and from practical viewpoint it is necessary to
have possibility to modify code generation in this case as well. This
change implements interaction of FP pragmas with function template
instantiations.

If a function template contains a floating-point control pragma, the
latter is a part of template definition and presents in all
instantiations. If a pragma in placed outside any function it acts on
function templates in the same way as on functions. For the task of
function instantiation such pragma is equivalent to the same pragma put
at the beginning of all affected function bodies.

In the case is explicit instantiation there is apparent connection
between a point in source code and instantiated function. It can
support interaction of pragmas that act in that point. For example, in
the code:

#pragma STDC FENV_ROUND FE_DOWNWARD
template float func_05<short>(float, float);

the instantiated function is created with the specified constant
rounding mode. The effect is same as if the template pattern were
textually inserted into the code with needed replacements.

Implicit instantiations occur with FP options deduced from LangOpts.
They have no apparent connection to source code and are not influenced
by FP pragmas.

[efriedma]

In the case is explicit instantiation there is apparent connection
between a point in source code and instantiated function. It can
support interaction of pragmas that act in that point. For example, in
the code:

#pragma STDC FENV_ROUND FE_DOWNWARD
template float func_05<short>(float, float);

the instantiated function is created with the specified constant
rounding mode. The effect is same as if the template pattern were
textually inserted into the code with needed replacements.

These pragmas aren't currently part of the C++ standard, but I strongly doubt the C++ standards committee would choose to do this. You would end up with undefined behavior due to mismatched definitions, if the template is implicitly instantiated elsewhere.

The "obvious" rule here is just to always use the pragma in effect at the point the template body is written.

[rjmccall]

I completely agree with Eli.

[sepavloff]

In D131143#3700373, @efriedma wrote:

In the case is explicit instantiation there is apparent connection
between a point in source code and instantiated function. It can
support interaction of pragmas that act in that point. For example, in
the code:

#pragma STDC FENV_ROUND FE_DOWNWARD
template float func_05<short>(float, float);

the instantiated function is created with the specified constant
rounding mode. The effect is same as if the template pattern were
textually inserted into the code with needed replacements.

These pragmas aren't currently part of the C++ standard, but I strongly doubt the C++ standards committee would choose to do this.

This is an attempt to implement the interaction as proposed in the review of D129464. It is, of course, an extension, which may be convenient but nothing serious would happen if it is not implemented.

You would end up with undefined behavior due to mismatched definitions, if the template is implicitly instantiated elsewhere.

Indeed, it makes the solution fragile.

The "obvious" rule here is just to always use the pragma in effect at the point the template body is written.

Sure, it is already works in this way.

clang/include/clang/AST/Expr.h

 public:
   // Get the FP features status of this operator. Only meaningful for
   // operations on floating point types.
   FPOptions getFPFeaturesInEffect(const LangOptions &LO) const {
     if (UnaryOperatorBits.HasFPFeatures)
       return getStoredFPFeatures().applyOverrides(LO);
     return FPOptions::defaultWithoutTrailingStorage(LO);
   }
-  FPOptionsOverride getFPOptionsOverride() const {
-    if (UnaryOperatorBits.HasFPFeatures)
+
+  FPOptionsOverride getFPFeatures() const {
+    if (hasStoredFPFeatures())
       return getStoredFPFeatures();
     return FPOptionsOverride();
   }
 
   friend TrailingObjects;
   friend class ASTReader;
   friend class ASTStmtReader;
   friend class ASTStmtWriter;

clang/include/clang/AST/Stmt.h

public:
   bool hasStoredFPFeatures() const { return CompoundStmtBits.HasFPFeatures; }
 
   /// Get FPOptionsOverride from trailing storage.
   FPOptionsOverride getStoredFPFeatures() const {
     assert(hasStoredFPFeatures());
     return *getTrailingObjects<FPOptionsOverride>();
   }
 
+  FPOptionsOverride getFPFeatures() const {
+    if (hasStoredFPFeatures())
+      return getStoredFPFeatures();
+    return FPOptionsOverride();
+  }
+
   /// Get FPOptions inside this statement. They may differ from outer options
   /// due to pragmas.
   /// \param CurFPOptions FPOptions outside this statement.
   FPOptions getNewFPOptions(FPOptions CurFPOptions) const {
     return hasStoredFPFeatures()
                ? getStoredFPFeatures().applyOverrides(CurFPOptions)
                : CurFPOptions;
   }

clang/include/clang/Sema/Sema.h

 
   /// Records and restores the CurFPFeatures state on entry/exit of compound
   /// statements.
   class FPFeaturesStateRAII {
   public:
     FPFeaturesStateRAII(Sema &S);
     ~FPFeaturesStateRAII();
     FPOptionsOverride getOverrides() { return OldOverrides; }
+    FPOptions getFPFeatures() { return OldFPFeaturesState; }
 
   private:
     Sema& S;
     FPOptions OldFPFeaturesState;
     FPOptionsOverride OldOverrides;
     LangOptions::FPEvalMethodKind OldEvalMethod;
     SourceLocation OldFPPragmaLocation;
   };

clang/lib/AST/ASTImporter.cpp

 ExpectedStmt ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
   Error Err = Error::success();
   auto ToSubExpr = importChecked(Err, E->getSubExpr());
   auto ToType = importChecked(Err, E->getType());
   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
   if (Err)
     return std::move(Err);
 
-  return UnaryOperator::Create(
-      Importer.getToContext(), ToSubExpr, E->getOpcode(), ToType,
-      E->getValueKind(), E->getObjectKind(), ToOperatorLoc, E->canOverflow(),
-      E->getFPOptionsOverride());
+  return UnaryOperator::Create(Importer.getToContext(), ToSubExpr,
+                               E->getOpcode(), ToType, E->getValueKind(),
+                               E->getObjectKind(), ToOperatorLoc,
+                               E->canOverflow(), E->getFPFeatures());
 }
 
 ExpectedStmt
 
 ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
   Error Err = Error::success();
   auto ToType = importChecked(Err, E->getType());
   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

if (PatternDecl->isDefaulted()) {
 
     ActOnStartOfFunctionDef(nullptr, Function);
 
     // Enter the scope of this instantiation. We don't use
     // PushDeclContext because we don't have a scope.
     Sema::ContextRAII savedContext(*this, Function);
 
     FPFeaturesStateRAII SavedFPFeatures(*this);
+    if (TSK != TSK_ExplicitInstantiationDefinition)
       CurFPFeatures = FPOptions(getLangOpts());
 
     if (addInstantiatedParametersToScope(Function, PatternDecl, Scope,
                                          TemplateArgs))
       return;
 
     StmtResult Body;
     if (PatternDecl->hasSkippedBody()) {
       ActOnSkippedFunctionBody(Function);

clang/lib/Sema/TreeTransform.h

private:
 
   TypeSourceInfo *TransformTSIInObjectScope(TypeLoc TL, QualType ObjectType,
                                             NamedDecl *FirstQualifierInScope,
                                             CXXScopeSpec &SS);
 
   QualType TransformDependentNameType(TypeLocBuilder &TLB,
                                       DependentNameTypeLoc TL,
                                       bool DeducibleTSTContext);
+
+  /// Sets FP options in Sema for use in instantiation of the given expression.
+  ///
+  /// \tparam TExpr Subclass of \c Expr, which must be able to keep \c FPOption.
+  template <typename TExpr> void setFPOptions(const TExpr *E) {
+    const LangOptions &LO = getSema().getLangOpts();
+    FPOptions &CurFPO = getSema().CurFPFeatures;
+    CurFPO = E->getFPFeatures().applyOverrides(CurFPO);
+    getSema().FpPragmaStack.CurrentValue = CurFPO.getChangesFrom(FPOptions(LO));
+    if (CurFPO.isFPConstrained())
+      getSema().getCurFunction()->setUsesFPIntrin();
+  }
 };
 
 template <typename Derived>
 StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S, StmtDiscardKind SDK) {
   if (!S)
     return S;
 
   switch (S->getStmtClass()) {
ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init,
   }
 
   if (MaterializeTemporaryExpr *MTE = dyn_cast<MaterializeTemporaryExpr>(Init))
     Init = MTE->getSubExpr();
 
   while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Init))
     Init = Binder->getSubExpr();
 
-  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Init))
-    Init = ICE->getSubExprAsWritten();
-
   if (CXXStdInitializerListExpr *ILE =
           dyn_cast<CXXStdInitializerListExpr>(Init))
     return TransformInitializer(ILE->getSubExpr(), NotCopyInit);
 
   // If this is copy-initialization, we only need to reconstruct
   // InitListExprs. Other forms of copy-initialization will be a no-op if
   // the initializer is already the right type.
   CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init);

 TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S,
                                               bool IsStmtExpr) {
   Sema::CompoundScopeRAII CompoundScope(getSema());
 
   const Stmt *ExprResult = S->getStmtExprResult();
   bool SubStmtInvalid = false;
   bool SubStmtChanged = false;
   SmallVector<Stmt*, 8> Statements;
+
+  Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
+  setFPOptions(S);
+
   for (auto *B : S->body()) {
     StmtResult Result = getDerived().TransformStmt(
         B, IsStmtExpr && B == ExprResult ? SDK_StmtExprResult : SDK_Discarded);
 
     if (Result.isInvalid()) {
       // Immediately fail if this was a DeclStmt, since it's very
       // likely that this will cause problems for future statements.
       if (isa<DeclStmt>(B))
         return StmtError();
 
       // Otherwise, just keep processing substatements and fail later.
       SubStmtInvalid = true;
       continue;
     }
 
     SubStmtChanged = SubStmtChanged || Result.get() != B;
     Statements.push_back(Result.getAs<Stmt>());
   }
 
   if (SubStmtInvalid)
     return StmtError();
 
-  if (!getDerived().AlwaysRebuild() &&
-      !SubStmtChanged)
+  if (!getDerived().AlwaysRebuild() && !SubStmtChanged &&
+      FPFeaturesState.getFPFeatures() == getSema().CurFPFeatures)
     return S;
 
   return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
                                           Statements,
                                           S->getRBracLoc(),
                                           IsStmtExpr);
 }
 
TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) {
   ExprResult SubExpr;
   if (E->getOpcode() == UO_AddrOf)
     SubExpr = TransformAddressOfOperand(E->getSubExpr());
   else
     SubExpr = TransformExpr(E->getSubExpr());
   if (SubExpr.isInvalid())
     return ExprError();
 
-  if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
+  Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
+  setFPOptions(E);
+
+  if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr() &&
+      FPFeaturesState.getFPFeatures() == getSema().CurFPFeatures)
     return E;
 
   return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
                                            E->getOpcode(),
                                            SubExpr.get());
 }
 
 template<typename Derived>
TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
 
   // Transform arguments.
   bool ArgChanged = false;
   SmallVector<Expr*, 8> Args;
   if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
                                   &ArgChanged))
     return ExprError();
 
-  if (!getDerived().AlwaysRebuild() &&
-      Callee.get() == E->getCallee() &&
-      !ArgChanged)
+  Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
+  setFPOptions(E);
+
+  if (!getDerived().AlwaysRebuild() && Callee.get() == E->getCallee() &&
+      !ArgChanged && FPFeaturesState.getFPFeatures() == getSema().CurFPFeatures)
     return SemaRef.MaybeBindToTemporary(E);
 
   // FIXME: Wrong source location information for the '('.
   SourceLocation FakeLParenLoc
     = ((Expr *)Callee.get())->getSourceRange().getBegin();
 
-  Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
-  if (E->hasStoredFPFeatures()) {
-    FPOptionsOverride NewOverrides = E->getFPFeatures();
-    getSema().CurFPFeatures =
-        NewOverrides.applyOverrides(getSema().getLangOpts());
-    getSema().FpPragmaStack.CurrentValue = NewOverrides;
-  }
-
   return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
                                       Args,
                                       E->getRParenLoc());
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
   ExprResult LHS = getDerived().TransformExpr(E->getLHS());
   if (LHS.isInvalid())
     return ExprError();
 
   ExprResult RHS = getDerived().TransformExpr(E->getRHS());
   if (RHS.isInvalid())
     return ExprError();
 
-  if (!getDerived().AlwaysRebuild() &&
-      LHS.get() == E->getLHS() &&
-      RHS.get() == E->getRHS())
+  Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
+  setFPOptions(E);
+
+  if (!getDerived().AlwaysRebuild() && LHS.get() == E->getLHS() &&
+      RHS.get() == E->getRHS() &&
+      FPFeaturesState.getFPFeatures() == getSema().CurFPFeatures)
     return E;
 
   if (E->isCompoundAssignmentOp())
-    // FPFeatures has already been established from trailing storage
+    // FPFeatures has already been established from trailing storage by
+    // TransformCompoundAssignOperator.
     return getDerived().RebuildBinaryOperator(
         E->getOperatorLoc(), E->getOpcode(), LHS.get(), RHS.get());
-  Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
-  FPOptionsOverride NewOverrides(E->getFPFeatures());
-  getSema().CurFPFeatures =
-      NewOverrides.applyOverrides(getSema().getLangOpts());
-  getSema().FpPragmaStack.CurrentValue = NewOverrides;
+
   return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
                                             LHS.get(), RHS.get());
 }
 
 template <typename Derived>
 ExprResult TreeTransform<Derived>::TransformCXXRewrittenBinaryOperator(
     CXXRewrittenBinaryOperator *E) {
   CXXRewrittenBinaryOperator::DecomposedForm Decomp = E->getDecomposedForm();
return getDerived().RebuildCXXRewrittenBinaryOperator(
       E->getOperatorLoc(), Decomp.Opcode, UnqualLookups, LHS.get(), RHS.get());
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformCompoundAssignOperator(
                                                       CompoundAssignOperator *E) {
   Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
-  FPOptionsOverride NewOverrides(E->getFPFeatures());
-  getSema().CurFPFeatures =
-      NewOverrides.applyOverrides(getSema().getLangOpts());
-  getSema().FpPragmaStack.CurrentValue = NewOverrides;
+  setFPOptions(E);
   return getDerived().TransformBinaryOperator(E);
 }
 
 template<typename Derived>
 ExprResult TreeTransform<Derived>::
 TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
   // Just rebuild the common and RHS expressions and see whether we
   // get any changes.
return getDerived().RebuildConditionalOperator(Cond.get(),
                                                  LHS.get(),
                                                  E->getColonLoc(),
                                                  RHS.get());
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
+  ExprResult SubExpr = getDerived().TransformExpr(E->getSubExprAsWritten());
+  if (SubExpr.isInvalid())
+    return ExprError();
+
   // Implicit casts are eliminated during transformation, since they
   // will be recomputed by semantic analysis after transformation.
-  return getDerived().TransformExpr(E->getSubExprAsWritten());
+  // If however the cast involves floating-point transformations, it may keep
+  // FP options with it. In this case the implicit cast must be processed here,
+  // because semantic actions made latter have no access to the FP options.
+  switch (E->getCastKind()) {
+  default:
+    return SubExpr;
+  case CastKind::CK_FloatingCast:
+  case CastKind::CK_FloatingComplexCast:
+  case CastKind::CK_FloatingComplexToIntegralComplex:
+  case CastKind::CK_IntegralComplexToFloatingComplex:
+  case CastKind::CK_IntegralToFloating:
+  case CastKind::CK_FloatingToIntegral:
+  case CastKind::CK_FloatingToBoolean:
+  case CastKind::CK_FloatingComplexToBoolean:
+    break;
+  }
+
+  Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
+  setFPOptions(E);
+
+  if (FPFeaturesState.getFPFeatures() == getSema().CurFPFeatures)
+    return SubExpr;
+
+  if (SubExpr.get()->isLValue())
+    SubExpr = ImplicitCastExpr::Create(
+        getSema().getASTContext(),
+        SubExpr.get()->getType().getNonReferenceType(), CK_LValueToRValue,
+        SubExpr.get(), nullptr, VK_PRValue, getSema().CurFPFeatureOverrides());
+  if (SubExpr.isInvalid())
+    return ExprError();
+
+  QualType T = getDerived().TransformType(E->getType());
+  if (T.isNull())
+    return ExprError();
+
+  return ImplicitCastExpr::Create(
+      getSema().getASTContext(), T, E->getCastKind(), SubExpr.get(), nullptr,
+      VK_PRValue, getSema().CurFPFeatureOverrides());
 }
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
   TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
   if (!Type)
     return ExprError();
 
   ExprResult SubExpr
     = getDerived().TransformExpr(E->getSubExprAsWritten());
   if (SubExpr.isInvalid())
     return ExprError();
 
-  if (!getDerived().AlwaysRebuild() &&
-      Type == E->getTypeInfoAsWritten() &&
-      SubExpr.get() == E->getSubExpr())
+  Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
+  setFPOptions(E);
+
+  if (!getDerived().AlwaysRebuild() && Type == E->getTypeInfoAsWritten() &&
+      SubExpr.get() == E->getSubExpr() &&
+      FPFeaturesState.getFPFeatures() == getSema().CurFPFeatures)
     return E;
 
   return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
                                             Type,
                                             E->getRParenLoc(),
                                             SubExpr.get());
 }
 
#include "clang/Basic/OperatorKinds.def"
 
   ExprResult Second;
   if (E->getNumArgs() == 2) {
     Second = getDerived().TransformExpr(E->getArg(1));
     if (Second.isInvalid())
       return ExprError();
   }
 
-  if (!getDerived().AlwaysRebuild() &&
-      Callee.get() == E->getCallee() &&
+  Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
+  setFPOptions(E);
+
+  if (!getDerived().AlwaysRebuild() && Callee.get() == E->getCallee() &&
       First.get() == E->getArg(0) &&
-      (E->getNumArgs() != 2 || Second.get() == E->getArg(1)))
+      (E->getNumArgs() != 2 || Second.get() == E->getArg(1)) &&
+      FPFeaturesState.getFPFeatures() == getSema().CurFPFeatures)
     return SemaRef.MaybeBindToTemporary(E);
 
-  Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
-  FPOptionsOverride NewOverrides(E->getFPFeatures());
-  getSema().CurFPFeatures =
-      NewOverrides.applyOverrides(getSema().getLangOpts());
-  getSema().FpPragmaStack.CurrentValue = NewOverrides;
-
   return getDerived().RebuildCXXOperatorCallExpr(E->getOperator(),
                                                  E->getOperatorLoc(),
                                                  Callee.get(),
                                                  First.get(),
                                                  Second.get());
 }
 
 template<typename Derived>
TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) {
   if (!Type)
     return ExprError();
 
   ExprResult SubExpr
     = getDerived().TransformExpr(E->getSubExprAsWritten());
   if (SubExpr.isInvalid())
     return ExprError();
 
-  if (!getDerived().AlwaysRebuild() &&
-      Type == E->getTypeInfoAsWritten() &&
-      SubExpr.get() == E->getSubExpr())
+  Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
+  setFPOptions(E);
+
+  if (!getDerived().AlwaysRebuild() && Type == E->getTypeInfoAsWritten() &&
+      SubExpr.get() == E->getSubExpr() &&
+      FPFeaturesState.getFPFeatures() == getSema().CurFPFeatures)
     return E;
+
   return getDerived().RebuildCXXNamedCastExpr(
       E->getOperatorLoc(), E->getStmtClass(), E->getAngleBrackets().getBegin(),
       Type, E->getAngleBrackets().getEnd(),
       // FIXME. this should be '(' location
       E->getAngleBrackets().getEnd(), SubExpr.get(), E->getRParenLoc());
 }
 
 template<typename Derived>
TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
   if (!Type)
     return ExprError();
 
   ExprResult SubExpr
     = getDerived().TransformExpr(E->getSubExprAsWritten());
   if (SubExpr.isInvalid())
     return ExprError();
 
-  if (!getDerived().AlwaysRebuild() &&
-      Type == E->getTypeInfoAsWritten() &&
-      SubExpr.get() == E->getSubExpr())
+  Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
+  setFPOptions(E);
+
+  if (!getDerived().AlwaysRebuild() && Type == E->getTypeInfoAsWritten() &&
+      SubExpr.get() == E->getSubExpr() &&
+      FPFeaturesState.getFPFeatures() == getSema().CurFPFeatures)
     return E;
 
   return getDerived().RebuildCXXFunctionalCastExpr(Type,
                                                    E->getLParenLoc(),
                                                    SubExpr.get(),
                                                    E->getRParenLoc(),
                                                    E->isListInitialization());
 }

clang/test/CodeGen/fp-pragma-template.cpp

+// RUN: %clang_cc1 -S -triple x86_64-linux-gnu -emit-llvm %s -o - | FileCheck %s
+
+
+// If a pragma is used inside template, it has effect on all instantiations.
+
+template <typename Ty>
+float func_01(float x, float y) {
+#pragma STDC FENV_ROUND FE_DOWNWARD
+  return x + y;
+}
+
+#pragma STDC FENV_ROUND FE_TONEAREST
+template float func_01<short>(float, float); 
+// CHECK-LABEL: define {{.*}}float @_Z7func_01IsEfff(float {{.*}}, float {{.*}}) {{.*}}{
+// CHECK: float @llvm.experimental.constrained.fadd.f32({{.*}}, metadata !"round.downward", metadata !"fpexcept.ignore")
+
+float func_02(float x, float y) {
+  return func_01<long>(x, y);
+}
+// CHECK-LABEL: define {{.*}}float @_Z7func_02ff(float {{.*}}, float {{.*}}) {{.*}}{
+// CHECK: call {{.*}}float @_Z7func_01IlEfff(
+
+// CHECK-LABEL: define {{.*}}float @_Z7func_01IlEfff(float {{.*}}, float {{.*}}) {{.*}}{
+// CHECK: call float @llvm.experimental.constrained.fadd.f32({{.*}}, metadata !"round.downward", metadata !"fpexcept.ignore")
+
+template <typename Ty>
+float func_03(float x, float y, float z) {
+#pragma STDC FENV_ROUND FE_TOWARDZERO
+  float res = 3.0F * x;
+  {
+    #pragma STDC FENV_ROUND FE_UPWARD
+    res += y;
+  }
+  return res - z;
+}
+
+#pragma STDC FENV_ROUND FE_DOWNWARD
+template float func_03<short>(float, float, float); 
+// CHECK-LABEL: define {{.*}}float @_Z7func_03IsEffff(float {{.*}}, float {{.*}}) {{.*}}{
+// CHECK: call float @llvm.experimental.constrained.fmul.f32({{.*}}, metadata !"round.towardzero", metadata !"fpexcept.ignore")
+// CHECK: call float @llvm.experimental.constrained.fadd.f32({{.*}}, metadata !"round.upward", metadata !"fpexcept.ignore")
+// CHECK: call float @llvm.experimental.constrained.fsub.f32({{.*}}, metadata !"round.towardzero", metadata !"fpexcept.ignore")
+
+
+// A pragma at file level has the same effect as if the same pragma were
+// specified at the start of each affected function.
+
+#pragma STDC FENV_ROUND FE_UPWARD
+template <typename Ty>
+float func_04(float x, float y) {
+  return x + y;
+}
+
+#pragma STDC FENV_ROUND FE_TONEAREST
+template float func_04<short>(float, float); 
+// CHECK-LABEL: define {{.*}}float @_Z7func_04IsEfff(float {{.*}}, float {{.*}}) {{.*}}{
+// CHECK: call float @llvm.experimental.constrained.fadd.f32({{.*}}, metadata !"round.upward", metadata !"fpexcept.ignore")
+
+
+// Explicit instantiation inherits FP features of the point of instantiation,
+// unless they are explicitly overridden by pragmas in the template.
+
+#pragma STDC FENV_ROUND FE_DYNAMIC
+template <typename Ty>
+float func_05(float x, float y) {
+  return x + y;
+}
+
+#pragma STDC FENV_ROUND FE_DOWNWARD
+template float func_05<short>(float, float); 
+// CHECK-LABEL: define {{.*}}float @_Z7func_05IsEfff(float {{.*}}, float {{.*}}) {{.*}}{
+// CHECK: call float @llvm.experimental.constrained.fadd.f32({{.*}}, metadata !"round.downward", metadata !"fpexcept.ignore")
+
+#pragma STDC FENV_ROUND FE_DYNAMIC
+float func_06(float x, float y) {
+  return func_05<long>(x, y);
+}
+// CHECK-LABEL: define {{.*}}float @_Z7func_06ff(float {{.*}}, float {{.*}}) {{.*}}{
+// CHECK: call {{.*}}float @_Z7func_05IlEfff(
+
+// CHECK-LABEL: define {{.*}}float @_Z7func_05IlEfff(float {{.*}}, float {{.*}}) {{.*}}{
+// CHECK: fadd