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/IR/Metadata.h"
11 #include "llvm/IR/Constants.h"
12 #include "llvm/IR/Instructions.h"
13 #include "llvm/IR/LLVMContext.h"
14 #include "llvm/IR/Module.h"
15 #include "llvm/IR/Type.h"
16 #include "llvm/Support/raw_ostream.h"
17 #include "gtest/gtest.h"
22 class MetadataTest : public testing::Test {
26 typedef MetadataTest MDStringTest;
28 // Test that construction of MDString with different value produces different
29 // MDString objects, even with the same string pointer and nulls in the string.
30 TEST_F(MDStringTest, CreateDifferent) {
31 char x[3] = { 'f', 0, 'A' };
32 MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
34 MDString *s2 = MDString::get(Context, StringRef(&x[0], 3));
38 // Test that creation of MDStrings with the same string contents produces the
39 // same MDString object, even with different pointers.
40 TEST_F(MDStringTest, CreateSame) {
41 char x[4] = { 'a', 'b', 'c', 'X' };
42 char y[4] = { 'a', 'b', 'c', 'Y' };
44 MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
45 MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));
49 // Test that MDString prints out the string we fed it.
50 TEST_F(MDStringTest, PrintingSimple) {
51 char *str = new char[13];
52 strncpy(str, "testing 1 2 3", 13);
53 MDString *s = MDString::get(Context, StringRef(str, 13));
54 strncpy(str, "aaaaaaaaaaaaa", 13);
58 raw_string_ostream oss(Str);
60 EXPECT_STREQ("metadata !\"testing 1 2 3\"", oss.str().c_str());
63 // Test printing of MDString with non-printable characters.
64 TEST_F(MDStringTest, PrintingComplex) {
65 char str[5] = {0, '\n', '"', '\\', (char)-1};
66 MDString *s = MDString::get(Context, StringRef(str+0, 5));
68 raw_string_ostream oss(Str);
70 EXPECT_STREQ("metadata !\"\\00\\0A\\22\\5C\\FF\"", oss.str().c_str());
73 typedef MetadataTest MDNodeTest;
75 // Test the two constructors, and containing other Constants.
76 TEST_F(MDNodeTest, Simple) {
77 char x[3] = { 'a', 'b', 'c' };
78 char y[3] = { '1', '2', '3' };
80 MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
81 MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));
82 ConstantAsMetadata *CI = ConstantAsMetadata::get(
83 ConstantInt::get(getGlobalContext(), APInt(8, 0)));
85 std::vector<Metadata *> V;
90 MDNode *n1 = MDNode::get(Context, V);
91 Metadata *const c1 = n1;
92 MDNode *n2 = MDNode::get(Context, c1);
93 Metadata *const c2 = n2;
94 MDNode *n3 = MDNode::get(Context, V);
95 MDNode *n4 = MDNode::getIfExists(Context, V);
96 MDNode *n5 = MDNode::getIfExists(Context, c1);
97 MDNode *n6 = MDNode::getIfExists(Context, c2);
102 EXPECT_EQ(n6, (Metadata *)nullptr);
104 EXPECT_EQ(3u, n1->getNumOperands());
105 EXPECT_EQ(s1, n1->getOperand(0));
106 EXPECT_EQ(CI, n1->getOperand(1));
107 EXPECT_EQ(s2, n1->getOperand(2));
109 EXPECT_EQ(1u, n2->getNumOperands());
110 EXPECT_EQ(n1, n2->getOperand(0));
113 TEST_F(MDNodeTest, Delete) {
114 Constant *C = ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 1);
115 Instruction *I = new BitCastInst(C, Type::getInt32Ty(getGlobalContext()));
117 Metadata *const V = LocalAsMetadata::get(I);
118 MDNode *n = MDNode::get(Context, V);
119 TrackingMDRef wvh(n);
126 TEST_F(MDNodeTest, SelfReference) {
127 // !0 = metadata !{metadata !0}
128 // !1 = metadata !{metadata !0}
130 MDNode *Temp = MDNode::getTemporary(Context, None);
131 Metadata *Args[] = {Temp};
132 MDNode *Self = MDNode::get(Context, Args);
133 Self->replaceOperandWith(0, Self);
134 MDNode::deleteTemporary(Temp);
135 ASSERT_EQ(Self, Self->getOperand(0));
137 // Self-references should be distinct, so MDNode::get() should grab a
138 // uniqued node that references Self, not Self.
140 MDNode *Ref1 = MDNode::get(Context, Args);
141 MDNode *Ref2 = MDNode::get(Context, Args);
142 EXPECT_NE(Self, Ref1);
143 EXPECT_EQ(Ref1, Ref2);
146 // !0 = metadata !{metadata !0, metadata !{}}
147 // !1 = metadata !{metadata !0, metadata !{}}
149 MDNode *Temp = MDNode::getTemporary(Context, None);
150 Metadata *Args[] = {Temp, MDNode::get(Context, None)};
151 MDNode *Self = MDNode::get(Context, Args);
152 Self->replaceOperandWith(0, Self);
153 MDNode::deleteTemporary(Temp);
154 ASSERT_EQ(Self, Self->getOperand(0));
156 // Self-references should be distinct, so MDNode::get() should grab a
157 // uniqued node that references Self, not Self itself.
159 MDNode *Ref1 = MDNode::get(Context, Args);
160 MDNode *Ref2 = MDNode::get(Context, Args);
161 EXPECT_NE(Self, Ref1);
162 EXPECT_EQ(Ref1, Ref2);
166 typedef MetadataTest MetadataAsValueTest;
168 TEST_F(MetadataAsValueTest, MDNode) {
169 MDNode *N = MDNode::get(Context, None);
170 auto *V = MetadataAsValue::get(Context, N);
171 EXPECT_TRUE(V->getType()->isMetadataTy());
172 EXPECT_EQ(N, V->getMetadata());
174 auto *V2 = MetadataAsValue::get(Context, N);
178 TEST_F(MetadataAsValueTest, MDNodeMDNode) {
179 MDNode *N = MDNode::get(Context, None);
180 Metadata *Ops[] = {N};
181 MDNode *N2 = MDNode::get(Context, Ops);
182 auto *V = MetadataAsValue::get(Context, N2);
183 EXPECT_TRUE(V->getType()->isMetadataTy());
184 EXPECT_EQ(N2, V->getMetadata());
186 auto *V2 = MetadataAsValue::get(Context, N2);
189 auto *V3 = MetadataAsValue::get(Context, N);
190 EXPECT_TRUE(V3->getType()->isMetadataTy());
192 EXPECT_EQ(N, V3->getMetadata());
195 TEST_F(MetadataAsValueTest, MDNodeConstant) {
196 auto *C = ConstantInt::getTrue(Context);
197 auto *MD = ConstantAsMetadata::get(C);
198 Metadata *Ops[] = {MD};
199 auto *N = MDNode::get(Context, Ops);
201 auto *V = MetadataAsValue::get(Context, MD);
202 EXPECT_TRUE(V->getType()->isMetadataTy());
203 EXPECT_EQ(MD, V->getMetadata());
205 auto *V2 = MetadataAsValue::get(Context, N);
206 EXPECT_EQ(MD, V2->getMetadata());
210 typedef MetadataTest ValueAsMetadataTest;
212 TEST_F(ValueAsMetadataTest, UpdatesOnRAUW) {
213 Type *Ty = Type::getInt1PtrTy(Context);
214 std::unique_ptr<GlobalVariable> GV0(
215 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
216 auto *MD = ValueAsMetadata::get(GV0.get());
217 EXPECT_TRUE(MD->getValue() == GV0.get());
218 ASSERT_TRUE(GV0->use_empty());
220 std::unique_ptr<GlobalVariable> GV1(
221 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
222 GV0->replaceAllUsesWith(GV1.get());
223 EXPECT_TRUE(MD->getValue() == GV1.get());
226 typedef MetadataTest TrackingMDRefTest;
228 TEST_F(TrackingMDRefTest, UpdatesOnRAUW) {
229 Type *Ty = Type::getInt1PtrTy(Context);
230 std::unique_ptr<GlobalVariable> GV0(
231 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
232 TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV0.get()));
233 EXPECT_TRUE(MD->getValue() == GV0.get());
234 ASSERT_TRUE(GV0->use_empty());
236 std::unique_ptr<GlobalVariable> GV1(
237 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
238 GV0->replaceAllUsesWith(GV1.get());
239 EXPECT_TRUE(MD->getValue() == GV1.get());
241 // Reset it, so we don't inadvertently test deletion.
245 TEST_F(TrackingMDRefTest, UpdatesOnDeletion) {
246 Type *Ty = Type::getInt1PtrTy(Context);
247 std::unique_ptr<GlobalVariable> GV(
248 new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
249 TypedTrackingMDRef<ValueAsMetadata> MD(ValueAsMetadata::get(GV.get()));
250 EXPECT_TRUE(MD->getValue() == GV.get());
251 ASSERT_TRUE(GV->use_empty());
257 TEST(NamedMDNodeTest, Search) {
259 ConstantAsMetadata *C =
260 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 1));
261 ConstantAsMetadata *C2 =
262 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 2));
264 Metadata *const V = C;
265 Metadata *const V2 = C2;
266 MDNode *n = MDNode::get(Context, V);
267 MDNode *n2 = MDNode::get(Context, V2);
269 Module M("MyModule", Context);
270 const char *Name = "llvm.NMD1";
271 NamedMDNode *NMD = M.getOrInsertNamedMetadata(Name);
276 raw_string_ostream oss(Str);
278 EXPECT_STREQ("!llvm.NMD1 = !{!0, !1}\n",