[DAE][SYCL] Enable DAE in SYCL kernel functions

llvm/include/llvm/InitializePasses.h

@@ -120,6 +120,7 @@ void initializeCostModelAnalysisPass(PassRegistry&);
 void initializeCrossDSOCFIPass(PassRegistry&);
 void initializeDAEPass(PassRegistry&);
 void initializeDAHPass(PassRegistry&);
+void initializeDAESYCLPass(PassRegistry&);
 void initializeDCELegacyPassPass(PassRegistry&);
 void initializeDSELegacyPassPass(PassRegistry&);
 void initializeDataFlowSanitizerPass(PassRegistry&);

llvm/include/llvm/LinkAllPasses.h

@@ -95,6 +95,7 @@ namespace {
       (void) llvm::createControlHeightReductionLegacyPass();
       (void) llvm::createCostModelAnalysisPass();
       (void) llvm::createDeadArgEliminationPass();
+      (void) llvm::createDeadArgEliminationSYCLPass();
       (void) llvm::createDeadCodeEliminationPass();
       (void) llvm::createDeadInstEliminationPass();
       (void) llvm::createDeadStoreEliminationPass();

llvm/include/llvm/Transforms/IPO.h

@@ -144,6 +144,9 @@ ModulePass *createDeadArgEliminationPass();
 /// bugpoint.
 ModulePass *createDeadArgHackingPass();
 
+/// DeadArgumentElimination pass for SYCL kernel functions
+ModulePass *createDeadArgEliminationSYCLPass();
+
 //===----------------------------------------------------------------------===//
 /// createArgumentPromotionPass - This pass promotes "by reference" arguments to
 /// be passed by value if the number of elements passed is smaller or

llvm/include/llvm/Transforms/IPO/DeadArgumentElimination.h

@@ -73,8 +73,10 @@ class DeadArgumentEliminationPass
   /// thus become dead in the end.
   enum Liveness { Live, MaybeLive };
 
-  DeadArgumentEliminationPass(bool ShouldHackArguments_ = false)
-      : ShouldHackArguments(ShouldHackArguments_) {}
+  DeadArgumentEliminationPass(bool ShouldHackArguments_ = false,
+                              bool CheckSyclKernels = false)
+      : ShouldHackArguments(ShouldHackArguments_),
+        CheckSyclKernels(CheckSyclKernels) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
 
@@ -121,6 +123,10 @@ class DeadArgumentEliminationPass
   /// (used only by bugpoint).
   bool ShouldHackArguments = false;
 
+  /// This allows to eliminate dead arguments in SYCL kernel functions with
+  /// external linkage
+  bool CheckSyclKernels = false;
+
 private:
   Liveness MarkIfNotLive(RetOrArg Use, UseVector &MaybeLiveUses);
   Liveness SurveyUse(const Use *U, UseVector &MaybeLiveUses,

llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp

@@ -41,6 +41,7 @@
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/IPO.h"
@@ -54,6 +55,11 @@ using namespace llvm;
 
 #define DEBUG_TYPE "deadargelim"
 
+static cl::opt<std::string>
+    IntegrationHeaderFileName("integr-header-file",
+                              cl::desc("Path to integration header file"),
+                              cl::value_desc("filename"), cl::Hidden);
+
 STATISTIC(NumArgumentsEliminated, "Number of unread args removed");
 STATISTIC(NumRetValsEliminated  , "Number of unused return values removed");
 STATISTIC(NumArgumentsReplacedWithUndef,
@@ -77,13 +83,15 @@ namespace {
     bool runOnModule(Module &M) override {
       if (skipModule(M))
         return false;
-      DeadArgumentEliminationPass DAEP(ShouldHackArguments());
+      DeadArgumentEliminationPass DAEP(ShouldHackArguments(),
+                                       CheckSyclKernels());
       ModuleAnalysisManager DummyMAM;
       PreservedAnalyses PA = DAEP.run(M, DummyMAM);
       return !PA.areAllPreserved();
     }
 
     virtual bool ShouldHackArguments() const { return false; }
+    virtual bool CheckSyclKernels() const { return false; }
   };
 
 } // end anonymous namespace
@@ -103,6 +111,7 @@ namespace {
     DAH() : DAE(ID) {}
 
     bool ShouldHackArguments() const override { return true; }
+    bool CheckSyclKernels() const override { return false; }
   };
 
 } // end anonymous namespace
@@ -113,12 +122,40 @@ INITIALIZE_PASS(DAH, "deadarghaX0r",
                 "Dead Argument Hacking (BUGPOINT USE ONLY; DO NOT USE)",
                 false, false)
 
+namespace {
+
+/// DAESYCL - DeadArgumentElimination pass for SYCL kernel functions even
+///           if they are external.
+struct DAESYCL : public DAE {
+  static char ID;
+
+  DAESYCL() : DAE(ID) {
+    initializeDAESYCLPass(*PassRegistry::getPassRegistry());
+  }
+
+  StringRef getPassName() const override {
+    return "Dead Argument Elimination for SYCL kernels";
+  }
+
+  bool ShouldHackArguments() const override { return false; }
+  bool CheckSyclKernels() const override { return true; }
+};
+
+} // end anonymous namespace
+
+char DAESYCL::ID = 0;
+
+INITIALIZE_PASS(DAESYCL, "deadargelim-sycl",
+                "Dead Argument Elimination for SYCL kernels", false, false)
+
 /// createDeadArgEliminationPass - This pass removes arguments from functions
 /// which are not used by the body of the function.
 ModulePass *llvm::createDeadArgEliminationPass() { return new DAE(); }
 
 ModulePass *llvm::createDeadArgHackingPass() { return new DAH(); }
 
+ModulePass *llvm::createDeadArgEliminationSYCLPass() { return new DAESYCL(); }
+
 /// DeleteDeadVarargs - If this is an function that takes a ... list, and if
 /// llvm.vastart is never called, the varargs list is dead for the function.
 bool DeadArgumentEliminationPass::DeleteDeadVarargs(Function &Fn) {
@@ -535,7 +572,14 @@ void DeadArgumentEliminationPass::SurveyFunction(const Function &F) {
                       << " has musttail calls\n");
   }
 
-  if (!F.hasLocalLinkage() && (!ShouldHackArguments || F.isIntrinsic())) {
+  // We can't modify arguments if the function is not local
+  // but we can do so for SYCL kernel function.
+  bool FuncIsSyclKernel =
+      CheckSyclKernels &&
+      StringRef(F.getParent()->getTargetTriple()).contains("sycldevice") &&
+      F.getCallingConv() == CallingConv::SPIR_KERNEL;
+  bool FuncIsLive = !F.hasLocalLinkage() && !FuncIsSyclKernel;
+  if (FuncIsLive && (!ShouldHackArguments || F.isIntrinsic())) {
     MarkLive(F);
     return;
   }
@@ -714,6 +758,83 @@ void DeadArgumentEliminationPass::PropagateLiveness(const RetOrArg &RA) {
   Uses.erase(Begin, I);
 }
 
+// Update kernel arguments table inside the integration header.
+// For example:
+//   static constexpr const bool param_omit_table[] = {
+//     // OMIT_TABLE_BEGIN
+//     // kernel_name_1
+//     false, false,     // <= update to true if the argument is dead
+//     // kernel_name_2
+//     false, false,
+//     // OMIT_TABLE_END
+//   };
+//   TODO: batch changes to multiple SYCL kernels and do one bulk update.
+constexpr StringLiteral OMIT_TABLE_BEGIN("// OMIT_TABLE_BEGIN");
+constexpr StringLiteral OMIT_TABLE_END("// OMIT_TABLE_END");
+static void updateIntegrationHeader(StringRef SyclKernelName,
+                                    const ArrayRef<bool> &ArgAlive) {
+  // TODO: Enable asserts once the driver will provide the option.
+  if (!IntegrationHeaderFileName.getNumOccurrences())
+    return;
+  // assert(IntegrationHeaderFileName.hasArgStr() &&
+  //       "Integration header file not specified!");
+  ErrorOr<std::unique_ptr<MemoryBuffer>> IntHeaderBuffer =
+      MemoryBuffer::getFile(IntegrationHeaderFileName);
+
+  if (!IntHeaderBuffer)
+    report_fatal_error("unable to read integration header file '" +
+                       IntegrationHeaderFileName +
+                       "': " + IntHeaderBuffer.getError().message());
+
+  // 1. Find the region between OMIT_TABLE_BEGIN and OMIT_TABLE_END
+  StringRef IntHeader((*IntHeaderBuffer)->getBuffer());
+  if (!IntHeader.contains(OMIT_TABLE_BEGIN))
+    report_fatal_error(OMIT_TABLE_BEGIN +
+                       " marker not found in integration header");
+  if (!IntHeader.contains(OMIT_TABLE_END))
+    report_fatal_error(OMIT_TABLE_END +
+                       " marker not found in integration header");
+
+  size_t BeginRegionPos =
+      IntHeader.find(OMIT_TABLE_BEGIN) + OMIT_TABLE_BEGIN.size();
+  size_t EndRegionPos = IntHeader.find(OMIT_TABLE_END);
+
+  StringRef OmitArgTable = IntHeader.slice(BeginRegionPos, EndRegionPos);
+
+  // 2. Find the line that corresponds to the SYCL kernel
+  if (!OmitArgTable.contains(SyclKernelName))
+    report_fatal_error(
+        "Argument table not found in integration header for function '" +
+        SyclKernelName + "'");
+
+  size_t BeginLinePos =
+      OmitArgTable.find(SyclKernelName) + SyclKernelName.size();
+  size_t EndLinePos = OmitArgTable.find("//", BeginLinePos);
+
+  StringRef OmitArgLine = OmitArgTable.slice(BeginLinePos, EndLinePos);
+
+  size_t LineLeftTrim = OmitArgLine.size() - OmitArgLine.ltrim().size();
+  size_t LineRightTrim = OmitArgLine.size() - OmitArgLine.rtrim().size();
+
+  // 3. Construct new file contents and replace only that string.
+  std::string NewIntHeader;
+  NewIntHeader +=
+      IntHeader.take_front(BeginRegionPos + BeginLinePos + LineLeftTrim);
+  for (auto &AliveArg : ArgAlive)
+    NewIntHeader += AliveArg ? "false, " : "true, ";
+  NewIntHeader += IntHeader.drop_front(BeginRegionPos + BeginLinePos +
+                                       OmitArgLine.size() - LineRightTrim);
+
+  // 4. Flush the string into the file.
+  std::error_code EC;
+  raw_fd_ostream File(IntegrationHeaderFileName, EC, sys::fs::F_Text);
+
+  if (EC)
+    report_fatal_error("Cannot open integration header for writing.");
+
+  File << NewIntHeader;
+}
+
 // RemoveDeadStuffFromFunction - Remove any arguments and return values from F
 // that are not in LiveValues. Transform the function and all of the callees of
 // the function to not have these arguments and return values.
@@ -757,6 +878,9 @@ bool DeadArgumentEliminationPass::RemoveDeadStuffFromFunction(Function *F) {
     }
   }
 
+  if (CheckSyclKernels)
+    updateIntegrationHeader(F->getName(), ArgAlive);
+
   // Find out the new return value.
   Type *RetTy = FTy->getReturnType();
   Type *NRetTy = nullptr;

llvm/lib/Transforms/IPO/IPO.cpp

@@ -30,6 +30,7 @@ void llvm::initializeIPO(PassRegistry &Registry) {
   initializeCrossDSOCFIPass(Registry);
   initializeDAEPass(Registry);
   initializeDAHPass(Registry);
+  initializeDAESYCLPass(Registry);
   initializeForceFunctionAttrsLegacyPassPass(Registry);
   initializeGlobalDCELegacyPassPass(Registry);
   initializeGlobalOptLegacyPassPass(Registry);

llvm/lib/Transforms/IPO/PassManagerBuilder.cpp

@@ -680,6 +680,7 @@ void PassManagerBuilder::populateModulePassManager(
   if (RunInliner) {
     MPM.add(createGlobalOptimizerPass());
     MPM.add(createGlobalDCEPass());
+    MPM.add(createDeadArgEliminationSYCLPass());
   }
 
   // If we are planning to perform ThinLTO later, let's not bloat the code with

llvm/test/Other/opt-O2-pipeline.ll

@@ -193,6 +193,7 @@
 ; CHECK-NEXT:         Branch Probability Analysis
 ; CHECK-NEXT:         Block Frequency Analysis
 ; CHECK-NEXT:     Dead Global Elimination
+; CHECK-NEXT:     Dead Argument Elimination for SYCL kernels
 ; CHECK-NEXT:     CallGraph Construction
 ; CHECK-NEXT:     Globals Alias Analysis
 ; CHECK-NEXT:     FunctionPass Manager

llvm/test/Other/opt-O3-pipeline-enable-matrix.ll

@@ -198,6 +198,7 @@
 ; CHECK-NEXT:         Branch Probability Analysis
 ; CHECK-NEXT:         Block Frequency Analysis
 ; CHECK-NEXT:     Dead Global Elimination
+; CHECK-NEXT:     Dead Argument Elimination for SYCL kernels
 ; CHECK-NEXT:     CallGraph Construction
 ; CHECK-NEXT:     Globals Alias Analysis
 ; CHECK-NEXT:     FunctionPass Manager

llvm/test/Other/opt-O3-pipeline.ll

@@ -198,6 +198,7 @@
 ; CHECK-NEXT:         Branch Probability Analysis
 ; CHECK-NEXT:         Block Frequency Analysis
 ; CHECK-NEXT:     Dead Global Elimination
+; CHECK-NEXT:     Dead Argument Elimination for SYCL kernels
 ; CHECK-NEXT:     CallGraph Construction
 ; CHECK-NEXT:     Globals Alias Analysis
 ; CHECK-NEXT:     FunctionPass Manager

llvm/test/Other/opt-Os-pipeline.ll

@@ -179,6 +179,7 @@
 ; CHECK-NEXT:         Branch Probability Analysis
 ; CHECK-NEXT:         Block Frequency Analysis
 ; CHECK-NEXT:     Dead Global Elimination
+; CHECK-NEXT:     Dead Argument Elimination for SYCL kernels
 ; CHECK-NEXT:     CallGraph Construction
 ; CHECK-NEXT:     Globals Alias Analysis
 ; CHECK-NEXT:     FunctionPass Manager

llvm/test/Transforms/DeadArgElim/sycl-kernels-neg1.ll

@@ -0,0 +1,13 @@
+; TODO: this should be crashing (not --crash) after enabling assert
+; RUN: opt < %s -deadargelim-sycl -S
+
+; Path to the integration header is not specified.
+
+target triple = "spir64-unknown-unknown-sycldevice"
+
+define weak_odr spir_kernel void @NegativeSyclKernel(float %arg1, float %arg2) {
+  call void @foo(float %arg1)
+  ret void
+}
+
+declare void @foo(float %arg)

llvm/test/Transforms/DeadArgElim/sycl-kernels-neg2.ll

@@ -0,0 +1,14 @@
+; RUN: rm -rf %t && mkdir -p %t
+; RUN: touch %t/int_header.h
+; RUN: not --crash opt < %s -deadargelim-sycl -S -integr-header-file %t/bad_file.h
+
+; Path to the integration header is wrong.
+
+target triple = "spir64-unknown-unknown-sycldevice"
+
+define weak_odr spir_kernel void @NegativeSyclKernel(float %arg1, float %arg2) {
+  call void @foo(float %arg1)
+  ret void
+}
+
+declare void @foo(float %arg)

llvm/test/Transforms/DeadArgElim/sycl-kernels-neg3.ll

@@ -0,0 +1,17 @@
+; RUN: rm -rf %t && mkdir -p %t
+; RUN: echo 'static constexpr const bool param_omit_table[] = {' >> %t/int_header.h
+; RUN: echo '    // NegativeSyclKernel' >> %t/int_header.h
+; RUN: echo '    false, false,' >> %t/int_header.h
+; RUN: echo '};' >> %t/int_header.h
+; RUN: not --crash opt < %s -deadargelim-sycl -S -integr-header-file %t/int_header.h
+
+; No OMIT_TABLE markers in the integration header.
+
+target triple = "spir64-unknown-unknown-sycldevice"
+
+define weak_odr spir_kernel void @NegativeSyclKernel(float %arg1, float %arg2) {
+  call void @foo(float %arg1)
+  ret void
+}
+
+declare void @foo(float %arg)

llvm/test/Transforms/DeadArgElim/sycl-kernels-neg4.ll

@@ -0,0 +1,19 @@
+; RUN: rm -rf %t && mkdir -p %t
+; RUN: echo 'static constexpr const bool param_omit_table[] = {' >> %t/int_header.h
+; RUN: echo '  // OMIT_TABLE_BEGIN' >> %t/int_header.h
+; RUN: echo '    // WrongKernelName' >> %t/int_header.h
+; RUN: echo '    false, false,' >> %t/int_header.h
+; RUN: echo '  // OMIT_TABLE_END' >> %t/int_header.h
+; RUN: echo '};' >> %t/int_header.h
+; RUN: not --crash opt < %s -deadargelim-sycl -S -integr-header-file %t/int_header.h
+
+; Wrong kernel name in the integration header.
+
+target triple = "spir64-unknown-unknown-sycldevice"
+
+define weak_odr spir_kernel void @NegativeSyclKernel(float %arg1, float %arg2) {
+  call void @foo(float %arg1)
+  ret void
+}
+
+declare void @foo(float %arg)

llvm/test/Transforms/DeadArgElim/sycl-kernels-neg5.ll

@@ -0,0 +1,20 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
+; RUN: opt < %s -deadargelim -S | FileCheck %s
+; RUN: opt < %s -deadargelim-sycl -S | FileCheck %s
+
+; This test ensures dead arguments are not eliminated
+; from a global function that is not a SYCL kernel.
+
+target triple = "spir64-unknown-unknown-sycldevice"
+
+define weak_odr void @NotASyclKernel(float %arg1, float %arg2) {
+; CHECK-LABEL: define {{[^@]+}}@NotASyclKernel
+; CHECK-SAME: (float [[ARG1:%.*]], float [[ARG2:%.*]])
+; CHECK-NEXT:    call void @foo(float [[ARG1]])
+; CHECK-NEXT:    ret void
+;
+  call void @foo(float %arg1)
+  ret void
+}
+
+declare void @foo(float %arg)