[Clang] Add support for -fcx-limited-range, -fcx-fortran-rules options.

[jcranmer-intel]

Summary

These are built on top of, and require, the complex intrinsics definitions to
work with. They are intended to be similar in operation to the gcc command line
options.

Depends on D119289

[aaron.ballman]

Adding some reviewers, but the changes here look reasonable to me. You should fix the clang-format issues, though.

[erichkeane]

Same, other than the clang-format, I see nothing to be concerned about. @mdtoguchi is my driver expert however.

[mdtoguchi]

clang/include/clang/Driver/Options.td

1853

Typical negate syntax would use -fno-cx-*

clang/lib/Driver/ToolChains/Clang.cpp

2958

Is there any need to disable any settings for -fno-fast-math?

[zahiraam]

clang/include/clang/Driver/Options.td

1853

+1.

clang/lib/Driver/ToolChains/Clang.cpp

2958

Yes. Under the fno-fast-math the fcx-limited-range is disabled. So we need a to set the CxRangeArg to a value that illustrate that, LangOptions::CX_None?

[MaskRay]

clang/test/Driver/complex-range-flags.c

3

delete

this is legacy which is not needed for a long time

6

Move CHECK lines below RUN

14

No need to wrap lines

clang/include/clang/Driver/Options.td

defm protect_parens : BoolFOption<"protect-parens",
   NegFlag<SetFalse>>;
 
 defm use_complex_intrinsics : BoolFOption<"use-complex-intrinsics",
   CodeGenOpts<"UseComplexIntrinsics">, DefaultFalse,
   PosFlag<SetTrue, [CoreOption, CC1Option],
           "Determines whether to lower _Complex operations to LLVM complex "
           "intrinsics">,
   NegFlag<SetFalse>>;
+def fcx_limited_range : Flag<["-"], "fcx-limited-range">, Group<f_Group>;
+def fnocx_limited_range : Flag<["-"], "fnocx-limited-range">, Group<f_Group>;
+def fcx_fortran_rules : Flag<["-"], "fcx-fortran-rules">, Group<f_Group>;
+def fnocx_fortran_rules : Flag<["-"], "fnocx-fortran-rules">, Group<f_Group>;
+def cx_rangeEQ : Joined<["-"], "fcx-range=">, Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"Specifies the behavior of complex multiplication and division">,
+  Values<"limited,nonan,full">,
+  NormalizedValuesScope<"LangOptions">,
+  NormalizedValues<["CX_Limited", "CX_NoNan", "CX_Full"]>,
+  MarshallingInfoEnum<LangOpts<"ComplexRange">, "CX_Full">;
 
 def ffor_scope : Flag<["-"], "ffor-scope">, Group<f_Group>;
 def fno_for_scope : Flag<["-"], "fno-for-scope">, Group<f_Group>;
 
 defm rewrite_imports : BoolFOption<"rewrite-imports",
   PreprocessorOutputOpts<"RewriteImports">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option]>, NegFlag<SetFalse>>;
 defm rewrite_includes : BoolFOption<"rewrite-includes",

clang/lib/Driver/ToolChains/Clang.cpp

static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
   bool AssociativeMath = false;
   bool ReciprocalMath = false;
   bool SignedZeros = true;
   bool TrappingMath = false; // Implemented via -ffp-exception-behavior
   bool TrappingMathPresent = false; // Is trapping-math in args, and not
                                     // overriden by ffp-exception-behavior?
   bool RoundingFPMath = false;
   bool RoundingMathPresent = false; // Is rounding-math in args?
+  LangOptions::ComplexRangeKind CxRangeArg =
+    LangOptions::CX_Full;
+  StringRef RulingRangeArg = "";
+  auto setCxRangeArg = [&CxRangeArg, &RulingRangeArg, &D, &Args](
+      LangOptions::ComplexRangeKind Kind, StringRef ArgName) {
+    if (!RulingRangeArg.empty() && Kind != CxRangeArg) {
+        D.Diag(clang::diag::warn_drv_overriding_flag_option)
+               << Args.MakeArgString(RulingRangeArg)
+               << Args.MakeArgString(ArgName);
+    }
+    RulingRangeArg = ArgName;
+    CxRangeArg = Kind;
+  };
   // -ffp-model values: strict, fast, precise
   StringRef FPModel = "";
   // -ffp-exception-behavior options: strict, maytrap, ignore
   StringRef FPExceptionBehavior = "";
   const llvm::DenormalMode DefaultDenormalFPMath =
       TC.getDefaultDenormalModeForType(Args, JA);
   const llvm::DenormalMode DefaultDenormalFP32Math =
       TC.getDefaultDenormalModeForType(Args, JA, &llvm::APFloat::IEEEsingle());
