1 files changed, 140 insertions, 0 deletions
diff --git a/backend/lib/CodeGen/MachineOptimizationPipeline.cpp b/backend/lib/CodeGen/MachineOptimizationPipeline.cpp
new file mode 100644
index 0000000..6fb6550
--- /dev/null
+++ b/backend/lib/CodeGen/MachineOptimizationPipeline.cpp
@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "rcc/CodeGen/MachineOptimizationPipeline.h"
+
+#include "rcc/CodeGen/LiveVariables.h"
+#include "rcc/CodeGen/MachineAnalyses.h"
+#include "rcc/CodeGen/MachineBlockPlacement.h"
+#include "rcc/CodeGen/MachineBranchOptimization.h"
+#include "rcc/CodeGen/MachineBranchRelaxation.h"
+#include "rcc/CodeGen/MachineCSE.h"
+#include "rcc/CodeGen/MachineCombiner.h"
+#include "rcc/CodeGen/MachineCopyPropagation.h"
+#include "rcc/CodeGen/MachineDCE.h"
+#include "rcc/CodeGen/MachineFinalization.h"
+#include "rcc/CodeGen/MachineLICM.h"
+#include "rcc/CodeGen/MachineMemoryFolding.h"
+#include "rcc/CodeGen/MachinePeepholeOptimizer.h"
+#include "rcc/CodeGen/MachinePseudoExpansion.h"
+#include "rcc/CodeGen/MachineScheduler.h"
+#include "rcc/CodeGen/MachineShrinkWrapping.h"
+#include "rcc/CodeGen/MachineSink.h"
+#include "rcc/CodeGen/MachineStackSlotColoring.h"
+#include "rcc/CodeGen/MachineTailDuplication.h"
+#include "rcc/CodeGen/PostRAScheduler.h"
+#include "rcc/CodeGen/PrologueEpilogueInsertion.h"
+
+#include <memory>
+#include <utility>
+
+namespace rcc {
+namespace {
+
+template <typename Pass, typename... Arguments>
+[[nodiscard]] Expected<void> addPass(MachineFunctionPassManager &Pipeline, Arguments &&...Values) {
+  return Pipeline.addPass(std::make_unique<Pass>(std::forward<Arguments>(Values)...));
+}
+
+} // namespace
+
+Expected<void> registerMachineOptimizationAnalyses(MachineFunctionAnalysisManager &Analyses) {
+  auto Registered = registerStage8MachineAnalyses(Analyses);
+  if (!Registered)
+    return std::unexpected(Registered.error());
+  return registerStage11MachineAnalyses(Analyses);
+}
+
+Expected<void>
+addSelectedSSAOptimizationPipeline(MachineFunctionPassManager &Pipeline,
+                                   const MachineOptimizationPipelineTargetInfo &TargetInfo) {
+  auto Added = addPass<MachineCombinerPass>(Pipeline, TargetInfo.Combiner);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachineMemoryFoldingPass>(Pipeline, TargetInfo.MemoryFolding);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachineCSEPass>(Pipeline);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachineDCEPass>(Pipeline);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachineLICMPass>(Pipeline, MachineCodeMotionStage::SelectedSSA);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachineSinkPass>(Pipeline, MachineCodeMotionStage::SelectedSSA);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachinePeepholeOptimizerPass>(Pipeline, TargetInfo.InstrInfo);
+  if (!Added)
+    return std::unexpected(Added.error());
+  return addPass<MachineDCEPass>(Pipeline);
+}
+
+Expected<void> addPreRegisterAllocationOptimizationPipeline(
+    MachineFunctionPassManager &Pipeline, const MachineOptimizationPipelineTargetInfo &TargetInfo) {
+  return addPass<MachineSchedulerPass>(Pipeline, TargetInfo.SchedulingModel,
+                                       TargetInfo.SchedulerOptions);
+}
+
+Expected<void> addPostRegisterAllocationPipeline(
+    MachineFunctionPassManager &Pipeline, const MachineOptimizationPipelineTargetInfo &TargetInfo,
+    MachineOptimizationPipelineOptions Options,
+    MachineFunctionPassManager::PassList PostRAPseudoExpansionTargetPasses) {
+  auto Added = addPass<MachineStackSlotColoringPass>(Pipeline);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachineLICMPass>(Pipeline, MachineCodeMotionStage::PostRegisterAllocation);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachineSinkPass>(Pipeline, MachineCodeMotionStage::PostRegisterAllocation);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachineShrinkWrappingPass>(Pipeline, TargetInfo.FrameLowering);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<PrologueEpilogueInsertionPass>(Pipeline, TargetInfo.FrameLowering,
+                                                 TargetInfo.FrameOptions);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachineBranchOptimizationPass>(Pipeline, TargetInfo.InstrInfo);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachineTailDuplicationPass>(Pipeline, TargetInfo.InstrInfo);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachineCopyPropagationPass>(
+      Pipeline, TargetInfo.InstrInfo,
+      MachineCopyPropagationOptions{.UseTargetCopyInstructions =
+                                        Options.UseTargetCopyInstructions});
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<ExpandPostRAPseudosPass>(Pipeline, TargetInfo.PseudoExpansion);
+  if (!Added)
+    return std::unexpected(Added.error());
+  for (std::unique_ptr<MachineFunctionPass> &TargetPass : PostRAPseudoExpansionTargetPasses) {
+    Added = Pipeline.addPass(std::move(TargetPass));
+    if (!Added)
+      return std::unexpected(Added.error());
+  }
+  Added = addPass<PostRASchedulerPass>(Pipeline, TargetInfo.SchedulingModel,
+                                       TargetInfo.SchedulerOptions);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachineBlockPlacementPass>(Pipeline);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<MachineBranchRelaxationPass>(Pipeline, TargetInfo.InstrInfo);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<TargetLatePseudoExpansionPass>(Pipeline, TargetInfo.PseudoExpansion,
+                                                 TargetInfo.InstrInfo);
+  if (!Added)
+    return std::unexpected(Added.error());
+  Added = addPass<FinalizeEmissionPseudosPass>(Pipeline);
+  if (!Added)
+    return std::unexpected(Added.error());
+  return addPass<FinalEncodabilityVerifierPass>(Pipeline, TargetInfo.InstrInfo);
+}
+
+} // namespace rcc