1 //===- llvm/unittest/IR/ValueTest.cpp - Value 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/AsmParser/Parser.h"
11 #include "llvm/IR/Function.h"
12 #include "llvm/IR/LLVMContext.h"
13 #include "llvm/IR/Module.h"
14 #include "llvm/IR/ModuleSlotTracker.h"
15 #include "llvm/IR/Value.h"
16 #include "llvm/Support/SourceMgr.h"
17 #include "gtest/gtest.h"
22 TEST(ValueTest
, UsedInBasicBlock
) {
25 const char *ModuleString
= "define void @f(i32 %x, i32 %y) {\n"
27 " %y1 = add i32 %y, 1\n"
28 " %y2 = add i32 %y, 1\n"
29 " %y3 = add i32 %y, 1\n"
30 " %y4 = add i32 %y, 1\n"
31 " %y5 = add i32 %y, 1\n"
32 " %y6 = add i32 %y, 1\n"
33 " %y7 = add i32 %y, 1\n"
34 " %y8 = add i32 %x, 1\n"
38 std::unique_ptr
<Module
> M
= parseAssemblyString(ModuleString
, Err
, C
);
40 Function
*F
= M
->getFunction("f");
42 EXPECT_FALSE(F
->isUsedInBasicBlock(&F
->front()));
43 EXPECT_TRUE((++F
->arg_begin())->isUsedInBasicBlock(&F
->front()));
44 EXPECT_TRUE(F
->arg_begin()->isUsedInBasicBlock(&F
->front()));
47 TEST(GlobalTest
, CreateAddressSpace
) {
49 std::unique_ptr
<Module
> M(new Module("TestModule", Ctx
));
50 Type
*Int8Ty
= Type::getInt8Ty(Ctx
);
51 Type
*Int32Ty
= Type::getInt32Ty(Ctx
);
53 GlobalVariable
*Dummy0
54 = new GlobalVariable(*M
,
57 GlobalValue::ExternalLinkage
,
58 Constant::getAllOnesValue(Int32Ty
),
61 GlobalVariable::NotThreadLocal
,
64 EXPECT_TRUE(Value::MaximumAlignment
== 536870912U);
65 Dummy0
->setAlignment(536870912U);
66 EXPECT_EQ(Dummy0
->getAlignment(), 536870912U);
68 // Make sure the address space isn't dropped when returning this.
69 Constant
*Dummy1
= M
->getOrInsertGlobal("dummy", Int32Ty
);
70 EXPECT_EQ(Dummy0
, Dummy1
);
71 EXPECT_EQ(1u, Dummy1
->getType()->getPointerAddressSpace());
74 // This one requires a bitcast, but the address space must also stay the same.
75 GlobalVariable
*DummyCast0
76 = new GlobalVariable(*M
,
79 GlobalValue::ExternalLinkage
,
80 Constant::getAllOnesValue(Int32Ty
),
83 GlobalVariable::NotThreadLocal
,
86 // Make sure the address space isn't dropped when returning this.
87 Constant
*DummyCast1
= M
->getOrInsertGlobal("dummy_cast", Int8Ty
);
88 EXPECT_EQ(1u, DummyCast1
->getType()->getPointerAddressSpace());
89 EXPECT_NE(DummyCast0
, DummyCast1
) << *DummyCast1
;
92 #ifdef GTEST_HAS_DEATH_TEST
94 TEST(GlobalTest
, AlignDeath
) {
96 std::unique_ptr
<Module
> M(new Module("TestModule", Ctx
));
97 Type
*Int32Ty
= Type::getInt32Ty(Ctx
);
99 new GlobalVariable(*M
, Int32Ty
, true, GlobalValue::ExternalLinkage
,
100 Constant::getAllOnesValue(Int32Ty
), "var", nullptr,
101 GlobalVariable::NotThreadLocal
, 1);
103 EXPECT_DEATH(Var
->setAlignment(536870913U), "Alignment is not a power of 2");
104 EXPECT_DEATH(Var
->setAlignment(1073741824U),
105 "Alignment is greater than MaximumAlignment");
110 TEST(ValueTest
, printSlots
) {
111 // Check that Value::print() and Value::printAsOperand() work with and
112 // without a slot tracker.
115 const char *ModuleString
= "define void @f(i32 %x, i32 %y) {\n"
117 " %0 = add i32 %y, 1\n"
118 " %1 = add i32 %y, 1\n"
122 std::unique_ptr
<Module
> M
= parseAssemblyString(ModuleString
, Err
, C
);
124 Function
*F
= M
->getFunction("f");
126 ASSERT_FALSE(F
->empty());
127 BasicBlock
&BB
= F
->getEntryBlock();
128 ASSERT_EQ(3u, BB
.size());
130 Instruction
*I0
= &*BB
.begin();
132 Instruction
*I1
= &*++BB
.begin();
135 ModuleSlotTracker
MST(M
.get());
137 #define CHECK_PRINT(INST, STR) \
141 raw_string_ostream OS(S); \
143 EXPECT_EQ(STR, OS.str()); \
147 raw_string_ostream OS(S); \
148 INST->print(OS, MST); \
149 EXPECT_EQ(STR, OS.str()); \
152 CHECK_PRINT(I0
, " %0 = add i32 %y, 1");
153 CHECK_PRINT(I1
, " %1 = add i32 %y, 1");
156 #define CHECK_PRINT_AS_OPERAND(INST, TYPE, STR) \
160 raw_string_ostream OS(S); \
161 INST->printAsOperand(OS, TYPE); \
162 EXPECT_EQ(StringRef(STR), StringRef(OS.str())); \
166 raw_string_ostream OS(S); \
167 INST->printAsOperand(OS, TYPE, MST); \
168 EXPECT_EQ(StringRef(STR), StringRef(OS.str())); \
171 CHECK_PRINT_AS_OPERAND(I0
, false, "%0");
172 CHECK_PRINT_AS_OPERAND(I1
, false, "%1");
173 CHECK_PRINT_AS_OPERAND(I0
, true, "i32 %0");
174 CHECK_PRINT_AS_OPERAND(I1
, true, "i32 %1");
175 #undef CHECK_PRINT_AS_OPERAND
178 TEST(ValueTest
, getLocalSlots
) {
179 // Verify that the getLocalSlot method returns the correct slot numbers.
181 const char *ModuleString
= "define void @f(i32 %x, i32 %y) {\n"
183 " %0 = add i32 %y, 1\n"
184 " %1 = add i32 %y, 1\n"
190 std::unique_ptr
<Module
> M
= parseAssemblyString(ModuleString
, Err
, C
);
192 Function
*F
= M
->getFunction("f");
194 ASSERT_FALSE(F
->empty());
195 BasicBlock
&EntryBB
= F
->getEntryBlock();
196 ASSERT_EQ(3u, EntryBB
.size());
197 BasicBlock
*BB2
= &*++F
->begin();
200 Instruction
*I0
= &*EntryBB
.begin();
202 Instruction
*I1
= &*++EntryBB
.begin();
205 ModuleSlotTracker
MST(M
.get());
206 MST
.incorporateFunction(*F
);
207 EXPECT_EQ(MST
.getLocalSlot(I0
), 0);
208 EXPECT_EQ(MST
.getLocalSlot(I1
), 1);
209 EXPECT_EQ(MST
.getLocalSlot(&EntryBB
), -1);
210 EXPECT_EQ(MST
.getLocalSlot(BB2
), 2);
213 #if defined(GTEST_HAS_DEATH_TEST) && !defined(NDEBUG)
214 TEST(ValueTest
, getLocalSlotDeath
) {
216 const char *ModuleString
= "define void @f(i32 %x, i32 %y) {\n"
218 " %0 = add i32 %y, 1\n"
219 " %1 = add i32 %y, 1\n"
225 std::unique_ptr
<Module
> M
= parseAssemblyString(ModuleString
, Err
, C
);
227 Function
*F
= M
->getFunction("f");
229 ASSERT_FALSE(F
->empty());
230 BasicBlock
*BB2
= &*++F
->begin();
233 ModuleSlotTracker
MST(M
.get());
234 EXPECT_DEATH(MST
.getLocalSlot(BB2
), "No function incorporated");
238 } // end anonymous namespace