[SYCL] Enable device code split by default

This patch introduces new device code split mode `auto`, which is
intended to automatically select the best device code split mode and
apply it.

At the moment, `auto` is equivalent to `per_source` for most cases and
it is equivalent to `off` in case of precense of function pointers.

Author: AlexeySachkov

clang/include/clang/Driver/Options.td

@@ -1987,11 +1987,11 @@ def fsycl_link_targets_EQ : CommaJoined<["-"], "fsycl-link-targets=">, Flags<[No
   HelpText<"Specify comma-separated list of triples SYCL offloading targets to produce linked device images">;
 def fsycl_device_code_split_EQ : Joined<["-"], "fsycl-device-code-split=">,
    Flags<[CC1Option, CoreOption]>, HelpText<"Perform SYCL device code split: per_kernel (device code module is "
-  "created for each SYCL kernel) | per_source (device code module is created for each source (translation unit)) | off (no device code split). "
-  "Default is 'off' - all kernels go into a single module`">, Values<"per_source, per_kernel, off">;
+  "created for each SYCL kernel) | per_source (device code module is created for each source (translation unit)) | off (no device code split). | auto (use heuristic to select the best way of splitting device code)"
+  "Default is 'auto' - automatically select how to split device code into modules">, Values<"per_source, per_kernel, off, auto">;
 def fsycl_device_code_split : Flag<["-"], "fsycl-device-code-split">, Alias<fsycl_device_code_split_EQ>,
-  AliasArgs<["per_source"]>, Flags<[CC1Option, CoreOption]>,
-  HelpText<"Perform SYCL device code split in the per_source mode i.e. create a device code module for each source (translation unit)">;
+  AliasArgs<["auto"]>, Flags<[CC1Option, CoreOption]>,
+  HelpText<"Perform SYCL device code split in the 'auto' mode i.e. use heuristic to distribute device code across modules">;
 def fsycl_id_queries_fit_in_int : Flag<["-"], "fsycl-id-queries-fit-in-int">,
   Flags<[CC1Option, CoreOption]>, HelpText<"Assume that SYCL ID queries fit "
   "within MAX_INT.">;

clang/lib/Driver/ToolChains/Clang.cpp

@@ -8142,12 +8142,17 @@ void SYCLPostLink::ConstructJob(Compilation &C, const JobAction &JA,
       addArgs(CmdArgs, TCArgs, {"-split=kernel"});
     else if (StringRef(A->getValue()) == "per_source")
       addArgs(CmdArgs, TCArgs, {"-split=source"});
+    else if (StringRef(A->getValue()) == "auto")
+      addArgs(CmdArgs, TCArgs, {"-split=auto"});
     else
       // split must be off
       assert(StringRef(A->getValue()) == "off");
+  } else {
+    // auto is the default split mode
+    addArgs(CmdArgs, TCArgs, {"-split=auto"});
   }
   // OPT_fsycl_device_code_split is not checked as it is an alias to
-  // -fsycl-device-code-split=per_source
+  // -fsycl-device-code-split=auto
 
   // Turn on Dead Parameter Elimination Optimization with early optimizations
   if (!getToolChain().getTriple().isNVPTX() &&

llvm/tools/sycl-post-link/sycl-post-link.cpp

@@ -90,16 +90,18 @@ static cl::opt<bool> OutputAssembly{"S",
 
 enum IRSplitMode {
   SPLIT_PER_TU,    // one module per translation unit
-  SPLIT_PER_KERNEL // one module per kernel
+  SPLIT_PER_KERNEL, // one module per kernel
+  SPLIT_AUTO // automatically select split mode
 };
 
 static cl::opt<IRSplitMode> SplitMode(
     "split", cl::desc("split input module"), cl::Optional,
     cl::init(SPLIT_PER_TU),
-    cl::values(clEnumValN(SPLIT_PER_TU, "source",
-                          "1 output module per source (translation unit)"),
-               clEnumValN(SPLIT_PER_KERNEL, "kernel",
-                          "1 output module per kernel")),
+    cl::values(
+        clEnumValN(SPLIT_PER_TU, "source",
+                   "1 output module per source (translation unit)"),
+        clEnumValN(SPLIT_PER_KERNEL, "kernel", "1 output module per kernel"),
+        clEnumValN(SPLIT_AUTO, "auto", "Choose split mode automatically")),
     cl::cat(PostLinkCat));
 
 static cl::opt<bool> DoSymGen{"symbols",
@@ -289,6 +291,25 @@ enum KernelMapEntryScope {
   Scope_Global     // single entry in the map for all kernels
 };
 
+static KernelMapEntryScope selectDeviceCodeSplitModeAutomatically(Module &M) {
+  // Here we can employ various heuristics to decide which way to split kernels
+  // is the best in each particular situation.
+  // At the moment, we assume that per-kernel split is the best way of splitting
+  // device code and it can be always selected unless there are functions marked
+  // with [[intel::device_indirectly_callable]] attribute, because it instructs
+  // us to make this function available to the whole program as it was compiled
+  // as a single module.
+  bool HasDeviceIndirectlyCallable = false;
+  for (auto &F : M.functions()) {
+    if (F.hasFnAttribute("referenced-indirectly"))
+      HasDeviceIndirectlyCallable = true;
+  }
+
+  if (HasDeviceIndirectlyCallable)
+    return Scope_Global;
+  return Scope_PerModule;
+}
+
 // This function decides how kernels of the input module M will be distributed
 // ("split") into multiple modules based on the command options and IR
 // attributes. The decision is recorded in the output map parameter
@@ -656,8 +677,13 @@ int main(int argc, char **argv) {
 
   if (DoSplit || DoSymGen) {
     KernelMapEntryScope Scope = Scope_Global;
-    if (DoSplit)
-      Scope = SplitMode == SPLIT_PER_KERNEL ? Scope_PerKernel : Scope_PerModule;
+    if (DoSplit) {
+      if (SplitMode == SPLIT_AUTO)
+        Scope = selectDeviceCodeSplitModeAutomatically(*MPtr);
+      else
+        Scope =
+            SplitMode == SPLIT_PER_KERNEL ? Scope_PerKernel : Scope_PerModule;
+    }
     collectKernelModuleMap(*MPtr, GlobalsSet, Scope);
   }