Bug Summary

File:unittests/IR/ValueTest.cpp
Location:line 234, column 3
Description:Function call argument is an uninitialized value

Annotated Source Code

1//===- llvm/unittest/IR/ValueTest.cpp - Value unit tests ------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
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"
18using namespace llvm;
19
20namespace {
21
22TEST(ValueTest, UsedInBasicBlock)class ValueTest_UsedInBasicBlock_Test : public ::testing::Test
{ public: ValueTest_UsedInBasicBlock_Test() {} private: virtual
void TestBody(); static ::testing::TestInfo* const test_info_
__attribute__ ((unused)); ValueTest_UsedInBasicBlock_Test(ValueTest_UsedInBasicBlock_Test
const &); void operator=(ValueTest_UsedInBasicBlock_Test
const &);};::testing::TestInfo* const ValueTest_UsedInBasicBlock_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"ValueTest", "UsedInBasicBlock", __null, __null, (::testing::
internal::GetTestTypeId()), ::testing::Test::SetUpTestCase, ::
testing::Test::TearDownTestCase, new ::testing::internal::TestFactoryImpl
< ValueTest_UsedInBasicBlock_Test>);void ValueTest_UsedInBasicBlock_Test
::TestBody()
{
23 LLVMContext C;
24
25 const char *ModuleString = "define void @f(i32 %x, i32 %y) {\n"
26 "bb0:\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"
35 " ret void\n"
36 "}\n";
37 SMDiagnostic Err;
38 std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
39
40 Function *F = M->getFunction("f");
41
42 EXPECT_FALSE(F->isUsedInBasicBlock(&F->front()))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(!(F->isUsedInBasicBlock
(&F->front())))) ; else ::testing::internal::AssertHelper
(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 42, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "F->isUsedInBasicBlock(&F->front())", "true", "false"
).c_str()) = ::testing::Message()
;
43 EXPECT_TRUE((++F->arg_begin())->isUsedInBasicBlock(&F->front()))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult((++F->arg_begin())
->isUsedInBasicBlock(&F->front()))) ; else ::testing
::internal::AssertHelper(::testing::TestPartResult::kNonFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 43, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "(++F->arg_begin())->isUsedInBasicBlock(&F->front())"
, "false", "true").c_str()) = ::testing::Message()
;
44 EXPECT_TRUE(F->arg_begin()->isUsedInBasicBlock(&F->front()))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(F->arg_begin()->
isUsedInBasicBlock(&F->front()))) ; else ::testing::internal
::AssertHelper(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 44, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "F->arg_begin()->isUsedInBasicBlock(&F->front())"
, "false", "true").c_str()) = ::testing::Message()
;
45}
46
47TEST(GlobalTest, CreateAddressSpace)class GlobalTest_CreateAddressSpace_Test : public ::testing::
Test { public: GlobalTest_CreateAddressSpace_Test() {} private
: virtual void TestBody(); static ::testing::TestInfo* const test_info_
__attribute__ ((unused)); GlobalTest_CreateAddressSpace_Test
(GlobalTest_CreateAddressSpace_Test const &); void operator
=(GlobalTest_CreateAddressSpace_Test const &);};::testing
::TestInfo* const GlobalTest_CreateAddressSpace_Test ::test_info_
= ::testing::internal::MakeAndRegisterTestInfo( "GlobalTest"
, "CreateAddressSpace", __null, __null, (::testing::internal::
GetTestTypeId()), ::testing::Test::SetUpTestCase, ::testing::
Test::TearDownTestCase, new ::testing::internal::TestFactoryImpl
< GlobalTest_CreateAddressSpace_Test>);void GlobalTest_CreateAddressSpace_Test
::TestBody()
{
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);
52
53 GlobalVariable *Dummy0
54 = new GlobalVariable(*M,
55 Int32Ty,
56 true,
57 GlobalValue::ExternalLinkage,
58 Constant::getAllOnesValue(Int32Ty),
59 "dummy",
60 nullptr,
61 GlobalVariable::NotThreadLocal,
62 1);
63
64 EXPECT_TRUE(Value::MaximumAlignment == 536870912U)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(Value::MaximumAlignment
== 536870912U)) ; else ::testing::internal::AssertHelper(::testing
::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 64, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "Value::MaximumAlignment == 536870912U", "false", "true").c_str
()) = ::testing::Message()
;
65 Dummy0->setAlignment(536870912U);
66 EXPECT_EQ(Dummy0->getAlignment(), 536870912U)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(Dummy0->getAlignment())) ==
1)>::Compare("Dummy0->getAlignment()", "536870912U", Dummy0
->getAlignment(), 536870912U))) ; else ::testing::internal
::AssertHelper(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 66, gtest_ar.failure_message()) = ::testing::Message()
;
67
68 // Make sure the address space isn't dropped when returning this.
69 Constant *Dummy1 = M->getOrInsertGlobal("dummy", Int32Ty);
70 EXPECT_EQ(Dummy0, Dummy1)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(Dummy0)) == 1)>::Compare("Dummy0"
, "Dummy1", Dummy0, Dummy1))) ; else ::testing::internal::AssertHelper
(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 70, gtest_ar.failure_message()) = ::testing::Message()
;
71 EXPECT_EQ(1u, Dummy1->getType()->getPointerAddressSpace())switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(1u)) == 1)>::Compare("1u",
"Dummy1->getType()->getPointerAddressSpace()", 1u, Dummy1
->getType()->getPointerAddressSpace()))) ; else ::testing
::internal::AssertHelper(::testing::TestPartResult::kNonFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 71, gtest_ar.failure_message()) = ::testing::Message()
;
72
73
74 // This one requires a bitcast, but the address space must also stay the same.
75 GlobalVariable *DummyCast0
76 = new GlobalVariable(*M,
77 Int32Ty,
78 true,
79 GlobalValue::ExternalLinkage,
80 Constant::getAllOnesValue(Int32Ty),
81 "dummy_cast",
82 nullptr,
83 GlobalVariable::NotThreadLocal,
84 1);
85
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())switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(1u)) == 1)>::Compare("1u",
"DummyCast1->getType()->getPointerAddressSpace()", 1u,
DummyCast1->getType()->getPointerAddressSpace()))) ; else
::testing::internal::AssertHelper(::testing::TestPartResult::
kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 88, gtest_ar.failure_message()) = ::testing::Message()
;
89 EXPECT_NE(DummyCast0, DummyCast1)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal::CmpHelperNE("DummyCast0", "DummyCast1"
, DummyCast0, DummyCast1))) ; else ::testing::internal::AssertHelper
(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 89, gtest_ar.failure_message()) = ::testing::Message()
<< *DummyCast1;
90}
91
92#ifdef GTEST_HAS_DEATH_TEST1
93#ifndef NDEBUG
94TEST(GlobalTest, AlignDeath)class GlobalTest_AlignDeath_Test : public ::testing::Test { public
: GlobalTest_AlignDeath_Test() {} private: virtual void TestBody
(); static ::testing::TestInfo* const test_info_ __attribute__
((unused)); GlobalTest_AlignDeath_Test(GlobalTest_AlignDeath_Test
const &); void operator=(GlobalTest_AlignDeath_Test const
&);};::testing::TestInfo* const GlobalTest_AlignDeath_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"GlobalTest", "AlignDeath", __null, __null, (::testing::internal
::GetTestTypeId()), ::testing::Test::SetUpTestCase, ::testing
::Test::TearDownTestCase, new ::testing::internal::TestFactoryImpl
< GlobalTest_AlignDeath_Test>);void GlobalTest_AlignDeath_Test
::TestBody()
{
95 LLVMContext &Ctx = getGlobalContext();
96 std::unique_ptr<Module> M(new Module("TestModule", Ctx));
97 Type *Int32Ty = Type::getInt32Ty(Ctx);
98 GlobalVariable *Var =
99 new GlobalVariable(*M, Int32Ty, true, GlobalValue::ExternalLinkage,
100 Constant::getAllOnesValue(Int32Ty), "var", nullptr,
101 GlobalVariable::NotThreadLocal, 1);
102
103 EXPECT_DEATH(Var->setAlignment(536870913U), "Alignment is not a power of 2")switch (0) case 0: default: if (::testing::internal::AlwaysTrue
()) { const ::testing::internal::RE& gtest_regex = ("Alignment is not a power of 2"
); ::testing::internal::DeathTest* gtest_dt; if (!::testing::
internal::DeathTest::Create("Var->setAlignment(536870913U)"
, &gtest_regex, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 103, &gtest_dt)) { goto gtest_label_103; } if (gtest_dt
!= __null) { ::testing::internal::scoped_ptr< ::testing::
internal::DeathTest> gtest_dt_ptr(gtest_dt); switch (gtest_dt
->AssumeRole()) { case ::testing::internal::DeathTest::OVERSEE_TEST
: if (!gtest_dt->Passed(::testing::internal::ExitedUnsuccessfully
(gtest_dt->Wait()))) { goto gtest_label_103; } break; case
::testing::internal::DeathTest::EXECUTE_TEST: { ::testing::internal
::DeathTest::ReturnSentinel gtest_sentinel(gtest_dt); if (::testing
::internal::AlwaysTrue()) { Var->setAlignment(536870913U);
}; gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE
); break; } } } } else gtest_label_103: ::testing::internal::
AssertHelper(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 103, ::testing::internal::DeathTest::LastMessage()) = ::testing
::Message()
;
104 EXPECT_DEATH(Var->setAlignment(1073741824U),switch (0) case 0: default: if (::testing::internal::AlwaysTrue
()) { const ::testing::internal::RE& gtest_regex = ("Alignment is greater than MaximumAlignment"
); ::testing::internal::DeathTest* gtest_dt; if (!::testing::
internal::DeathTest::Create("Var->setAlignment(1073741824U)"
, &gtest_regex, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 105, &gtest_dt)) { goto gtest_label_105; } if (gtest_dt
!= __null) { ::testing::internal::scoped_ptr< ::testing::
internal::DeathTest> gtest_dt_ptr(gtest_dt); switch (gtest_dt
->AssumeRole()) { case ::testing::internal::DeathTest::OVERSEE_TEST
: if (!gtest_dt->Passed(::testing::internal::ExitedUnsuccessfully
(gtest_dt->Wait()))) { goto gtest_label_105; } break; case
::testing::internal::DeathTest::EXECUTE_TEST: { ::testing::internal
::DeathTest::ReturnSentinel gtest_sentinel(gtest_dt); if (::testing
::internal::AlwaysTrue()) { Var->setAlignment(1073741824U)
; }; gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE
); break; } } } } else gtest_label_105: ::testing::internal::
AssertHelper(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 105, ::testing::internal::DeathTest::LastMessage()) = ::testing
::Message()
105 "Alignment is greater than MaximumAlignment")switch (0) case 0: default: if (::testing::internal::AlwaysTrue
()) { const ::testing::internal::RE& gtest_regex = ("Alignment is greater than MaximumAlignment"
); ::testing::internal::DeathTest* gtest_dt; if (!::testing::
internal::DeathTest::Create("Var->setAlignment(1073741824U)"
, &gtest_regex, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 105, &gtest_dt)) { goto gtest_label_105; } if (gtest_dt
!= __null) { ::testing::internal::scoped_ptr< ::testing::
internal::DeathTest> gtest_dt_ptr(gtest_dt); switch (gtest_dt
->AssumeRole()) { case ::testing::internal::DeathTest::OVERSEE_TEST
: if (!gtest_dt->Passed(::testing::internal::ExitedUnsuccessfully
(gtest_dt->Wait()))) { goto gtest_label_105; } break; case
::testing::internal::DeathTest::EXECUTE_TEST: { ::testing::internal
::DeathTest::ReturnSentinel gtest_sentinel(gtest_dt); if (::testing
::internal::AlwaysTrue()) { Var->setAlignment(1073741824U)
; }; gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE
); break; } } } } else gtest_label_105: ::testing::internal::
AssertHelper(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 105, ::testing::internal::DeathTest::LastMessage()) = ::testing
::Message()
;
106}
107#endif
108#endif
109
110TEST(ValueTest, printSlots)class ValueTest_printSlots_Test : public ::testing::Test { public
: ValueTest_printSlots_Test() {} private: virtual void TestBody
(); static ::testing::TestInfo* const test_info_ __attribute__
((unused)); ValueTest_printSlots_Test(ValueTest_printSlots_Test
const &); void operator=(ValueTest_printSlots_Test const
&);};::testing::TestInfo* const ValueTest_printSlots_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"ValueTest", "printSlots", __null, __null, (::testing::internal
::GetTestTypeId()), ::testing::Test::SetUpTestCase, ::testing
::Test::TearDownTestCase, new ::testing::internal::TestFactoryImpl
< ValueTest_printSlots_Test>);void ValueTest_printSlots_Test
::TestBody()
{
111 // Check that Value::print() and Value::printAsOperand() work with and
112 // without a slot tracker.
113 LLVMContext C;
114
115 const char *ModuleString = "define void @f(i32 %x, i32 %y) {\n"
116 "entry:\n"
117 " %0 = add i32 %y, 1\n"
118 " %1 = add i32 %y, 1\n"
119 " ret void\n"
120 "}\n";
121 SMDiagnostic Err;
122 std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
123
124 Function *F = M->getFunction("f");
125 ASSERT_TRUE(F)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(F)) ; else return ::testing
::internal::AssertHelper(::testing::TestPartResult::kFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 125, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "F", "false", "true").c_str()) = ::testing::Message()
;
126 ASSERT_FALSE(F->empty())switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(!(F->empty()))) ; else
return ::testing::internal::AssertHelper(::testing::TestPartResult
::kFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 126, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "F->empty()", "true", "false").c_str()) = ::testing::Message
()
;
127 BasicBlock &BB = F->getEntryBlock();
128 ASSERT_EQ(3u, BB.size())switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(3u)) == 1)>::Compare("3u",
"BB.size()", 3u, BB.size()))) ; else return ::testing::internal
::AssertHelper(::testing::TestPartResult::kFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 128, gtest_ar.failure_message()) = ::testing::Message()
;
129
130 Instruction *I0 = &*BB.begin();
131 ASSERT_TRUE(I0)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(I0)) ; else return ::
testing::internal::AssertHelper(::testing::TestPartResult::kFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 131, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "I0", "false", "true").c_str()) = ::testing::Message()
;
132 Instruction *I1 = &*++BB.begin();
133 ASSERT_TRUE(I1)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(I1)) ; else return ::
testing::internal::AssertHelper(::testing::TestPartResult::kFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 133, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "I1", "false", "true").c_str()) = ::testing::Message()
;
134
135 ModuleSlotTracker MST(M.get());
136
137#define CHECK_PRINT(INST, STR) \
138 do { \
139 { \
140 std::string S; \
141 raw_string_ostream OS(S); \
142 INST->print(OS); \
143 EXPECT_EQ(STR, OS.str())switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(STR)) == 1)>::Compare("STR"
, "OS.str()", STR, OS.str()))) ; else ::testing::internal::AssertHelper
(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 143, gtest_ar.failure_message()) = ::testing::Message()
; \
144 } \
145 { \
146 std::string S; \
147 raw_string_ostream OS(S); \
148 INST->print(OS, MST); \
149 EXPECT_EQ(STR, OS.str())switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(STR)) == 1)>::Compare("STR"
, "OS.str()", STR, OS.str()))) ; else ::testing::internal::AssertHelper
(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 149, gtest_ar.failure_message()) = ::testing::Message()
; \
150 } \
151 } while (false)
152 CHECK_PRINT(I0, " %0 = add i32 %y, 1");
153 CHECK_PRINT(I1, " %1 = add i32 %y, 1");
154#undef CHECK_PRINT
155
156#define CHECK_PRINT_AS_OPERAND(INST, TYPE, STR) \
157 do { \
158 { \
159 std::string S; \
160 raw_string_ostream OS(S); \
161 INST->printAsOperand(OS, TYPE); \
162 EXPECT_EQ(StringRef(STR), StringRef(OS.str()))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(StringRef(STR))) == 1)>::Compare
("StringRef(STR)", "StringRef(OS.str())", StringRef(STR), StringRef
(OS.str())))) ; else ::testing::internal::AssertHelper(::testing
::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 162, gtest_ar.failure_message()) = ::testing::Message()
; \
163 } \
164 { \
165 std::string S; \
166 raw_string_ostream OS(S); \
167 INST->printAsOperand(OS, TYPE, MST); \
168 EXPECT_EQ(StringRef(STR), StringRef(OS.str()))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(StringRef(STR))) == 1)>::Compare
("StringRef(STR)", "StringRef(OS.str())", StringRef(STR), StringRef
(OS.str())))) ; else ::testing::internal::AssertHelper(::testing
::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 168, gtest_ar.failure_message()) = ::testing::Message()
; \
169 } \
170 } while (false)
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
176}
177
178TEST(ValueTest, getLocalSlots)class ValueTest_getLocalSlots_Test : public ::testing::Test {
public: ValueTest_getLocalSlots_Test() {} private: virtual void
TestBody(); static ::testing::TestInfo* const test_info_ __attribute__
((unused)); ValueTest_getLocalSlots_Test(ValueTest_getLocalSlots_Test
const &); void operator=(ValueTest_getLocalSlots_Test const
&);};::testing::TestInfo* const ValueTest_getLocalSlots_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"ValueTest", "getLocalSlots", __null, __null, (::testing::internal
::GetTestTypeId()), ::testing::Test::SetUpTestCase, ::testing
::Test::TearDownTestCase, new ::testing::internal::TestFactoryImpl
< ValueTest_getLocalSlots_Test>);void ValueTest_getLocalSlots_Test
::TestBody()
{
179 // Verify that the getLocalSlot method returns the correct slot numbers.
180 LLVMContext C;
181 const char *ModuleString = "define void @f(i32 %x, i32 %y) {\n"
182 "entry:\n"
183 " %0 = add i32 %y, 1\n"
184 " %1 = add i32 %y, 1\n"
185 " br label %2\n"
186 "\n"
187 " ret void\n"
188 "}\n";
189 SMDiagnostic Err;
190 std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
191
192 Function *F = M->getFunction("f");
193 ASSERT_TRUE(F)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(F)) ; else return ::testing
::internal::AssertHelper(::testing::TestPartResult::kFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 193, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "F", "false", "true").c_str()) = ::testing::Message()
;
194 ASSERT_FALSE(F->empty())switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(!(F->empty()))) ; else
return ::testing::internal::AssertHelper(::testing::TestPartResult
::kFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 194, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "F->empty()", "true", "false").c_str()) = ::testing::Message
()
;
195 BasicBlock &EntryBB = F->getEntryBlock();
196 ASSERT_EQ(3u, EntryBB.size())switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(3u)) == 1)>::Compare("3u",
"EntryBB.size()", 3u, EntryBB.size()))) ; else return ::testing
::internal::AssertHelper(::testing::TestPartResult::kFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 196, gtest_ar.failure_message()) = ::testing::Message()
;
197 BasicBlock *BB2 = &*++F->begin();
198 ASSERT_TRUE(BB2)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(BB2)) ; else return ::
testing::internal::AssertHelper(::testing::TestPartResult::kFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 198, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "BB2", "false", "true").c_str()) = ::testing::Message()
;
199
200 Instruction *I0 = &*EntryBB.begin();
201 ASSERT_TRUE(I0)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(I0)) ; else return ::
testing::internal::AssertHelper(::testing::TestPartResult::kFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 201, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "I0", "false", "true").c_str()) = ::testing::Message()
;
202 Instruction *I1 = &*++EntryBB.begin();
203 ASSERT_TRUE(I1)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(I1)) ; else return ::
testing::internal::AssertHelper(::testing::TestPartResult::kFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 203, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "I1", "false", "true").c_str()) = ::testing::Message()
;
204
205 ModuleSlotTracker MST(M.get());
206 MST.incorporateFunction(*F);
207 EXPECT_EQ(MST.getLocalSlot(I0), 0)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(MST.getLocalSlot(I0))) == 1)>
::Compare("MST.getLocalSlot(I0)", "0", MST.getLocalSlot(I0), 0
))) ; else ::testing::internal::AssertHelper(::testing::TestPartResult
::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 207, gtest_ar.failure_message()) = ::testing::Message()
;
208 EXPECT_EQ(MST.getLocalSlot(I1), 1)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(MST.getLocalSlot(I1))) == 1)>
::Compare("MST.getLocalSlot(I1)", "1", MST.getLocalSlot(I1), 1
))) ; else ::testing::internal::AssertHelper(::testing::TestPartResult
::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 208, gtest_ar.failure_message()) = ::testing::Message()
;
209 EXPECT_EQ(MST.getLocalSlot(&EntryBB), -1)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(MST.getLocalSlot(&EntryBB
))) == 1)>::Compare("MST.getLocalSlot(&EntryBB)", "-1"
, MST.getLocalSlot(&EntryBB), -1))) ; else ::testing::internal
::AssertHelper(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 209, gtest_ar.failure_message()) = ::testing::Message()
;
210 EXPECT_EQ(MST.getLocalSlot(BB2), 2)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(MST.getLocalSlot(BB2))) == 1)
>::Compare("MST.getLocalSlot(BB2)", "2", MST.getLocalSlot(
BB2), 2))) ; else ::testing::internal::AssertHelper(::testing
::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 210, gtest_ar.failure_message()) = ::testing::Message()
;
211}
212
213#if defined(GTEST_HAS_DEATH_TEST1) && !defined(NDEBUG)
214TEST(ValueTest, getLocalSlotDeath)class ValueTest_getLocalSlotDeath_Test : public ::testing::Test
{ public: ValueTest_getLocalSlotDeath_Test() {} private: virtual
void TestBody(); static ::testing::TestInfo* const test_info_
__attribute__ ((unused)); ValueTest_getLocalSlotDeath_Test(ValueTest_getLocalSlotDeath_Test
const &); void operator=(ValueTest_getLocalSlotDeath_Test
const &);};::testing::TestInfo* const ValueTest_getLocalSlotDeath_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"ValueTest", "getLocalSlotDeath", __null, __null, (::testing
::internal::GetTestTypeId()), ::testing::Test::SetUpTestCase,
::testing::Test::TearDownTestCase, new ::testing::internal::
TestFactoryImpl< ValueTest_getLocalSlotDeath_Test>);void
ValueTest_getLocalSlotDeath_Test::TestBody()
{
215 LLVMContext C;
216 const char *ModuleString = "define void @f(i32 %x, i32 %y) {\n"
217 "entry:\n"
218 " %0 = add i32 %y, 1\n"
219 " %1 = add i32 %y, 1\n"
220 " br label %2\n"
221 "\n"
222 " ret void\n"
223 "}\n";
224 SMDiagnostic Err;
225 std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
226
227 Function *F = M->getFunction("f");
228 ASSERT_TRUE(F)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(F)) ; else return ::testing
::internal::AssertHelper(::testing::TestPartResult::kFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 228, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "F", "false", "true").c_str()) = ::testing::Message()
;
229 ASSERT_FALSE(F->empty())switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(!(F->empty()))) ; else
return ::testing::internal::AssertHelper(::testing::TestPartResult
::kFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 229, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "F->empty()", "true", "false").c_str()) = ::testing::Message
()
;
230 BasicBlock *BB2 = &*++F->begin();
231 ASSERT_TRUE(BB2)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(BB2)) ; else return ::
testing::internal::AssertHelper(::testing::TestPartResult::kFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 231, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "BB2", "false", "true").c_str()) = ::testing::Message()
;
232
233 ModuleSlotTracker MST(M.get());
234 EXPECT_DEATH(MST.getLocalSlot(BB2), "No function incorporated")switch (0) case 0: default: if (::testing::internal::AlwaysTrue
()) { const ::testing::internal::RE& gtest_regex = ("No function incorporated"
); ::testing::internal::DeathTest* gtest_dt; if (!::testing::
internal::DeathTest::Create("MST.getLocalSlot(BB2)", &gtest_regex
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 234, &gtest_dt)) { goto gtest_label_234; } if (gtest_dt
!= __null) { ::testing::internal::scoped_ptr< ::testing::
internal::DeathTest> gtest_dt_ptr(gtest_dt); switch (gtest_dt
->AssumeRole()) { case ::testing::internal::DeathTest::OVERSEE_TEST
: if (!gtest_dt->Passed(::testing::internal::ExitedUnsuccessfully
(gtest_dt->Wait()))) { goto gtest_label_234; } break; case
::testing::internal::DeathTest::EXECUTE_TEST: { ::testing::internal
::DeathTest::ReturnSentinel gtest_sentinel(gtest_dt); if (::testing
::internal::AlwaysTrue()) { MST.getLocalSlot(BB2); }; gtest_dt
->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE);
break; } } } } else gtest_label_234: ::testing::internal::AssertHelper
(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn255820/unittests/IR/ValueTest.cpp"
, 234, ::testing::internal::DeathTest::LastMessage()) = ::testing
::Message()
;
Within the expansion of the macro 'EXPECT_DEATH':
a
Function call argument is an uninitialized value
235}
236#endif
237
238} // end anonymous namespace