[SYCL][FE][Driver] Implement floating point accuracy control

clang/include/clang/Basic/Attr.td

@@ -2741,6 +2741,13 @@ def ReturnsTwice : InheritableAttr {
   let SimpleHandler = 1;
 }
 
+def FPBuiltinMaxError : StmtAttr {
+  let Spellings = [Clang<"fpbultin_max_error">];
+  let Subjects = SubjectList<[Function]>;
+  let Documentation = [Undocumented];
+  let SimpleHandler = 1;
+}
+
 def DisableTailCalls : InheritableAttr {
   let Spellings = [Clang<"disable_tail_calls">];
   let Subjects = SubjectList<[Function, ObjCMethod]>;

clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -61,6 +61,10 @@ def err_drv_no_cuda_libdevice : Error<
   "via '--cuda-path', or pass '-nocudalib' to build without linking with "
   "libdevice">;
 
+def warn_function_fp_accuray_already_set : Warning <"FP accuracy value of '%0' has already "
+  "been assigned to function '%1'">;
+def warn_all_fp_accuray_already_set : Warning <"FP accuracy value of '%0' has already "
+  "been assigned to all functions in the program">;
 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 "

clang/include/clang/Basic/FPOptions.def

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

clang/include/clang/Basic/LangOptions.def

@@ -336,6 +336,7 @@ BENIGN_LANGOPT(RoundingMath, 1, false, "Do not assume default floating-point rou
 BENIGN_ENUM_LANGOPT(FPExceptionMode, FPExceptionModeKind, 2, FPE_Default, "FP Exception Behavior Mode type")
 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 floating point arithmetic")
+BENIGN_ENUM_LANGOPT(FPAccuracy, FPAccuracyKind, 2, 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

@@ -22,6 +22,7 @@
 #include "clang/Basic/TargetCXXABI.h"
 #include "clang/Basic/Visibility.h"
 #include "llvm/ADT/FloatingPointMode.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/TargetParser/Triple.h"
 #include <optional>
@@ -303,6 +304,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 };
 
@@ -386,6 +396,13 @@ class LangOptions : public LangOptionsBase {
     IncompleteOnly = 3,
   };
 
+  using FPAccuracyMapTy =
+      llvm::MapVector<std::string, std::string, llvm::StringMap<unsigned>>;
+  FPAccuracyMapTy FPAccuracyMap;
+  using FPAccuracyFuncMapTy =
+      llvm::MapVector<std::string, FPAccuracyMapTy, llvm::StringMap<unsigned>>;
+  FPAccuracyFuncMapTy FPAccuracyFuncMap;
+
 public:
   /// The used language standard.
   LangStandard::Kind LangStd;

clang/include/clang/Driver/Options.td

@@ -1700,6 +1700,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_accuracy_attr_EQ : Joined<["-"], "ffp-accuracy-attr=">, 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",
@@ -6946,6 +6953,11 @@ 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.)
 
+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<"Defines the accuracy for math library "
+  "functions.">;
 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,

clang/lib/CodeGen/CGBuiltin.cpp

@@ -489,13 +489,35 @@ static Value *EmitISOVolatileStore(CodeGenFunction &CGF, const CallExpr *E) {
   return Store;
 }
 
+static CallInst *CreateBuiltinCallWithAttr(CodeGenFunction &CGF,
+                                           llvm::Function *F,
+                                           ArrayRef<Value *> Args) {
+  llvm::CallInst *CI = CGF.Builder.CreateCall(F, Args);
+  unsigned BuiltinID = CGF.getCurrentBuiltinID();
+  StringRef Name = CGF.CGM.getContext().BuiltinInfo.getName(BuiltinID);
+  llvm::AttributeList AttrList;
+  CGF.CGM.getFPAccuracyFuncAttributes(Name, AttrList);
+  // TODO: Needs some processing here to call fp::getAccuracyForFPBuiltin
+  // before setting the attribute for the call.
+  CI->setAttributes(AttrList);
+  return CI;
+}
+
 // Emit a simple mangled intrinsic that has 1 argument and a return type
 // matching the argument type. Depending on mode, this may be a constrained
 // floating-point intrinsic.
 static Value *emitUnaryMaybeConstrainedFPBuiltin(CodeGenFunction &CGF,
                                 const CallExpr *E, unsigned IntrinsicID,
                                 unsigned ConstrainedIntrinsicID) {
   llvm::Value *Src0 = CGF.EmitScalarExpr(E->getArg(0));
+  if (!CGF.getLangOpts().FPAccuracyMap.empty()) {
+    Function *Func = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
+    return CreateBuiltinCallWithAttr(CGF, Func, {Src0});
+  }
+  if (!CGF.getLangOpts().FPAccuracyFuncMap.empty()) {
+    Function *Func = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
+    return CreateBuiltinCallWithAttr(CGF, Func, {Src0});
+  }
 
   if (CGF.Builder.getIsFPConstrained()) {
     CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);
@@ -2216,6 +2238,8 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
                                                Result.Val.getFloat()));
   }
 
