Add options rounding and exceptions to pragma fp

[sepavloff]

Summary

Pragma 'clang fp' is extended to support two new options, 'rounding' and
'exceptions'. They allow to specifying floating point environment more
precisely than '#pragma STDC FENV_ACCESS' does. Syntax of the pragma is
described in LanguageExtensions.rst.
The primary goal of this change is to facilitate development of support
for floating point operations in non-default or dynamic environment.

[aaron.ballman]

clang/docs/LanguageExtensions.rst

3146

specifies rounding mode -> specifies the rounding mode

3151

The last sentence is a bit ambiguous because "this option" could mean "rounding modes in general" or it could mean "the dynamic rounding mode". I would reword it to:

compiler does not guarantee to process it in all cases -> the compiler may ignore a dynamic rounding mode in some situations

or

compiler does not guarantee to process it in all cases -> the compiler may ignore an explicit rounding mode in some situations

3157

Will this link remain stable?

3158

Same issue here as above, reword similarly.

clang/lib/Parse/ParsePragma.cpp

2670

Given that all of these strings are known at compile time, I would rather see use of a %select in the diagnostic.

2697

Same here.

[kpn]

clang/docs/LanguageExtensions.rst

3151

I'd go with the latter, or perhaps "the compiler may ignore the rounding mode setting in some situations."

Currently, sometimes llvm will ignore the setting entirely, other times it will assume dynamic despite the setting being more specific.

Also:
s/assume particular/assume any particular/
s/experimental, compiler/experimental; the compiler/

[sepavloff]

Updated patch

[sepavloff]

clang/lib/Parse/ParsePragma.cpp

2697

This case is different from the above, the list of expected arguments depend on the current option.

[aaron.ballman]

clang/lib/Parse/ParsePragma.cpp

2697

The case isn't different in the way that matters -- all of the strings that get passed in to the diagnostic come from string literals. You should be able to put the literals into the %select and map TokFPAnnotValue::* to an index, right?

[sepavloff]

Updated patch

[sepavloff]

clang/lib/Parse/ParsePragma.cpp

2697

I see, thank you)

[aaron.ballman]

This generally LGTM, but there are open questions on https://reviews.llvm.org/D66092#1625380 that I think need to be answered before this should be committed.

clang/lib/Parse/ParsePragma.cpp

2680

Might as well move this down to around line 2710, closer to where it's used. This way we don't allocate something only to ignore it due to errors in fewer situations.

[sepavloff]

clang/lib/Parse/ParsePragma.cpp

2680

Actually it cannot be closer. It is created just before the loop, in which fields of *AnnotValue are read.

[aaron.ballman]

clang/lib/Parse/ParsePragma.cpp

2680

Ah, you're right, I didn't see that was inside the loop itself. Nevermind. :-)

[andrew.w.kaylor]

clang/docs/LanguageExtensions.rst

3127

This part of the documentation is ambiguous in light of the new options. I suppose "[t]he pragma" here refers to "#pragma clang fp contract" but the first paragraph refers to "#pragma clang fp" as "the pragma."

3152

You should say something about whether the rounding mode is applied or assumed. The rounding mode argument in the constrained FP intrinsics is assumed. The compiler is not required to do anything to force the hardware into that rounding mode. I think we want that behavior here as well. I believe this follows the semantics of the STDC FENV_ROUND pragmas that were introduced by ISO TS-18661.

3159

I'm not sure what this is supposed to mean. What are the circumstances under which the compiler may ignore an explicit exception behavior? Do you mean that it isn't supposed to happen but it might while the feature is under development?

[sepavloff]

clang/docs/LanguageExtensions.rst

3152

Hm. I understood the proposal as if pragma FENV_ROUND is applied. If I am wrong, and that pragma is only a hint to compiler, it is not suitable for our purposes. We need a mean to generate constrained intrinsics from C/C++ code. it would facilitate adaptation of LLVM passes for specific floating point options, including rounding, exception behavior, FENV_ACCESS an so on. It also would allow users to tune code generation. In this case pragma FENV_ROUND is a different functionality, which should be developed separately.

3159

The purpose is to have a tool that would allow developing support of constrained nodes in LLVM pipeline. So we discourage using this pragma by end users. Yes, you are right, it means a feature under development.

[lebedev.ri]

