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->begin()));
43 EXPECT_TRUE((++F->arg_begin())->isUsedInBasicBlock(F->begin()));
44 EXPECT_TRUE(F->arg_begin()->isUsedInBasicBlock(F->begin()));
47 TEST(GlobalTest, CreateAddressSpace) {
48 LLVMContext &Ctx = getGlobalContext();
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) {
95 LLVMContext &Ctx = getGlobalContext();
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