[SYCL][Driver][FPGA] Remove support for FPGA related options (#16864)

Removes support for any FPGA related options and any options that use
FPGA specific arguments. Upon usage of any of these options, a specific
error will be emitted:

> clang++ -fintelfpga file.cpp
clang++: error: option '-fintelfpga' is not supported and has been
removed from the compiler. Please see the compiler documentation for
more details

The following options are being handled:

- -fintelfpga
- -fsycl-targets=spir64_fpga[-unknown-unknown]
- -fsycl-link=early/image
- -Xsycl-target-backend=spir64_fpga "opt"
- -reuse-exe=arg
- -fsycl-help=fpga

This mainly removes support of the options as specified, subsequent
cleanup of driver behaviors will be done in a later change.

Due to the broad impact of these changes, all associated LIT tests have
been updated/removed.

Associated issue:  #16929

Author: mdtoguchi

clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -22,6 +22,9 @@ def err_drv_unsupported_option_argument : Error<
   "unsupported argument '%1' to option '%0'">;
 def err_drv_unsupported_option_argument_for_target : Error<
   "unsupported argument '%1' to option '%0' for target '%2'">;
+def err_drv_unsupported_opt_removed : Error<
+  "option '%0' is not supported and has been removed from the compiler. Please "
+  "see the compiler documentation for more details">;
 def err_drv_unknown_stdin_type : Error<
   "-E or -x required when input is from standard input">;
 def err_drv_unknown_stdin_type_clang_cl : Error<

clang/include/clang/Driver/Driver.h

@@ -617,7 +617,11 @@ class Driver {
 
   /// getSYCLDeviceTriple - Returns the SYCL device triple for the
   /// specified subarch
-  llvm::Triple getSYCLDeviceTriple(StringRef TargetArch = "spir64") const;
+  // TODO: Additional Arg input parameter is for diagnostic output information
+  // regarding FPGA support removal. This should be cleaned up in a future
+  // release.
+  llvm::Triple getSYCLDeviceTriple(StringRef TargetArch = "spir64",
+                                   const llvm::opt::Arg *Arg = nullptr) const;
 
   /// PrintActions - Print the list of actions.
   void PrintActions(const Compilation &C) const;

clang/include/clang/Driver/Options.h

@@ -27,6 +27,7 @@ enum ClangFlags {
   Ignored = (1 << 9),
   TargetSpecific = (1 << 10),
   Deprecated = (1 << 11),
+  UnsupportedRemoved = (1 << 12),
 };
 
 // Flags specifically for clang option visibility. We alias DefaultVis to

clang/include/clang/Driver/Options.td

@@ -51,6 +51,11 @@ def NoArgumentUnused : OptionFlag;
 // lines that use it.
 def Unsupported : OptionFlag;
 
+// UnsupportedRemoved - The option is unsupported and recently removed. Allows
+// for special diagnostic handling, and the driver will reject command
+// lines that use it.
+def UnsupportedRemoved : OptionFlag;
+
 // Ignored - The option is unsupported, and the driver will silently ignore it.
 def Ignored : OptionFlag;
 
@@ -6982,8 +6987,8 @@ defm : FlangIgnoredDiagOpt<"target-lifetime">;
 
 // C++ SYCL options
 let Group = sycl_Group in {
-def reuse_exe_EQ : Joined<["-"], "reuse-exe=">, Visibility<[ClangOption, CLOption, DXCOption]>,
-  HelpText<"Speed up FPGA aoc compile if the device code in <exe> is unchanged.">,
+def reuse_exe_EQ : Joined<["-"], "reuse-exe=">,
+  Visibility<[ClangOption, CLOption, DXCOption]>, Flags<[UnsupportedRemoved]>,
   MetaVarName<"<exe>">;
 def fsycl : Flag<["-"], "fsycl">,
   HelpText<"Enable SYCL C++ extensions">;
@@ -7031,10 +7036,9 @@ def fsycl_default_sub_group_size
 def fsycl_default_sub_group_size_EQ
     : Joined<["-"], "fsycl-default-sub-group-size=">,
       Alias<fsycl_default_sub_group_size>, Visibility<[ClangOption, CC1Option]>;
-def fintelfpga : Flag<["-"], "fintelfpga">,
+def fintelfpga : Flag<["-"], "fintelfpga">, Flags<[UnsupportedRemoved]>,
   Visibility<[ClangOption, CLOption, CC1Option]>,
-  MarshallingInfoFlag<LangOpts<"IntelFPGA">>,
-  HelpText<"Perform ahead-of-time compilation for FPGA">;
+  MarshallingInfoFlag<LangOpts<"IntelFPGA">>;
 def fsycl_embed_ir : Flag<["-"], "fsycl-embed-ir">,
   HelpText<"Embed LLVM IR for runtime kernel fusion">;
 defm sycl_esimd_force_stateless_mem : BoolFOption<"sycl-esimd-force-stateless-mem",
@@ -7131,11 +7135,9 @@ def fsycl_use_bitcode : Flag<["-"], "fsycl-use-bitcode">,
 def fno_sycl_use_bitcode : Flag<["-"], "fno-sycl-use-bitcode">,
   Alias<fsycl_device_obj_EQ>, AliasArgs<["spirv"]>, Flags<[Deprecated]>,
   HelpText<"Use SPIR-V instead of LLVM bitcode in fat objects (deprecated)">;
-def fsycl_link_EQ : Joined<["-"], "fsycl-link=">,
-  HelpText<"Generate partially linked device and host object to be used at "
-           "various stages of compilation">, Values<"image,early">;
+def fsycl_link_EQ : Joined<["-"], "fsycl-link=">;
 def fsycl_link : Flag<["-"], "fsycl-link">, Alias<fsycl_link_EQ>,
-  AliasArgs<["early"]>, HelpText<"Generate partially linked device object to "
+  AliasArgs<["default"]>, HelpText<"Generate partially linked device object to "
   "be used with the host link">;
 defm sycl_unnamed_lambda
     : BoolFOption<

clang/lib/Driver/Driver.cpp

@@ -340,6 +340,17 @@ InputArgList Driver::ParseArgStrings(ArrayRef<const char *> ArgStrings,
                        DiagnosticsEngine::Warning;
       continue;
     }
+    // Emit an unsupported and removed diagnostic for any options that were
+    // previously supported and subsequently removed.  This is considered a
+    // special case scenario that is currently being used for FPGA related
+    // options that did not go through the regular deprecation process.
+    if (A->getOption().hasFlag(options::UnsupportedRemoved)) {
+      Diag(diag::err_drv_unsupported_opt_removed) << A->getAsString(Args);
+      ContainsError |= Diags.getDiagnosticLevel(
+                           diag::err_drv_unsupported_opt_removed,
+                           SourceLocation()) > DiagnosticsEngine::Warning;
+      continue;
+    }
 
     // Deprecated options emit a diagnostic about deprecation, but are still
     // supported until removed. It's possible to have a deprecated option which
@@ -886,6 +897,10 @@ static bool isValidSYCLTriple(llvm::Triple T) {
       ((T.getArch() == llvm::Triple::spir && A != "spir") ||
        (T.getArch() == llvm::Triple::spir64 && A != "spir64")))
     return false;
+
+  // spir64_fpga is not supported.
+  if (T.isSPIR() && T.getSubArch() == llvm::Triple::SPIRSubArch_fpga)
+    return false;
   return true;
 }
 
@@ -896,10 +911,19 @@ static const char *getDefaultSYCLArch(Compilation &C) {
   return "spir64";
 }
 
-llvm::Triple Driver::getSYCLDeviceTriple(StringRef TargetArch) const {
+llvm::Triple Driver::getSYCLDeviceTriple(StringRef TargetArch,
+                                         const Arg *Arg) const {
   SmallVector<StringRef, 5> SYCLAlias = {
       "spir",       "spir64",  "spir64_fpga", "spir64_x86_64",
       "spir64_gen", "spirv32", "spirv64",     "nvptx64"};
+  // spir64_fpga is no longer supported.
+  llvm::Triple TargetTriple(TargetArch);
+  if (Arg && !Arg->isClaimed() && TargetTriple.isSPIR() &&
+      TargetTriple.getSubArch() == llvm::Triple::SPIRSubArch_fpga) {
+    Diag(diag::err_drv_unsupported_opt_removed)
+        << Arg->getSpelling().str() + TargetArch.str();
+    Arg->claim();
+  }
   if (llvm::is_contained(SYCLAlias, TargetArch)) {
     llvm::Triple TT;
     TT.setArchName(TargetArch);
@@ -1239,8 +1263,17 @@ void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
         << ArgValue << A->getOption().getName();
   };
 
+  // TODO: Transition to using -fsycl-link as a flag as opposed to an option
+  // that takes an argument.  The use of 'default' is a temporary solution as we
+  // remove FPGA support.
   Arg *SYCLLink = getArgRequiringSYCLRuntime(options::OPT_fsycl_link_EQ);
-  checkSingleArgValidity(SYCLLink, {"early", "image"});
+  checkSingleArgValidity(SYCLLink, {"early", "image", "default"});
+
+  // Use of -fsycl-link=early and -fsycl-link=image are not supported.
+  if (SYCLLink && (SYCLLink->getValue() == StringRef("early") ||
+                   SYCLLink->getValue() == StringRef("image")))
+    Diag(diag::err_drv_unsupported_opt_removed)
+        << SYCLLink->getAsString(C.getInputArgs());
 
   Arg *DeviceCodeSplit =
       C.getInputArgs().getLastArg(options::OPT_fsycl_device_code_split_EQ);
@@ -1268,7 +1301,7 @@ void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
       getArgRequiringSYCLRuntime(options::OPT_fsycl_force_target_EQ);
   if (SYCLForceTarget) {
     StringRef Val(SYCLForceTarget->getValue());
-    llvm::Triple TT(getSYCLDeviceTriple(Val));
+    llvm::Triple TT(getSYCLDeviceTriple(Val, SYCLForceTarget));
     if (!isValidSYCLTriple(TT))
       Diag(clang::diag::err_drv_invalid_sycl_target) << Val;
   }
@@ -2730,7 +2763,6 @@ void Driver::PrintHelp(bool ShowHidden) const {
                       VisibilityMask);
 }
 
-
 // Print the help from any of the given tools which are used for AOT
 // compilation for SYCL
 void Driver::PrintSYCLToolHelp(const Compilation &C) const {
@@ -2743,9 +2775,12 @@ void Driver::PrintSYCLToolHelp(const Compilation &C) const {
     if (AV == "gen" || AV == "all")
       HelpArgs.push_back(std::make_tuple(getSYCLDeviceTriple("spir64_gen"),
                                          "ocloc", "--help", ""));
-    if (AV == "fpga" || AV == "all")
+    if (AV == "fpga") {
+      Diag(diag::err_drv_unsupported_opt_removed)
+          << A->getSpelling().str() + AV.str();
       HelpArgs.push_back(std::make_tuple(getSYCLDeviceTriple("spir64_fpga"),
                                          "aoc", "-help", "-sycl"));
+    }
     if (AV == "x86_64" || AV == "all")
       HelpArgs.push_back(std::make_tuple(getSYCLDeviceTriple("spir64_x86_64"),
                                          "opencl-aot", "--help", ""));
@@ -4003,9 +4038,9 @@ bool Driver::checkForSYCLDefaultDevice(Compilation &C,
 
   // Do not do the check if the default device is passed in -fsycl-targets
   // or if -fsycl-targets isn't passed (that implies default device)
-  if (const Arg *A = Args.getLastArg(options::OPT_fsycl_targets_EQ)) {
+  if (const Arg *A = Args.getLastArgNoClaim(options::OPT_fsycl_targets_EQ)) {
     for (const char *Val : A->getValues()) {
-      llvm::Triple TT(C.getDriver().getSYCLDeviceTriple(Val));
+      llvm::Triple TT(C.getDriver().getSYCLDeviceTriple(Val, A));
       if ((TT.isSPIROrSPIRV()) && TT.getSubArch() == llvm::Triple::NoSubArch)
         // Default triple found
         return false;
@@ -6652,7 +6687,8 @@ class OffloadingActionBuilder final {
               continue;
             }
 
-            llvm::Triple TT(C.getDriver().getSYCLDeviceTriple(Val));
+            llvm::Triple TT(
+                C.getDriver().getSYCLDeviceTriple(Val, SYCLTargetsValues));
             std::string NormalizedName = TT.normalize();
 
             // Make sure we don't have a duplicate triple.

clang/lib/Driver/ToolChain.cpp

@@ -1720,7 +1720,7 @@ llvm::opt::DerivedArgList *ToolChain::TranslateOffloadTargetArgs(
           A->getOption().matches(options::OPT_Xsycl_frontend);
       if (A->getOption().matches(options::OPT_Xsycl_frontend_EQ)) {
         // Passing device args: -Xsycl-target-frontend=<triple> -opt=val.
-        if (getDriver().getSYCLDeviceTriple(A->getValue(0)) == Triple)
+        if (getDriver().getSYCLDeviceTriple(A->getValue(0), A) == Triple)
           Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
         else
           continue;

clang/lib/Driver/ToolChains/SYCL.cpp

@@ -1870,23 +1870,23 @@ void SYCLToolChain::TranslateTargetOpt(const llvm::Triple &Triple,
     bool OptNoTriple;
     OptNoTriple = A->getOption().matches(Opt);
     if (A->getOption().matches(Opt_EQ)) {
+      const llvm::Triple OptTargetTriple =
+          getDriver().getSYCLDeviceTriple(A->getValue(), A);
       // Passing device args: -X<Opt>=<triple> -opt=val.
       StringRef GenDevice = SYCL::gen::resolveGenDevice(A->getValue());
       bool IsGenTriple = Triple.isSPIR() &&
                          Triple.getSubArch() == llvm::Triple::SPIRSubArch_gen;
       if (IsGenTriple) {
         if (Device != GenDevice && !Device.empty())
           continue;
-        if (getDriver().getSYCLDeviceTriple(A->getValue()) != Triple &&
-            GenDevice.empty())
+        if (OptTargetTriple != Triple && GenDevice.empty())
           // Triples do not match, but only skip when we know we are not
           // comparing against intel_gpu_*
           continue;
-        if (getDriver().getSYCLDeviceTriple(A->getValue()) == Triple &&
-            !Device.empty())
+        if (OptTargetTriple == Triple && !Device.empty())
           // Triples match, but we are expecting a specific device to be set.
           continue;
-      } else if (getDriver().getSYCLDeviceTriple(A->getValue()) != Triple)
+      } else if (OptTargetTriple != Triple)
         continue;
     } else if (!OptNoTriple)
       // Don't worry about any of the other args, we only want to pass what is

clang/test/CodeGenSYCL/fpga-attr-do-while-loops.cpp

@@ -22,8 +22,5 @@
 // RUN: %clang -### -target x86_64-unknown-linux-gnu -fsycl \
 // RUN:    -fsycl-targets=spir64_x86_64 -ftarget-export-symbols %s 2>&1 \
 // RUN:   | FileCheck -check-prefix=UNUSED %s
-// RUN: %clang -### -target x86_64-unknown-linux-gnu -fsycl \
-// RUN:    -fsycl-targets=spir64_fpga -ftarget-export-symbols %s 2>&1 \
-// RUN:   | FileCheck -check-prefix=UNUSED %s
 
 // UNUSED: argument unused during compilation: '-ftarget-export-symbols'

clang/test/Driver/ftarget-export-symbols.cpp

@@ -2,12 +2,4 @@
 // RUN:  | FileCheck %s
 // RUN:  %clang_cl --target=x86_64-pc-windows-msvc -fsycl %s -### 2>&1 \
 // RUN:  | FileCheck %s
-// RUN:  %clangxx -target x86_64-pc-windows-msvc -fsycl -fintelfpga -fsycl-link=early %s -### 2>&1 \
-// RUN:  | FileCheck %s
-// RUN:  %clangxx -target x86_64-pc-windows-msvc -fsycl -fintelfpga -fsycl-link=image %s -### 2>&1 \
-// RUN:  | FileCheck %s
-// RUN:  %clang_cl --target=x86_64-pc-windows-msvc -fsycl -fintelfpga -fsycl-link=early %s -### 2>&1 \
-// RUN:  | FileCheck %s
-// RUN:  %clang_cl --target=x86_64-pc-windows-msvc -fsycl -fintelfpga -fsycl-link=image %s -### 2>&1 \
-// RUN:  | FileCheck %s
 // CHECK: /IGNORE:4078