llvm/unittests/CodeGen/RegAllocScoreTest.cpp

   1 //===- MachineInstrTest.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 #include "../lib/CodeGen/RegAllocScore.h"
  10 #include "llvm/ADT/Triple.h"
  11 #include "llvm/CodeGen/MachineBasicBlock.h"
  12 #include "llvm/CodeGen/MachineFunction.h"
  13 #include "llvm/CodeGen/MachineInstr.h"
  14 #include "llvm/CodeGen/MachineMemOperand.h"
  15 #include "llvm/CodeGen/MachineModuleInfo.h"
  16 #include "llvm/CodeGen/TargetFrameLowering.h"
  17 #include "llvm/CodeGen/TargetInstrInfo.h"
  18 #include "llvm/CodeGen/TargetLowering.h"
  19 #include "llvm/CodeGen/TargetSubtargetInfo.h"
  20 #include "llvm/IR/DebugInfoMetadata.h"
  21 #include "llvm/IR/IRBuilder.h"
  22 #include "llvm/IR/ModuleSlotTracker.h"
  23 #include "llvm/MC/MCAsmInfo.h"
  24 #include "llvm/MC/MCSymbol.h"
  25 #include "llvm/MC/TargetRegistry.h"
  26 #include "llvm/Support/TargetSelect.h"
  27 #include "llvm/Target/TargetMachine.h"
  28 #include "llvm/Target/TargetOptions.h"
  29 #include "gtest/gtest.h"
  30
  31 using namespace llvm;
  32 extern cl::opt<double> CopyWeight;
  33 extern cl::opt<double> LoadWeight;
  34 extern cl::opt<double> StoreWeight;
  35 extern cl::opt<double> CheapRematWeight;
  36 extern cl::opt<double> ExpensiveRematWeight;
  37
  38 namespace {
  39 // Include helper functions to ease the manipulation of MachineFunctions.
  40 #include "MFCommon.inc"
  41
  42 // MachineFunction::CreateMachineInstr doesn't copy the MCInstrDesc, it
  43 // takes its address. So we want a bunch of pre-allocated mock MCInstrDescs.
  44 #define MOCK_INSTR(MACRO)                                                      \
  45   MACRO(Copy, TargetOpcode::COPY, 0)                                           \
  46   MACRO(Load, 0, 1ULL << MCID::MayLoad)                                        \
  47   MACRO(Store, 0, 1ULL << MCID::MayStore)                                      \
  48   MACRO(LoadStore, 0, (1ULL << MCID::MayLoad) | (1ULL << MCID::MayStore))      \
  49   MACRO(CheapRemat, 0, 1ULL << MCID::CheapAsAMove)                             \
  50   MACRO(ExpensiveRemat, 0, 0)                                                  \
  51   MACRO(Dbg, TargetOpcode::DBG_LABEL,                                          \
  52         (1ULL << MCID::MayLoad) | (1ULL << MCID::MayStore))                    \
  53   MACRO(InlAsm, TargetOpcode::INLINEASM,                                       \
  54         (1ULL << MCID::MayLoad) | (1ULL << MCID::MayStore))                    \
  55   MACRO(Kill, TargetOpcode::KILL,                                              \
  56         (1ULL << MCID::MayLoad) | (1ULL << MCID::MayStore))
  57
  58 enum MockInstrId {
  59 #define MOCK_INSTR_ID(ID, IGNORE, IGNORE2) ID,
  60   MOCK_INSTR(MOCK_INSTR_ID)
  61 #undef MOCK_INSTR_ID
  62       TotalMockInstrs
  63 };
  64
  65 const std::array<MCInstrDesc, MockInstrId::TotalMockInstrs> MockInstrDescs{{
  66 #define MOCK_SPEC(IGNORE, OPCODE, FLAGS)                                       \
  67   {OPCODE, 0, 0, 0, 0, FLAGS, 0, nullptr, nullptr, nullptr},
  68     MOCK_INSTR(MOCK_SPEC)
  69 #undef MOCK_SPEC
  70 }};
  71
  72 MachineInstr *createMockCopy(MachineFunction &MF) {
  73   return MF.CreateMachineInstr(MockInstrDescs[MockInstrId::Copy], DebugLoc());
  74 }
  75
  76 MachineInstr *createMockLoad(MachineFunction &MF) {
  77   return MF.CreateMachineInstr(MockInstrDescs[MockInstrId::Load], DebugLoc());
  78 }
  79
  80 MachineInstr *createMockStore(MachineFunction &MF) {
  81   return MF.CreateMachineInstr(MockInstrDescs[MockInstrId::Store], DebugLoc());
  82 }
  83
  84 MachineInstr *createMockLoadStore(MachineFunction &MF) {
  85   return MF.CreateMachineInstr(MockInstrDescs[MockInstrId::LoadStore],
  86                                DebugLoc());
  87 }
  88
  89 MachineInstr *createMockCheapRemat(MachineFunction &MF) {
  90   return MF.CreateMachineInstr(MockInstrDescs[MockInstrId::CheapRemat],
  91                                DebugLoc());
  92 }
  93
  94 MachineInstr *createMockExpensiveRemat(MachineFunction &MF) {
  95   return MF.CreateMachineInstr(MockInstrDescs[MockInstrId::ExpensiveRemat],
  96                                DebugLoc());
  97 }
  98
  99 MachineInstr *createMockDebug(MachineFunction &MF) {
 100   return MF.CreateMachineInstr(MockInstrDescs[MockInstrId::Dbg], DebugLoc());
 101 }
 102
 103 MachineInstr *createMockKill(MachineFunction &MF) {
 104   return MF.CreateMachineInstr(MockInstrDescs[MockInstrId::Kill], DebugLoc());
 105 }
 106
 107 MachineInstr *createMockInlineAsm(MachineFunction &MF) {
 108   return MF.CreateMachineInstr(MockInstrDescs[MockInstrId::InlAsm], DebugLoc());
 109 }
 110
 111 TEST(RegAllocScoreTest, SkipDebugKillInlineAsm) {
 112   LLVMContext Ctx;
 113   Module Mod("Module", Ctx);
 114   auto MF = createMachineFunction(Ctx, Mod);
 115
 116   auto *MBB = MF->CreateMachineBasicBlock();
 117   MF->insert(MF->end(), MBB);
 118   auto MBBFreqMock = [&](const MachineBasicBlock &_MBB) -> double {
 119     assert(&_MBB == MBB);
 120     return 0.5;
 121   };
 122   auto Next = MBB->end();
 123   Next = MBB->insertAfter(Next, createMockInlineAsm(*MF));
 124   Next = MBB->insertAfter(Next, createMockDebug(*MF));
 125   Next = MBB->insertAfter(Next, createMockKill(*MF));
 126   const auto Score = llvm::calculateRegAllocScore(
 127       *MF, MBBFreqMock, [](const MachineInstr &) { return false; });
 128   ASSERT_EQ(MF->size(), 1U);
 129   ASSERT_EQ(Score, RegAllocScore());
 130 }
 131
 132 TEST(RegAllocScoreTest, Counts) {
 133   LLVMContext Ctx;
 134   Module Mod("Module", Ctx);
 135   auto MF = createMachineFunction(Ctx, Mod);
 136
 137   auto *MBB1 = MF->CreateMachineBasicBlock();
 138   auto *MBB2 = MF->CreateMachineBasicBlock();
 139   MF->insert(MF->end(), MBB1);
 140   MF->insert(MF->end(), MBB2);
 141   const double Freq1 = 0.5;
 142   const double Freq2 = 10.0;
 143   auto MBBFreqMock = [&](const MachineBasicBlock &MBB) -> double {
 144     if (&MBB == MBB1)
 145       return Freq1;
 146     if (&MBB == MBB2)
 147       return Freq2;
 148     llvm_unreachable("We only created 2 basic blocks");
 149   };
 150   auto Next = MBB1->end();
 151   Next = MBB1->insertAfter(Next, createMockCopy(*MF));
 152   Next = MBB1->insertAfter(Next, createMockLoad(*MF));
 153   Next = MBB1->insertAfter(Next, createMockLoad(*MF));
 154   Next = MBB1->insertAfter(Next, createMockStore(*MF));
 155   auto *CheapRemat = createMockCheapRemat(*MF);
 156   MBB1->insertAfter(Next, CheapRemat);
 157   Next = MBB2->end();
 158   Next = MBB2->insertAfter(Next, createMockLoad(*MF));
 159   Next = MBB2->insertAfter(Next, createMockStore(*MF));
 160   Next = MBB2->insertAfter(Next, createMockLoadStore(*MF));
 161   auto *ExpensiveRemat = createMockExpensiveRemat(*MF);
 162   MBB2->insertAfter(Next, ExpensiveRemat);
 163   auto IsRemat = [&](const MachineInstr &MI) {
 164     return &MI == CheapRemat || &MI == ExpensiveRemat;
 165   };
 166   ASSERT_EQ(MF->size(), 2U);
 167   const auto TotalScore =
 168       llvm::calculateRegAllocScore(*MF, MBBFreqMock, IsRemat);
 169   ASSERT_EQ(Freq1, TotalScore.copyCounts());
 170   ASSERT_EQ(2.0 * Freq1 + Freq2, TotalScore.loadCounts());
 171   ASSERT_EQ(Freq1 + Freq2, TotalScore.storeCounts());
 172   ASSERT_EQ(Freq2, TotalScore.loadStoreCounts());
 173   ASSERT_EQ(Freq1, TotalScore.cheapRematCounts());
 174   ASSERT_EQ(Freq2, TotalScore.expensiveRematCounts());
 175   ASSERT_EQ(TotalScore.getScore(),
 176             TotalScore.copyCounts() * CopyWeight +
 177                 TotalScore.loadCounts() * LoadWeight +
 178                 TotalScore.storeCounts() * StoreWeight +
 179                 TotalScore.loadStoreCounts() * (LoadWeight + StoreWeight) +
 180                 TotalScore.cheapRematCounts() * CheapRematWeight +
 181                 TotalScore.expensiveRematCounts() * ExpensiveRematWeight
 182
 183   );
 184 }
 185 } // end namespace