Since LLVM already has strict FP nodes, i'd personally like to see this RFC to not
discuss "let's add XYZ", but discuss what features it targets to accomplish,
what features are already achievable via strict FP nodes,
and instead of adding a third set of FP operations,
try to propose to extend strict FP nodes,

[andrew.w.kaylor]

clang/docs/LanguageExtensions.rst

3152

Sorry, I didn't mean to introduce confusion by bringing up FENV_ROUND, and after reading the description you linked on the other review I'm not sure it does what I was previously told it would anyway. Let's ignore that and just talk about what you're intending to do here.

If you only generate constrained intrinsics and do not generate an explicit rounding mode control change instruction (such as a call to fesetround) then the declared rounding mode may not actually be used. According to the definition in the LLVM Language Reference, when you set a rounding mode in a constrained FP intrinsic, the optimizer will assume that rounding mode is in effect and it may use it to perform transformations like constant folding. However, there is no requirement for the compiler to generate code (in response to the constrained intrinsic) to set the rounding mode. Architectures that encode the rounding mode in the instructions may use the rounding mode information (though the LLVM back end isn't currently well structured to enable that), but in cases where the rounding mode is controlled by processor state, the constrained intrinsic will not change it.

Hopefully that clarifies what I was asking about here. Do you intend for use of these pragmas to actually change the rounding mode or merely describe it? If the pragmas are intended to change the rounding mode, you will need to generate instructions to do that.

clang/docs/LanguageExtensions.rst

 ====================================================
 
 The ``#pragma clang fp`` pragma allows floating-point options to be specified
 for a section of the source code. This pragma can only appear at file scope or
 at the start of a compound statement (excluding comments). When using within a
 compound statement, the pragma is active within the scope of the compound
 statement.
 
-Currently, only FP contraction can be controlled with the pragma. ``#pragma
-clang fp contract`` specifies whether the compiler should contract a multiply
-and an addition (or subtraction) into a fused FMA operation when supported by
-the target.
+Currently, only FP contraction, rounding mode and exception behavior can be
+controlled with the pragma.
+
+The option ``contract`` specifies whether the compiler should contract a
+multiply and an addition (or subtraction) into a fused FMA operation when
+supported by the target.
 
 The pragma can take three values: ``on``, ``fast`` and ``off``.  The ``on``
 option is identical to using ``#pragma STDC FP_CONTRACT(ON)`` and it allows
 fusion as specified the language standard.  The ``fast`` option allows fusiong
 in cases when the language standard does not make this possible (e.g. across
 statements in C)
 
 .. code-block:: c++
 
   for(...) {
     #pragma clang fp contract(fast)
     a = b[i] * c[i];
     d[i] += a;
   }
 
 
 The pragma can also be used with ``off`` which turns FP contraction off for a
 section of the code. This can be useful when fast contraction is otherwise
 enabled for the translation unit with the ``-ffp-contract=fast`` flag.
 
+The option ``rounding`` specifies rounding mode applied to floating point
+operations. It may take one of the values: ``tonearest``, ``downward``,
+``upward``, ``towardzero`` and ``dynamic``. The first four values represent
+corresponding IEEE rounding rules, ``tonearest`` being the default mode. The
+value ``dynamic`` informs the compiler that it must not assume particular
+rounding mode. This option is experimental, compiler does not guarantee to
+process it in all cases.
+
+The option ``exceptions`` specify floating point exception behavior. It may
+take one the the values: ``ignore``, ``maytrap`` or ``strict``. Default value
+is ``ignore``. Meaning of these values is same as for `constrained floating
+point intrinsics <http://llvm.org/docs/LangRef.html#id2115>`_. This option is
+experimental, compiler does not guarantee to process it in all cases.
+
+A ``#pragma clang fp`` pragma may contain any number of options:
+
+.. code-block:: c++
+
+  void func(float *dest, float a, float b) {
+    #pragma clang fp exceptions(maytrap) contract(fast) rounding(downward)
+    *dest = a + b;
+  }
+
+
 Specifying an attribute for multiple declarations (#pragma clang attribute)
 ===========================================================================
 
 The ``#pragma clang attribute`` directive can be used to apply an attribute to
 multiple declarations. The ``#pragma clang attribute push`` variation of the
 directive pushes a new "scope" of ``#pragma clang attribute`` that attributes
 can be added to. The ``#pragma clang attribute (...)`` variation adds an
 attribute to that scope, and the ``#pragma clang attribute pop`` variation pops

clang/include/clang/Basic/DiagnosticParseKinds.td

def err_pragma_loop_missing_argument : Error<
   "missing argument; expected %select{an integer value|"
   "'enable'%select{|, 'full'}1%select{|, 'assume_safety'}2 or 'disable'}0">;
 def err_pragma_loop_invalid_option : Error<
   "%select{invalid|missing}0 option%select{ %1|}0; expected vectorize, "
   "vectorize_width, interleave, interleave_count, unroll, unroll_count, "
   "pipeline, pipeline_initiation_interval, vectorize_predicate, or distribute">;
 
 def err_pragma_fp_invalid_option : Error<
-  "%select{invalid|missing}0 option%select{ %1|}0; expected contract">;
+  "%select{invalid|missing}0 option%select{ %1|}0; expected %2">;
 def err_pragma_fp_invalid_argument : Error<
-  "unexpected argument '%0' to '#pragma clang fp %1'; "
-  "expected 'on', 'fast' or 'off'">;
+  "unexpected argument '%0' to '#pragma clang fp %1'; expected %2">;
 def err_pragma_fp_scope : Error<
   "'#pragma clang fp' can only appear at file scope or at the start of a "
   "compound statement">;
 
 def err_pragma_invalid_keyword : Error<
   "invalid argument; expected 'enable'%select{|, 'full'}0%select{|, 'assume_safety'}1 or 'disable'">;
 def err_pragma_pipeline_invalid_keyword : Error<
     "invalid argument; expected 'disable'">;

clang/lib/Parse/ParsePragma.cpp

void PragmaOptimizeHandler::HandlePragma(Preprocessor &PP,
   }
 
   Actions.ActOnPragmaOptimize(IsOn, FirstToken.getLocation());
 }
 
 namespace {
 /// Used as the annotation value for tok::annot_pragma_fp.
 struct TokFPAnnotValue {
-  enum FlagKinds { Contract };
-  enum FlagValues { On, Off, Fast };
+  enum FlagKinds { Contract, RoundingMode, Exceptions };
 
-  FlagKinds FlagKind;
-  FlagValues FlagValue;
+  llvm::Optional<LangOptions::FPContractModeKind> ContractValue;
+  llvm::Optional<LangOptions::FPRoundingModeKind> RoundingModeValue;
+  llvm::Optional<LangOptions::FPExceptionModeKind> ExceptionsValue;
 };
 } // end anonymous namespace
 
 void PragmaFPHandler::HandlePragma(Preprocessor &PP,
                                    PragmaIntroducer Introducer, Token &Tok) {
   // fp
   Token PragmaName = Tok;
   SmallVector<Token, 1> TokenList;
+  static const StringRef ExpectedOptionsText =
+      "'contract', 'rounding' or 'exceptions'";
 
   PP.Lex(Tok);
   if (Tok.isNot(tok::identifier)) {
     PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_option)
-        << /*MissingOption=*/true << "";
+        << /*MissingOption=*/true << "" << ExpectedOptionsText;
     return;
   }
 
+  auto *AnnotValue = new (PP.getPreprocessorAllocator()) TokFPAnnotValue;
   while (Tok.is(tok::identifier)) {
     IdentifierInfo *OptionInfo = Tok.getIdentifierInfo();
 
     auto FlagKind =
         llvm::StringSwitch<llvm::Optional<TokFPAnnotValue::FlagKinds>>(
             OptionInfo->getName())
             .Case("contract", TokFPAnnotValue::Contract)
+            .Case("rounding", TokFPAnnotValue::RoundingMode)
+            .Case("exceptions", TokFPAnnotValue::Exceptions)
             .Default(None);
     if (!FlagKind) {
       PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_option)
-          << /*MissingOption=*/false << OptionInfo;
+          << /*MissingOption=*/false << OptionInfo << ExpectedOptionsText;
       return;
     }
     PP.Lex(Tok);
+    StringRef ExpectedArgumentText;
+    switch (*FlagKind) {
+    case TokFPAnnotValue::Contract:
+      ExpectedArgumentText = "'on', 'fast' or 'off'";
+      break;
+    case TokFPAnnotValue::RoundingMode:
+      ExpectedArgumentText =
+          "'tonearest', 'downward', 'upward', 'towardzero' or 'dynamic'";
+      break;
+    case TokFPAnnotValue::Exceptions:
+      ExpectedArgumentText = "'ignore', 'maytrap' or 'strict'";
+      break;
+    }
 
     // Read '('
     if (Tok.isNot(tok::l_paren)) {
       PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
       return;
     }
     PP.Lex(Tok);
 
     if (Tok.isNot(tok::identifier)) {
       PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument)
-          << PP.getSpelling(Tok) << OptionInfo->getName();
+          << PP.getSpelling(Tok) << OptionInfo->getName()
+          << ExpectedArgumentText;
       return;
     }
     const IdentifierInfo *II = Tok.getIdentifierInfo();
 
