[Clang] Add support for STDC CX_LIMITED_RANGE pragma.

[jcranmer-intel]

Summary

This pragma is defined in the C specification. Notably, the C specification
makes the "DEFAULT" value identical to "OFF" for this pragma, unlike other
floating-point pragmas which are undefined behavior. This may be surprising to
some users.

This patch builds on, and requires, the complex intrinsics to make the pragmas
work properly.

Depends on D119290

[aaron.ballman]

Adding some more reviewers for visibility.

Please address the clang-format issues; also, this seems to be missing all of the test I would expect to see in Preprocessor or Parser for checking that the proper diagnostics are emitted or CodeGen tests for more complicated situations, like:

_Complex float range_scoped(_Complex float a, _Complex float b) {
// CHECK-COMMON: @range_scoped
// CHECK-COMMON: call{{.*}}complex.fmul{{.*}} #[[FULL]]
// CHECK-COMMON: call{{.*}}complex.fdiv{{.*}} #[[FULL]]
#pragma STDC CX_LIMITED_RANGE OFF
  _Complex float res = a * b;
  {
#pragma STDC CX_LIMITED_RANGE DEFAULT
    res += a / b;
#pragma STDC CX_LIMITED_RANGE OFF
    res += a / b;
  }
  return res;
}

What should the behavior be if this pragma is at file scope instead of block scope (should that be diagnosed)?

(Also, this functionality should get a release note and potentially some public documentation?)

clang/lib/Lex/Pragma.cpp

1028

Good catch, but do we have a test case for this change?

[tahonermann]

Resigning to remove this old review from my review queue.

clang/include/clang/Basic/TokenKinds.def

 PRAGMA_ANNOTATION(pragma_fenv_access)
 PRAGMA_ANNOTATION(pragma_fenv_access_ms)
 
 // Annotation for #pragma STDC FENV_ROUND
 // The lexer produces these so that they only take effect when the parser
 // handles them.
 PRAGMA_ANNOTATION(pragma_fenv_round)
 
+// Annotation for #pragma STDC CX_LIMITED_RANGE
+// The lexer produces these so that they only take effect when the parser
+// handles them.
+PRAGMA_ANNOTATION(pragma_cx_limited_range)
+
 // Annotation for #pragma float_control
 // The lexer produces these so that they only take effect when the parser
 // handles them.
 PRAGMA_ANNOTATION(pragma_float_control)
 
 // Annotation for #pragma pointers_to_members...
 // The lexer produces these so that they only take effect when the parser
 // handles them.

clang/include/clang/Parse/Parser.h

private:
   /// #pragma STDC FENV_ACCESS...
   void HandlePragmaFEnvAccess();
 
   /// Handle the annotation token produced for
   /// #pragma STDC FENV_ROUND...
   void HandlePragmaFEnvRound();
 
   /// Handle the annotation token produced for
+  /// #pragma STDC CX_LIMITED_RANGE...
+  void HandlePragmaComplexLimitedRange();
+
+  /// Handle the annotation token produced for
   /// #pragma float_control
   void HandlePragmaFloatControl();
 
   /// \brief Handle the annotation token produced for
   /// #pragma clang fp ...
   void HandlePragmaFP();
 
   /// Handle the annotation token produced for

clang/include/clang/Sema/Sema.h

   /// Called on well formed
   /// \#pragma clang fp reassociate
   void ActOnPragmaFPReassociate(SourceLocation Loc, bool IsEnabled);
 
   /// ActOnPragmaFenvAccess - Called on well formed
   /// \#pragma STDC FENV_ACCESS
   void ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled);
 
+  /// ActOnPragmaComplexLimitedRange - Called on well formed
+  /// \#pragma STDC CX_LIMITED_RANGE
+  void ActOnPragmaComplexLimitedRange(SourceLocation Loc,
+                                      LangOptions::ComplexRangeKind Range);
+
   /// Called on well formed '\#pragma clang fp' that has option 'exceptions'.
   void ActOnPragmaFPExceptions(SourceLocation Loc,
                                LangOptions::FPExceptionModeKind);
 
   /// Called to set constant rounding mode for floating point operations.
   void setRoundingMode(SourceLocation Loc, llvm::RoundingMode);
 
   /// Called to set exception behavior for floating point operations.

clang/lib/Lex/Pragma.cpp

else if (II->isStr("DEFAULT"))
     Result = tok::OOS_DEFAULT;
   else {
     Diag(Tok, diag::ext_on_off_switch_syntax);
     return true;
   }
 
   // Verify that this is followed by EOD.
   LexUnexpandedToken(Tok);
