[llvm-branch-commits] [LoongArch] Introduce LoongArchCodeGenPassBuilder (PR #244946)

via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Sat Nov 21 14:06:07 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-backend-loongarch

Author: Aiden Grossman (boomanaiden154)

<details>
<summary>Changes</summary>

Standard NewPM pipeline setup intentionally mirroring the existing
LoongArchTargetPassConfig as closely as possible.


---
Full diff: https://github.com/llvm/llvm-project/pull/244946.diff


6 Files Affected:

- (modified) llvm/lib/Target/LoongArch/CMakeLists.txt (+2) 
- (added) llvm/lib/Target/LoongArch/LoongArchCodeGenPassBuilder.cpp (+169) 
- (added) llvm/lib/Target/LoongArch/LoongArchPassRegistry.def (+21) 
- (modified) llvm/lib/Target/LoongArch/LoongArchTargetMachine.cpp (+4-4) 
- (modified) llvm/lib/Target/LoongArch/LoongArchTargetMachine.h (+8) 
- (added) llvm/test/CodeGen/LoongArch/newpm-pipeline.ll (+143) 


``````````diff
diff --git a/llvm/lib/Target/LoongArch/CMakeLists.txt b/llvm/lib/Target/LoongArch/CMakeLists.txt
index 739f0f3d65b0e..fba52fa7bd310 100644
--- a/llvm/lib/Target/LoongArch/CMakeLists.txt
+++ b/llvm/lib/Target/LoongArch/CMakeLists.txt
@@ -17,6 +17,7 @@ add_public_tablegen_target(LoongArchCommonTableGen)
 
 add_llvm_target(LoongArchCodeGen
   LoongArchAsmPrinter.cpp
+  LoongArchCodeGenPassBuilder.cpp
   LoongArchDeadRegisterDefinitions.cpp
   LoongArchExpandAtomicPseudoInsts.cpp
   LoongArchExpandPseudoInsts.cpp
@@ -45,6 +46,7 @@ add_llvm_target(LoongArchCodeGen
   LoongArchDesc
   LoongArchInfo
   MC
+  Passes
   Scalar
   SelectionDAG
   Support
diff --git a/llvm/lib/Target/LoongArch/LoongArchCodeGenPassBuilder.cpp b/llvm/lib/Target/LoongArch/LoongArchCodeGenPassBuilder.cpp
new file mode 100644
index 0000000000000..2a8b3f09fa4a7
--- /dev/null
+++ b/llvm/lib/Target/LoongArch/LoongArchCodeGenPassBuilder.cpp
@@ -0,0 +1,169 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "LoongArch.h"
+#include "LoongArchTargetMachine.h"
+#include "llvm/CodeGen/AtomicExpand.h"
+#include "llvm/CodeGen/BranchRelaxation.h"
+#include "llvm/CodeGen/MachineCombiner.h"
+#include "llvm/CodeGen/TypePromotion.h"
+#include "llvm/IR/PassInstrumentation.h"
+#include "llvm/Passes/CodeGenPassBuilder.h"
+#include "llvm/Passes/PassBuilder.h"
+#include "llvm/Support/CodeGen.h"
+#include "llvm/Target/CGPassBuilderOption.h"
+#include "llvm/Transforms/Scalar/LoopDataPrefetch.h"
+
+using namespace llvm;
+
+extern cl::opt<bool> EnableLoopDataPrefetch;
+extern cl::opt<bool> EnableMachineCombiner;
+extern cl::opt<bool> EnableMergeBaseOffset;
+extern cl::opt<bool> EnableLoongArchDeadRegisterElimination;
+
+namespace {
+
+class LoongArchCodeGenPassBuilder : public CodeGenPassBuilder {
+  using Base = CodeGenPassBuilder;
+
+  LoongArchTargetMachine &getTM() const {
+    return static_cast<LoongArchTargetMachine &>(TM);
+  }
+
+public:
+  explicit LoongArchCodeGenPassBuilder(LoongArchTargetMachine &TM,
+                                       const CGPassBuilderOption &Opts,
+                                       PassInstrumentationCallbacks *PIC)
+      : CodeGenPassBuilder(TM, Opts, PIC) {}
+
+protected:
+  void addIRPasses(PassManagerWrapper &PMW) override;
+  void addCodeGenPrepare(PassManagerWrapper &PMW) override;
+  Error addInstSelector(PassManagerWrapper &PMW) override;
+  void addMachineSSAOptimization(PassManagerWrapper &PMW) override;
+  void addILPOpts(PassManagerWrapper &PMW) override;
+  void addPreRegAlloc(PassManagerWrapper &PMW) override;
+  Error addRegAssignAndRewriteFast(PassManagerWrapper &PMW) override;
+  Expected<bool>
+  addRegAssignAndRewriteOptimized(PassManagerWrapper &PMW) override;
+  void addPreEmitPass(PassManagerWrapper &PMW) override;
+  void addPreEmitPass2(PassManagerWrapper &PMW) override;
+  void addAsmPrinterBegin(PassManagerWrapper &PMW) override;
+  void addAsmPrinter(PassManagerWrapper &PMW) override;
+  void addAsmPrinterEnd(PassManagerWrapper &PMW) override;
+};
+
+} // namespace
+
+void LoongArchCodeGenPassBuilder::addIRPasses(PassManagerWrapper &PMW) {
+  // Run LoopDataPrefetch
+  //
+  // Run this before LSR to remove the multiplies involved in computing the
+  // pointer values N iterations ahead.
+  if (getOptLevel() != CodeGenOptLevel::None && EnableLoopDataPrefetch)
+    addFunctionPass(LoopDataPrefetchPass(), PMW);
+  addFunctionPass(AtomicExpandPass(getTM()), PMW);
+
+  Base::addIRPasses(PMW);
+}
+
+void LoongArchCodeGenPassBuilder::addCodeGenPrepare(PassManagerWrapper &PMW) {
+  if (getOptLevel() != CodeGenOptLevel::None)
+    addFunctionPass(TypePromotionPass(getTM()), PMW);
+
+  Base::addCodeGenPrepare(PMW);
+}
+
+Error LoongArchCodeGenPassBuilder::addInstSelector(PassManagerWrapper &PMW) {
+  addMachineFunctionPass(LoongArchISelDAGToDAGPass(getTM(), getOptLevel()),
+                         PMW);
+
+  return Error::success();
+}
+
+void LoongArchCodeGenPassBuilder::addMachineSSAOptimization(
+    PassManagerWrapper &PMW) {
+  Base::addMachineSSAOptimization(PMW);
+
+  if (getTM().getTargetTriple().isLoongArch64()) {
+    // TODO(boomanaiden154): Add LoongArchOptWInstrsPass
+  }
+}
+
+void LoongArchCodeGenPassBuilder::addILPOpts(PassManagerWrapper &PMW) {
+  if (EnableMachineCombiner)
+    addMachineFunctionPass(MachineCombinerPass(), PMW);
+}
+
+void LoongArchCodeGenPassBuilder::addPreRegAlloc(PassManagerWrapper &PMW) {
+  // TODO(boomanaiden154): Add LoongArchPreRAExpandPseudoPass
+  if (getOptLevel() != CodeGenOptLevel::None && EnableMergeBaseOffset) {
+    // TODO(boomanaiden154): Add LoongArchMergeBaseOffsetOptPass
+  }
+}
+
+Error LoongArchCodeGenPassBuilder::addRegAssignAndRewriteFast(
+    PassManagerWrapper &PMW) {
+  if (getOptLevel() != CodeGenOptLevel::None &&
+      EnableLoongArchDeadRegisterElimination) {
+    // TODO(boomanaiden154): Add LoongArchDeadRegisterDefinitionsPass
+  }
+
+  return Base::addRegAssignAndRewriteFast(PMW);
+}
+
+Expected<bool> LoongArchCodeGenPassBuilder::addRegAssignAndRewriteOptimized(
+    PassManagerWrapper &PMW) {
+  if (getOptLevel() != CodeGenOptLevel::None &&
+      EnableLoongArchDeadRegisterElimination) {
+    // TODO(boomanaiden154): Add LoongArchDeadRegisterDefinitionsPass
+  }
+
+  return Base::addRegAssignAndRewriteOptimized(PMW);
+}
+
+void LoongArchCodeGenPassBuilder::addPreEmitPass(PassManagerWrapper &PMW) {
+  addMachineFunctionPass(BranchRelaxationPass(), PMW);
+}
+
+void LoongArchCodeGenPassBuilder::addPreEmitPass2(PassManagerWrapper &PMW) {
+  // TODO(boomanaiden154): Add LoongArchExpandPseudosPass
+  // Schedule the expansion of AtomicPseudos at the last possible moment,
+  // avoiding the possibility for other passes to break the requirements for
+  // forward progress in the LL/SC block.
+  // TODO(boomanaiden154): Add LoongArchExpandAtomicPseudoPass
+  if (getOptLevel() != CodeGenOptLevel::None) {
+    // TODO(boomanaiden154): Add LoongArchMemoryBarrierOptPass
+  }
+}
+
+void LoongArchCodeGenPassBuilder::addAsmPrinterBegin(PassManagerWrapper &PMW) {
+  // TODO(boomanaiden154): Add LoongArchAsmPrinterBeginPass
+}
+
+void LoongArchCodeGenPassBuilder::addAsmPrinter(PassManagerWrapper &PMW) {
+  // TODO(boomanaiden154): Add LoongArchAsmPrinterPass
+}
+
+void LoongArchCodeGenPassBuilder::addAsmPrinterEnd(PassManagerWrapper &PMW) {
+  // TODO(boomanaiden154): Add LoongArchAsmPrinterEndPass
+}
+
+void LoongArchTargetMachine::registerPassBuilderCallbacks(PassBuilder &PB){
+#define GET_PASS_REGISTRY "LoongArchPassRegistry.def"
+#include "llvm/Passes/TargetPassRegistry.inc"
+}
+
+Error LoongArchTargetMachine::buildCodeGenPipeline(
+    ModulePassManager &MPM, ModuleAnalysisManager &MAM, raw_pwrite_stream &Out,
+    raw_pwrite_stream *DwoOut, CodeGenFileType FileType,
+    const CGPassBuilderOption &Opt, MCContext &Ctx,
+    PassInstrumentationCallbacks *PIC) {
+  auto CGPB = LoongArchCodeGenPassBuilder(*this, Opt, PIC);
+  return CGPB.buildPipeline(MPM, MAM, Out, DwoOut, FileType, Ctx);
+}
diff --git a/llvm/lib/Target/LoongArch/LoongArchPassRegistry.def b/llvm/lib/Target/LoongArch/LoongArchPassRegistry.def
new file mode 100644
index 0000000000000..20bd9e1411659
--- /dev/null
+++ b/llvm/lib/Target/LoongArch/LoongArchPassRegistry.def
@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is used as the registry of passes that are part of the LoongArch
+// backend.
+//
+//===----------------------------------------------------------------------===//
+
+// NOTE: NO INCLUDE GUARD DESIRED!
+
+#ifndef MACHINE_FUNCTION_PASS
+#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS)
+#endif
+MACHINE_FUNCTION_PASS("loongarch-isel",
+                      LoongArchISelDAGToDAGPass(*this, getOptLevel()))
+#undef MACHINE_FUNCTION_PASS
diff --git a/llvm/lib/Target/LoongArch/LoongArchTargetMachine.cpp b/llvm/lib/Target/LoongArch/LoongArchTargetMachine.cpp
index f594abf059305..989e86f6868b6 100644
--- a/llvm/lib/Target/LoongArch/LoongArchTargetMachine.cpp
+++ b/llvm/lib/Target/LoongArch/LoongArchTargetMachine.cpp
@@ -47,19 +47,19 @@ LLVMInitializeLoongArchTarget() {
   initializeLoongArchLateBranchOptPass(*PR);
 }
 
-static cl::opt<bool> EnableLoongArchDeadRegisterElimination(
+cl::opt<bool> EnableLoongArchDeadRegisterElimination(
     "loongarch-enable-dead-defs", cl::Hidden,
     cl::desc("Enable the pass that removes dead"
              " definitons and replaces stores to"
              " them with stores to r0"),
     cl::init(true));
 
-static cl::opt<bool>
+cl::opt<bool>
     EnableLoopDataPrefetch("loongarch-enable-loop-data-prefetch", cl::Hidden,
                            cl::desc("Enable the loop data prefetch pass"),
                            cl::init(true));
 
-static cl::opt<bool>
+cl::opt<bool>
     EnableMergeBaseOffset("loongarch-enable-merge-offset",
                           cl::desc("Enable the merge base offset pass"),
                           cl::init(true), cl::Hidden);
@@ -69,7 +69,7 @@ static cl::opt<bool>
                    cl::desc("Enable sinking and folding of instruction copies"),
                    cl::init(true), cl::Hidden);
 
-static cl::opt<bool>
+cl::opt<bool>
     EnableMachineCombiner("loongarch-enable-machine-combiner",
                           cl::desc("Enable the machine combiner pass"),
                           cl::init(true), cl::Hidden);
diff --git a/llvm/lib/Target/LoongArch/LoongArchTargetMachine.h b/llvm/lib/Target/LoongArch/LoongArchTargetMachine.h
index 5bcfa67fdfa9c..b0cf6a7f3c0d2 100644
--- a/llvm/lib/Target/LoongArch/LoongArchTargetMachine.h
+++ b/llvm/lib/Target/LoongArch/LoongArchTargetMachine.h
@@ -51,6 +51,14 @@ class LoongArchTargetMachine : public CodeGenTargetMachineImpl {
                            unsigned DestAS) const override {
     return true;
   }
+
+  void registerPassBuilderCallbacks(PassBuilder &PB) override;
+
+  Error buildCodeGenPipeline(ModulePassManager &MPM, ModuleAnalysisManager &MAM,
+                             raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
+                             CodeGenFileType FileType,
+                             const CGPassBuilderOption &Opt, MCContext &Ctx,
+                             PassInstrumentationCallbacks *PIC) override;
 };
 
 } // end namespace llvm
diff --git a/llvm/test/CodeGen/LoongArch/newpm-pipeline.ll b/llvm/test/CodeGen/LoongArch/newpm-pipeline.ll
new file mode 100644
index 0000000000000..35b05630b1467
--- /dev/null
+++ b/llvm/test/CodeGen/LoongArch/newpm-pipeline.ll
@@ -0,0 +1,143 @@
+; RUN: llc -enable-new-pm -mtriple=loongarch64 -O0 -print-pipeline-passes=tree < %s 2>&1 \
+; RUN:   | FileCheck %s --check-prefix=O0
+; RUN: llc -enable-new-pm -mtriple=loongarch32 -print-pipeline-passes=tree < %s 2>&1 \
+; RUN:   | FileCheck %s --check-prefix=O2
+; RUN: llc -enable-new-pm -mtriple=loongarch64 -print-pipeline-passes=tree < %s 2>&1 \
+; RUN:   | FileCheck %s --check-prefix=O2
+
+; O0: require<MachineModuleAnalysis>
+; O0-NEXT: require<profile-summary>
+; O0-NEXT: require<collector-metadata>
+; O0-NEXT: require<runtime-libcall-info>
+; O0-NEXT: require<libcall-lowering-info>
+; O0-NEXT: pre-isel-intrinsic-lowering
+; O0-NEXT: function
+; O0-NEXT:   expand-ir-insts<O0>
+; O0-NEXT:   atomic-expand
+; O0-NEXT:   verify
+; O0-NEXT:   gc-lowering
+; O0-NEXT: shadow-stack-gc-lowering
+; O0-NEXT: function
+; O0-NEXT:   unreachableblockelim
+; O0-NEXT:   ee-instrument<post-inline>
+; O0-NEXT:   scalarize-masked-mem-intrin
+; O0-NEXT:   expand-reductions
+; O0-NEXT:   sjlj-eh-prepare
+; O0-NEXT:   dwarf-eh-prepare
+; O0-NEXT:   inline-asm-prepare
+; O0-NEXT:   safe-stack
+; O0-NEXT:   stack-protector
+; O0-NEXT:   verify
+; O0-NEXT: function
+; O0-NEXT:   machine-function
+; O0-NEXT:     loongarch-isel
+; O0-NEXT:     finalize-isel
+; O0-NEXT:     localstackalloc
+; O0-NEXT:     phi-node-elimination
+; O0-NEXT:     regallocfast
+; O0-NEXT:     remove-redundant-debug-values
+; O0-NEXT:     fixup-statepoint-caller-saved
+; O0-NEXT:     prolog-epilog
+; O0-NEXT:     post-ra-pseudos
+; O0-NEXT:     fentry-insert
+; O0-NEXT:     xray-instrumentation
+; O0-NEXT:     patchable-function
+; O0-NEXT:     branch-relaxation
+; O0-NEXT:     funclet-layout
+; O0-NEXT:     remove-loads-into-fake-uses
+; O0-NEXT:     StackMapLivenessPass
+; O0-NEXT:     live-debug-values
+; O0-NEXT:     machine-sanmd
+; O0-NEXT:     stack-frame-layout
+; O0-NEXT:     verify
+; O0-NEXT:   free-machine-function
+
+; O2: require<MachineModuleAnalysis>
+; O2-NEXT: require<profile-summary>
+; O2-NEXT: require<collector-metadata>
+; O2-NEXT: require<runtime-libcall-info>
+; O2-NEXT: require<libcall-lowering-info>
+; O2-NEXT: function
+; O2-NEXT:   objc-arc-contract
+; O2-NEXT: pre-isel-intrinsic-lowering
+; O2-NEXT: function
+; O2-NEXT:   expand-ir-insts<O2>
+; O2-NEXT:   loop-data-prefetch
+; O2-NEXT:   atomic-expand
+; O2-NEXT:   verify
+; O2-NEXT:   loop
+; O2-NEXT:     canon-freeze
+; O2-NEXT:     loop-reduce
+; O2-NEXT:   gc-lowering
+; O2-NEXT: shadow-stack-gc-lowering
+; O2-NEXT: function
+; O2-NEXT:   unreachableblockelim
+; O2-NEXT:   consthoist
+; O2-NEXT:   replace-with-veclib
+; O2-NEXT:   partially-inline-libcalls
+; O2-NEXT:   ee-instrument<post-inline>
+; O2-NEXT:   scalarize-masked-mem-intrin
+; O2-NEXT:   expand-reductions
+; O2-NEXT:   typepromotion
+; O2-NEXT:   codegenprepare
+; O2-NEXT:   sjlj-eh-prepare
+; O2-NEXT:   dwarf-eh-prepare
+; O2-NEXT:   inline-asm-prepare
+; O2-NEXT:   safe-stack
+; O2-NEXT:   stack-protector
+; O2-NEXT:   verify
+; O2-NEXT: function
+; O2-NEXT:   machine-function
+; O2-NEXT:     loongarch-isel
+; O2-NEXT:     finalize-isel
+; O2-NEXT:     early-tailduplication
+; O2-NEXT:     opt-phis
+; O2-NEXT:     stack-coloring
+; O2-NEXT:     localstackalloc
+; O2-NEXT:     dead-mi-elimination
+; O2-NEXT:     machine-combiner
+; O2-NEXT:     early-machinelicm
+; O2-NEXT:     machine-cse
+; O2-NEXT:     machine-sink
+; O2-NEXT:     peephole-opt
+; O2-NEXT:     dead-mi-elimination
+; O2-NEXT:     detect-dead-lanes
+; O2-NEXT:     init-undef
+; O2-NEXT:     process-implicit-defs
+; O2-NEXT:     unreachable-mbb-elimination
+; O2-NEXT:     require<live-intervals>
+; O2-NEXT:     require<machine-loops>
+; O2-NEXT:     phi-node-elimination
+; O2-NEXT:     two-address-instruction
+; O2-NEXT:     register-coalescer
+; O2-NEXT:     rename-independent-subregs
+; O2-NEXT:     machine-scheduler
+; O2-NEXT:     greedy<all>
+; O2-NEXT:     virt-reg-rewriter
+; O2-NEXT:     stack-slot-coloring
+; O2-NEXT:     machine-cp
+; O2-NEXT:     machinelicm
+; O2-NEXT:     remove-redundant-debug-values
+; O2-NEXT:     fixup-statepoint-caller-saved
+; O2-NEXT:     postra-machine-sink
+; O2-NEXT:     shrink-wrap
+; O2-NEXT:     prolog-epilog
+; O2-NEXT:     machine-latecleanup
+; O2-NEXT:     branch-folder
+; O2-NEXT:     tailduplication
+; O2-NEXT:     machine-cp
+; O2-NEXT:     post-ra-pseudos
+; O2-NEXT:     post-RA-sched
+; O2-NEXT:     block-placement
+; O2-NEXT:     fentry-insert
+; O2-NEXT:     xray-instrumentation
+; O2-NEXT:     patchable-function
+; O2-NEXT:     branch-relaxation
+; O2-NEXT:     funclet-layout
+; O2-NEXT:     remove-loads-into-fake-uses
+; O2-NEXT:     StackMapLivenessPass
+; O2-NEXT:     live-debug-values
+; O2-NEXT:     machine-sanmd
+; O2-NEXT:     stack-frame-layout
+; O2-NEXT:     verify
+; O2-NEXT:   free-machine-function

``````````

</details>


https://github.com/llvm/llvm-project/pull/244946


More information about the llvm-branch-commits mailing list