case options::OPT_ffast_math:
       AssociativeMath = true;
       ReciprocalMath = true;
       ApproxFunc = true;
       SignedZeros = false;
       TrappingMath = false;
       RoundingFPMath = false;
       // If fast-math is set then set the fp-contract mode to fast.
       FPContract = "fast";
+      CxRangeArg = LangOptions::CX_NoNan;
       break;
     case options::OPT_fno_fast_math:
       HonorINFs = true;
       HonorNaNs = true;
       // Turning on -ffast-math (with either flag) removes the need for
       // MathErrno. However, turning *off* -ffast-math merely restores the
       // toolchain default (which may be false).
       MathErrno = TC.IsMathErrnoDefault();
       AssociativeMath = false;
       ReciprocalMath = false;
       ApproxFunc = false;
       SignedZeros = true;
       // -fno_fast_math restores default denormal and fpcontract handling
       DenormalFPMath = DefaultDenormalFPMath;
       DenormalFP32Math = llvm::DenormalMode::getIEEE();
       if (!JA.isDeviceOffloading(Action::OFK_Cuda) &&
           !JA.isOffloading(Action::OFK_HIP))
         if (FPContract == "fast") {
           FPContract = "on";
           D.Diag(clang::diag::warn_drv_overriding_flag_option)
               << "-ffp-contract=fast"
               << "-ffp-contract=on";
         }
       break;
+
+    case options::OPT_fcx_limited_range:
+      setCxRangeArg(LangOptions::CX_Limited, "fcx-limited-range");
+      break;
+    case options::OPT_fnocx_limited_range:
+      setCxRangeArg(LangOptions::CX_Full, "fcx-limited-range");
+      break;
+    case options::OPT_fcx_fortran_rules:
+      setCxRangeArg(LangOptions::CX_NoNan, "fcx-fortran-rules");
+      break;
+    case options::OPT_fnocx_fortran_rules:
+      setCxRangeArg(LangOptions::CX_Full, "fcx-fortran-rules");
+      break;
     }
     if (StrictFPModel) {
       // If -ffp-model=strict has been specified on command line but
       // subsequent options conflict then emit warning diagnostic.
       if (HonorINFs && HonorNaNs && !AssociativeMath && !ReciprocalMath &&
           SignedZeros && TrappingMath && RoundingFPMath && !ApproxFunc &&
           DenormalFPMath == llvm::DenormalMode::getIEEE() &&
           DenormalFP32Math == llvm::DenormalMode::getIEEE() &&
default:
     DefaultUseComplexIntrinsics = false;
     break;
   }
   if (Args.hasFlag(options::OPT_fuse_complex_intrinsics,
                    options::OPT_fno_use_complex_intrinsics,
                    DefaultUseComplexIntrinsics)) {
     CmdArgs.push_back("-fuse-complex-intrinsics");
   }
+
+  switch (CxRangeArg) {
+  case LangOptions::CX_Limited:
+    CmdArgs.push_back("-fcx-range=limited");
+    break;
+  case LangOptions::CX_NoNan:
+    CmdArgs.push_back("-fcx-range=nonan");
+    break;
+  case LangOptions::CX_Full:
+    CmdArgs.push_back("-fcx-range=full");
+    break;
+  }
 }
 
 static void RenderAnalyzerOptions(const ArgList &Args, ArgStringList &CmdArgs,
                                   const llvm::Triple &Triple,
                                   const InputInfo &Input) {
   // Enable region store model by default.
   CmdArgs.push_back("-analyzer-store=region");
 

clang/test/Driver/complex-range-flags.c

+// Test that the tri-valued complex range argument gets set appropriately.
+
+// REQUIRES: clang-driver
+
+// CHECK-FULL-RANGE: "-cc1"
+// CHECK-FULL-RANGE: "-fcx-range=full"
+
+// CHECK-LIMITED-RANGE: "-cc1"
+// CHECK-LIMITED-RANGE: "-fcx-range=limited"
+
+// CHECK-NONAN-RANGE: "-cc1"
+// CHECK-NONAN-RANGE: "-fcx-range=nonan"
+
+// RUN: %clang -### -c %s 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-FULL-RANGE %s
+
+// RUN: %clang -### -c -fcx-limited-range %s 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-LIMITED-RANGE %s
+
+// RUN: %clang -### -c -fcx-fortran-rules %s 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-NONAN-RANGE %s