+  CurrentBuiltinIDRAII CB(*this, BuiltinID);
+
   // If current long-double semantics is IEEE 128-bit, replace math builtins
   // of long-double with f128 equivalent.
   // TODO: This mutation should also be applied to other targets other than PPC,
@@ -2276,9 +2300,8 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     case Builtin::BI__builtin_cosf16:
     case Builtin::BI__builtin_cosl:
     case Builtin::BI__builtin_cosf128:
-      return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
-                                   Intrinsic::cos,
-                                   Intrinsic::experimental_constrained_cos));
+      return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(
+          *this, E, Intrinsic::cos, Intrinsic::fpbuiltin_cos));
 
     case Builtin::BIexp:
     case Builtin::BIexpf:
@@ -2481,9 +2504,8 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     case Builtin::BI__builtin_sinf16:
     case Builtin::BI__builtin_sinl:
     case Builtin::BI__builtin_sinf128:
-      return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(*this, E,
-                                   Intrinsic::sin,
-                                   Intrinsic::experimental_constrained_sin));
+      return RValue::get(emitUnaryMaybeConstrainedFPBuiltin(
+          *this, E, Intrinsic::sin, Intrinsic::fpbuiltin_cos));
 
     case Builtin::BIsqrt:
     case Builtin::BIsqrtf:

clang/lib/CodeGen/CGCall.cpp