-  if (Tok.isNot(tok::eod))
+  if (Tok.isNot(tok::eod)) {
     Diag(Tok, diag::ext_pragma_syntax_eod);
+    DiscardUntilEndOfDirective();
+  }
   return false;
 }
 
 namespace {
 
 /// PragmaOnceHandler - "\#pragma once" marks the file as atomically included.
 struct PragmaOnceHandler : public PragmaHandler {
   PragmaOnceHandler() : PragmaHandler("once") {}

clang/lib/Parse/ParsePragma.cpp

 
 /// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...".
 struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler {
   PragmaSTDC_CX_LIMITED_RANGEHandler() : PragmaHandler("CX_LIMITED_RANGE") {}
 
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &Tok) override {
     tok::OnOffSwitch OOS;
-    PP.LexOnOffSwitch(OOS);
+    if (PP.LexOnOffSwitch(OOS))
+     return;
+
+    MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
+                                1);
+    Toks[0].startToken();
+    Toks[0].setKind(tok::annot_pragma_cx_limited_range);
+    Toks[0].setLocation(Tok.getLocation());
+    Toks[0].setAnnotationEndLoc(Tok.getLocation());
+    Toks[0].setAnnotationValue(reinterpret_cast<void*>(
+                               static_cast<uintptr_t>(OOS)));
+    PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
+                        /*IsReinject=*/false);
   }
 };
 
 /// Handler for "\#pragma STDC FENV_ROUND ...".
 struct PragmaSTDC_FENV_ROUNDHandler : public PragmaHandler {
   PragmaSTDC_FENV_ROUNDHandler() : PragmaHandler("FENV_ROUND") {}
 
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
void Parser::HandlePragmaFEnvRound() {
   assert(Tok.is(tok::annot_pragma_fenv_round));
   auto RM = static_cast<llvm::RoundingMode>(
       reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
 
   SourceLocation PragmaLoc = ConsumeAnnotationToken();
   Actions.setRoundingMode(PragmaLoc, RM);
 }
 
+void Parser::HandlePragmaComplexLimitedRange() {
+  assert(Tok.is(tok::annot_pragma_cx_limited_range));
+  tok::OnOffSwitch OOS =
+    static_cast<tok::OnOffSwitch>(
+    reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
+
+  LangOptions::ComplexRangeKind Range;
+  switch (OOS) {
+  case tok::OOS_ON:
+    Range = LangOptions::CX_Limited;
+    break;
+  case tok::OOS_OFF:
+    Range = LangOptions::CX_Full;
+    break;
+  case tok::OOS_DEFAULT:
+    // Section 7.3.4 says the default is "OFF" here, not implementation-defined.
+    Range = LangOptions::CX_Full;
+    break;
+  }
+
+  SourceLocation PragmaLoc = ConsumeAnnotationToken();
+  Actions.ActOnPragmaComplexLimitedRange(PragmaLoc, Range);
+}
+
 StmtResult Parser::HandlePragmaCaptured()
 {
   assert(Tok.is(tok::annot_pragma_captured));
   ConsumeAnnotationToken();
 
   if (Tok.isNot(tok::l_brace)) {
     PP.Diag(Tok, diag::err_expected) << tok::l_brace;
     return StmtError();

clang/lib/Parse/ParseStmt.cpp

case tok::annot_pragma_fenv_access_ms:
     return StmtEmpty();
 
   case tok::annot_pragma_fenv_round:
     ProhibitAttributes(Attrs);
     Diag(Tok, diag::err_pragma_file_or_compound_scope) << "STDC FENV_ROUND";
     ConsumeAnnotationToken();
     return StmtError();
 
+  case tok::annot_pragma_cx_limited_range:
+    ProhibitAttributes(Attrs);
+    Diag(Tok, diag::err_pragma_file_or_compound_scope) << "STDC CX_LIMITED_RANGE";
+    ConsumeAnnotationToken();
+    return StmtError();
+
   case tok::annot_pragma_float_control:
     ProhibitAttributes(Attrs);
     Diag(Tok, diag::err_pragma_file_or_compound_scope) << "float_control";
     ConsumeAnnotationToken();
     return StmtError();
 
   case tok::annot_pragma_opencl_extension:
     ProhibitAttributes(Attrs);
case tok::annot_pragma_fp:
       break;
     case tok::annot_pragma_fenv_access:
     case tok::annot_pragma_fenv_access_ms:
       HandlePragmaFEnvAccess();
       break;
     case tok::annot_pragma_fenv_round:
       HandlePragmaFEnvRound();
       break;
+    case tok::annot_pragma_cx_limited_range:
+      HandlePragmaComplexLimitedRange();
+      break;
     case tok::annot_pragma_float_control:
       HandlePragmaFloatControl();
       break;
     case tok::annot_pragma_ms_pointers_to_members:
       HandlePragmaMSPointersToMembers();
       break;
     case tok::annot_pragma_ms_pragma:
       HandlePragmaMSPragma();

clang/lib/Parse/Parser.cpp

case tok::annot_pragma_fp_contract:
     return nullptr;
   case tok::annot_pragma_fenv_access:
   case tok::annot_pragma_fenv_access_ms:
     HandlePragmaFEnvAccess();
     return nullptr;
   case tok::annot_pragma_fenv_round:
     HandlePragmaFEnvRound();
     return nullptr;
+  case tok::annot_pragma_cx_limited_range:
+    HandlePragmaComplexLimitedRange();
+    return nullptr;
   case tok::annot_pragma_float_control:
     HandlePragmaFloatControl();
     return nullptr;
   case tok::annot_pragma_fp:
     HandlePragmaFP();
     break;
   case tok::annot_pragma_opencl_extension:
     HandlePragmaOpenCLExtension();

clang/lib/Sema/SemaAttr.cpp

if (IsEnabled) {
     NewFPFeatures.setFPExceptionModeOverride(LangOptions::FPE_Strict);
   } else {
     NewFPFeatures.setAllowFEnvAccessOverride(false);
   }
   FpPragmaStack.Act(Loc, PSK_Set, StringRef(), NewFPFeatures);
   CurFPFeatures = NewFPFeatures.applyOverrides(LO);
 }
 
+void Sema::ActOnPragmaComplexLimitedRange(SourceLocation Loc,
+                                          LangOptions::ComplexRangeKind Range) {
+  FPOptionsOverride NewFPFeatures = CurFPFeatureOverrides();
+  NewFPFeatures.setComplexRangeOverride(Range);
+  FpPragmaStack.Act(Loc, PSK_Set, StringRef(), NewFPFeatures);
+  CurFPFeatures = NewFPFeatures.applyOverrides(getLangOpts());
+}
+
 void Sema::ActOnPragmaFPExceptions(SourceLocation Loc,
                                    LangOptions::FPExceptionModeKind FPE) {
   setExceptionMode(Loc, FPE);
 }
 
 void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
                                        SourceLocation Loc) {
   // Visibility calculations will consider the namespace's visibility.

clang/test/CodeGen/cx-limited-range-pragma.c

+// RUN: %clang_cc1 %s -O0 -emit-llvm -triple x86_64-unknown-unknown -fuse-complex-intrinsics -fcx-range=limited -o - | FileCheck %s --check-prefixes=CHECK-COMMON,CHECK-LIMITED
+// RUN: %clang_cc1 %s -O0 -emit-llvm -triple x86_64-unknown-unknown -fuse-complex-intrinsics -fcx-range=nonan -o - | FileCheck %s --check-prefixes=CHECK-COMMON,CHECK-NO-NAN
+// RUN: %clang_cc1 %s -O0 -emit-llvm -triple x86_64-unknown-unknown -fuse-complex-intrinsics -fcx-range=full -o - | FileCheck %s --check-prefixes=CHECK-COMMON,CHECK-FULL
+
+_Complex float range_limited(_Complex float a, _Complex float b) {
+// CHECK-COMMON: @range_limited
+// CHECK-COMMON: call{{.*}}complex.fmul{{.*}} #[[LIMITED:[0-9]+]]
+// CHECK-COMMON: call{{.*}}complex.fdiv{{.*}} #[[LIMITED]]
+#pragma STDC CX_LIMITED_RANGE ON
+  return a * b + a / b;
+}
+
+_Complex float range_full(_Complex float a, _Complex float b) {
+// CHECK-COMMON: @range_full
+// CHECK-COMMON: call{{.*}}complex.fmul{{.*}} #[[FULL:[0-9]+]]
+// CHECK-COMMON: call{{.*}}complex.fdiv{{.*}} #[[FULL]]
+#pragma STDC CX_LIMITED_RANGE OFF
+  return a * b + a / b;
+}
+
+_Complex float range_default(_Complex float a, _Complex float b) {
+// CHECK-LIMITED: @range_default
+// CHECK-LIMITED: call{{.*}}complex.fmul{{.*}} #[[LIMITED]]
+// CHECK-LIMITED: call{{.*}}complex.fdiv{{.*}} #[[LIMITED]]
+// CHECK-NO-NAN: @range_default
+// CHECK-NO-NAN: call{{.*}}complex.fmul{{.*}} #[[LIMITED]]
+// CHECK-NO-NAN: call{{.*}}complex.fdiv{{.*}} #[[NONAN:[0-9]+]]
+// CHECK-FULL: @range_default
+// CHECK-FULL: call{{.*}}complex.fmul{{.*}} #[[FULL]]
+// CHECK-FULL: call{{.*}}complex.fdiv{{.*}} #[[FULL]]
+  return a * b + a / b;
+}
+
+_Complex float range_scoped(_Complex float a, _Complex float b) {
+// CHECK-COMMON: @range_scoped
+// CHECK-COMMON: call{{.*}}complex.fmul{{.*}} #[[FULL]]
+// CHECK-COMMON: call{{.*}}complex.fdiv{{.*}} #[[FULL]]
+#pragma STDC CX_LIMITED_RANGE OFF
+  _Complex float res = a * b;
+  {
+#pragma STDC CX_LIMITED_RANGE DEFAULT
+    res += a / b;
+  }
+  return res;
+}
+
+// CHECK-COMMON: attributes #[[LIMITED]] = { "complex-range"="limited" }
+// CHECK-COMMON: attributes #[[FULL]] = { "complex-range"="full" }
+// CHECK-NO-NAN: attributes #[[NONAN]] = { "complex-range"="no-nan" }