Changed the place where the options are added in order for the options

to be applied to OpenMP too.

Author: zahiraam

clang/lib/Driver/ToolChains/Clang.cpp

@@ -1721,6 +1721,40 @@ static void CollectARMPACBTIOptions(const ToolChain &TC, const ArgList &Args,
   }
 }
 
+static void EmitAccuracyDiag(const Driver &D, const JobAction &JA,
+                             StringRef AccuracValStr, StringRef TargetPrecStr) {
+  if (JA.isDeviceOffloading(Action::OFK_SYCL)) {
+    D.Diag(clang::diag::warn_acuracy_conflicts_with_explicit_target_prec_option)
+        << AccuracValStr << TargetPrecStr;
+  }
+}
+
+void Clang::AddSPIRTargetArgs(const ArgList &Args, ArgStringList &CmdArgs,
+                              const JobAction &JA, const Driver &D) const {
+  if (JA.isDeviceOffloading(Action::OFK_SYCL)) {
+    if (Arg *A = Args.getLastArg(options::OPT_ffp_model_EQ)) {
+      if (!strcmp(A->getValue(), "fast")) {
+        CmdArgs.push_back("-fno-offload-fp32-prec-div");
+        CmdArgs.push_back("-fno-offload-fp32-prec-sqrt");
+      }
+    }
+    if (Arg *A = Args.getLastArg(options::OPT_ffp_accuracy_EQ)) {
+      if (Args.getLastArg(options::OPT_fno_offload_fp32_prec_div))
+        EmitAccuracyDiag(D, JA, A->getValue(), "-fno-offload-fp32-prec-div");
+      if (Args.getLastArg(options::OPT_fno_offload_fp32_prec_sqrt))
+        EmitAccuracyDiag(D, JA, A->getValue(), "-fno-offload-fp32-prec-sqrt");
+    }
+    if (Args.getLastArg(options::OPT_fno_offload_fp32_prec_div))
+      CmdArgs.push_back("-fno-offload-fp32-prec-div");
+    else
+      CmdArgs.push_back("-foffload-fp32-prec-div");
+    if (Args.getLastArg(options::OPT_fno_offload_fp32_prec_sqrt))
+      CmdArgs.push_back("-fno-offload-fp32-prec-sqrt");
+    else
+      CmdArgs.push_back("-foffload-fp32-prec-sqrt");
+  }
+}
+
 void Clang::AddARMTargetArgs(const llvm::Triple &Triple, const ArgList &Args,
                              ArgStringList &CmdArgs, bool KernelOrKext) const {
   RenderARMABI(getToolChain().getDriver(), Triple, Args, CmdArgs);
@@ -1771,8 +1805,10 @@ void Clang::AddARMTargetArgs(const llvm::Triple &Triple, const ArgList &Args,
 
 void Clang::RenderTargetOptions(const llvm::Triple &EffectiveTriple,
                                 const ArgList &Args, bool KernelOrKext,
-                                ArgStringList &CmdArgs) const {
+                                ArgStringList &CmdArgs,
+                                const JobAction &JA) const {
   const ToolChain &TC = getToolChain();
+  const Driver &D = TC.getDriver();
 
   // Add the target features
   getTargetFeatures(TC.getDriver(), EffectiveTriple, Args, CmdArgs, false);
@@ -1782,6 +1818,10 @@ void Clang::RenderTargetOptions(const llvm::Triple &EffectiveTriple,
   default:
     break;
 
+  case llvm::Triple::spir:
+  case llvm::Triple::spir64:
+    AddSPIRTargetArgs(Args, CmdArgs, JA, D);
+    break;
   case llvm::Triple::arm:
   case llvm::Triple::armeb:
   case llvm::Triple::thumb:
@@ -2942,14 +2982,6 @@ static void EmitComplexRangeDiag(const Driver &D, std::string str1,
   }
 }
 
-static void EmitAccuracyDiag(const Driver &D, const JobAction &JA,
-                             StringRef AccuracValStr, StringRef TargetPrecStr) {
-  if (JA.isDeviceOffloading(Action::OFK_SYCL)) {
-    D.Diag(clang::diag::warn_acuracy_conflicts_with_explicit_target_prec_option)
-        << AccuracValStr << TargetPrecStr;
-  }
-}
-
 static std::string
 RenderComplexRangeOption(LangOptions::ComplexRangeKind Range) {
   std::string ComplexRangeStr = ComplexRangeKindToStr(Range);
@@ -3006,8 +3038,6 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
   LangOptions::ComplexRangeKind Range = LangOptions::ComplexRangeKind::CX_None;
   std::string ComplexRangeStr = "";
   std::string GccRangeComplexOption = "";
-  bool NoOffloadFp32PrecDiv = false;
-  bool NoOffloadFp32PrecSqrt = false;
 
   // Lambda to set fast-math options. This is also used by -ffp-model=fast
   auto applyFastMath = [&]() {
@@ -3037,12 +3067,6 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
               : ComplexArithmeticStr(LangOptions::ComplexRangeKind::CX_Basic));
     Range = LangOptions::ComplexRangeKind::CX_Basic;
     SeenUnsafeMathModeOption = true;
-    if (JA.isDeviceOffloading(Action::OFK_SYCL)) {
-      // when fp-model=fast is used the default precision for division and
-      // sqrt is not precise.
-      NoOffloadFp32PrecDiv = true;
-      NoOffloadFp32PrecSqrt = true;
-    }
   };
 
   // Lambda to consolidate common handling for fp-contract
@@ -3076,19 +3100,6 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
     // If this isn't an FP option skip the claim below
     default: continue;
 
-    case options::OPT_foffload_fp32_prec_div:
-    case options::OPT_foffload_fp32_prec_sqrt:
-      break;
-    case options::OPT_fno_offload_fp32_prec_sqrt:
-      if (!FPAccuracy.empty())
-        EmitAccuracyDiag(D, JA, FPAccuracy, "-fno-offload-fp32-prec-sqrt");
-      NoOffloadFp32PrecSqrt = true;
-      break;
-    case options::OPT_fno_offload_fp32_prec_div:
-      if (!FPAccuracy.empty())
-        EmitAccuracyDiag(D, JA, FPAccuracy, "-fno-offload-fp32-prec-div");
-      NoOffloadFp32PrecDiv = true;
-      break;
     case options::OPT_fcx_limited_range:
       if (GccRangeComplexOption.empty()) {
         if (Range != LangOptions::ComplexRangeKind::CX_Basic)
@@ -3173,10 +3184,6 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
     case options::OPT_ffp_accuracy_EQ: {
       StringRef Val = A->getValue();
       FPAccuracy = Val;
-      if (NoOffloadFp32PrecDiv)
-        EmitAccuracyDiag(D, JA, FPAccuracy, "-fno-offload-fp32-prec-div");
-      if (NoOffloadFp32PrecSqrt)
-        EmitAccuracyDiag(D, JA, FPAccuracy, "-fno-offload-fp32-prec-sqrt");
       break;
     }
     case options::OPT_ffp_model_EQ: {
@@ -3590,16 +3597,6 @@ static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
     CmdArgs.push_back("-fno-cx-limited-range");
   if (Args.hasArg(options::OPT_fno_cx_fortran_rules))
     CmdArgs.push_back("-fno-cx-fortran-rules");
-  if (JA.isDeviceOffloading(Action::OFK_SYCL)) {
-    if (NoOffloadFp32PrecDiv)
-      CmdArgs.push_back("-fno-offload-fp32-prec-div");
-    else
-      CmdArgs.push_back("-foffload-fp32-prec-div");
-    if (NoOffloadFp32PrecSqrt)
-      CmdArgs.push_back("-fno-offload-fp32-prec-sqrt");
-    else
-      CmdArgs.push_back("-foffload-fp32-prec-sqrt");
-  }
 }
 
 static void RenderAnalyzerOptions(const ArgList &Args, ArgStringList &CmdArgs,
@@ -6849,7 +6846,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
     CmdArgs.push_back(Args.MakeArgString(CPU));
   }
 
-  RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs);
+  RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs, JA);
 
   // Add clang-cl arguments.
   types::ID InputType = Input.getType();

clang/lib/Driver/ToolChains/Clang.h

@@ -47,14 +47,18 @@ class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
 
   void RenderTargetOptions(const llvm::Triple &EffectiveTriple,
                            const llvm::opt::ArgList &Args, bool KernelOrKext,
-                           llvm::opt::ArgStringList &CmdArgs) const;
+                           llvm::opt::ArgStringList &CmdArgs,
+                           const JobAction &JA) const;
 
   void AddAArch64TargetArgs(const llvm::opt::ArgList &Args,
                             llvm::opt::ArgStringList &CmdArgs) const;
   void AddARMTargetArgs(const llvm::Triple &Triple,
                         const llvm::opt::ArgList &Args,
                         llvm::opt::ArgStringList &CmdArgs,
                         bool KernelOrKext) const;
+  void AddSPIRTargetArgs(const llvm::opt::ArgList &Args,
+                          llvm::opt::ArgStringList &CmdArgs,
+                          const JobAction &JA, const Driver &D) const;
   void AddARM64TargetArgs(const llvm::opt::ArgList &Args,
                           llvm::opt::ArgStringList &CmdArgs) const;
   void AddLoongArchTargetArgs(const llvm::opt::ArgList &Args,