llvm-project

1
//===- llvm/unittests/IR/MemoryModelRelaxationAnnotationsTest.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/IR/MemoryModelRelaxationAnnotations.h"
10
#include "llvm/ADT/STLExtras.h"
11
#include "llvm/IR/Metadata.h"
12
#include "llvm/IR/Module.h"
13
#include "gtest/gtest.h"
14

15
using namespace llvm;
16

17
namespace {
18

19
void checkMMRA(const MMRAMetadata &MMRA,
20
               ArrayRef<MMRAMetadata::TagT> Expected) {
21
  EXPECT_EQ(MMRA.size(), Expected.size());
22
  for (const auto &E : Expected)
23
    EXPECT_TRUE(MMRA.hasTag(E.first, E.second));
24
}
25

26
MMRAMetadata createFromMD(LLVMContext &Ctx,
27
                          ArrayRef<MMRAMetadata::TagT> Expected) {
28
  SmallVector<Metadata *> MD;
29
  for (const auto &Tag : Expected)
30
    MD.push_back(MMRAMetadata::getTagMD(Ctx, Tag));
31
  return MDTuple::get(Ctx, MD);
32
}
33

34
TEST(MMRATest, MDParse) {
35
  LLVMContext Ctx;
36

37
  // No nesting:
38
  // !{!"foo", "!bar"}
39
  MDNode *FooBar =
40
      MDTuple::get(Ctx, {MDString::get(Ctx, "foo"), MDString::get(Ctx, "bar")});
41
  MMRAMetadata FooBarMMRA(FooBar);
42

43
  checkMMRA(FooBarMMRA, {{"foo", "bar"}});
44

45
  // Nested:
46
  // !{!{!"foo", "!bar"}, !{!"bux", !"qux"}}
47
  MDNode *BuxQux =
48
      MDTuple::get(Ctx, {MDString::get(Ctx, "bux"), MDString::get(Ctx, "qux")});
49
  MDNode *Nested = MDTuple::get(Ctx, {FooBar, BuxQux});
50
  MMRAMetadata NestedMMRA(Nested);
51

52
  checkMMRA(NestedMMRA, {{"foo", "bar"}, {"bux", "qux"}});
53
}
54

55
TEST(MMRATest, GetMD) {
56
  LLVMContext Ctx;
57

58
  EXPECT_EQ(MMRAMetadata::getMD(Ctx, {}), nullptr);
59

60
  MDTuple *SingleMD = MMRAMetadata::getMD(Ctx, {{"foo", "bar"}});
61
  EXPECT_EQ(SingleMD->getNumOperands(), 2u);
62
  EXPECT_EQ(cast<MDString>(SingleMD->getOperand(0))->getString(), "foo");
63
  EXPECT_EQ(cast<MDString>(SingleMD->getOperand(1))->getString(), "bar");
64

65
  MDTuple *MultiMD = MMRAMetadata::getMD(Ctx, {{"foo", "bar"}, {"bux", "qux"}});
66
  EXPECT_EQ(MultiMD->getNumOperands(), 2u);
67

68
  MDTuple *FooBar = cast<MDTuple>(MultiMD->getOperand(0));
69
  EXPECT_EQ(cast<MDString>(FooBar->getOperand(0))->getString(), "foo");
70
  EXPECT_EQ(cast<MDString>(FooBar->getOperand(1))->getString(), "bar");
71
  MDTuple *BuxQux = cast<MDTuple>(MultiMD->getOperand(1));
72
  EXPECT_EQ(cast<MDString>(BuxQux->getOperand(0))->getString(), "bux");
73
  EXPECT_EQ(cast<MDString>(BuxQux->getOperand(1))->getString(), "qux");
74
}
75

76
TEST(MMRATest, Utility) {
77
  LLVMContext Ctx;
78
  MMRAMetadata MMRA =
79
      createFromMD(Ctx, {{"foo", "0"}, {"foo", "1"}, {"bar", "x"}});
80

81
  EXPECT_TRUE(MMRA.hasTagWithPrefix("foo"));
82
  EXPECT_TRUE(MMRA.hasTagWithPrefix("bar"));
83
  EXPECT_FALSE(MMRA.hasTagWithPrefix("x"));
84

85
  EXPECT_TRUE(MMRA.hasTag("foo", "0"));
86
  EXPECT_TRUE(MMRA.hasTag("foo", "1"));
87
  EXPECT_TRUE(MMRA.hasTag("bar", "x"));
88
}
89

90
TEST(MMRATest, Operators) {
91
  LLVMContext Ctx;
92

93
  MMRAMetadata A = createFromMD(Ctx, {{"foo", "0"}, {"bar", "x"}});
94
  MMRAMetadata B = createFromMD(Ctx, {{"foo", "0"}, {"bar", "y"}});
95

96
  // ensure we have different objects by creating copies.
97
  EXPECT_EQ(MMRAMetadata(A), MMRAMetadata(A));
98
  EXPECT_TRUE((bool)A);
99

100
  EXPECT_EQ(MMRAMetadata(B), MMRAMetadata(B));
101
  EXPECT_TRUE((bool)B);
102

103
  EXPECT_NE(A, B);
104

105
  EXPECT_EQ(MMRAMetadata(), MMRAMetadata());
106
  EXPECT_NE(A, MMRAMetadata());
107
  EXPECT_NE(B, MMRAMetadata());
108

109
  MMRAMetadata Empty;
110
  EXPECT_FALSE((bool)Empty);
111
}
112

113
TEST(MMRATest, Compatibility) {
114
  LLVMContext Ctx;
115

116
  MMRAMetadata Foo0 = createFromMD(Ctx, {{"foo", "0"}});
117
  MMRAMetadata Foo1 = createFromMD(Ctx, {{"foo", "1"}});
118
  MMRAMetadata Foo10 = createFromMD(Ctx, {{"foo", "0"}, {"foo", "1"}});
119

120
  MMRAMetadata Bar = createFromMD(Ctx, {{"bar", "y"}});
121

122
  MMRAMetadata Empty;
123

124
  // Other set has no tag with same prefix
125
  EXPECT_TRUE(Foo0.isCompatibleWith(Bar));
126
  EXPECT_TRUE(Bar.isCompatibleWith(Foo0));
127

128
  EXPECT_TRUE(Foo0.isCompatibleWith(Empty));
129
  EXPECT_TRUE(Empty.isCompatibleWith(Foo0));
130

131
  EXPECT_TRUE(Empty.isCompatibleWith(MMRAMetadata()));
132
  EXPECT_TRUE(MMRAMetadata().isCompatibleWith(Empty));
133

134
  // Other set has conflicting tags.
135
  EXPECT_FALSE(Foo1.isCompatibleWith(Foo0));
136
  EXPECT_FALSE(Foo0.isCompatibleWith(Foo1));
137

138
  // Both have common tags.
139
  EXPECT_TRUE(Foo0.isCompatibleWith(Foo0));
140
  EXPECT_TRUE(Foo0.isCompatibleWith(Foo10));
141
  EXPECT_TRUE(Foo10.isCompatibleWith(Foo0));
142

143
  EXPECT_TRUE(Foo1.isCompatibleWith(Foo1));
144
  EXPECT_TRUE(Foo1.isCompatibleWith(Foo10));
145
  EXPECT_TRUE(Foo10.isCompatibleWith(Foo1));
146

147
  // Try with more prefixes now:
148
  MMRAMetadata Multiple0 =
149
      createFromMD(Ctx, {{"foo", "y"}, {"foo", "x"}, {"bar", "z"}});
150
  MMRAMetadata Multiple1 =
151
      createFromMD(Ctx, {{"foo", "z"}, {"foo", "x"}, {"bar", "y"}});
152
  MMRAMetadata Multiple2 =
153
      createFromMD(Ctx, {{"foo", "z"}, {"foo", "x"}, {"bux", "y"}});
154

155
  // Multiple0 and Multiple1 are not compatible because "bar" is getting in the
156
  // way.
157
  EXPECT_FALSE(Multiple0.isCompatibleWith(Multiple1));
158
  EXPECT_FALSE(Multiple1.isCompatibleWith(Multiple0));
159

160
  EXPECT_TRUE(Multiple0.isCompatibleWith(Empty));
161
  EXPECT_TRUE(Empty.isCompatibleWith(Multiple0));
162
  EXPECT_TRUE(Multiple1.isCompatibleWith(Empty));
163
  EXPECT_TRUE(Empty.isCompatibleWith(Multiple1));
164

165
  // Multiple2 is compatible with both 1/0 because there is always "foo:x" in
166
  // common, and the other prefixes are unique to each set.
167
  EXPECT_TRUE(Multiple2.isCompatibleWith(Multiple0));
168
  EXPECT_TRUE(Multiple0.isCompatibleWith(Multiple2));
169
  EXPECT_TRUE(Multiple2.isCompatibleWith(Multiple1));
170
  EXPECT_TRUE(Multiple1.isCompatibleWith(Multiple2));
171
}
172

173
TEST(MMRATest, Combine) {
174
  LLVMContext Ctx;
175

176
  MMRAMetadata Foo0 = createFromMD(Ctx, {{"foo", "0"}});
177
  MMRAMetadata Foo10 = createFromMD(Ctx, {{"foo", "0"}, {"foo", "1"}});
178
  MMRAMetadata Bar0 = createFromMD(Ctx, {{"bar", "0"}});
179
  MMRAMetadata BarFoo0 = createFromMD(Ctx, {{"bar", "0"}, {"foo", "0"}});
180

181
  {
182
    // foo is common to both sets
183
    MMRAMetadata Combined = MMRAMetadata::combine(Ctx, Foo0, Foo10);
184
    EXPECT_EQ(Combined, Foo10);
185
  }
186

187
  {
188
    // nothing is common
189
    MMRAMetadata Combined = MMRAMetadata::combine(Ctx, Foo0, Bar0);
190
    EXPECT_TRUE(Combined.empty());
191
  }
192

193
  {
194
    // only foo is common.
195
    MMRAMetadata Combined = MMRAMetadata::combine(Ctx, BarFoo0, Foo0);
196
    EXPECT_EQ(Combined, Foo0);
197
  }
198

199
  {
200
    // only bar is common.
201
    MMRAMetadata Combined = MMRAMetadata::combine(Ctx, BarFoo0, Bar0);
202
    EXPECT_EQ(Combined, Bar0);
203
  }
204

205
  {
206
    // only foo is common
207
    MMRAMetadata Combined = MMRAMetadata::combine(Ctx, BarFoo0, Foo10);
208
    EXPECT_EQ(Combined, Foo10);
209
  }
210
}
211

212
} // namespace
213