lib/Target/AArch64/AArch64PreLegalizerCombiner.cpp

   1 //=== lib/CodeGen/GlobalISel/AArch64PreLegalizerCombiner.cpp --------------===//
   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 // This pass does combining of machine instructions at the generic MI level,
  10 // before the legalizer.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "AArch64TargetMachine.h"
  15 #include "llvm/CodeGen/GlobalISel/Combiner.h"
  16 #include "llvm/CodeGen/GlobalISel/CombinerHelper.h"
  17 #include "llvm/CodeGen/GlobalISel/CombinerInfo.h"
  18 #include "llvm/CodeGen/GlobalISel/GISelKnownBits.h"
  19 #include "llvm/CodeGen/GlobalISel/MIPatternMatch.h"
  20 #include "llvm/CodeGen/MachineDominators.h"
  21 #include "llvm/CodeGen/MachineFunctionPass.h"
  22 #include "llvm/CodeGen/TargetPassConfig.h"
  23 #include "llvm/Support/Debug.h"
  24
  25 #define DEBUG_TYPE "aarch64-prelegalizer-combiner"
  26
  27 using namespace llvm;
  28 using namespace MIPatternMatch;
  29
  30 #define AARCH64PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_DEPS
  31 #include "AArch64GenGICombiner.inc"
  32 #undef AARCH64PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_DEPS
  33
  34 namespace {
  35 #define AARCH64PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_H
  36 #include "AArch64GenGICombiner.inc"
  37 #undef AARCH64PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_H
  38
  39 class AArch64PreLegalizerCombinerInfo : public CombinerInfo {
  40   GISelKnownBits *KB;
  41   MachineDominatorTree *MDT;
  42
  43 public:
  44   AArch64GenPreLegalizerCombinerHelper Generated;
  45
  46   AArch64PreLegalizerCombinerInfo(bool EnableOpt, bool OptSize, bool MinSize,
  47                                   GISelKnownBits *KB, MachineDominatorTree *MDT)
  48       : CombinerInfo(/*AllowIllegalOps*/ true, /*ShouldLegalizeIllegal*/ false,
  49                      /*LegalizerInfo*/ nullptr, EnableOpt, OptSize, MinSize),
  50         KB(KB), MDT(MDT) {
  51     if (!Generated.parseCommandLineOption())
  52       report_fatal_error("Invalid rule identifier");
  53   }
  54
  55   virtual bool combine(GISelChangeObserver &Observer, MachineInstr &MI,
  56                        MachineIRBuilder &B) const override;
  57 };
  58
  59 bool AArch64PreLegalizerCombinerInfo::combine(GISelChangeObserver &Observer,
  60                                               MachineInstr &MI,
  61                                               MachineIRBuilder &B) const {
  62   CombinerHelper Helper(Observer, B, KB, MDT);
  63
  64   switch (MI.getOpcode()) {
  65   case TargetOpcode::G_CONCAT_VECTORS:
  66     return Helper.tryCombineConcatVectors(MI);
  67   case TargetOpcode::G_LOAD:
  68   case TargetOpcode::G_SEXTLOAD:
  69   case TargetOpcode::G_ZEXTLOAD: {
  70     bool Changed = false;
  71     Changed |= Helper.tryCombineExtendingLoads(MI);
  72     Changed |= Helper.tryCombineIndexedLoadStore(MI);
  73     return Changed;
  74   }
  75   case TargetOpcode::G_STORE:
  76     return Helper.tryCombineIndexedLoadStore(MI);
  77   case TargetOpcode::G_INTRINSIC_W_SIDE_EFFECTS:
  78     switch (MI.getIntrinsicID()) {
  79     case Intrinsic::memcpy:
  80     case Intrinsic::memmove:
  81     case Intrinsic::memset: {
  82       // If we're at -O0 set a maxlen of 32 to inline, otherwise let the other
  83       // heuristics decide.
  84       unsigned MaxLen = EnableOpt ? 0 : 32;
  85       // Try to inline memcpy type calls if optimizations are enabled.
  86       return (!EnableMinSize) ? Helper.tryCombineMemCpyFamily(MI, MaxLen)
  87                               : false;
  88     }
  89     default:
  90       break;
  91     }
  92   }
  93
  94   if (Generated.tryCombineAll(Observer, MI, B))
  95     return true;
  96
  97   return false;
  98 }
  99
 100 #define AARCH64PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_CPP
 101 #include "AArch64GenGICombiner.inc"
 102 #undef AARCH64PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_CPP
 103
 104 // Pass boilerplate
 105 // ================
 106
 107 class AArch64PreLegalizerCombiner : public MachineFunctionPass {
 108 public:
 109   static char ID;
 110
 111   AArch64PreLegalizerCombiner(bool IsOptNone = false);
 112
 113   StringRef getPassName() const override { return "AArch64PreLegalizerCombiner"; }
 114
 115   bool runOnMachineFunction(MachineFunction &MF) override;
 116
 117   void getAnalysisUsage(AnalysisUsage &AU) const override;
 118 private:
 119   bool IsOptNone;
 120 };
 121 } // end anonymous namespace
 122
 123 void AArch64PreLegalizerCombiner::getAnalysisUsage(AnalysisUsage &AU) const {
 124   AU.addRequired<TargetPassConfig>();
 125   AU.setPreservesCFG();
 126   getSelectionDAGFallbackAnalysisUsage(AU);
 127   AU.addRequired<GISelKnownBitsAnalysis>();
 128   AU.addPreserved<GISelKnownBitsAnalysis>();
 129   if (!IsOptNone) {
 130     AU.addRequired<MachineDominatorTree>();
 131     AU.addPreserved<MachineDominatorTree>();
 132   }
 133   MachineFunctionPass::getAnalysisUsage(AU);
 134 }
 135
 136 AArch64PreLegalizerCombiner::AArch64PreLegalizerCombiner(bool IsOptNone)
 137     : MachineFunctionPass(ID), IsOptNone(IsOptNone) {
 138   initializeAArch64PreLegalizerCombinerPass(*PassRegistry::getPassRegistry());
 139 }
 140
 141 bool AArch64PreLegalizerCombiner::runOnMachineFunction(MachineFunction &MF) {
 142   if (MF.getProperties().hasProperty(
 143           MachineFunctionProperties::Property::FailedISel))
 144     return false;
 145   auto *TPC = &getAnalysis<TargetPassConfig>();
 146   const Function &F = MF.getFunction();
 147   bool EnableOpt =
 148       MF.getTarget().getOptLevel() != CodeGenOpt::None && !skipFunction(F);
 149   GISelKnownBits *KB = &getAnalysis<GISelKnownBitsAnalysis>().get(MF);
 150   MachineDominatorTree *MDT =
 151       IsOptNone ? nullptr : &getAnalysis<MachineDominatorTree>();
 152   AArch64PreLegalizerCombinerInfo PCInfo(EnableOpt, F.hasOptSize(),
 153                                          F.hasMinSize(), KB, MDT);
 154   Combiner C(PCInfo, TPC);
 155   return C.combineMachineInstrs(MF, /*CSEInfo*/ nullptr);
 156 }
 157
 158 char AArch64PreLegalizerCombiner::ID = 0;
 159 INITIALIZE_PASS_BEGIN(AArch64PreLegalizerCombiner, DEBUG_TYPE,
 160                       "Combine AArch64 machine instrs before legalization",
 161                       false, false)
 162 INITIALIZE_PASS_DEPENDENCY(TargetPassConfig)
 163 INITIALIZE_PASS_DEPENDENCY(GISelKnownBitsAnalysis)
 164 INITIALIZE_PASS_END(AArch64PreLegalizerCombiner, DEBUG_TYPE,
 165                     "Combine AArch64 machine instrs before legalization", false,
 166                     false)
 167
 168
 169 namespace llvm {
 170 FunctionPass *createAArch64PreLegalizeCombiner(bool IsOptNone) {
 171   return new AArch64PreLegalizerCombiner(IsOptNone);
 172 }
 173 } // end namespace llvm