llvm/lib/Target/RISCV/GISel/RISCVPostLegalizerCombiner.cpp

   1 //=== RISCVPostLegalizerCombiner.cpp --------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 ///
   9 /// \file
  10 /// Post-legalization combines on generic MachineInstrs.
  11 ///
  12 /// The combines here must preserve instruction legality.
  13 ///
  14 /// Combines which don't rely on instruction legality should go in the
  15 /// RISCVPreLegalizerCombiner.
  16 ///
  17 //===----------------------------------------------------------------------===//
  18
  19 #include "RISCVTargetMachine.h"
  20 #include "llvm/CodeGen/GlobalISel/CSEInfo.h"
  21 #include "llvm/CodeGen/GlobalISel/Combiner.h"
  22 #include "llvm/CodeGen/GlobalISel/CombinerHelper.h"
  23 #include "llvm/CodeGen/GlobalISel/CombinerInfo.h"
  24 #include "llvm/CodeGen/GlobalISel/GIMatchTableExecutorImpl.h"
  25 #include "llvm/CodeGen/GlobalISel/GISelKnownBits.h"
  26 #include "llvm/CodeGen/GlobalISel/GenericMachineInstrs.h"
  27 #include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
  28 #include "llvm/CodeGen/MachineDominators.h"
  29 #include "llvm/CodeGen/MachineFunctionPass.h"
  30 #include "llvm/CodeGen/MachineRegisterInfo.h"
  31 #include "llvm/CodeGen/TargetPassConfig.h"
  32
  33 #define GET_GICOMBINER_DEPS
  34 #include "RISCVGenPostLegalizeGICombiner.inc"
  35 #undef GET_GICOMBINER_DEPS
  36
  37 #define DEBUG_TYPE "riscv-postlegalizer-combiner"
  38
  39 using namespace llvm;
  40
  41 namespace {
  42
  43 #define GET_GICOMBINER_TYPES
  44 #include "RISCVGenPostLegalizeGICombiner.inc"
  45 #undef GET_GICOMBINER_TYPES
  46
  47 class RISCVPostLegalizerCombinerImpl : public Combiner {
  48 protected:
  49   // TODO: Make CombinerHelper methods const.
  50   mutable CombinerHelper Helper;
  51   const RISCVPostLegalizerCombinerImplRuleConfig &RuleConfig;
  52   const RISCVSubtarget &STI;
  53
  54 public:
  55   RISCVPostLegalizerCombinerImpl(
  56       MachineFunction &MF, CombinerInfo &CInfo, const TargetPassConfig *TPC,
  57       GISelKnownBits &KB, GISelCSEInfo *CSEInfo,
  58       const RISCVPostLegalizerCombinerImplRuleConfig &RuleConfig,
  59       const RISCVSubtarget &STI, MachineDominatorTree *MDT,
  60       const LegalizerInfo *LI);
  61
  62   static const char *getName() { return "RISCVPostLegalizerCombiner"; }
  63
  64   bool tryCombineAll(MachineInstr &I) const override;
  65
  66 private:
  67 #define GET_GICOMBINER_CLASS_MEMBERS
  68 #include "RISCVGenPostLegalizeGICombiner.inc"
  69 #undef GET_GICOMBINER_CLASS_MEMBERS
  70 };
  71
  72 #define GET_GICOMBINER_IMPL
  73 #include "RISCVGenPostLegalizeGICombiner.inc"
  74 #undef GET_GICOMBINER_IMPL
  75
  76 RISCVPostLegalizerCombinerImpl::RISCVPostLegalizerCombinerImpl(
  77     MachineFunction &MF, CombinerInfo &CInfo, const TargetPassConfig *TPC,
  78     GISelKnownBits &KB, GISelCSEInfo *CSEInfo,
  79     const RISCVPostLegalizerCombinerImplRuleConfig &RuleConfig,
  80     const RISCVSubtarget &STI, MachineDominatorTree *MDT,
  81     const LegalizerInfo *LI)
  82     : Combiner(MF, CInfo, TPC, &KB, CSEInfo),
  83       Helper(Observer, B, /*IsPreLegalize*/ false, &KB, MDT, LI),
  84       RuleConfig(RuleConfig), STI(STI),
  85 #define GET_GICOMBINER_CONSTRUCTOR_INITS
  86 #include "RISCVGenPostLegalizeGICombiner.inc"
  87 #undef GET_GICOMBINER_CONSTRUCTOR_INITS
  88 {
  89 }
  90
  91 class RISCVPostLegalizerCombiner : public MachineFunctionPass {
  92 public:
  93   static char ID;
  94
  95   RISCVPostLegalizerCombiner();
  96
  97   StringRef getPassName() const override {
  98     return "RISCVPostLegalizerCombiner";
  99   }
 100
 101   bool runOnMachineFunction(MachineFunction &MF) override;
 102   void getAnalysisUsage(AnalysisUsage &AU) const override;
 103
 104 private:
 105   RISCVPostLegalizerCombinerImplRuleConfig RuleConfig;
 106 };
 107 } // end anonymous namespace
 108
 109 void RISCVPostLegalizerCombiner::getAnalysisUsage(AnalysisUsage &AU) const {
 110   AU.addRequired<TargetPassConfig>();
 111   AU.setPreservesCFG();
 112   getSelectionDAGFallbackAnalysisUsage(AU);
 113   AU.addRequired<GISelKnownBitsAnalysis>();
 114   AU.addPreserved<GISelKnownBitsAnalysis>();
 115   AU.addRequired<MachineDominatorTree>();
 116   AU.addPreserved<MachineDominatorTree>();
 117   AU.addRequired<GISelCSEAnalysisWrapperPass>();
 118   AU.addPreserved<GISelCSEAnalysisWrapperPass>();
 119   MachineFunctionPass::getAnalysisUsage(AU);
 120 }
 121
 122 RISCVPostLegalizerCombiner::RISCVPostLegalizerCombiner()
 123     : MachineFunctionPass(ID) {
 124   initializeRISCVPostLegalizerCombinerPass(*PassRegistry::getPassRegistry());
 125
 126   if (!RuleConfig.parseCommandLineOption())
 127     report_fatal_error("Invalid rule identifier");
 128 }
 129
 130 bool RISCVPostLegalizerCombiner::runOnMachineFunction(MachineFunction &MF) {
 131   if (MF.getProperties().hasProperty(
 132           MachineFunctionProperties::Property::FailedISel))
 133     return false;
 134   assert(MF.getProperties().hasProperty(
 135              MachineFunctionProperties::Property::Legalized) &&
 136          "Expected a legalized function?");
 137   auto *TPC = &getAnalysis<TargetPassConfig>();
 138   const Function &F = MF.getFunction();
 139   bool EnableOpt =
 140       MF.getTarget().getOptLevel() != CodeGenOptLevel::None && !skipFunction(F);
 141
 142   const RISCVSubtarget &ST = MF.getSubtarget<RISCVSubtarget>();
 143   const auto *LI = ST.getLegalizerInfo();
 144
 145   GISelKnownBits *KB = &getAnalysis<GISelKnownBitsAnalysis>().get(MF);
 146   MachineDominatorTree *MDT = &getAnalysis<MachineDominatorTree>();
 147   GISelCSEAnalysisWrapper &Wrapper =
 148       getAnalysis<GISelCSEAnalysisWrapperPass>().getCSEWrapper();
 149   auto *CSEInfo = &Wrapper.get(TPC->getCSEConfig());
 150
 151   CombinerInfo CInfo(/*AllowIllegalOps*/ true, /*ShouldLegalizeIllegal*/ false,
 152                      /*LegalizerInfo*/ nullptr, EnableOpt, F.hasOptSize(),
 153                      F.hasMinSize());
 154   RISCVPostLegalizerCombinerImpl Impl(MF, CInfo, TPC, *KB, CSEInfo,
 155                                         RuleConfig, ST, MDT, LI);
 156   return Impl.combineMachineInstrs();
 157 }
 158
 159 char RISCVPostLegalizerCombiner::ID = 0;
 160 INITIALIZE_PASS_BEGIN(RISCVPostLegalizerCombiner, DEBUG_TYPE,
 161                       "Combine RISC-V MachineInstrs after legalization", false,
 162                       false)
 163 INITIALIZE_PASS_DEPENDENCY(TargetPassConfig)
 164 INITIALIZE_PASS_DEPENDENCY(GISelKnownBitsAnalysis)
 165 INITIALIZE_PASS_END(RISCVPostLegalizerCombiner, DEBUG_TYPE,
 166                     "Combine RISC-V MachineInstrs after legalization", false,
 167                     false)
 168
 169 namespace llvm {
 170 FunctionPass *createRISCVPostLegalizerCombiner() {
 171   return new RISCVPostLegalizerCombiner();
 172 }
 173 } // end namespace llvm