@@ -1840,6 +1840,22 @@ void CodeGenModule::getDefaultFunctionAttributes(StringRef Name,
                                                  bool HasOptnone,
                                                  bool AttrOnCallSite,
                                                llvm::AttrBuilder &FuncAttrs) {
+  for (const auto &M : getLangOpts().FPAccuracyMap) {
+    llvm::StringSet<> FuncOwnAttrs;
+    FuncAttrs.addAttribute("fpaccuracy=", M.second);
+    FuncOwnAttrs.insert(M.first);
+  }
+  if (!getLangOpts().FPAccuracyFuncMap.empty()) {
+    llvm::StringSet<> FuncOwnAttrs;
+    auto FuncMapIt = getLangOpts().FPAccuracyFuncMap.find(Name.str());
+    if (FuncMapIt != getLangOpts().FPAccuracyFuncMap.end()) {
+      for (const std::pair<std::string, std::string> &AttrPair :
+           FuncMapIt->second) {
+        FuncAttrs.addAttribute("fpaccuracy=", AttrPair.second);
+        FuncOwnAttrs.insert(AttrPair.first);
+      }
+    }
+  }
   // OptimizeNoneAttr takes precedence over -Os or -Oz. No warning needed.
   if (!HasOptnone) {
     if (CodeGenOpts.OptimizeSize)

clang/lib/CodeGen/CodeGenFunction.h

@@ -1597,6 +1597,28 @@ class CodeGenFunction : public CodeGenTypeCache {
   SourceLocation LastStopPoint;
 
 public:
+  /// Class to manage the BuiltinID for the current builtin expression during
+  /// processing in EmitBuiltinExpr.
+  class CurrentBuiltinIDRAII {
+    CodeGenFunction &CGF;
+    unsigned SavedBuiltinID;
+
+  public:
+    CurrentBuiltinIDRAII(CodeGenFunction &CGF, unsigned BuiltinID)
+        : CGF(CGF), SavedBuiltinID(CGF.CurrentBuiltinID) {
+      CGF.CurrentBuiltinID = BuiltinID;
+    }
+    ~CurrentBuiltinIDRAII() { CGF.CurrentBuiltinID = SavedBuiltinID; }
+  };
+
+private:
+  unsigned CurrentBuiltinID = /*NotBuiltin*/ 0;
+
+public:
+  unsigned getCurrentBuiltinID() {
+    assert(CurrentBuiltinID != /*NotBuiltin*/ 0);
+    return CurrentBuiltinID;
+  }
   /// Source location information about the default argument or member
   /// initializer expression we're evaluating, if any.
   CurrentSourceLocExprScope CurSourceLocExprScope;

clang/lib/CodeGen/CodeGenModule.cpp

@@ -7852,3 +7852,12 @@ void CodeGenModule::moveLazyEmissionStates(CodeGenModule *NewBuilder) {
 
   NewBuilder->ABI->MangleCtx = std::move(ABI->MangleCtx);
 }
+
+void CodeGenModule::getFPAccuracyFuncAttributes(StringRef Name,
+                                                llvm::AttributeList &AttrList) {
+  llvm::AttrBuilder FuncAttrs(getLLVMContext());
+  getDefaultFunctionAttributes(Name, /*HasOptNone*/ false,
+                               /*AttrOnCallSite*/ true, FuncAttrs);
+  AttrList = llvm::AttributeList::get(
+      getLLVMContext(), llvm::AttributeList::FunctionIndex, FuncAttrs);
+}

clang/lib/CodeGen/CodeGenModule.h

@@ -1591,6 +1591,9 @@ class CodeGenModule : public CodeGenTypeCache {
   /// because we'll lose all important information after each repl.
   void moveLazyEmissionStates(CodeGenModule *NewBuilder);
 
+  void getFPAccuracyFuncAttributes(StringRef Name,
+                                   llvm::AttributeList &AttrList);
+
 private:
   llvm::Constant *GetOrCreateLLVMFunction(
       StringRef MangledName, llvm::Type *Ty, GlobalDecl D, bool ForVTable,

clang/lib/Driver/ToolChains/Clang.cpp

@@ -5981,6 +5981,27 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
           << A->getAsString(Args) << TripleStr;
   }
 
+  std::string FpAccuracyAttr;
+  auto RenderFPAccuracyOptions = [&FpAccuracyAttr](const Twine &optStr) {
+    optStr.isSingleStringRef();
+    if (FpAccuracyAttr.empty())
+      FpAccuracyAttr = std::move(std::string("-ffp-accuracy-attr="));
+    else
+      FpAccuracyAttr += " ";
+    FpAccuracyAttr += optStr.str();
+  };
+  for (const Arg *A : Args) {
+    unsigned OptionID = A->getOption().getID();
+    switch (OptionID) {
+    case options::OPT_ffp_accuracy_EQ:
+      RenderFPAccuracyOptions(A->getValue());
+      A->claim();
+      break;
+    }
+  }
+  if (!FpAccuracyAttr.empty())
+    CmdArgs.push_back(Args.MakeArgString(FpAccuracyAttr));
+
   // Decide whether to use verbose asm. Verbose assembly is the default on
   // toolchains which have the integrated assembler on by default.
   bool IsIntegratedAssemblerDefault = TC.IsIntegratedAssemblerDefault();

clang/lib/Frontend/CompilerInvocation.cpp

@@ -3323,6 +3323,21 @@ void CompilerInvocation::GenerateLangArgs(const LangOptions &Opts,
 #include "clang/Driver/Options.inc"
 #undef LANG_OPTION_WITH_MARSHALLING
 
+  for (const auto &M : Opts.FPAccuracyMap) {
+    SmallString<128> S;
+    S += M.second;
+    GenerateArg(Args, OPT_ffp_accuracy_attr_EQ, S, SA);
+  }
+  for (const auto &F : Opts.FPAccuracyFuncMap) {
+    for (const auto &C : F.second) {
+      SmallString<128> S;
+      S += C.second;
+      S += ':';
+      S += F.first;
+      GenerateArg(Args, OPT_ffp_accuracy_attr_EQ, S, SA);
+    }
+  }
+
   // The '-fcf-protection=' option is generated by CodeGenOpts generator.
 
   if (Opts.ObjC) {
@@ -3565,6 +3580,65 @@ void CompilerInvocation::GenerateLangArgs(const LangOptions &Opts,
     GenerateArg(Args, OPT_fno_gpu_rdc, SA);
 }
 
+void CompilerInvocation::ParseFpAccuracyArgs(LangOptions &Opts, ArgList &Args,
+                                             DiagnosticsEngine &Diags) {
+  for (StringRef Values : Args.getAllArgValues(OPT_ffp_accuracy_attr_EQ)) {
+    SmallVector<StringRef, 8> ValuesArr;
+    Values.split(ValuesArr, ' ');
+    for (const auto &Val : ValuesArr) {
+      SmallVector<StringRef, 3> ValElement;
+      Val.split(ValElement, ':');
+      // The option is of the form -ffp-accuracy=value.
+      if (ValElement.size() == 1) {
+        StringRef FPAccuracy = ValElement[0];
+        if (!(FPAccuracy.equals("default") || FPAccuracy.equals("high") ||
+              FPAccuracy.equals("low") || FPAccuracy.equals("medium") ||
+              FPAccuracy.equals("sycl") || FPAccuracy.equals("cuda")))
+          Diags.Report(diag::err_drv_unsupported_option_argument)
+              << "ffp-accuracy" << FPAccuracy;
+        std::pair<LangOptions::FPAccuracyMapTy::iterator, bool> Result =
+            Opts.FPAccuracyMap.insert({"fp-accuracy", FPAccuracy.str()});
+        if (!Result.second) {
+          Diags.Report(diag::warn_all_fp_accuray_already_set)
+              << Result.first->second;
+        }
+      }
+      // The option is of the form -ffp-accuracy=value:[f1, ... fn].
+      if (ValElement.size() == 2) {
+        SmallVector<StringRef, 30> FuncList;
+        ValElement[1].split(FuncList, ',');
+        for (StringRef FuncName : FuncList) {
+          if (FuncName.front() == '[')
+            FuncName = FuncName.drop_front(1);
+          if (FuncName.back() == ']')
+            FuncName = FuncName.drop_back(1);
+          auto FuncMapIt = Opts.FPAccuracyFuncMap.find(FuncName.str());
+          if (FuncMapIt != Opts.FPAccuracyFuncMap.end()) {
+            // The math function has already been assigned an fp accuracy.
+            std::pair<LangOptions::FPAccuracyMapTy::iterator, bool> Result =
+                FuncMapIt->second.insert({"fp-accuracy", ValElement[0].str()});
+            if (!Result.second) {
+              Diags.Report(diag::warn_function_fp_accuray_already_set)
+                  << Result.first->second << FuncName.str();
+            }
+          } else {
+            LangOptions::FPAccuracyMapTy FPAccMap;
+            StringRef FPAccuracy = ValElement[0];
+            if (!(FPAccuracy.equals("default") || FPAccuracy.equals("high") ||
+                  FPAccuracy.equals("low") || FPAccuracy.equals("medium") ||
+                  FPAccuracy.equals("sycl") || FPAccuracy.equals("cuda")))
+              Diags.Report(diag::err_drv_unsupported_option_argument)
+                  << "ffp-accuracy" << FPAccuracy;
+            FPAccMap.insert({"fp-accuracy", FPAccuracy.str()});
+            Opts.FPAccuracyFuncMap.insert(
+                {FuncName.str(), std::move(FPAccMap)});
+          }
+        }
+      }
+    }
+  }
+}
+
 bool CompilerInvocation::ParseLangArgs(LangOptions &Opts, ArgList &Args,
                                        InputKind IK, const llvm::Triple &T,
                                        std::vector<std::string> &Includes,
@@ -3721,6 +3795,8 @@ bool CompilerInvocation::ParseLangArgs(LangOptions &Opts, ArgList &Args,
 #include "clang/Driver/Options.inc"
 #undef LANG_OPTION_WITH_MARSHALLING
 
+  ParseFpAccuracyArgs(Opts, Args, Diags);
+
   if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
     StringRef Name = A->getValue();
     if (Name == "full" || Name == "branch") {