| 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(""); |
| 28 |
MDString *Str1 = MDHelper.createString("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(0.0); |
| 35 |
MDNode *MD1 = MDHelper.createFPMath(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(0); |
| 40 |
EXPECT_TRUE(mdconst::hasa<ConstantFP>(Op)); |
| 41 |
ConstantFP *Val = mdconst::extract<ConstantFP>(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(A, A); |
| 49 |
MDNode *R1 = MDHelper.createRange(A, 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>(R1->getOperand(0)); |
| 56 |
ConstantInt *C1 = mdconst::extract<ConstantInt>(R1->getOperand(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("Root"); |
| 75 |
MDNode *R1 = MDHelper.createTBAARoot("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("Root"); |
| 85 |
MDNode *N0 = MDHelper.createTBAANode("Node", R); |
| 86 |
MDNode *N1 = MDHelper.createTBAANode("edoN", R); |
| 87 |
MDNode *N2 = MDHelper.createTBAANode("Node", R, true); |
| 88 |
MDNode *N3 = MDHelper.createTBAANode("Node", 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, APInt(8, 1)); |
| 111 |
ConstantInt *C2 = ConstantInt::get(Context, APInt(8, 2)); |
| 112 |
MDNode *PCS = MDHelper.createPCSections({{"s1", {C1, C2}}, {"s2", {}}}); |
| 113 |
ASSERT_EQ(PCS->getNumOperands(), 3U); |
| 114 |
const auto *S1 = dyn_cast<MDString>(PCS->getOperand(0)); |
| 115 |
const auto *Aux = dyn_cast<MDNode>(PCS->getOperand(1)); |
| 116 |
const auto *S2 = dyn_cast<MDString>(PCS->getOperand(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 |