[SYCL][FE][Driver] Implement floating point accuracy control (#8280)

This patch implements the accuracy controls for floating-point math
functions in DPC++. Using the -ffp-accuracy command line option, the
user can request an accuracy level for all math functions or for
specific ones. Calls to fpbuiltin intrinsics llvm.fpbuilin.* are then
generated.

Syntax: 

Linux:   -ffp-accuracy=[default|value][:funclist]
Windows: /Qfp-accuracy:[default|value][:funclist]

funclist is an optional comma separated list of math library functions.

-ffp-accuracy=[default|value]
default: Use the implementation defined accuracy for all math library
functions.
            This is equivalent to not using this option.         
value: Use the defined standard accuracy for what each accuracy value
            means for all math library functions.

-ffp-accuracy=[default|value][:funclist]

default: Use the implementation defined accuracy for the math library
functions in funclist.
            This is equivalent to not using this option.
value: Use the defined standard accuracy for what each accuracy value
            means for the math library functions in funclist.

value is one of the following values denoting the library function
accuracy.

high	This is equivalent to max-error = 1.0.
medium	This is equivalent to max-error = 4.
low This is equivalent to accuracy-bits = 11 for single-precision
functions.
accuracy-bits = 26 for double-precision functions.
sycl Determined by the OpenCL specification for math function accuracy:
https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_C.html#relative-error-as-ulps
cuda Determined by standard
https://docs.nvidia.com/cuda/cuda-c-programming-guide/#mathematical-functions-appendix

Author: zahiraam

clang/include/clang/Basic/CodeGenOptions.def

@@ -373,6 +373,10 @@ CODEGENOPT(VirtualFunctionElimination, 1, 0) ///< Whether to apply the dead
                                              /// virtual function elimination
                                              /// optimization.
 
+/// Whether accuracy levels for math library functions are requested by the
+/// user. These accuracy levels will then be expressed in terms of ULPs.
+CODEGENOPT(FPAccuracy, 1, 0)
+
 /// Whether to use public LTO visibility for entities in std and stdext
 /// namespaces. This is enabled by clang-cl's /MT and /MTd flags.
 CODEGENOPT(LTOVisibilityPublicStd, 1, 0)

clang/include/clang/Basic/DiagnosticCommonKinds.td

@@ -301,6 +301,9 @@ def warn_stack_clash_protection_inline_asm : Warning<
 def warn_slh_does_not_support_asm_goto : Warning<
   "speculative load hardening does not protect functions with asm goto">,
   InGroup<DiagGroup<"slh-asm-goto">>;
+
+def err_drv_incompatible_options : Error<
+  "the combination of '%0' and '%1' is incompatible">;
 }
 
 // Sema && Serialization

clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -63,6 +63,10 @@ def err_drv_no_cuda_libdevice : Error<
   "via '--cuda-path', or pass '-nocudalib' to build without linking with "
   "libdevice">;
 
+def warn_function_fp_accuracy_already_set : Warning <
+  "floating point accuracy value of '%0' has already been assigned to "
+  "function '%1'">,
+  InGroup<DiagGroup<"fp-accuracy-already-set">>;
 def err_drv_no_rocm_device_lib : Error<
   "cannot find ROCm device library%select{| for %1|for ABI version %1}0; provide its path via "
   "'--rocm-path' or '--rocm-device-lib-path', or pass '-nogpulib' to build "
@@ -141,8 +145,9 @@ def err_drv_invalid_unwindlib_name : Error<
   "invalid unwind library name in argument '%0'">;
 def err_drv_incompatible_unwindlib : Error<
   "--rtlib=libgcc requires --unwindlib=libgcc">;
-def err_drv_incompatible_options : Error<
-  "the combination of '%0' and '%1' is incompatible">;
+def err_drv_incompatible_fp_accuracy_options : Error<
+  "floating point accuracy requirements cannot be guaranteed when '-fmath-errno' "
+  "is enabled; use '-fno-math-errno' to enable floating point accuracy control">;
 def err_drv_invalid_stdlib_name : Error<
   "invalid library name in argument '%0'">;
 def err_drv_invalid_output_with_multiple_archs : Error<

clang/include/clang/Basic/FPOptions.def

@@ -26,5 +26,6 @@ OPTION(AllowReciprocal, bool, 1, NoSignedZero)
 OPTION(AllowApproxFunc, bool, 1, AllowReciprocal)
 OPTION(FPEvalMethod, LangOptions::FPEvalMethodKind, 2, AllowApproxFunc)
 OPTION(Float16ExcessPrecision, LangOptions::ExcessPrecisionKind, 2, FPEvalMethod)
-OPTION(BFloat16ExcessPrecision, LangOptions::ExcessPrecisionKind, 2, FPEvalMethod)
+OPTION(BFloat16ExcessPrecision, LangOptions::ExcessPrecisionKind, 2, Float16ExcessPrecision)
+OPTION(FPAccuracy, LangOptions::FPAccuracyKind, 3, BFloat16ExcessPrecision)
 #undef OPTION

clang/include/clang/Basic/LangOptions.def

