1 //===- MachineInstrBundleIteratorTest.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 "llvm/CodeGen/MIRParser/MIRParser.h" 10 #include "llvm/CodeGen/MIRPrinter.h" 11 #include "llvm/CodeGen/MachineFunction.h" 12 #include "llvm/CodeGen/MachineMemOperand.h" 13 #include "llvm/CodeGen/MachineModuleInfo.h" 14 #include "llvm/CodeGen/MachineModuleSlotTracker.h" 15 #include "llvm/CodeGen/MachineOperand.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/FileCheck/FileCheck.h" 21 #include "llvm/IR/MDBuilder.h" 22 #include "llvm/IR/ModuleSlotTracker.h" 23 #include "llvm/MC/MCAsmInfo.h" 24 #include "llvm/Support/SourceMgr.h" 25 #include "llvm/Support/TargetRegistry.h" 26 #include "llvm/Support/TargetSelect.h" 27 #include "llvm/Target/TargetMachine.h" 28 #include "gtest/gtest.h" 29 30 using namespace llvm; 31 32 class MachineMetadataTest : public testing::Test { 33 public: 34 MachineMetadataTest() {} 35 36 protected: 37 LLVMContext Context; 38 std::unique_ptr<Module> M; 39 std::unique_ptr<MIRParser> MIR; 40 41 static void SetUpTestCase() { 42 InitializeAllTargetInfos(); 43 InitializeAllTargets(); 44 InitializeAllTargetMCs(); 45 } 46 47 void SetUp() override { M = std::make_unique<Module>("Dummy", Context); } 48 49 void addHooks(ModuleSlotTracker &MST, const MachineOperand &MO) { 50 // Setup hooks to assign slot numbers for the specified machine metadata. 51 MST.setProcessHook([&MO](AbstractSlotTrackerStorage *AST, const Module *M, 52 bool ShouldInitializeAllMetadata) { 53 if (ShouldInitializeAllMetadata) { 54 if (MO.isMetadata()) 55 AST->createMetadataSlot(MO.getMetadata()); 56 } 57 }); 58 MST.setProcessHook([&MO](AbstractSlotTrackerStorage *AST, const Function *F, 59 bool ShouldInitializeAllMetadata) { 60 if (!ShouldInitializeAllMetadata) { 61 if (MO.isMetadata()) 62 AST->createMetadataSlot(MO.getMetadata()); 63 } 64 }); 65 } 66 67 std::unique_ptr<LLVMTargetMachine> 68 createTargetMachine(std::string TT, StringRef CPU, StringRef FS) { 69 std::string Error; 70 const Target *T = TargetRegistry::lookupTarget(TT, Error); 71 if (!T) 72 return nullptr; 73 TargetOptions Options; 74 return std::unique_ptr<LLVMTargetMachine>(static_cast<LLVMTargetMachine *>( 75 T->createTargetMachine(TT, CPU, FS, Options, None, None))); 76 } 77 78 std::unique_ptr<Module> parseMIR(const TargetMachine &TM, StringRef MIRCode, 79 const char *FnName, MachineModuleInfo &MMI) { 80 SMDiagnostic Diagnostic; 81 std::unique_ptr<MemoryBuffer> MBuffer = MemoryBuffer::getMemBuffer(MIRCode); 82 MIR = createMIRParser(std::move(MBuffer), Context); 83 if (!MIR) 84 return nullptr; 85 86 std::unique_ptr<Module> Mod = MIR->parseIRModule(); 87 if (!Mod) 88 return nullptr; 89 90 Mod->setDataLayout(TM.createDataLayout()); 91 92 if (MIR->parseMachineFunctions(*Mod, MMI)) { 93 M.reset(); 94 return nullptr; 95 } 96 97 return Mod; 98 } 99 }; 100 101 // Helper to dump the printer output into a string. 102 static std::string print(std::function<void(raw_ostream &OS)> PrintFn) { 103 std::string Str; 104 raw_string_ostream OS(Str); 105 PrintFn(OS); 106 OS.flush(); 107 return Str; 108 } 109 110 TEST_F(MachineMetadataTest, TrivialHook) { 111 // Verify that post-process hook is invoked to assign slot numbers for 112 // machine metadata. 113 ASSERT_TRUE(M); 114 115 // Create a MachineOperand with a metadata and print it. 116 Metadata *MDS = MDString::get(Context, "foo"); 117 MDNode *Node = MDNode::get(Context, MDS); 118 MachineOperand MO = MachineOperand::CreateMetadata(Node); 119 120 // Checking some preconditions on the newly created 121 // MachineOperand. 122 ASSERT_TRUE(MO.isMetadata()); 123 ASSERT_EQ(MO.getMetadata(), Node); 124 125 ModuleSlotTracker MST(M.get()); 126 addHooks(MST, MO); 127 128 // Print a MachineOperand containing a metadata node. 129 EXPECT_EQ("!0", print([&](raw_ostream &OS) { 130 MO.print(OS, MST, LLT{}, /*OpIdx*/ ~0U, /*PrintDef=*/false, 131 /*IsStandalone=*/false, 132 /*ShouldPrintRegisterTies=*/false, /*TiedOperandIdx=*/0, 133 /*TRI=*/nullptr, 134 /*IntrinsicInfo=*/nullptr); 135 })); 136 // Print the definition of that metadata node. 137 EXPECT_EQ("!0 = !{!\"foo\"}", 138 print([&](raw_ostream &OS) { Node->print(OS, MST); })); 139 } 140 141 TEST_F(MachineMetadataTest, BasicHook) { 142 // Verify that post-process hook is invoked to assign slot numbers for 143 // machine metadata. When both LLVM IR and machine IR contain metadata, 144 // ensure that machine metadata is always assigned after LLVM IR. 145 ASSERT_TRUE(M); 146 147 // Create a MachineOperand with a metadata and print it. 148 Metadata *MachineMDS = MDString::get(Context, "foo"); 149 MDNode *MachineNode = MDNode::get(Context, MachineMDS); 150 MachineOperand MO = MachineOperand::CreateMetadata(MachineNode); 151 152 // Checking some preconditions on the newly created 153 // MachineOperand. 154 ASSERT_TRUE(MO.isMetadata()); 155 ASSERT_EQ(MO.getMetadata(), MachineNode); 156 157 // Create metadata in LLVM IR. 158 NamedMDNode *MD = M->getOrInsertNamedMetadata("namedmd"); 159 Metadata *MDS = MDString::get(Context, "bar"); 160 MDNode *Node = MDNode::get(Context, MDS); 161 MD->addOperand(Node); 162 163 ModuleSlotTracker MST(M.get()); 164 addHooks(MST, MO); 165 166 // Print a MachineOperand containing a metadata node. 167 EXPECT_EQ("!1", print([&](raw_ostream &OS) { 168 MO.print(OS, MST, LLT{}, /*OpIdx*/ ~0U, /*PrintDef=*/false, 169 /*IsStandalone=*/false, 170 /*ShouldPrintRegisterTies=*/false, /*TiedOperandIdx=*/0, 171 /*TRI=*/nullptr, 172 /*IntrinsicInfo=*/nullptr); 173 })); 174 // Print the definition of these unnamed metadata nodes. 175 EXPECT_EQ("!0 = !{!\"bar\"}", 176 print([&](raw_ostream &OS) { Node->print(OS, MST); })); 177 EXPECT_EQ("!1 = !{!\"foo\"}", 178 print([&](raw_ostream &OS) { MachineNode->print(OS, MST); })); 179 } 180 181 static bool checkOutput(std::string CheckString, std::string Output) { 182 auto CheckBuffer = MemoryBuffer::getMemBuffer(CheckString, ""); 183 auto OutputBuffer = MemoryBuffer::getMemBuffer(Output, "Output", false); 184 185 SmallString<4096> CheckFileBuffer; 186 FileCheckRequest Req; 187 FileCheck FC(Req); 188 StringRef CheckFileText = 189 FC.CanonicalizeFile(*CheckBuffer.get(), CheckFileBuffer); 190 191 SourceMgr SM; 192 SM.AddNewSourceBuffer(MemoryBuffer::getMemBuffer(CheckFileText, "CheckFile"), 193 SMLoc()); 194 Regex PrefixRE = FC.buildCheckPrefixRegex(); 195 if (FC.readCheckFile(SM, CheckFileText, PrefixRE)) 196 return false; 197 198 auto OutBuffer = OutputBuffer->getBuffer(); 199 SM.AddNewSourceBuffer(std::move(OutputBuffer), SMLoc()); 200 return FC.checkInput(SM, OutBuffer); 201 } 202 203 TEST_F(MachineMetadataTest, MMSlotTrackerAArch64) { 204 auto TM = createTargetMachine(Triple::normalize("aarch64--"), "", ""); 205 if (!TM) 206 GTEST_SKIP(); 207 208 StringRef MIRString = R"MIR( 209 --- | 210 define i32 @test0(i32* %p) { 211 %r = load i32, i32* %p, align 4 212 ret i32 %r 213 } 214 ... 215 --- 216 name: test0 217 liveins: 218 - { reg: '$x0', virtual-reg: '%0' } 219 body: | 220 bb.0 (%ir-block.0): 221 liveins: $x0 222 223 %0:gpr64common = COPY $x0 224 %1:gpr32 = LDRWui %0, 0 :: (load 4 from %ir.p) 225 ... 226 )MIR"; 227 228 MachineModuleInfo MMI(TM.get()); 229 M = parseMIR(*TM, MIRString, "test0", MMI); 230 ASSERT_TRUE(M); 231 232 auto *MF = MMI.getMachineFunction(*M->getFunction("test0")); 233 auto *MBB = MF->getBlockNumbered(0); 234 235 auto &MI = MBB->back(); 236 ASSERT_TRUE(MI.hasOneMemOperand()); 237 238 // Create and attached scoped AA metadata on that instruction with one MMO. 239 MDBuilder MDB(Context); 240 MDNode *Domain = MDB.createAnonymousAliasScopeDomain("domain"); 241 MDNode *Scope0 = MDB.createAnonymousAliasScope(Domain, "scope0"); 242 MDNode *Scope1 = MDB.createAnonymousAliasScope(Domain, "scope1"); 243 MDNode *Set0 = MDNode::get(Context, {Scope0}); 244 MDNode *Set1 = MDNode::get(Context, {Scope1}); 245 246 AAMDNodes AAInfo; 247 AAInfo.TBAA = AAInfo.TBAAStruct = nullptr; 248 AAInfo.Scope = Set0; 249 AAInfo.NoAlias = Set1; 250 251 auto *OldMMO = MI.memoperands().front(); 252 auto *NewMMO = MF->getMachineMemOperand(OldMMO, AAInfo); 253 MI.setMemRefs(*MF, NewMMO); 254 255 MachineModuleSlotTracker MST(MF); 256 // Print that MI with new machine metadata, which slot numbers should be 257 // assigned. 258 EXPECT_EQ("%1:gpr32 = LDRWui %0, 0 :: (load 4 from %ir.p, " 259 "!alias.scope !0, !noalias !3)", 260 print([&](raw_ostream &OS) { 261 MI.print(OS, MST, /*IsStandalone=*/false, /*SkipOpers=*/false, 262 /*SkipDebugLoc=*/false, /*AddNewLine=*/false); 263 })); 264 265 std::vector<const MDNode *> Generated{Domain, Scope0, Scope1, Set0, Set1}; 266 // Examine machine metadata collected. They should match ones 267 // afore-generated. 268 std::vector<const MDNode *> Collected; 269 MachineModuleSlotTracker::MachineMDNodeListType MDList; 270 MST.collectMachineMDNodes(MDList); 271 for (auto &MD : MDList) 272 Collected.push_back(MD.second); 273 274 std::sort(Generated.begin(), Generated.end()); 275 std::sort(Collected.begin(), Collected.end()); 276 EXPECT_EQ(Collected, Generated); 277 278 // FileCheck the output from MIR printer. 279 std::string Output = print([&](raw_ostream &OS) { printMIR(OS, *MF); }); 280 std::string CheckString = R"( 281 CHECK: machineMetadataNodes: 282 CHECK-DAG: ![[MMDOMAIN:[0-9]+]] = distinct !{!{{[0-9]+}}, !"domain"} 283 CHECK-DAG: ![[MMSCOPE0:[0-9]+]] = distinct !{!{{[0-9]+}}, ![[MMDOMAIN]], !"scope0"} 284 CHECK-DAG: ![[MMSCOPE1:[0-9]+]] = distinct !{!{{[0-9]+}}, ![[MMDOMAIN]], !"scope1"} 285 CHECK-DAG: ![[MMSET0:[0-9]+]] = !{![[MMSCOPE0]]} 286 CHECK-DAG: ![[MMSET1:[0-9]+]] = !{![[MMSCOPE1]]} 287 CHECK: body: 288 CHECK: %1:gpr32 = LDRWui %0, 0 :: (load 4 from %ir.p, !alias.scope ![[MMSET0]], !noalias ![[MMSET1]]) 289 )"; 290 EXPECT_TRUE(checkOutput(CheckString, Output)); 291 } 292 293 TEST_F(MachineMetadataTest, MMSlotTrackerX64) { 294 auto TM = createTargetMachine(Triple::normalize("x86_64--"), "", ""); 295 if (!TM) 296 GTEST_SKIP(); 297 298 StringRef MIRString = R"MIR( 299 --- | 300 define i32 @test0(i32* %p) { 301 %r = load i32, i32* %p, align 4 302 ret i32 %r 303 } 304 ... 305 --- 306 name: test0 307 liveins: 308 - { reg: '$rdi', virtual-reg: '%0' } 309 body: | 310 bb.0 (%ir-block.0): 311 liveins: $rdi 312 313 %0:gr64 = COPY $rdi 314 %1:gr32 = MOV32rm %0, 1, $noreg, 0, $noreg :: (load 4 from %ir.p) 315 ... 316 )MIR"; 317 318 MachineModuleInfo MMI(TM.get()); 319 M = parseMIR(*TM, MIRString, "test0", MMI); 320 ASSERT_TRUE(M); 321 322 auto *MF = MMI.getMachineFunction(*M->getFunction("test0")); 323 auto *MBB = MF->getBlockNumbered(0); 324 325 auto &MI = MBB->back(); 326 ASSERT_FALSE(MI.memoperands_empty()); 327 ASSERT_TRUE(MI.hasOneMemOperand()); 328 329 // Create and attached scoped AA metadata on that instruction with one MMO. 330 MDBuilder MDB(Context); 331 MDNode *Domain = MDB.createAnonymousAliasScopeDomain("domain"); 332 MDNode *Scope0 = MDB.createAnonymousAliasScope(Domain, "scope0"); 333 MDNode *Scope1 = MDB.createAnonymousAliasScope(Domain, "scope1"); 334 MDNode *Set0 = MDNode::get(Context, {Scope0}); 335 MDNode *Set1 = MDNode::get(Context, {Scope1}); 336 337 AAMDNodes AAInfo; 338 AAInfo.TBAA = AAInfo.TBAAStruct = nullptr; 339 AAInfo.Scope = Set0; 340 AAInfo.NoAlias = Set1; 341 342 auto *OldMMO = MI.memoperands().front(); 343 auto *NewMMO = MF->getMachineMemOperand(OldMMO, AAInfo); 344 MI.setMemRefs(*MF, NewMMO); 345 346 MachineModuleSlotTracker MST(MF); 347 // Print that MI with new machine metadata, which slot numbers should be 348 // assigned. 349 EXPECT_EQ("%1:gr32 = MOV32rm %0, 1, $noreg, 0, $noreg :: (load 4 from %ir.p, " 350 "!alias.scope !0, !noalias !3)", 351 print([&](raw_ostream &OS) { 352 MI.print(OS, MST, /*IsStandalone=*/false, /*SkipOpers=*/false, 353 /*SkipDebugLoc=*/false, /*AddNewLine=*/false); 354 })); 355 356 std::vector<const MDNode *> Generated{Domain, Scope0, Scope1, Set0, Set1}; 357 // Examine machine metadata collected. They should match ones 358 // afore-generated. 359 std::vector<const MDNode *> Collected; 360 MachineModuleSlotTracker::MachineMDNodeListType MDList; 361 MST.collectMachineMDNodes(MDList); 362 for (auto &MD : MDList) 363 Collected.push_back(MD.second); 364 365 std::sort(Generated.begin(), Generated.end()); 366 std::sort(Collected.begin(), Collected.end()); 367 EXPECT_EQ(Collected, Generated); 368 369 // FileCheck the output from MIR printer. 370 std::string Output = print([&](raw_ostream &OS) { printMIR(OS, *MF); }); 371 std::string CheckString = R"( 372 CHECK: machineMetadataNodes: 373 CHECK-DAG: ![[MMDOMAIN:[0-9]+]] = distinct !{!{{[0-9]+}}, !"domain"} 374 CHECK-DAG: ![[MMSCOPE0:[0-9]+]] = distinct !{!{{[0-9]+}}, ![[MMDOMAIN]], !"scope0"} 375 CHECK-DAG: ![[MMSCOPE1:[0-9]+]] = distinct !{!{{[0-9]+}}, ![[MMDOMAIN]], !"scope1"} 376 CHECK-DAG: ![[MMSET0:[0-9]+]] = !{![[MMSCOPE0]]} 377 CHECK-DAG: ![[MMSET1:[0-9]+]] = !{![[MMSCOPE1]]} 378 CHECK: body: 379 CHECK: %1:gr32 = MOV32rm %0, 1, $noreg, 0, $noreg :: (load 4 from %ir.p, !alias.scope ![[MMSET0]], !noalias ![[MMSET1]]) 380 )"; 381 EXPECT_TRUE(checkOutput(CheckString, Output)); 382 } 383 384 TEST_F(MachineMetadataTest, MMSlotTrackerAMDGPU) { 385 auto TM = createTargetMachine(Triple::normalize("amdgcn-amd-amdhsa"), 386 "gfx1010", ""); 387 if (!TM) 388 GTEST_SKIP(); 389 390 StringRef MIRString = R"MIR( 391 --- | 392 define i32 @test0(i32* %p) { 393 %r = load i32, i32* %p, align 4 394 ret i32 %r 395 } 396 ... 397 --- 398 name: test0 399 liveins: 400 - { reg: '$vgpr0', virtual-reg: '%0' } 401 - { reg: '$vgpr1', virtual-reg: '%1' } 402 - { reg: '$sgpr30_sgpr31', virtual-reg: '%2' } 403 body: | 404 bb.0 (%ir-block.0): 405 liveins: $vgpr0, $vgpr1, $sgpr30_sgpr31 406 407 %2:sreg_64 = COPY $sgpr30_sgpr31 408 %1:vgpr_32 = COPY $vgpr1 409 %0:vgpr_32 = COPY $vgpr0 410 %8:vreg_64 = REG_SEQUENCE %0, %subreg.sub0, %1, %subreg.sub1 411 %6:vreg_64 = COPY %8 412 %5:vgpr_32 = FLAT_LOAD_DWORD killed %6, 0, 0, implicit $exec, implicit $flat_scr :: (load 4 from %ir.p) 413 ... 414 )MIR"; 415 416 MachineModuleInfo MMI(TM.get()); 417 M = parseMIR(*TM, MIRString, "test0", MMI); 418 ASSERT_TRUE(M); 419 420 auto *MF = MMI.getMachineFunction(*M->getFunction("test0")); 421 auto *MBB = MF->getBlockNumbered(0); 422 423 auto &MI = MBB->back(); 424 ASSERT_FALSE(MI.memoperands_empty()); 425 ASSERT_TRUE(MI.hasOneMemOperand()); 426 427 // Create and attached scoped AA metadata on that instruction with one MMO. 428 MDBuilder MDB(Context); 429 MDNode *Domain = MDB.createAnonymousAliasScopeDomain("domain"); 430 MDNode *Scope0 = MDB.createAnonymousAliasScope(Domain, "scope0"); 431 MDNode *Scope1 = MDB.createAnonymousAliasScope(Domain, "scope1"); 432 MDNode *Set0 = MDNode::get(Context, {Scope0}); 433 MDNode *Set1 = MDNode::get(Context, {Scope1}); 434 435 AAMDNodes AAInfo; 436 AAInfo.TBAA = AAInfo.TBAAStruct = nullptr; 437 AAInfo.Scope = Set0; 438 AAInfo.NoAlias = Set1; 439 440 auto *OldMMO = MI.memoperands().front(); 441 auto *NewMMO = MF->getMachineMemOperand(OldMMO, AAInfo); 442 MI.setMemRefs(*MF, NewMMO); 443 444 MachineModuleSlotTracker MST(MF); 445 // Print that MI with new machine metadata, which slot numbers should be 446 // assigned. 447 EXPECT_EQ( 448 "%5:vgpr_32 = FLAT_LOAD_DWORD killed %4, 0, 0, implicit $exec, implicit " 449 "$flat_scr :: (load 4 from %ir.p, !alias.scope !0, !noalias !3)", 450 print([&](raw_ostream &OS) { 451 MI.print(OS, MST, /*IsStandalone=*/false, /*SkipOpers=*/false, 452 /*SkipDebugLoc=*/false, /*AddNewLine=*/false); 453 })); 454 455 std::vector<const MDNode *> Generated{Domain, Scope0, Scope1, Set0, Set1}; 456 // Examine machine metadata collected. They should match ones 457 // afore-generated. 458 std::vector<const MDNode *> Collected; 459 MachineModuleSlotTracker::MachineMDNodeListType MDList; 460 MST.collectMachineMDNodes(MDList); 461 for (auto &MD : MDList) 462 Collected.push_back(MD.second); 463 464 std::sort(Generated.begin(), Generated.end()); 465 std::sort(Collected.begin(), Collected.end()); 466 EXPECT_EQ(Collected, Generated); 467 468 // FileCheck the output from MIR printer. 469 std::string Output = print([&](raw_ostream &OS) { printMIR(OS, *MF); }); 470 std::string CheckString = R"( 471 CHECK: machineMetadataNodes: 472 CHECK-DAG: ![[MMDOMAIN:[0-9]+]] = distinct !{!{{[0-9]+}}, !"domain"} 473 CHECK-DAG: ![[MMSCOPE0:[0-9]+]] = distinct !{!{{[0-9]+}}, ![[MMDOMAIN]], !"scope0"} 474 CHECK-DAG: ![[MMSCOPE1:[0-9]+]] = distinct !{!{{[0-9]+}}, ![[MMDOMAIN]], !"scope1"} 475 CHECK-DAG: ![[MMSET0:[0-9]+]] = !{![[MMSCOPE0]]} 476 CHECK-DAG: ![[MMSET1:[0-9]+]] = !{![[MMSCOPE1]]} 477 CHECK: body: 478 CHECK: %5:vgpr_32 = FLAT_LOAD_DWORD killed %4, 0, 0, implicit $exec, implicit $flat_scr :: (load 4 from %ir.p, !alias.scope ![[MMSET0]], !noalias ![[MMSET1]]) 479 )"; 480 EXPECT_TRUE(checkOutput(CheckString, Output)); 481 } 482