-    auto FlagValue =
-        llvm::StringSwitch<llvm::Optional<TokFPAnnotValue::FlagValues>>(
+    if (FlagKind == TokFPAnnotValue::Contract) {
+      AnnotValue->ContractValue =
+          llvm::StringSwitch<llvm::Optional<LangOptions::FPContractModeKind>>(
               II->getName())
-            .Case("on", TokFPAnnotValue::On)
-            .Case("off", TokFPAnnotValue::Off)
-            .Case("fast", TokFPAnnotValue::Fast)
+              .Case("on", LangOptions::FPContractModeKind::FPC_On)
+              .Case("off", LangOptions::FPContractModeKind::FPC_Off)
+              .Case("fast", LangOptions::FPContractModeKind::FPC_Fast)
               .Default(llvm::None);
-
-    if (!FlagValue) {
+      if (!AnnotValue->ContractValue) {
         PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument)
-          << PP.getSpelling(Tok) << OptionInfo->getName();
+            << PP.getSpelling(Tok) << OptionInfo->getName()
+            << "'on', 'fast' or 'off'";
         return;
       }
+    } else if (FlagKind == TokFPAnnotValue::RoundingMode) {
+      AnnotValue->RoundingModeValue =
+          llvm::StringSwitch<llvm::Optional<LangOptions::FPRoundingModeKind>>(
+              II->getName())
+              .Case("tonearest", LangOptions::FPRoundingModeKind::ToNearest)
+              .Case("downward", LangOptions::FPRoundingModeKind::Downward)
+              .Case("upward", LangOptions::FPRoundingModeKind::Upward)
+              .Case("towardzero", LangOptions::FPRoundingModeKind::TowardZero)
+              .Case("dynamic", LangOptions::FPRoundingModeKind::Dynamic)
+              .Default(llvm::None);
+      if (!AnnotValue->RoundingModeValue) {
+        PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument)
+            << PP.getSpelling(Tok) << OptionInfo->getName()
+            << "'dynamic', 'tonearest', 'downward', 'upward' or 'towardzero'";
+        return;
+      }
+    } else if (FlagKind == TokFPAnnotValue::Exceptions) {
+      AnnotValue->ExceptionsValue =
+          llvm::StringSwitch<llvm::Optional<LangOptions::FPExceptionModeKind>>(
+              II->getName())
+              .Case("ignore", LangOptions::FPExceptionModeKind::Ignore)
+              .Case("maytrap", LangOptions::FPExceptionModeKind::MayTrap)
+              .Case("strict", LangOptions::FPExceptionModeKind::Strict)
+              .Default(llvm::None);
+      if (!AnnotValue->ExceptionsValue) {
+        PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument)
+            << PP.getSpelling(Tok) << OptionInfo->getName()
+            << "'ignore', 'maytrap' or 'strict'";
+        return;
+      }
+    }
     PP.Lex(Tok);
 
     // Read ')'
     if (Tok.isNot(tok::r_paren)) {
       PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
       return;
     }
     PP.Lex(Tok);
