llvm/unittests/Target/AArch64/InstSizes.cpp

   1 #include "AArch64Subtarget.h"
   2 #include "AArch64TargetMachine.h"
   3 #include "llvm/CodeGen/MIRParser/MIRParser.h"
   4 #include "llvm/CodeGen/MachineModuleInfo.h"
   5 #include "llvm/MC/TargetRegistry.h"
   6 #include "llvm/Support/MemoryBuffer.h"
   7 #include "llvm/Support/TargetSelect.h"
   8
   9 #include "gtest/gtest.h"
  10
  11 using namespace llvm;
  12
  13 namespace {
  14 std::unique_ptr<LLVMTargetMachine> createTargetMachine() {
  15   auto TT(Triple::normalize("aarch64--"));
  16   std::string CPU("generic");
  17   std::string FS("+pauth,+mops,+mte");
  18
  19   LLVMInitializeAArch64TargetInfo();
  20   LLVMInitializeAArch64Target();
  21   LLVMInitializeAArch64TargetMC();
  22
  23   std::string Error;
  24   const Target *TheTarget = TargetRegistry::lookupTarget(TT, Error);
  25
  26   return std::unique_ptr<LLVMTargetMachine>(static_cast<LLVMTargetMachine *>(
  27       TheTarget->createTargetMachine(TT, CPU, FS, TargetOptions(), std::nullopt,
  28                                      std::nullopt, CodeGenOptLevel::Default)));
  29 }
  30
  31 std::unique_ptr<AArch64InstrInfo> createInstrInfo(TargetMachine *TM) {
  32   AArch64Subtarget ST(TM->getTargetTriple(), std::string(TM->getTargetCPU()),
  33                       std::string(TM->getTargetCPU()),
  34                       std::string(TM->getTargetFeatureString()), *TM,
  35                       /* isLittle */ false);
  36   return std::make_unique<AArch64InstrInfo>(ST);
  37 }
  38
  39 /// The \p InputIRSnippet is only needed for things that can't be expressed in
  40 /// the \p InputMIRSnippet (global variables etc)
  41 /// TODO: Some of this might be useful for other architectures as well - extract
  42 ///       the platform-independent parts somewhere they can be reused.
  43 void runChecks(
  44     LLVMTargetMachine *TM, AArch64InstrInfo *II, const StringRef InputIRSnippet,
  45     const StringRef InputMIRSnippet,
  46     std::function<void(AArch64InstrInfo &, MachineFunction &)> Checks) {
  47   LLVMContext Context;
  48
  49   auto MIRString =
  50     "--- |\n"
  51     "  declare void @sizes()\n"
  52     + InputIRSnippet.str() +
  53     "...\n"
  54     "---\n"
  55     "name: sizes\n"
  56     "jumpTable:\n"
  57     "  kind:            block-address\n"
  58     "  entries:\n"
  59     "    - id:              0\n"
  60     "      blocks:          [ '%bb.0' ]\n"
  61     "body: |\n"
  62     "  bb.0:\n"
  63     + InputMIRSnippet.str();
  64
  65   std::unique_ptr<MemoryBuffer> MBuffer = MemoryBuffer::getMemBuffer(MIRString);
  66   std::unique_ptr<MIRParser> MParser =
  67       createMIRParser(std::move(MBuffer), Context);
  68   ASSERT_TRUE(MParser);
  69
  70   std::unique_ptr<Module> M = MParser->parseIRModule();
  71   ASSERT_TRUE(M);
  72
  73   M->setTargetTriple(TM->getTargetTriple().getTriple());
  74   M->setDataLayout(TM->createDataLayout());
  75
  76   MachineModuleInfo MMI(TM);
  77   bool Res = MParser->parseMachineFunctions(*M, MMI);
  78   ASSERT_FALSE(Res);
  79
  80   auto F = M->getFunction("sizes");
  81   ASSERT_TRUE(F != nullptr);
  82   auto &MF = MMI.getOrCreateMachineFunction(*F);
  83
  84   Checks(*II, MF);
  85 }
  86
  87 } // anonymous namespace
  88
  89 TEST(InstSizes, Authenticated) {
  90   std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
  91   ASSERT_TRUE(TM);
  92   std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
  93
  94   auto isAuthInst = [](AArch64InstrInfo &II, MachineFunction &MF) {
  95     auto I = MF.begin()->begin();
  96     EXPECT_EQ(4u, II.getInstSizeInBytes(*I));
  97     EXPECT_TRUE(I->getDesc().isAuthenticated());
  98   };
  99
 100   runChecks(TM.get(), II.get(), "",
 101             "    \n"
 102             "    BLRAA $x10, $x9\n",
 103             isAuthInst);
 104
 105   runChecks(TM.get(), II.get(), "",
 106             "    \n"
 107             "    RETAB implicit $lr, implicit $sp, implicit killed $x0\n",
 108             isAuthInst);
 109
 110   runChecks(TM.get(), II.get(), "",
 111             "    \n"
 112             "    frame-destroy AUTIASP implicit-def $lr, implicit killed $lr, implicit $sp\n",
 113             isAuthInst);
 114
 115   runChecks(TM.get(), II.get(), "",
 116             "    \n"
 117             "    frame-destroy AUTIBSP implicit-def $lr, implicit killed $lr, implicit $sp\n",
 118             isAuthInst);
 119 }
 120
 121 TEST(InstSizes, STACKMAP) {
 122   std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
 123   ASSERT_TRUE(TM);
 124   std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
 125
 126   runChecks(TM.get(), II.get(), "", "    STACKMAP 0, 16\n"
 127                                     "    STACKMAP 1, 32\n",
 128             [](AArch64InstrInfo &II, MachineFunction &MF) {
 129               auto I = MF.begin()->begin();
 130               EXPECT_EQ(16u, II.getInstSizeInBytes(*I));
 131               ++I;
 132               EXPECT_EQ(32u, II.getInstSizeInBytes(*I));
 133             });
 134 }
 135
 136 TEST(InstSizes, PATCHPOINT) {
 137   std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
 138   std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
 139
 140   runChecks(TM.get(), II.get(), "",
 141             "    PATCHPOINT 0, 16, 0, 0, 0, csr_aarch64_aapcs\n"
 142             "    PATCHPOINT 1, 32, 0, 0, 0, csr_aarch64_aapcs\n",
 143             [](AArch64InstrInfo &II, MachineFunction &MF) {
 144               auto I = MF.begin()->begin();
 145               EXPECT_EQ(16u, II.getInstSizeInBytes(*I));
 146               ++I;
 147               EXPECT_EQ(32u, II.getInstSizeInBytes(*I));
 148             });
 149 }
 150
 151 TEST(InstSizes, STATEPOINT) {
 152   std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
 153   std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
 154
 155   runChecks(TM.get(), II.get(), "",
 156             "    STATEPOINT 0, 0, 0, @sizes, 2, 0, 2, 0, 2, 0, 2, 1, 1, 8,"
 157             " $sp, 24, 2, 0, 2, 1, 0, 0\n",
 158             [](AArch64InstrInfo &II, MachineFunction &MF) {
 159               auto I = MF.begin()->begin();
 160               EXPECT_EQ(4u, II.getInstSizeInBytes(*I));
 161             });
 162 }
 163
 164 TEST(InstSizes, SPACE) {
 165   std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
 166   std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
 167
 168   runChecks(TM.get(), II.get(), "",
 169             "    $xzr = SPACE 1024, undef $xzr\n"
 170             "    dead $xzr = SPACE 4096, $xzr\n",
 171             [](AArch64InstrInfo &II, MachineFunction &MF) {
 172               auto I = MF.begin()->begin();
 173               EXPECT_EQ(1024u, II.getInstSizeInBytes(*I));
 174               ++I;
 175               EXPECT_EQ(4096u, II.getInstSizeInBytes(*I));
 176             });
 177 }
 178
 179 TEST(InstSizes, TLSDESC_CALLSEQ) {
 180   std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
 181   std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
 182
 183   runChecks(
 184       TM.get(), II.get(),
 185       "  @ThreadLocalGlobal = external thread_local global i32, align 8\n",
 186       "    TLSDESC_CALLSEQ target-flags(aarch64-tls) @ThreadLocalGlobal\n",
 187       [](AArch64InstrInfo &II, MachineFunction &MF) {
 188         auto I = MF.begin()->begin();
 189         EXPECT_EQ(16u, II.getInstSizeInBytes(*I));
 190       });
 191 }
 192
 193 TEST(InstSizes, StoreSwiftAsyncContext) {
 194   std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
 195   std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
 196
 197   runChecks(
 198       TM.get(), II.get(), "",
 199       "    StoreSwiftAsyncContext $x0, $x1, 12, implicit-def $x16, "
 200       "implicit-def $x17\n",
 201       [](AArch64InstrInfo &II, MachineFunction &MF) {
 202         auto I = MF.begin()->begin();
 203         EXPECT_EQ(20u, II.getInstSizeInBytes(*I));
 204       });
 205 }
 206
 207 TEST(InstSizes, SpeculationBarrierISBDSBEndBB) {
 208   std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
 209   std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
 210
 211   runChecks(
 212       TM.get(), II.get(), "",
 213       "    SpeculationBarrierISBDSBEndBB\n"
 214       "    BR $x8\n",
 215       [](AArch64InstrInfo &II, MachineFunction &MF) {
 216         auto I = MF.begin()->begin();
 217         EXPECT_EQ(8u, II.getInstSizeInBytes(*I));
 218       });
 219 }
 220
 221 TEST(InstSizes, SpeculationBarrierSBEndBB) {
 222   std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
 223   std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
 224
 225   runChecks(
 226       TM.get(), II.get(), "",
 227       "    SpeculationBarrierSBEndBB\n"
 228       "    BR $x8\n",
 229       [](AArch64InstrInfo &II, MachineFunction &MF) {
 230         auto I = MF.begin()->begin();
 231         EXPECT_EQ(4u, II.getInstSizeInBytes(*I));
 232       });
 233 }
 234
 235 TEST(InstSizes, JumpTable) {
 236   std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
 237   std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
 238
 239   runChecks(TM.get(), II.get(), "",
 240             "    $x10, $x11 = JumpTableDest32 $x9, $x8, %jump-table.0\n"
 241             "    $x10, $x11 = JumpTableDest16 $x9, $x8, %jump-table.0\n"
 242             "    $x10, $x11 = JumpTableDest8 $x9, $x8, %jump-table.0\n",
 243             [](AArch64InstrInfo &II, MachineFunction &MF) {
 244               auto I = MF.begin()->begin();
 245               EXPECT_EQ(12u, II.getInstSizeInBytes(*I));
 246               ++I;
 247               EXPECT_EQ(12u, II.getInstSizeInBytes(*I));
 248               ++I;
 249               EXPECT_EQ(12u, II.getInstSizeInBytes(*I));
 250             });
 251 }
 252
 253 TEST(InstSizes, MOPSMemoryPseudos) {
 254   std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
 255   std::unique_ptr<AArch64InstrInfo> II = createInstrInfo(TM.get());
 256
 257   runChecks(TM.get(), II.get(), "",
 258             "  $x0, $x1, $x2 = MOPSMemoryMovePseudo $x0, $x1, $x2, "
 259             "implicit-def $nzcv\n"
 260             "  $x0, $x1 = MOPSMemorySetPseudo $x0, $x1, $x2, "
 261             "implicit-def $nzcv\n"
 262             "  $x0, $x1, $x8 = MOPSMemoryCopyPseudo $x0, $x1, $x8, "
 263             "implicit-def $nzcv\n"
 264             "  $x0, $x1 = MOPSMemorySetTaggingPseudo $x0, $x1, $x2, "
 265             "implicit-def $nzcv\n",
 266             [](AArch64InstrInfo &II, MachineFunction &MF) {
 267               auto I = MF.begin()->begin();
 268               EXPECT_EQ(12u, II.getInstSizeInBytes(*I));
 269               ++I;
 270               EXPECT_EQ(12u, II.getInstSizeInBytes(*I));
 271               ++I;
 272               EXPECT_EQ(12u, II.getInstSizeInBytes(*I));
 273               ++I;
 274               EXPECT_EQ(12u, II.getInstSizeInBytes(*I));
 275             });
 276 }