contrib/llvm-project/llvm/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_INTRINSIC_W_SIDE_EFFECTS:
  66     switch (MI.getIntrinsicID()) {
  67     case Intrinsic::memcpy:
  68     case Intrinsic::memmove:
  69     case Intrinsic::memset: {
  70       // If we're at -O0 set a maxlen of 32 to inline, otherwise let the other
  71       // heuristics decide.
  72       unsigned MaxLen = EnableOpt ? 0 : 32;
  73       // Try to inline memcpy type calls if optimizations are enabled.
  74       return (!EnableMinSize) ? Helper.tryCombineMemCpyFamily(MI, MaxLen)
  75                               : false;
  76     }
  77     default:
  78       break;
  79     }
  80   }
  81
  82   if (Generated.tryCombineAll(Observer, MI, B, Helper))
  83     return true;
  84
  85   switch (MI.getOpcode()) {
  86   case TargetOpcode::G_CONCAT_VECTORS:
  87     return Helper.tryCombineConcatVectors(MI);
  88   case TargetOpcode::G_SHUFFLE_VECTOR:
  89     return Helper.tryCombineShuffleVector(MI);
  90   }
  91
  92   return false;
  93 }
  94
  95 #define AARCH64PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_CPP
  96 #include "AArch64GenGICombiner.inc"
  97 #undef AARCH64PRELEGALIZERCOMBINERHELPER_GENCOMBINERHELPER_CPP
  98
  99 // Pass boilerplate
 100 // ================
 101
 102 class AArch64PreLegalizerCombiner : public MachineFunctionPass {
 103 public:
 104   static char ID;
 105
 106   AArch64PreLegalizerCombiner(bool IsOptNone = false);
 107
 108   StringRef getPassName() const override { return "AArch64PreLegalizerCombiner"; }
 109
 110   bool runOnMachineFunction(MachineFunction &MF) override;
 111
 112   void getAnalysisUsage(AnalysisUsage &AU) const override;
 113 private:
 114   bool IsOptNone;
 115 };
 116 } // end anonymous namespace
 117
 118 void AArch64PreLegalizerCombiner::getAnalysisUsage(AnalysisUsage &AU) const {
 119   AU.addRequired<TargetPassConfig>();
 120   AU.setPreservesCFG();
 121   getSelectionDAGFallbackAnalysisUsage(AU);
 122   AU.addRequired<GISelKnownBitsAnalysis>();
 123   AU.addPreserved<GISelKnownBitsAnalysis>();
 124   if (!IsOptNone) {
 125     AU.addRequired<MachineDominatorTree>();
 126     AU.addPreserved<MachineDominatorTree>();
 127   }
 128   MachineFunctionPass::getAnalysisUsage(AU);
 129 }
 130
 131 AArch64PreLegalizerCombiner::AArch64PreLegalizerCombiner(bool IsOptNone)
 132     : MachineFunctionPass(ID), IsOptNone(IsOptNone) {
 133   initializeAArch64PreLegalizerCombinerPass(*PassRegistry::getPassRegistry());
 134 }
 135
 136 bool AArch64PreLegalizerCombiner::runOnMachineFunction(MachineFunction &MF) {
 137   if (MF.getProperties().hasProperty(
 138           MachineFunctionProperties::Property::FailedISel))
 139     return false;
 140   auto *TPC = &getAnalysis<TargetPassConfig>();
 141   const Function &F = MF.getFunction();
 142   bool EnableOpt =
 143       MF.getTarget().getOptLevel() != CodeGenOpt::None && !skipFunction(F);
 144   GISelKnownBits *KB = &getAnalysis<GISelKnownBitsAnalysis>().get(MF);
 145   MachineDominatorTree *MDT =
 146       IsOptNone ? nullptr : &getAnalysis<MachineDominatorTree>();
 147   AArch64PreLegalizerCombinerInfo PCInfo(EnableOpt, F.hasOptSize(),
 148                                          F.hasMinSize(), KB, MDT);
 149   Combiner C(PCInfo, TPC);
 150   return C.combineMachineInstrs(MF, /*CSEInfo*/ nullptr);
 151 }
 152
 153 char AArch64PreLegalizerCombiner::ID = 0;
 154 INITIALIZE_PASS_BEGIN(AArch64PreLegalizerCombiner, DEBUG_TYPE,
 155                       "Combine AArch64 machine instrs before legalization",
 156                       false, false)
 157 INITIALIZE_PASS_DEPENDENCY(TargetPassConfig)
 158 INITIALIZE_PASS_DEPENDENCY(GISelKnownBitsAnalysis)
 159 INITIALIZE_PASS_END(AArch64PreLegalizerCombiner, DEBUG_TYPE,
 160                     "Combine AArch64 machine instrs before legalization", false,
 161                     false)
 162
 163
 164 namespace llvm {
 165 FunctionPass *createAArch64PreLegalizeCombiner(bool IsOptNone) {
 166   return new AArch64PreLegalizerCombiner(IsOptNone);
 167 }
 168 } // end namespace llvm