@@ -338,6 +338,7 @@ BENIGN_ENUM_LANGOPT(FPExceptionMode, FPExceptionModeKind, 2, FPE_Default, "FP Ex
 BENIGN_ENUM_LANGOPT(FPEvalMethod, FPEvalMethodKind, 2, FEM_UnsetOnCommandLine, "FP type used for floating point arithmetic")
 ENUM_LANGOPT(Float16ExcessPrecision, ExcessPrecisionKind, 2, FPP_Standard, "Intermediate truncation behavior for Float16 arithmetic")
 ENUM_LANGOPT(BFloat16ExcessPrecision, ExcessPrecisionKind, 2, FPP_Standard, "Intermediate truncation behavior for BFloat16 arithmetic")
+BENIGN_ENUM_LANGOPT(FPAccuracy, FPAccuracyKind, 3, FPA_Default, "Accuracy for floating point operations and library functions")
 LANGOPT(NoBitFieldTypeAlign , 1, 0, "bit-field type alignment")
 LANGOPT(HexagonQdsp6Compat , 1, 0, "hexagon-qdsp6 backward compatibility")
 LANGOPT(ObjCAutoRefCount , 1, 0, "Objective-C automated reference counting")

clang/include/clang/Basic/LangOptions.h

@@ -303,6 +303,15 @@ class LangOptions : public LangOptionsBase {
 
   enum ExcessPrecisionKind { FPP_Standard, FPP_Fast, FPP_None };
 
+  enum FPAccuracyKind {
+    FPA_Default,
+    FPA_High,
+    FPA_Medium,
+    FPA_Low,
+    FPA_Sycl,
+    FPA_Cuda,
+  };
+
   /// Possible exception handling behavior.
   enum class ExceptionHandlingKind { None, SjLj, WinEH, DwarfCFI, Wasm };
 
@@ -509,6 +518,10 @@ class LangOptions : public LangOptionsBase {
   /// records.
   std::string OptRecordFile;
 
+  std::string FPAccuracyVal;
+  using FPAccuracyFuncMapTy = std::map<std::string, std::string>;
+  FPAccuracyFuncMapTy FPAccuracyFuncMap;
+
   LangOptions();
 
   /// Set language defaults for the given input language and

clang/include/clang/Driver/Options.td

@@ -1729,6 +1729,13 @@ def ffp_exception_behavior_EQ : Joined<["-"], "ffp-exception-behavior=">, Group<
   Values<"ignore,maytrap,strict">, NormalizedValuesScope<"LangOptions">,
   NormalizedValues<["FPE_Ignore", "FPE_MayTrap", "FPE_Strict"]>,
   MarshallingInfoEnum<LangOpts<"FPExceptionMode">, "FPE_Default">;
+def ffp_accuracy_EQ : Joined<["-"], "ffp-accuracy=">, Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"Specifies the required accuracy for floating-point operations and library calls.">,
+  Values<"default,high,medium,low,sycl,cuda">, NormalizedValuesScope<"LangOptions">,
+  NormalizedValues<["FPA_Default", "FPA_High", "FPA_Medium", "FPA_Low", "FPA_Sycl", "FPA_Cuda"]>,
+  MarshallingInfoEnum<LangOpts<"FPAccuracy">, "FPA_Default">;
+def ffp_builtin_accuracy_EQ : Joined<["-"], "ffp-builtin-accuracy=">, Group<f_Group>, Flags<[CC1Option]>;
+
 defm fast_math : BoolFOption<"fast-math",
   LangOpts<"FastMath">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option, CoreOption, FC1Option, FlangOption], "Allow aggressive, lossy floating-point optimizations",
@@ -7020,6 +7027,14 @@ class CLRemainingArgsJoined<string name> : Option<["/", "-"], name,
 // (We don't put any of these in cl_compile_Group as the options they alias are
 // already in the right group.)
 
+// INTEL_CUSTOMIZATION
+def _SLASH_Qfp_accuracy_EQ : CLJoined<"Qfp-accuracy=">,
+  Alias<ffp_accuracy_EQ>;
+def _SLASH_Qfp_accuracy_COL : CLJoined<"Qfp-accuracy:">,
+  Alias<ffp_accuracy_EQ>,HelpText<"Specifies the required accuracy for "
+  "floating-point operations and library calls.">;
+// END INTEL_CUSTOMIZATION
+
 def _SLASH_Brepro : CLFlag<"Brepro">,
   HelpText<"Do not write current time into COFF output (breaks link.exe /incremental)">,
   Alias<mno_incremental_linker_compatible>;

clang/include/clang/Frontend/CompilerInvocation.h

@@ -276,6 +276,9 @@ class CompilerInvocation : public CompilerInvocationRefBase,
                             std::vector<std::string> &Includes,
                             DiagnosticsEngine &Diags);
 
+  static void ParseFpAccuracyArgs(LangOptions &Opts, llvm::opt::ArgList &Args,
+                                  DiagnosticsEngine &Diags);
+
   /// Generate command line options from LangOptions.
   static void GenerateLangArgs(const LangOptions &Opts,
                                SmallVectorImpl<const char *> &Args,