Allow #pragma float_control(push|pop) within a language linkage specification

[aaron.ballman]

Summary

Currently, we prohibit this pragma from appearing within a language linkage specification, but this is useful functionality that is supported by MSVC (which is where we inherited this feature from). This patch allows you to use the pragma within an extern "C" {} (etc) block.

[erichkeane]

Just one documentation change suggested.

[erichkeane]

Weird, phab didn't let me save the comment on the last one... done the right way this time :)

clang/docs/LanguageExtensions.rst

3549

[erichkeane]

Doc change can be done as a part of the commit btw, otherwise this is fine to me.

[mibintc]

Thanks for fixing this Aaron, just curious was there a bug report?

[mibintc]

Adding @zahiraam FYI

[aaron.ballman]

In D106863#2907362, @mibintc wrote:

Thanks for fixing this Aaron, just curious was there a bug report?

There's no public bug to close from this, but it came as an internal (to Intel) report from a user.

Thank you for the reviews! I made the documentation change and pushed in b0ef3d8f666fa6008abb09340b73d9340d442569.

clang/docs/LanguageExtensions.rst

.. code-block:: c++
   void func(float *dest, float a, float b) {
     #pragma clang fp exceptions(maytrap) contract(fast) reassociate(on)
     ...
   }
 
 
 The ``#pragma float_control`` pragma allows precise floating-point
 semantics and floating-point exception behavior 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.  This pragma is modeled after a Microsoft pragma with the
-same spelling and syntax.  For pragmas specified at file scope, a stack
-is supported so that the ``pragma float_control`` settings can be pushed or popped.
+for a section of the source code. This pragma can only appear at file or
+namespace scope, within a language linkage specification 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.  This pragma
+is modeled after a Microsoft pragma with the same spelling and syntax.  For
+pragmas specified at file or namespace scope, or within a language linkage
+specification, a stack is supported so that the ``pragma float_control``
+settings can be pushed or popped.
 
 When ``pragma float_control(precise, on)`` is enabled, the section of code
 governed by the pragma uses precise floating point semantics, effectively
 ``-ffast-math`` is disabled and ``-ffp-contract=on``
 (fused multiply add) is enabled.
 
 When ``pragma float_control(except, on)`` is enabled, the section of code governed
 by the pragma behaves as though the command-line option

clang/include/clang/Basic/DiagnosticSemaKinds.td

def note_pragma_pack_pop_instead_reset : Note<
   "did you intend to use '#pragma pack (pop)' instead of '#pragma pack()'?">;
 // Follow the Microsoft implementation.
 def warn_pragma_pack_show : Warning<"value of #pragma pack(show) == %0">;
 def warn_pragma_pack_pop_identifier_and_alignment : Warning<
   "specifying both a name and alignment to 'pop' is undefined">;
 def warn_pragma_pop_failed : Warning<"#pragma %0(pop, ...) failed: %1">,
   InGroup<IgnoredPragmas>;
 def err_pragma_fc_pp_scope : Error<
-  "'#pragma float_control push/pop' can only appear at file scope or namespace scope">;
+  "'#pragma float_control push/pop' can only appear at file or namespace scope "
+  "or within a language linkage specification">;
 def err_pragma_fc_noprecise_requires_nofenv : Error<
   "'#pragma float_control(precise, off)' is illegal when fenv_access is enabled">;
 def err_pragma_fc_except_requires_precise : Error<
   "'#pragma float_control(except, on)' is illegal when precise is disabled">;
 def err_pragma_fc_noprecise_requires_noexcept : Error<
   "'#pragma float_control(precise, off)' is illegal when except is enabled">;
 def err_pragma_fenv_requires_precise : Error<
   "'#pragma STDC FENV_ACCESS ON' is illegal when precise is disabled">;

clang/lib/Sema/SemaAttr.cpp

void Sema::ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
   Consumer.HandleTopLevelDecl(DeclGroupRef(PDMD));
 }
 
 void Sema::ActOnPragmaFloatControl(SourceLocation Loc,
                                    PragmaMsStackAction Action,
                                    PragmaFloatControlKind Value) {
   FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
   if ((Action == PSK_Push_Set || Action == PSK_Push || Action == PSK_Pop) &&
-      !(CurContext->isTranslationUnit()) && !CurContext->isNamespace()) {
-    // Push and pop can only occur at file or namespace scope.
+      !(CurContext->isTranslationUnit()) && !CurContext->isNamespace() &&
+      !isa<LinkageSpecDecl>(CurContext)) {
+    // Push and pop can only occur at file or namespace scope, or within a
+    // language linkage declaration.
     Diag(Loc, diag::err_pragma_fc_pp_scope);
     return;
   }
   switch (Value) {
   default:
     llvm_unreachable("invalid pragma float_control kind");
   case PFC_Precise:
     NewFPFeatures.setFPPreciseEnabled(true);

clang/test/Parser/fp-floatcontrol-syntax.cpp

 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -DCHECK_ERROR %s -verify 
 
 float function_scope(float a) {
 #pragma float_control(precise, on) junk // expected-warning {{extra tokens at end of '#pragma float_control' - ignored}}
   return a;
 }
 
+// Ok, at namespace scope.
+namespace foo {
+#pragma float_control(push)
+#pragma float_control(pop)
+}
+
+// Ok, within a language linkage specification.
+extern "C" {
+#pragma float_control(push)
+#pragma float_control(pop)
+}
+
+// Same.
+extern "C++" {
+#pragma float_control(push)
+#pragma float_control(pop)
+}
+
 #ifdef CHECK_ERROR
+// Ok at file scope.
 #pragma float_control(push)
 #pragma float_control(pop)
 #pragma float_control(precise, on, push)
 void check_stack() {
-#pragma float_control(push)                   // expected-error {{can only appear at file scope or namespace scope}}
-#pragma float_control(pop)                    // expected-error {{can only appear at file scope or namespace scope}}
-#pragma float_control(precise, on, push)      // expected-error {{can only appear at file scope or namespace scope}}
-#pragma float_control(except, on, push)       // expected-error {{can only appear at file scope or namespace scope}}
+  // Not okay within a function declaration.
+#pragma float_control(push)                   // expected-error {{can only appear at file or namespace scope or within a language linkage specification}}
+#pragma float_control(pop)                    // expected-error {{can only appear at file or namespace scope or within a language linkage specification}}
+#pragma float_control(precise, on, push)      // expected-error {{can only appear at file or namespace scope or within a language linkage specification}}
+#pragma float_control(except, on, push)       // expected-error {{can only appear at file or namespace scope or within a language linkage specification}}
 #pragma float_control(except, on, push, junk) // expected-error {{float_control is malformed}}
   return;
 }
 #endif
 
 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fdenormal-fp-math=preserve-sign,preserve-sign -fsyntax-only %s -DDEFAULT -verify
 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only %s -ffp-contract=fast -DPRECISE -verify
 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only %s -ffp-contract=off -frounding-math -ffp-exception-behavior=strict -DSTRICT -verify