[SYCL] Add support for -fsycl-help=arg

Use -fsycl-help=arg where are is: gen, fpga, x86_64, all
These correspond to the subarch values used to trigger AOT compilation.  Use of
this option will call the corresponding offline compiler to emit the help
directly from that tool.

Signed-off-by: Michael D Toguchi <[email protected]>

Author: mdtoguchi

clang/include/clang/Driver/Driver.h

@@ -440,6 +440,9 @@ class Driver {
   /// \param ShowHidden - Show hidden options.
   void PrintHelp(bool ShowHidden) const;
 
+  /// PrintSYCLToolHelp - Print help text from offline compiler tools.
+  void PrintSYCLToolHelp(const Compilation &C) const;
+
   /// PrintVersion - Print the driver version.
   void PrintVersion(const Compilation &C, raw_ostream &OS) const;
 

clang/include/clang/Driver/Options.td

@@ -1753,6 +1753,11 @@ def fsycl_link : Flag<["-"], "fsycl-link">, Alias<fsycl_link_EQ>,
   HelpText<"Generate partially linked device object to be used with the host link">;
 def fsycl_unnamed_lambda : Flag<["-"], "fsycl-unnamed-lambda">,
   Flags<[CC1Option]>, HelpText<"Allow unnamed SYCL lambda kernels">;
+def fsycl_help_EQ : Joined<["-"], "fsycl-help=">,
+  Flags<[DriverOption]>, HelpText<"Emit help information from the related offline compilation tool">, Values<"all,fpga,gen,x86_64">;
+def fsycl_help : Flag<["-"], "fsycl-help">, Alias<fsycl_help_EQ>,
+  Flags<[DriverOption]>, AliasArgs<["all"]>, HelpText<"Emit help information "
+  "from all of the offline compilation tools">;
 def fsyntax_only : Flag<["-"], "fsyntax-only">,
   Flags<[DriverOption,CoreOption,CC1Option]>, Group<Action_Group>;
 def ftabstop_EQ : Joined<["-"], "ftabstop=">, Group<f_Group>;

clang/lib/Driver/Driver.cpp

@@ -1669,6 +1669,59 @@ void Driver::PrintHelp(bool ShowHidden) const {
                       /*ShowAllAliases=*/false);
 }
 
+llvm::Triple makeDeviceTriple(StringRef subArch) {
+  llvm::Triple TT;
+  TT.setArchName(subArch);
+  TT.setVendor(llvm::Triple::UnknownVendor);
+  TT.setOS(llvm::Triple(llvm::sys::getProcessTriple()).getOS());
+  TT.setEnvironment(llvm::Triple::SYCLDevice);
+  return TT;
+}
+
+// Print the help from any of the given tools which are used for AOT
+// compilation for SYCL
+void Driver::PrintSYCLToolHelp(const Compilation &C) const {
+  SmallVector<std::tuple<llvm::Triple, StringRef, StringRef>, 4> HelpArgs;
+  // Populate the vector with the tools and help options
+  if (Arg *A = C.getArgs().getLastArg(options::OPT_fsycl_help_EQ)) {
+    StringRef AV(A->getValue());
+    llvm::Triple T;
+    if (AV == "gen" || AV == "all")
+      HelpArgs.push_back(std::make_tuple(makeDeviceTriple("spir64_gen"),
+                                         "ocloc", "-?"));
+    if (AV == "fpga" || AV == "all")
+      HelpArgs.push_back(std::make_tuple(makeDeviceTriple("spir64_fpga"),
+                                         "aoc", "-help"));
+    if (AV == "x86_64" || AV == "all")
+      HelpArgs.push_back(std::make_tuple(makeDeviceTriple("spir64_x86_64"),
+                                         "ioc64", "-help"));
+    if (HelpArgs.empty()) {
+      C.getDriver().Diag(diag::err_drv_unsupported_option_argument)
+                         << A->getOption().getName() << AV;
+      return;
+    }
+  }
+
+  // Go through the args and emit the help information for each.
+  for (auto &HA : HelpArgs) {
+    llvm::outs() << "Emitting help information for " << std::get<1>(HA) << '\n'
+        << "Use triple of '" << std::get<0>(HA).normalize() <<
+        "' to enable ahead of time compilation\n";
+    // do not run the tools with -###.
+    if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH))
+      continue;
+    std::vector<StringRef> ToolArgs = { std::get<1>(HA), std::get<2>(HA) };
+    StringRef ExecPath(C.getDefaultToolChain().GetProgramPath(std::get<1>(HA).data()));
+    auto ToolBinary = llvm::sys::findProgramByName(ExecPath);
+    if (ToolBinary.getError()) {
+      C.getDriver().Diag(diag::err_drv_command_failure) << ExecPath;
+      continue;
+    }
+    // Run the Tool.
+    llvm::sys::ExecuteAndWait(ToolBinary.get(), ToolArgs);
+  }
+}
+
 void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const {
   // FIXME: The following handlers should use a callback mechanism, we don't
   // know what the client would like to do.
@@ -1809,6 +1862,11 @@ bool Driver::HandleImmediateArgs(const Compilation &C) {
     return false;
   }
 
+  if (C.getArgs().hasArg(options::OPT_fsycl_help_EQ)) {
+    PrintSYCLToolHelp(C);
+    return false;
+  }
+
   if (C.getArgs().hasArg(options::OPT__version)) {
     // Follow gcc behavior and use stdout for --version and stderr for -v.
     PrintVersion(C, llvm::outs());

clang/test/Driver/sycl.c

@@ -11,3 +11,18 @@
 // NO-BITCODE: "{{.*}}llvm-spirv"{{.*}} "-spirv-no-deref-attr"
 // TARGET: "-triple" "spir64-unknown-linux-sycldevice"{{.*}} "-fsycl-is-device"{{.*}} "-emit-llvm-bc"
 // COMBINED: "-triple" "spir64-unknown-{{.*}}-sycldevice"{{.*}} "-fsycl-is-device"{{.*}} "-emit-llvm-bc"
+
+// -fsycl-help tests
+// Test with a bad argument is expected to fail
+// RUN: not %clang -fsycl-help=foo %s 2>&1 | FileCheck %s --check-prefix=SYCL-HELP-BADARG
+// RUN: %clang -### -fsycl-help=gen %s 2>&1 | FileCheck %s --check-prefix=SYCL-HELP-GEN
+// RUN: %clang -### -fsycl-help=fpga %s 2>&1 | FileCheck %s --check-prefix=SYCL-HELP-FPGA
+// RUN: %clang -### -fsycl-help=x86_64 %s 2>&1 | FileCheck %s --check-prefix=SYCL-HELP-CPU
+// RUN: %clang -### -fsycl-help %s 2>&1 | FileCheck %s --check-prefixes=SYCL-HELP-GEN,SYCL-HELP-FPGA,SYCL-HELP-CPU
+// SYCL-HELP-BADARG: unsupported argument 'foo' to option 'fsycl-help='
+// SYCL-HELP-GEN: Emitting help information for ocloc
+// SYCL-HELP-GEN: Use triple of 'spir64_gen-unknown-{{.*}}-sycldevice' to enable ahead of time compilation
+// SYCL-HELP-FPGA: Emitting help information for aoc
+// SYCL-HELP-FPGA: Use triple of 'spir64_fpga-unknown-{{.*}}-sycldevice' to enable ahead of time compilation
+// SYCL-HELP-CPU: Emitting help information for ioc64
+// SYCL-HELP-CPU: Use triple of 'spir64_x86_64-unknown-{{.*}}-sycldevice' to enable ahead of time compilation