1 //===- llvm/unittest/IR/Metadata.cpp - Metadata unit tests ----------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/ADT/STLExtras.h"
11 #include "llvm/IR/Constants.h"
12 #include "llvm/IR/Instructions.h"
13 #include "llvm/IR/LLVMContext.h"
14 #include "llvm/IR/Metadata.h"
15 #include "llvm/IR/Module.h"
16 #include "llvm/IR/Type.h"
17 #include "llvm/Support/raw_ostream.h"
18 #include "gtest/gtest.h"
23 class MetadataTest : public testing::Test {
26 MDNode *getNode() { return MDNode::get(Context, None); }
27 MDNode *getNode(Metadata *MD) { return MDNode::get(Context, MD); }
28 MDNode *getNode(Metadata *MD1, Metadata *MD2) {
29 Metadata *MDs[] = {MD1, MD2};
30 return MDNode::get(Context, MDs);
33 typedef MetadataTest MDStringTest;
35 // Test that construction of MDString with different value produces different
36 // MDString objects, even with the same string pointer and nulls in the string.
37 TEST_F(MDStringTest, CreateDifferent) {
38 char x[3] = { 'f', 0, 'A' };
39 MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
41 MDString *s2 = MDString::get(Context, StringRef(&x[0], 3));
45 // Test that creation of MDStrings with the same string contents produces the
46 // same MDString object, even with different pointers.
47 TEST_F(MDStringTest, CreateSame) {
48 char x[4] = { 'a', 'b', 'c', 'X' };
49 char y[4] = { 'a', 'b', 'c', 'Y' };
51 MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
52 MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));
56 // Test that MDString prints out the string we fed it.
57 TEST_F(MDStringTest, PrintingSimple) {
58 char *str = new char[13];
59 strncpy(str, "testing 1 2 3", 13);
60 MDString *s = MDString::get(Context, StringRef(str, 13));
61 strncpy(str, "aaaaaaaaaaaaa", 13);
65 raw_string_ostream oss(Str);
67 EXPECT_STREQ("!\"testing 1 2 3\"", oss.str().c_str());
70 // Test printing of MDString with non-printable characters.
71 TEST_F(MDStringTest, PrintingComplex) {
72 char str[5] = {0, '\n', '"', '\\', (char)-1};
73 MDString *s = MDString::get(Context, StringRef(str+0, 5));
75 raw_string_ostream oss(Str);
77 EXPECT_STREQ("!\"\\00\\0A\\22\\5C\\FF\"", oss.str().c_str());
80 typedef MetadataTest MDNodeTest;
82 // Test the two constructors, and containing other Constants.
83 TEST_F(MDNodeTest, Simple) {
84 char x[3] = { 'a', 'b', 'c' };
85 char y[3] = { '1', '2', '3' };
87 MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
88 MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));
89 ConstantAsMetadata *CI = ConstantAsMetadata::get(
90 ConstantInt::get(getGlobalContext(), APInt(8, 0)));
92 std::vector<Metadata *> V;
97 MDNode *n1 = MDNode::get(Context, V);
98 Metadata *const c1 = n1;
99 MDNode *n2 = MDNode::get(Context, c1);
100 Metadata *const c2 = n2;
101 MDNode *n3 = MDNode::get(Context, V);
102 MDNode *n4 = MDNode::getIfExists(Context, V);
103 MDNode *n5 = MDNode::getIfExists(Context, c1);
104 MDNode *n6 = MDNode::getIfExists(Context, c2);
109 EXPECT_EQ(n6, (Metadata *)nullptr);
111 EXPECT_EQ(3u, n1->getNumOperands());
112 EXPECT_EQ(s1, n1->getOperand(0));
113 EXPECT_EQ(CI, n1->getOperand(1));
114 EXPECT_EQ(s2, n1->getOperand(2));
116 EXPECT_EQ(1u, n2->getNumOperands());
117 EXPECT_EQ(n1, n2->getOperand(0));
120 TEST_F(MDNodeTest, Delete) {
121 Constant *C = ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 1);
122 Instruction *I = new BitCastInst(C, Type::getInt32Ty(getGlobalContext()));
124 Metadata *const V = LocalAsMetadata::get(I);
125 MDNode *n = MDNode::get(Context, V);
126 TrackingMDRef wvh(n);
133 TEST_F(MDNodeTest, DeleteMDNodeFwdDecl) {
134 delete MDNode::getTemporary(Context, None);
137 TEST_F(MDNodeTest, SelfReference) {
141 MDNode *Temp = MDNode::getTemporary(Context, None);
142 Metadata *Args[] = {Temp};
143 MDNode *Self = MDNode::get(Context, Args);
144 Self->replaceOperandWith(0, Self);
145 MDNode::deleteTemporary(Temp);
146 ASSERT_EQ(Self, Self->getOperand(0));
148 // Self-references should be distinct, so MDNode::get() should grab a
149 // uniqued node that references Self, not Self.
151 MDNode *Ref1 = MDNode::get(Context, Args);
152 MDNode *Ref2 = MDNode::get(Context, Args);
153 EXPECT_NE(Self, Ref1);
154 EXPECT_EQ(Ref1, Ref2);
160 MDNode *Temp = MDNode::getTemporary(Context, None);
161 Metadata *Args[] = {Temp, MDNode::get(Context, None)};
162 MDNode *Self = MDNode::get(Context, Args);
163 Self->replaceOperandWith(0, Self);
164 MDNode::deleteTemporary(Temp);
165 ASSERT_EQ(Self, Self->getOperand(0));
167 // Self-references should be distinct, so MDNode::get() should grab a
168 // uniqued node that references Self, not Self itself.
170 MDNode *Ref1 = MDNode::get(Context, Args);
171 MDNode *Ref2 = MDNode::get(Context, Args);
172 EXPECT_NE(Self, Ref1);
173 EXPECT_EQ(Ref1, Ref2);
177 TEST_F(MDNodeTest, Print) {
178 Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 7);
179 MDString *S = MDString::get(Context, "foo");
180 MDNode *N0 = getNode();
181 MDNode *N1 = getNode(N0);
182 MDNode *N2 = getNode(N0, N1);
184 Metadata *Args[] = {ConstantAsMetadata::get(C), S, nullptr, N0, N1, N2};
185 MDNode *N = MDNode::get(Context, Args);
187 std::string Expected;
189 raw_string_ostream OS(Expected);
191 C->printAsOperand(OS);
193 S->printAsOperand(OS);
195 MDNode *Nodes[] = {N0, N1, N2};
196 for (auto *Node : Nodes)
197 OS << ", <" << (void *)Node << ">";
203 raw_string_ostream OS(Actual);
207 EXPECT_EQ(Expected, Actual);
210 TEST_F(MDNodeTest, NullOperand) {
212 MDNode *Empty = MDNode::get(Context, None);
214 // metadata !{metadata !{}}
215 Metadata *Ops[] = {Empty};
216 MDNode *N = MDNode::get(Context, Ops);
217 ASSERT_EQ(Empty, N->getOperand(0));
219 // metadata !{metadata !{}} => metadata !{null}
220 N->replaceOperandWith(0, nullptr);
221 ASSERT_EQ(nullptr, N->getOperand(0));
225 MDNode *NullOp = MDNode::get(Context, Ops);
226 ASSERT_EQ(nullptr, NullOp->getOperand(0));
227 EXPECT_EQ(N, NullOp);
230 TEST_F(MDNodeTest, DistinctOnUniquingCollision) {
232 MDNode *Empty = MDNode::get(Context, None);
233 ASSERT_TRUE(Empty->isResolved());
234 EXPECT_FALSE(Empty->isDistinct());
237 Metadata *Wrapped1Ops[] = {Empty};
238 MDNode *Wrapped1 = MDNode::get(Context, Wrapped1Ops);
239 ASSERT_EQ(Empty, Wrapped1->getOperand(0));
240 ASSERT_TRUE(Wrapped1->isResolved());
241 EXPECT_FALSE(Wrapped1->isDistinct());
244 Metadata *Wrapped2Ops[] = {Wrapped1};
245 MDNode *Wrapped2 = MDNode::get(Context, Wrapped2Ops);
246 ASSERT_EQ(Wrapped1, Wrapped2->getOperand(0));
247 ASSERT_TRUE(Wrapped2->isResolved());
248 EXPECT_FALSE(Wrapped2->isDistinct());
250 // !{!{!{}}} => !{!{}}
251 Wrapped2->replaceOperandWith(0, Empty);
252 ASSERT_EQ(Empty, Wrapped2->getOperand(0));
253 EXPECT_TRUE(Wrapped2->isDistinct());
254 EXPECT_FALSE(Wrapped1->isDistinct());
257 TEST_F(MDNodeTest, getDistinct) {
259 MDNode *Empty = MDNode::get(Context, None);
260 ASSERT_TRUE(Empty->isResolved());
261 ASSERT_FALSE(Empty->isDistinct());
262 ASSERT_EQ(Empty, MDNode::get(Context, None));
265 MDNode *Distinct1 = MDNode::getDistinct(Context, None);
266 MDNode *Distinct2 = MDNode::getDistinct(Context, None);
267 EXPECT_TRUE(Distinct1->isResolved());
268 EXPECT_TRUE(Distinct2->isDistinct());
269 EXPECT_NE(Empty, Distinct1);
270 EXPECT_NE(Empty, Distinct2);
271 EXPECT_NE(Distinct1, Distinct2);
274 ASSERT_EQ(Empty, MDNode::get(Context, None));
277 TEST_F(MDNodeTest, isUniqued) {
278 MDNode *U = MDTuple::get(Context, None);
279 MDNode *D = MDTuple::getDistinct(Context, None);
280 MDNode *T = MDTuple::getTemporary(Context, None);
281 EXPECT_TRUE(U->isUniqued());
282 EXPECT_FALSE(D->isUniqued());
283 EXPECT_FALSE(T->isUniqued());
284 MDNode::deleteTemporary(T);
287 TEST_F(MDNodeTest, isDistinct) {
288 MDNode *U = MDTuple::get(Context, None);
289 MDNode *D = MDTuple::getDistinct(Context, None);
290 MDNode *T = MDTuple::getTemporary(Context, None);
291 EXPECT_FALSE(U->isDistinct());
292 EXPECT_TRUE(D->isDistinct());
293 EXPECT_FALSE(T->isDistinct());
294 MDNode::deleteTemporary(T);
297 TEST_F(MDNodeTest, isTemporary) {
298 MDNode *U = MDTuple::get(Context, None);
299 MDNode *D = MDTuple::getDistinct(Context, None);
300 MDNode *T = MDTuple::getTemporary(Context, None);
301 EXPECT_FALSE(U->isTemporary());
302 EXPECT_FALSE(D->isTemporary());
303 EXPECT_TRUE(T->isTemporary());
304 MDNode::deleteTemporary(T);
307 TEST_F(MDNodeTest, getDistinctWithUnresolvedOperands) {
309 MDNodeFwdDecl *Temp = MDNode::getTemporary(Context, None);
310 ASSERT_FALSE(Temp->isResolved());
312 // distinct !{temporary !{}}
313 Metadata *Ops[] = {Temp};
314 MDNode *Distinct = MDNode::getDistinct(Context, Ops);
315 EXPECT_TRUE(Distinct->isResolved());
316 EXPECT_EQ(Temp, Distinct->getOperand(0));
318 // temporary !{} => !{}
319 MDNode *Empty = MDNode::get(Context, None);
320 Temp->replaceAllUsesWith(Empty);
321 MDNode::deleteTemporary(Temp);
322 EXPECT_EQ(Empty, Distinct->getOperand(0));
325 TEST_F(MDNodeTest, handleChangedOperandRecursion) {
327 MDNode *N0 = MDNode::get(Context, None);
330 std::unique_ptr<MDNodeFwdDecl> Temp3(MDNode::getTemporary(Context, None));
331 Metadata *Ops1[] = {Temp3.get(), nullptr};
332 MDNode *N1 = MDNode::get(Context, Ops1);
335 Metadata *Ops2[] = {Temp3.get(), N0};
336 MDNode *N2 = MDNode::get(Context, Ops2);
339 Metadata *Ops3[] = {N2};
340 MDNode *N3 = MDNode::get(Context, Ops3);
341 Temp3->replaceAllUsesWith(N3);
344 Metadata *Ops4[] = {N1};
345 MDNode *N4 = MDNode::get(Context, Ops4);
347 // Confirm that the cycle prevented RAUW from getting dropped.
348 EXPECT_TRUE(N0->isResolved());
349 EXPECT_FALSE(N1->isResolved());
350 EXPECT_FALSE(N2->isResolved());
351 EXPECT_FALSE(N3->isResolved());
352 EXPECT_FALSE(N4->isResolved());
354 // Create a couple of distinct nodes to observe what's going on.
356 // !5 = distinct !{!2}
357 // !6 = distinct !{!3}
358 Metadata *Ops5[] = {N2};
359 MDNode *N5 = MDNode::getDistinct(Context, Ops5);
360 Metadata *Ops6[] = {N3};
361 MDNode *N6 = MDNode::getDistinct(Context, Ops6);
363 // Mutate !2 to look like !1, causing a uniquing collision (and an RAUW).
364 // This will ripple up, with !3 colliding with !4, and RAUWing. Since !2
365 // references !3, this can cause a re-entry of handleChangedOperand() when !3
366 // is not ready for it.
368 // !2->replaceOperandWith(1, nullptr)
369 // !2: !{!3, !0} => !{!3, null}
370 // !2->replaceAllUsesWith(!1)
371 // !3: !{!2] => !{!1}
372 // !3->replaceAllUsesWith(!4)
373 N2->replaceOperandWith(1, nullptr);
375 // If all has gone well, N2 and N3 will have been RAUW'ed and deleted from
376 // under us. Just check that the other nodes are sane.
380 // !5 = distinct !{!1}
381 // !6 = distinct !{!4}
382 EXPECT_EQ(N4, N1->getOperand(0));
383 EXPECT_EQ(N1, N4->getOperand(0));
384 EXPECT_EQ(N1, N5->getOperand(0));
385 EXPECT_EQ(N4, N6->getOperand(0));
388 TEST_F(MDNodeTest, replaceResolvedOperand) {
389 // Check code for replacing one resolved operand with another. If doing this
390 // directly (via replaceOperandWith()) becomes illegal, change the operand to
391 // a global value that gets RAUW'ed.
393 // Use a temporary node to keep N from being resolved.
394 std::unique_ptr<MDNodeFwdDecl> Temp(MDNodeFwdDecl::get(Context, None));
395 Metadata *Ops[] = {nullptr, Temp.get()};
397 MDNode *Empty = MDTuple::get(Context, ArrayRef<Metadata *>());
398 MDNode *N = MDTuple::get(Context, Ops);
399 EXPECT_EQ(nullptr, N->getOperand(0));
400 ASSERT_FALSE(N->isResolved());
402 // Check code for replacing resolved nodes.
403 N->replaceOperandWith(0, Empty);
404 EXPECT_EQ(Empty, N->getOperand(0));
406 // Check code for adding another unresolved operand.
407 N->replaceOperandWith(0, Temp.get());
408 EXPECT_EQ(Temp.get(), N->getOperand(0));
410 // Remove the references to Temp; required for teardown.
411 Temp->replaceAllUsesWith(nullptr);
414 typedef MetadataTest MDLocationTest;
416 TEST_F(MDLocationTest, Overflow) {
417 MDNode *N = MDNode::get(Context, None);
419 MDLocation *L = MDLocation::get(Context, 2, 7, N);
420 EXPECT_EQ(2u, L->getLine());
421 EXPECT_EQ(7u, L->getColumn());
423 unsigned U24 = 1u << 24;
424 unsigned U16 = 1u << 16;
426 MDLocation *L = MDLocation::get(Context, U24 - 1, U16 - 1, N);
427 EXPECT_EQ(U24 - 1, L->getLine());
428 EXPECT_EQ(U16 - 1, L->getColumn());
431 MDLocation *L = MDLocation::get(Context, U24, U16, N);
432 EXPECT_EQ(0u, L->getLine());
433 EXPECT_EQ(0u, L->getColumn());
436 MDLocation *L = MDLocation::get(Context, U24 + 1, U16 + 1, N);
437 EXPECT_EQ(0u, L->getLine());
438 EXPECT_EQ(0u, L->getColumn());
442 TEST_F(MDLocationTest, getDistinct) {
443 MDNode *N = MDNode::get(Context, None);
444 MDLocation *L0 = MDLocation::getDistinct(Context, 2, 7, N);
445 EXPECT_TRUE(L0->isDistinct());
446 MDLocation *L1 = MDLocation::get(Context, 2, 7, N);
447 EXPECT_FALSE(L1->isDistinct());
448 EXPECT_EQ(L1, MDLocation::get(Context, 2, 7, N));
451 typedef MetadataTest MetadataAsValueTest;
453 TEST_F(MetadataAsValueTest, MDNode) {
454 MDNode *N = MDNode::get(Context, None);
455 auto *V = MetadataAsValue::get(Context, N);
456 EXPECT_TRUE(V->getType()->isMetadataTy());
457 EXPECT_EQ(N, V->getMetadata());
459 auto *V2 = MetadataAsValue::get(Context, N);
463 TEST_F(MetadataAsValueTest, MDNodeMDNode) {
464 MDNode *N = MDNode::get(Context, None);
465 Metadata *Ops[] = {N};
466 MDNode *N2 = MDNode::get(Context, Ops);
467 auto *V = MetadataAsValue::get(Context, N2);
468 EXPECT_TRUE(V->getType()->isMetadataTy());
469 EXPECT_EQ(N2, V->getMetadata());
471 auto *V2 = MetadataAsValue::get(Context, N2);
474 auto *V3 = MetadataAsValue::get(Context, N);
475 EXPECT_TRUE(V3->getType()->isMetadataTy());
477 EXPECT_EQ(N, V3->getMetadata());
480 TEST_F(MetadataAsValueTest, MDNodeConstant) {
481 auto *C = ConstantInt::getTrue(Context);
482 auto *MD = ConstantAsMetadata::get(C);
483 Metadata *Ops[] = {MD};
484 auto *N = MDNode::get(Context, Ops);
486 auto *V = MetadataAsValue::get(Context, MD);
487 EXPECT_TRUE(V->getType()->isMetadataTy());
488 EXPECT_EQ(MD, V->getMetadata());
490 auto *V2 = MetadataAsValue::get(Context, N);
491 EXPECT_EQ(MD, V2->getMetadata());
495 typedef MetadataTest ValueAsMetadataTest;
497 TEST_F(ValueAsMetadataTest, UpdatesOnRAUW) {
498 Type *Ty = Type::getInt1PtrTy(Context);
499 std::unique_ptr<GlobalVariable> GV0(
500 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
501 auto *MD = ValueAsMetadata::get(GV0.get());
502 EXPECT_TRUE(MD->getValue() == GV0.get());
503 ASSERT_TRUE(GV0->use_empty());
505 std::unique_ptr<GlobalVariable> GV1(
506 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
507 GV0->replaceAllUsesWith(GV1.get());
508 EXPECT_TRUE(MD->getValue() == GV1.get());
511 TEST_F(ValueAsMetadataTest, CollidingDoubleUpdates) {
512 // Create a constant.
513 ConstantAsMetadata *CI = ConstantAsMetadata::get(
514 ConstantInt::get(getGlobalContext(), APInt(8, 0)));
516 // Create a temporary to prevent nodes from resolving.
517 std::unique_ptr<MDNodeFwdDecl> Temp(MDNode::getTemporary(Context, None));
519 // When the first operand of N1 gets reset to nullptr, it'll collide with N2.
520 Metadata *Ops1[] = {CI, CI, Temp.get()};
521 Metadata *Ops2[] = {nullptr, CI, Temp.get()};
523 auto *N1 = MDTuple::get(Context, Ops1);
524 auto *N2 = MDTuple::get(Context, Ops2);
527 // Tell metadata that the constant is getting deleted.
529 // After this, N1 will be invalid, so don't touch it.
530 ValueAsMetadata::handleDeletion(CI->getValue());
531 EXPECT_EQ(nullptr, N2->getOperand(0));
532 EXPECT_EQ(nullptr, N2->getOperand(1));
533 EXPECT_EQ(Temp.get(), N2->getOperand(2));
535 // Clean up Temp for teardown.
536 Temp->replaceAllUsesWith(nullptr);
539 typedef MetadataTest TrackingMDRefTest;
541 TEST_F(TrackingMDRefTest, UpdatesOnRAUW) {
542 Type *Ty = Type::getInt1PtrTy(Context);
543 std::unique_ptr<GlobalVariable> GV0(
544 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
545 TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV0.get()));
546 EXPECT_TRUE(MD->getValue() == GV0.get());
547 ASSERT_TRUE(GV0->use_empty());
549 std::unique_ptr<GlobalVariable> GV1(
550 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
551 GV0->replaceAllUsesWith(GV1.get());
552 EXPECT_TRUE(MD->getValue() == GV1.get());
554 // Reset it, so we don't inadvertently test deletion.
558 TEST_F(TrackingMDRefTest, UpdatesOnDeletion) {
559 Type *Ty = Type::getInt1PtrTy(Context);
560 std::unique_ptr<GlobalVariable> GV(
561 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
562 TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV.get()));
563 EXPECT_TRUE(MD->getValue() == GV.get());
564 ASSERT_TRUE(GV->use_empty());
570 TEST(NamedMDNodeTest, Search) {
572 ConstantAsMetadata *C =
573 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 1));
574 ConstantAsMetadata *C2 =
575 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 2));
577 Metadata *const V = C;
578 Metadata *const V2 = C2;
579 MDNode *n = MDNode::get(Context, V);
580 MDNode *n2 = MDNode::get(Context, V2);
582 Module M("MyModule", Context);
583 const char *Name = "llvm.NMD1";
584 NamedMDNode *NMD = M.getOrInsertNamedMetadata(Name);
589 raw_string_ostream oss(Str);
591 EXPECT_STREQ("!llvm.NMD1 = !{!0, !1}\n",