1 | //===- llvm/unittests/MDBuilderTest.cpp - MDBuilder unit tests ------------===// |
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/MDBuilder.h" |
10 | #include "llvm/IR/Constants.h" |
11 | #include "llvm/IR/IRBuilder.h" |
12 | #include "llvm/IR/Metadata.h" |
13 | #include "llvm/IR/Operator.h" |
14 | #include "gtest/gtest.h" |
15 | |
16 | using namespace llvm; |
17 | |
18 | namespace { |
19 | |
20 | class MDBuilderTest : public testing::Test { |
21 | protected: |
22 | LLVMContext Context; |
23 | }; |
24 | |
25 | TEST_F(MDBuilderTest, createString) { |
26 | MDBuilder MDHelper(Context); |
27 | MDString *Str0 = MDHelper.createString(Str: "" ); |
28 | MDString *Str1 = MDHelper.createString(Str: "string" ); |
29 | EXPECT_EQ(Str0->getString(), StringRef("" )); |
30 | EXPECT_EQ(Str1->getString(), StringRef("string" )); |
31 | } |
32 | TEST_F(MDBuilderTest, createFPMath) { |
33 | MDBuilder MDHelper(Context); |
34 | MDNode *MD0 = MDHelper.createFPMath(Accuracy: 0.0); |
35 | MDNode *MD1 = MDHelper.createFPMath(Accuracy: 1.0); |
36 | EXPECT_EQ(MD0, (MDNode *)nullptr); |
37 | EXPECT_NE(MD1, (MDNode *)nullptr); |
38 | EXPECT_EQ(MD1->getNumOperands(), 1U); |
39 | Metadata *Op = MD1->getOperand(I: 0); |
40 | EXPECT_TRUE(mdconst::hasa<ConstantFP>(Op)); |
41 | ConstantFP *Val = mdconst::extract<ConstantFP>(MD&: Op); |
42 | EXPECT_TRUE(Val->getType()->isFloatingPointTy()); |
43 | EXPECT_TRUE(Val->isExactlyValue(1.0)); |
44 | } |
45 | TEST_F(MDBuilderTest, createRangeMetadata) { |
46 | MDBuilder MDHelper(Context); |
47 | APInt A(8, 1), B(8, 2); |
48 | MDNode *R0 = MDHelper.createRange(Lo: A, Hi: A); |
49 | MDNode *R1 = MDHelper.createRange(Lo: A, Hi: B); |
50 | EXPECT_EQ(R0, (MDNode *)nullptr); |
51 | EXPECT_NE(R1, (MDNode *)nullptr); |
52 | EXPECT_EQ(R1->getNumOperands(), 2U); |
53 | EXPECT_TRUE(mdconst::hasa<ConstantInt>(R1->getOperand(0))); |
54 | EXPECT_TRUE(mdconst::hasa<ConstantInt>(R1->getOperand(1))); |
55 | ConstantInt *C0 = mdconst::extract<ConstantInt>(MD: R1->getOperand(I: 0)); |
56 | ConstantInt *C1 = mdconst::extract<ConstantInt>(MD: R1->getOperand(I: 1)); |
57 | EXPECT_EQ(C0->getValue(), A); |
58 | EXPECT_EQ(C1->getValue(), B); |
59 | } |
60 | TEST_F(MDBuilderTest, createAnonymousTBAARoot) { |
61 | MDBuilder MDHelper(Context); |
62 | MDNode *R0 = MDHelper.createAnonymousTBAARoot(); |
63 | MDNode *R1 = MDHelper.createAnonymousTBAARoot(); |
64 | EXPECT_NE(R0, R1); |
65 | EXPECT_GE(R0->getNumOperands(), 1U); |
66 | EXPECT_GE(R1->getNumOperands(), 1U); |
67 | EXPECT_EQ(R0->getOperand(0), R0); |
68 | EXPECT_EQ(R1->getOperand(0), R1); |
69 | EXPECT_TRUE(R0->getNumOperands() == 1 || R0->getOperand(1) == nullptr); |
70 | EXPECT_TRUE(R1->getNumOperands() == 1 || R1->getOperand(1) == nullptr); |
71 | } |
72 | TEST_F(MDBuilderTest, createTBAARoot) { |
73 | MDBuilder MDHelper(Context); |
74 | MDNode *R0 = MDHelper.createTBAARoot(Name: "Root" ); |
75 | MDNode *R1 = MDHelper.createTBAARoot(Name: "Root" ); |
76 | EXPECT_EQ(R0, R1); |
77 | EXPECT_GE(R0->getNumOperands(), 1U); |
78 | EXPECT_TRUE(isa<MDString>(R0->getOperand(0))); |
79 | EXPECT_EQ(cast<MDString>(R0->getOperand(0))->getString(), "Root" ); |
80 | EXPECT_TRUE(R0->getNumOperands() == 1 || R0->getOperand(1) == nullptr); |
81 | } |
82 | TEST_F(MDBuilderTest, createTBAANode) { |
83 | MDBuilder MDHelper(Context); |
84 | MDNode *R = MDHelper.createTBAARoot(Name: "Root" ); |
85 | MDNode *N0 = MDHelper.createTBAANode(Name: "Node" , Parent: R); |
86 | MDNode *N1 = MDHelper.createTBAANode(Name: "edoN" , Parent: R); |
87 | MDNode *N2 = MDHelper.createTBAANode(Name: "Node" , Parent: R, isConstant: true); |
88 | MDNode *N3 = MDHelper.createTBAANode(Name: "Node" , Parent: R); |
89 | EXPECT_EQ(N0, N3); |
90 | EXPECT_NE(N0, N1); |
91 | EXPECT_NE(N0, N2); |
92 | EXPECT_GE(N0->getNumOperands(), 2U); |
93 | EXPECT_GE(N1->getNumOperands(), 2U); |
94 | EXPECT_GE(N2->getNumOperands(), 3U); |
95 | EXPECT_TRUE(isa<MDString>(N0->getOperand(0))); |
96 | EXPECT_TRUE(isa<MDString>(N1->getOperand(0))); |
97 | EXPECT_TRUE(isa<MDString>(N2->getOperand(0))); |
98 | EXPECT_EQ(cast<MDString>(N0->getOperand(0))->getString(), "Node" ); |
99 | EXPECT_EQ(cast<MDString>(N1->getOperand(0))->getString(), "edoN" ); |
100 | EXPECT_EQ(cast<MDString>(N2->getOperand(0))->getString(), "Node" ); |
101 | EXPECT_EQ(N0->getOperand(1), R); |
102 | EXPECT_EQ(N1->getOperand(1), R); |
103 | EXPECT_EQ(N2->getOperand(1), R); |
104 | EXPECT_TRUE(mdconst::hasa<ConstantInt>(N2->getOperand(2))); |
105 | EXPECT_EQ(mdconst::extract<ConstantInt>(N2->getOperand(2))->getZExtValue(), |
106 | 1U); |
107 | } |
108 | TEST_F(MDBuilderTest, createPCSections) { |
109 | MDBuilder MDHelper(Context); |
110 | ConstantInt *C1 = ConstantInt::get(Context, V: APInt(8, 1)); |
111 | ConstantInt *C2 = ConstantInt::get(Context, V: APInt(8, 2)); |
112 | MDNode *PCS = MDHelper.createPCSections(Sections: {{"s1" , {C1, C2}}, {"s2" , {}}}); |
113 | ASSERT_EQ(PCS->getNumOperands(), 3U); |
114 | const auto *S1 = dyn_cast<MDString>(Val: PCS->getOperand(I: 0)); |
115 | const auto *Aux = dyn_cast<MDNode>(Val: PCS->getOperand(I: 1)); |
116 | const auto *S2 = dyn_cast<MDString>(Val: PCS->getOperand(I: 2)); |
117 | ASSERT_NE(S1, nullptr); |
118 | ASSERT_NE(Aux, nullptr); |
119 | ASSERT_NE(S2, nullptr); |
120 | EXPECT_EQ(S1->getString(), "s1" ); |
121 | EXPECT_EQ(S2->getString(), "s2" ); |
122 | ASSERT_EQ(Aux->getNumOperands(), 2U); |
123 | ASSERT_TRUE(isa<ConstantAsMetadata>(Aux->getOperand(0))); |
124 | ASSERT_TRUE(isa<ConstantAsMetadata>(Aux->getOperand(1))); |
125 | EXPECT_EQ(mdconst::extract<ConstantInt>(Aux->getOperand(0))->getValue(), |
126 | C1->getValue()); |
127 | EXPECT_EQ(mdconst::extract<ConstantInt>(Aux->getOperand(1))->getValue(), |
128 | C2->getValue()); |
129 | } |
130 | } // namespace |
131 | |