Legacy Pass Manager wrapper for the ADCE pass

This change introduces an initial wrapper for the
ADCE pass. The wrapper allows the New Pass
Manager's implementation of the ADCE pass to be
executed using the Legacy Pass Manager
infrastructure.

Author: michalpaszkowski

IGC/CMakeLists.txt

@@ -1660,6 +1660,7 @@ set(IGC_BUILD__SRC__IGC__igc_common
 set(IGC_BUILD__SRC__IGC__igc_dll
     ${IGC_BUILD__SRC__IGC__igc_common}
     ${IGC_BUILD__SRC__IGC_DriverInterface__igc_dll}
+    ${IGC_WrapperLLVM_SRC}
   )
 
 

IGC/Compiler/CISACodeGen/ShaderCodeGen.cpp

@@ -156,6 +156,7 @@ SPDX-License-Identifier: MIT
 #include <llvm/Transforms/Utils.h>
 #include <llvm/Transforms/Scalar.h>
 #include <llvm/Bitcode/BitcodeWriter.h>
+#include "llvmWrapper/Transforms/Scalar/ADCE.h"
 #include "common/LLVMWarningsPop.hpp"
 #include "Compiler/CISACodeGen/PatternMatchPass.hpp"
 #include "Compiler/CISACodeGen/EmitVISAPass.hpp"
@@ -557,7 +558,7 @@ void AddLegalizationPasses(CodeGenContext &ctx, IGCPassManager &mpm, PSSignature
     // DCE doesn't remove dead control flow; ADCE does (currently)
     // otherwise you'd have to call createCFGSimplificationPass and DCE
     // iteratively e.g..
-    mpm.add(llvm::createAggressiveDCEPass());
+    mpm.add(IGCLLVM::createLegacyWrappedADCEPass());
     // TODO: we probably should be running other passes on the result
 
     if (!IGC::ForceAlwaysInline(&ctx)) {
@@ -811,7 +812,7 @@ void AddLegalizationPasses(CodeGenContext &ctx, IGCPassManager &mpm, PSSignature
       mpm.add(llvm::createLICMPass(100, 500, true));
       mpm.add(llvm::createEarlyCSEPass());
     }
-    mpm.add(createAggressiveDCEPass());
+    mpm.add(IGCLLVM::createLegacyWrappedADCEPass());
     // As DPC++ FE apply LICM we cannot reduce register pressure just
     // by turning off LICM at IGC in some cases so apply sinking address arithmetic
     if ((IGC_IS_FLAG_ENABLED(ForceAddressArithSinking) ||
@@ -1477,7 +1478,7 @@ void OptimizeIR(CodeGenContext *const pContext) {
 
       mpm.add(llvm::createDeadCodeEliminationPass());
       if (!extensiveShader(pContext))
-        mpm.add(llvm::createAggressiveDCEPass());
+        mpm.add(IGCLLVM::createLegacyWrappedADCEPass());
 
       mpm.add(new BreakConstantExpr());
       mpm.add(new IGCConstProp(IGC_IS_FLAG_ENABLED(EnableSimplifyGEP)));
@@ -1726,7 +1727,7 @@ void OptimizeIR(CodeGenContext *const pContext) {
     }
     if (IGC_IS_FLAG_ENABLED(EnableVectorizer)) {
       mpm.add(new IGCVectorizer());
-      mpm.add(llvm::createAggressiveDCEPass());
+      mpm.add(IGCLLVM::createLegacyWrappedADCEPass());
       if (IGC_IS_FLAG_ENABLED(VectorizerCheckScalarizer))
         mpm.add(createScalarizerPass(SelectiveScalarizer::Auto));
     }

IGC/WrapperLLVM/CMakeLists.txt

@@ -68,10 +68,15 @@ set(IGC_WrapperLLVM_HDR
     "${CMAKE_CURRENT_SOURCE_DIR}/include/llvmWrapper/Transforms/Utils/ScalarEvolutionExpander.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/llvmWrapper/Transforms/Utils/ValueMapper.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/llvmWrapper/Transforms/Utils/BasicBlockUtils.h"
-
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/llvmWrapper/Transforms/InitializePasses.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/llvmWrapper/Transforms/Scalar/ADCE.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/include/lldWrapper/Common/Driver.h"
   )
 
+set(IGC_WrapperLLVM_SRC
+    "${CMAKE_CURRENT_SOURCE_DIR}/lib/llvmWrapper/Transforms/Scalar/ADCE.cpp"
+  )
+
 include_directories(
     "${CMAKE_CURRENT_SOURCE_DIR}/include"
     "${CMAKE_CURRENT_SOURCE_DIR}"
@@ -90,6 +95,8 @@ igc_sg_register(
     "WrapperLLVM"
     FILES
       ${IGC_WrapperLLVM_HDR}
+      ${IGC_WrapperLLVM_SRC}
   )
 
 set(IGC_WrapperLLVM_HDR ${IGC_WrapperLLVM_HDR} PARENT_SCOPE)
+set(IGC_WrapperLLVM_SRC ${IGC_WrapperLLVM_SRC} PARENT_SCOPE)

IGC/WrapperLLVM/include/llvmWrapper/Transforms/InitializePasses.h

@@ -0,0 +1,18 @@
+/*========================== begin_copyright_notice ============================
+
+Copyright (C) 2025 Intel Corporation
+
+SPDX-License-Identifier: MIT
+
+============================= end_copyright_notice ===========================*/
+
+#ifndef IGCLLVM_TRANSFORMS_INITIALIZE_PASSES_H
+#define IGCLLVM_TRANSFORMS_INITIALIZE_PASSES_H
+
+namespace llvm {
+class PassRegistry;
+}
+
+void initializeADCELegacyPassWrapperPass(llvm::PassRegistry &);
+
+#endif // IGCLLVM_TRANSFORMS_INITIALIZE_PASSES_H

IGC/WrapperLLVM/include/llvmWrapper/Transforms/Scalar/ADCE.h

@@ -0,0 +1,37 @@
+/*========================== begin_copyright_notice ============================
+
+Copyright (C) 2025 Intel Corporation
+
+SPDX-License-Identifier: MIT
+
+============================= end_copyright_notice ===========================*/
+
+#ifndef IGCLLVM_TRANSFORMS_SCALAR_LEGACY_ADCE_H
+#define IGCLLVM_TRANSFORMS_SCALAR_LEGACY_ADCE_H
+
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/Pass.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Passes/PassBuilder.h"
+
+using namespace llvm;
+
+namespace IGCLLVM {
+
+struct ADCELegacyPassWrapper : public FunctionPass {
+  ADCELegacyPassWrapper();
+  static char ID;
+
+  bool runOnFunction(llvm::Function &F);
+  void getAnalysisUsage(AnalysisUsage &AU) const;
+
+private:
+  FunctionAnalysisManager FAM;
+  PassBuilder PB;
+};
+
+FunctionPass *createLegacyWrappedADCEPass();
+
+} // end namespace IGCLLVM
+
+#endif // IGCLLVM_TRANSFORMS_SCALAR_LEGACY_ADCE_H

IGC/WrapperLLVM/lib/llvmWrapper/Transforms/Scalar/ADCE.cpp

@@ -0,0 +1,74 @@
+/*========================== begin_copyright_notice ============================
+
+Copyright (C) 2025 Intel Corporation
+
+SPDX-License-Identifier: MIT
+
+============================= end_copyright_notice ===========================*/
+
+#include "llvmWrapper/Transforms/Scalar/ADCE.h"
+
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Transforms/Scalar/ADCE.h"
+#include "llvm/Analysis/GlobalsModRef.h"
+#include "llvm/Analysis/PostDominators.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/IR/Value.h"
+#include "llvm/Pass.h"
+#include "llvm/Passes/PassBuilder.h"
+
+#include "llvmWrapper/Transforms/InitializePasses.h"
+#include "Compiler/IGCPassSupport.h"
+
+using namespace llvm;
+
+namespace IGCLLVM {
+
+ADCELegacyPassWrapper::ADCELegacyPassWrapper() : FunctionPass(ID) {
+  initializeADCELegacyPassPass(*PassRegistry::getPassRegistry());
+  PB.registerFunctionAnalyses(FAM);
+}
+
+bool ADCELegacyPassWrapper::runOnFunction(Function &F) {
+  // The legacy pass manager implementation of the pass used to skip some functions. In the new pass manager
+  // implementation this is done globally through the pass manager. Check and skip explicitly here to preserve the old
+  // behavior.
+  if (skipFunction(F))
+    return false;
+
+  // Run the New Pass Manager implementation of the pass. Note, there is no need to inject any analyses for
+  // PostDominatorTree as ADCE does not actually use it but only "requires" it to mark it as preserved.
+  ADCEPass Implementation;
+  Implementation.run(F, FAM);
+  return true;
+}
+
+void ADCELegacyPassWrapper::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.addRequired<PostDominatorTreeWrapperPass>();
+  AU.addPreserved<DominatorTreeWrapperPass>();
+  AU.addPreserved<PostDominatorTreeWrapperPass>();
+  AU.addPreserved<GlobalsAAWrapperPass>();
+}
+
+char ADCELegacyPassWrapper::ID = 0;
+FunctionPass *createLegacyWrappedADCEPass() {
+// For LLVM versions older than 16, use the legacy ADCE pass implementation. The new pass manager implementation has a
+// bit different handling of CFG analyses preservation.
+#if LLVM_VERSION_MAJOR < 16
+  return llvm::createAggressiveDCEPass();
+#endif
+
+  return new ADCELegacyPassWrapper();
+}
+
+} // namespace IGCLLVM
+
+using namespace IGCLLVM;
+#define PASS_FLAG "adce-legacy-wrapped"
+#define PASS_DESCRIPTION "Aggressive Dead Code Elimination LPM Wrapped"
+#define PASS_CFG_ONLY false
+#define PASS_ANALYSIS false
+IGC_INITIALIZE_PASS_BEGIN(ADCELegacyPassWrapper, PASS_FLAG, PASS_DESCRIPTION, PASS_CFG_ONLY, PASS_ANALYSIS)
+IGC_INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
+IGC_INITIALIZE_PASS_END(ADCELegacyPassWrapper, PASS_FLAG, PASS_DESCRIPTION, PASS_CFG_ONLY, PASS_ANALYSIS)