+  }
+
+  if (Tok.isNot(tok::eod)) {
+    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
+        << "clang fp";
+    return;
+  }
 
-    auto *AnnotValue = new (PP.getPreprocessorAllocator())
-        TokFPAnnotValue{*FlagKind, *FlagValue};
-    // Generate the loop hint token.
-    Token FPTok;
-    FPTok.startToken();
-    FPTok.setKind(tok::annot_pragma_fp);
-    FPTok.setLocation(PragmaName.getLocation());
-    FPTok.setAnnotationEndLoc(PragmaName.getLocation());
-    FPTok.setAnnotationValue(reinterpret_cast<void *>(AnnotValue));
-    TokenList.push_back(FPTok);
-  }
-
-  if (Tok.isNot(tok::eod)) {
-    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
-        << "clang fp";
-    return;
-  }
 
   auto TokenArray = llvm::make_unique<Token[]>(TokenList.size());
   std::copy(TokenList.begin(), TokenList.end(), TokenArray.get());
 
   PP.EnterTokenStream(std::move(TokenArray), TokenList.size(),
                       /*DisableMacroExpansion=*/false, /*IsReinject=*/false);
 }
 
 void Parser::HandlePragmaFP() {
   assert(Tok.is(tok::annot_pragma_fp));
   auto *AnnotValue =
       reinterpret_cast<TokFPAnnotValue *>(Tok.getAnnotationValue());
 
-  LangOptions::FPContractModeKind FPC;
-  switch (AnnotValue->FlagValue) {
-  case TokFPAnnotValue::On:
-    FPC = LangOptions::FPC_On;
-    break;
-  case TokFPAnnotValue::Fast:
-    FPC = LangOptions::FPC_Fast;
-    break;
-  case TokFPAnnotValue::Off:
-    FPC = LangOptions::FPC_Off;
-    break;
-  }
+  if (AnnotValue->ContractValue)
+    Actions.ActOnPragmaFPContract(*AnnotValue->ContractValue);
+  if (AnnotValue->RoundingModeValue)
+    Actions.setRoundingMode(*AnnotValue->RoundingModeValue);
+  if (AnnotValue->ExceptionsValue)
+    Actions.setExceptionMode(*AnnotValue->ExceptionsValue);
 
-  Actions.ActOnPragmaFPContract(FPC);
   ConsumeAnnotationToken();
 }
 
 /// Parses loop or unroll pragma hint value and fills in Info.
 static bool ParseLoopHintValue(Preprocessor &PP, Token &Tok, Token PragmaName,
                                Token Option, bool ValueInParens,
                                PragmaLoopHintInfo &Info) {
   SmallVector<Token, 1> ValueList;

clang/test/Parser/pragma-fp.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s
 
 void test_0(int *List, int Length) {
-/* expected-error@+1 {{missing option; expected contract}} */
+/* expected-error@+1 {{missing option; expected 'contract', 'rounding' or 'exceptions'}} */
 #pragma clang fp
   for (int i = 0; i < Length; i++) {
     List[i] = i;
   }
 }
 void test_1(int *List, int Length) {
-/* expected-error@+1 {{invalid option 'blah'; expected contract}} */
+/* expected-error@+1 {{invalid option 'blah'; expected 'contract', 'rounding' or 'exceptions'}} */
 #pragma clang fp blah
   for (int i = 0; i < Length; i++) {
     List[i] = i;
   }
 }
 
 void test_3(int *List, int Length) {
 /* expected-error@+1 {{expected '('}} */

 
 void test_8(int *List, int Length) {
   for (int i = 0; i < Length; i++) {
     List[i] = i;
 /* expected-error@+1 {{'#pragma clang fp' can only appear at file scope or at the start of a compound statement}} */
 #pragma clang fp contract(fast)
   }
 }
+
+
+void test_10(float *dest, float a, float b) {
+/* expected-error@+1 {{expected '('}} */
+#pragma clang fp rounding on
+  *dest = a + b;
+}
+
+void test_11(float *dest, float a, float b) {
+/* expected-error@+1 {{unexpected argument 'while' to '#pragma clang fp rounding'; expected 'tonearest', 'downward', 'upward', 'towardzero' or 'dynamic'}} */
+#pragma clang fp rounding(while)
+  *dest = a + b;
+}
+
+void test_12(float *dest, float a, float b) {
+#pragma clang fp rounding(downward)
+  *dest = a + b;
+}
+
+void test_13(float *dest, float a, float b) {
+#pragma clang fp contract(fast) rounding(downward)
+  *dest = a + b;
+}
+
+void test_14(float *dest, float a, float b) {
+/* expected-error@+1 {{unexpected argument 'on' to '#pragma clang fp exceptions'; expected 'ignore', 'maytrap' or 'strict'}} */
+#pragma clang fp exceptions(on)
+  *dest = a + b;
+}
+
+void test_15(float *dest, float a, float b) {
+#pragma clang fp exceptions(maytrap) contract(fast) rounding(downward)
+  *dest = a + b;
+}