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/MC/TargetRegistry.h"
25 #include "llvm/Support/SourceMgr.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 (s32) 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 (s32) 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 (s32) from %ir.p, !alias.scope ![[MMSET0]], !noalias ![[MMSET1]])
289 )";
290   EXPECT_TRUE(checkOutput(CheckString, Output));
291 }
292 
293 TEST_F(MachineMetadataTest, isMetaInstruction) {
294   auto TM = createTargetMachine(Triple::normalize("x86_64--"), "", "");
295   if (!TM)
296     GTEST_SKIP();
297 
298   StringRef MIRString = R"MIR(
299 --- |
300   define void @test0(i32 %b) {
301     ret void
302   }
303   !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
304   !1 = !DIFile(filename: "a.c", directory: "/tmp")
305   !2 = !{i32 7, !"Dwarf Version", i32 4}
306   !3 = !{i32 2, !"Debug Info Version", i32 3}
307   !4 = !{i32 1, !"wchar_size", i32 4}
308   !5 = !{i32 7, !"uwtable", i32 1}
309   !6 = !{i32 7, !"frame-pointer", i32 2}
310   !7 = !{!""}
311   !8 = distinct !DISubprogram(name: "test0", scope: !1, file: !1, line: 1, type: !9, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !12)
312   !9 = !DISubroutineType(types: !10)
313   !10 = !{null, !11}
314   !11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
315   !12 = !{}
316   !13 = !DILocalVariable(name: "b", arg: 1, scope: !8, file: !1, line: 1, type: !11)
317   !14 = !DILocation(line: 1, column: 16, scope: !8)
318 ...
319 ---
320 name:            test0
321 machineFunctionInfo
322 body:             |
323   bb.0:
324   $rdi = IMPLICIT_DEF
325   KILL $rsi
326   CFI_INSTRUCTION undefined $rax
327   EH_LABEL 0
328   GC_LABEL 0
329   DBG_VALUE $rax, $noreg, !13, !DIExpression(), debug-location !14
330   DBG_LABEL 0
331   LIFETIME_START 0
332   LIFETIME_END 0
333   PSEUDO_PROBE 6699318081062747564, 1, 0, 0
334   $xmm0 = ARITH_FENCE $xmm0
335 ...
336 )MIR";
337 
338   MachineModuleInfo MMI(TM.get());
339   M = parseMIR(*TM, MIRString, "test0", MMI);
340   ASSERT_TRUE(M);
341 
342   auto *MF = MMI.getMachineFunction(*M->getFunction("test0"));
343   auto *MBB = MF->getBlockNumbered(0);
344 
345   for (auto It = MBB->begin(); It != MBB->end(); ++It) {
346     MachineInstr &MI = *It;
347     ASSERT_TRUE(MI.isMetaInstruction());
348   }
349 }
350 
351 TEST_F(MachineMetadataTest, MMSlotTrackerX64) {
352   auto TM = createTargetMachine(Triple::normalize("x86_64--"), "", "");
353   if (!TM)
354     GTEST_SKIP();
355 
356   StringRef MIRString = R"MIR(
357 --- |
358   define i32 @test0(i32* %p) {
359     %r = load i32, i32* %p, align 4
360     ret i32 %r
361   }
362 ...
363 ---
364 name:            test0
365 liveins:
366   - { reg: '$rdi', virtual-reg: '%0' }
367 body:             |
368   bb.0 (%ir-block.0):
369     liveins: $rdi
370 
371   %0:gr64 = COPY $rdi
372   %1:gr32 = MOV32rm %0, 1, $noreg, 0, $noreg :: (load (s32) from %ir.p)
373 ...
374 )MIR";
375 
376   MachineModuleInfo MMI(TM.get());
377   M = parseMIR(*TM, MIRString, "test0", MMI);
378   ASSERT_TRUE(M);
379 
380   auto *MF = MMI.getMachineFunction(*M->getFunction("test0"));
381   auto *MBB = MF->getBlockNumbered(0);
382 
383   auto &MI = MBB->back();
384   ASSERT_FALSE(MI.memoperands_empty());
385   ASSERT_TRUE(MI.hasOneMemOperand());
386 
387   // Create and attached scoped AA metadata on that instruction with one MMO.
388   MDBuilder MDB(Context);
389   MDNode *Domain = MDB.createAnonymousAliasScopeDomain("domain");
390   MDNode *Scope0 = MDB.createAnonymousAliasScope(Domain, "scope0");
391   MDNode *Scope1 = MDB.createAnonymousAliasScope(Domain, "scope1");
392   MDNode *Set0 = MDNode::get(Context, {Scope0});
393   MDNode *Set1 = MDNode::get(Context, {Scope1});
394 
395   AAMDNodes AAInfo;
396   AAInfo.TBAA = AAInfo.TBAAStruct = nullptr;
397   AAInfo.Scope = Set0;
398   AAInfo.NoAlias = Set1;
399 
400   auto *OldMMO = MI.memoperands().front();
401   auto *NewMMO = MF->getMachineMemOperand(OldMMO, AAInfo);
402   MI.setMemRefs(*MF, NewMMO);
403 
404   MachineModuleSlotTracker MST(MF);
405   // Print that MI with new machine metadata, which slot numbers should be
406   // assigned.
407   EXPECT_EQ("%1:gr32 = MOV32rm %0, 1, $noreg, 0, $noreg :: (load (s32) from %ir.p, "
408             "!alias.scope !0, !noalias !3)",
409             print([&](raw_ostream &OS) {
410               MI.print(OS, MST, /*IsStandalone=*/false, /*SkipOpers=*/false,
411                        /*SkipDebugLoc=*/false, /*AddNewLine=*/false);
412             }));
413 
414   std::vector<const MDNode *> Generated{Domain, Scope0, Scope1, Set0, Set1};
415   // Examine machine metadata collected. They should match ones
416   // afore-generated.
417   std::vector<const MDNode *> Collected;
418   MachineModuleSlotTracker::MachineMDNodeListType MDList;
419   MST.collectMachineMDNodes(MDList);
420   for (auto &MD : MDList)
421     Collected.push_back(MD.second);
422 
423   std::sort(Generated.begin(), Generated.end());
424   std::sort(Collected.begin(), Collected.end());
425   EXPECT_EQ(Collected, Generated);
426 
427   // FileCheck the output from MIR printer.
428   std::string Output = print([&](raw_ostream &OS) { printMIR(OS, *MF); });
429   std::string CheckString = R"(
430 CHECK: machineMetadataNodes:
431 CHECK-DAG: ![[MMDOMAIN:[0-9]+]] = distinct !{!{{[0-9]+}}, !"domain"}
432 CHECK-DAG: ![[MMSCOPE0:[0-9]+]] = distinct !{!{{[0-9]+}}, ![[MMDOMAIN]], !"scope0"}
433 CHECK-DAG: ![[MMSCOPE1:[0-9]+]] = distinct !{!{{[0-9]+}}, ![[MMDOMAIN]], !"scope1"}
434 CHECK-DAG: ![[MMSET0:[0-9]+]] = !{![[MMSCOPE0]]}
435 CHECK-DAG: ![[MMSET1:[0-9]+]] = !{![[MMSCOPE1]]}
436 CHECK: body:
437 CHECK: %1:gr32 = MOV32rm %0, 1, $noreg, 0, $noreg :: (load (s32) from %ir.p, !alias.scope ![[MMSET0]], !noalias ![[MMSET1]])
438 )";
439   EXPECT_TRUE(checkOutput(CheckString, Output));
440 }
441 
442 TEST_F(MachineMetadataTest, MMSlotTrackerAMDGPU) {
443   auto TM = createTargetMachine(Triple::normalize("amdgcn-amd-amdhsa"),
444                                 "gfx1010", "");
445   if (!TM)
446     GTEST_SKIP();
447 
448   StringRef MIRString = R"MIR(
449 --- |
450   define i32 @test0(i32* %p) {
451     %r = load i32, i32* %p, align 4
452     ret i32 %r
453   }
454 ...
455 ---
456 name:            test0
457 liveins:
458   - { reg: '$vgpr0', virtual-reg: '%0' }
459   - { reg: '$vgpr1', virtual-reg: '%1' }
460   - { reg: '$sgpr30_sgpr31', virtual-reg: '%2' }
461 body:             |
462   bb.0 (%ir-block.0):
463     liveins: $vgpr0, $vgpr1, $sgpr30_sgpr31
464 
465     %2:sreg_64 = COPY $sgpr30_sgpr31
466     %1:vgpr_32 = COPY $vgpr1
467     %0:vgpr_32 = COPY $vgpr0
468     %8:vreg_64 = REG_SEQUENCE %0, %subreg.sub0, %1, %subreg.sub1
469     %6:vreg_64 = COPY %8
470     %5:vgpr_32 = FLAT_LOAD_DWORD killed %6, 0, 0, implicit $exec, implicit $flat_scr :: (load (s32) from %ir.p)
471 ...
472 )MIR";
473 
474   MachineModuleInfo MMI(TM.get());
475   M = parseMIR(*TM, MIRString, "test0", MMI);
476   ASSERT_TRUE(M);
477 
478   auto *MF = MMI.getMachineFunction(*M->getFunction("test0"));
479   auto *MBB = MF->getBlockNumbered(0);
480 
481   auto &MI = MBB->back();
482   ASSERT_FALSE(MI.memoperands_empty());
483   ASSERT_TRUE(MI.hasOneMemOperand());
484 
485   // Create and attached scoped AA metadata on that instruction with one MMO.
486   MDBuilder MDB(Context);
487   MDNode *Domain = MDB.createAnonymousAliasScopeDomain("domain");
488   MDNode *Scope0 = MDB.createAnonymousAliasScope(Domain, "scope0");
489   MDNode *Scope1 = MDB.createAnonymousAliasScope(Domain, "scope1");
490   MDNode *Set0 = MDNode::get(Context, {Scope0});
491   MDNode *Set1 = MDNode::get(Context, {Scope1});
492 
493   AAMDNodes AAInfo;
494   AAInfo.TBAA = AAInfo.TBAAStruct = nullptr;
495   AAInfo.Scope = Set0;
496   AAInfo.NoAlias = Set1;
497 
498   auto *OldMMO = MI.memoperands().front();
499   auto *NewMMO = MF->getMachineMemOperand(OldMMO, AAInfo);
500   MI.setMemRefs(*MF, NewMMO);
501 
502   MachineModuleSlotTracker MST(MF);
503   // Print that MI with new machine metadata, which slot numbers should be
504   // assigned.
505   EXPECT_EQ(
506       "%5:vgpr_32 = FLAT_LOAD_DWORD killed %4, 0, 0, implicit $exec, implicit "
507       "$flat_scr :: (load (s32) from %ir.p, !alias.scope !0, !noalias !3)",
508       print([&](raw_ostream &OS) {
509         MI.print(OS, MST, /*IsStandalone=*/false, /*SkipOpers=*/false,
510                  /*SkipDebugLoc=*/false, /*AddNewLine=*/false);
511       }));
512 
513   std::vector<const MDNode *> Generated{Domain, Scope0, Scope1, Set0, Set1};
514   // Examine machine metadata collected. They should match ones
515   // afore-generated.
516   std::vector<const MDNode *> Collected;
517   MachineModuleSlotTracker::MachineMDNodeListType MDList;
518   MST.collectMachineMDNodes(MDList);
519   for (auto &MD : MDList)
520     Collected.push_back(MD.second);
521 
522   std::sort(Generated.begin(), Generated.end());
523   std::sort(Collected.begin(), Collected.end());
524   EXPECT_EQ(Collected, Generated);
525 
526   // FileCheck the output from MIR printer.
527   std::string Output = print([&](raw_ostream &OS) { printMIR(OS, *MF); });
528   std::string CheckString = R"(
529 CHECK: machineMetadataNodes:
530 CHECK-DAG: ![[MMDOMAIN:[0-9]+]] = distinct !{!{{[0-9]+}}, !"domain"}
531 CHECK-DAG: ![[MMSCOPE0:[0-9]+]] = distinct !{!{{[0-9]+}}, ![[MMDOMAIN]], !"scope0"}
532 CHECK-DAG: ![[MMSCOPE1:[0-9]+]] = distinct !{!{{[0-9]+}}, ![[MMDOMAIN]], !"scope1"}
533 CHECK-DAG: ![[MMSET0:[0-9]+]] = !{![[MMSCOPE0]]}
534 CHECK-DAG: ![[MMSET1:[0-9]+]] = !{![[MMSCOPE1]]}
535 CHECK: body:
536 CHECK: %5:vgpr_32 = FLAT_LOAD_DWORD killed %4, 0, 0, implicit $exec, implicit $flat_scr :: (load (s32) from %ir.p, !alias.scope ![[MMSET0]], !noalias ![[MMSET1]])
537 )";
538   EXPECT_TRUE(checkOutput(CheckString, Output));
539 }
540