Mercurial > hg > CbC > CbC_llvm

comparison unittests/AsmParser/AsmParserTest.cpp @ 95:afa8332a0e37 LLVM3.8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM 3.8
author Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date Tue, 13 Oct 2015 17:48:58 +0900
parents
children 1172e4bd9c6f
comparison
equal deleted inserted replaced
84:f3e34b893a5f 95:afa8332a0e37
1 //===- llvm/unittest/AsmParser/AsmParserTest.cpp - asm parser unittests ---===//
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/ADT/StringRef.h"
11 #include "llvm/AsmParser/Parser.h"
12 #include "llvm/AsmParser/SlotMapping.h"
13 #include "llvm/IR/Constants.h"
14 #include "llvm/IR/LLVMContext.h"
15 #include "llvm/IR/Module.h"
16 #include "llvm/Support/SourceMgr.h"
17 #include "gtest/gtest.h"
18
19 using namespace llvm;
20
21 namespace {
22
23 TEST(AsmParserTest, NullTerminatedInput) {
24 LLVMContext &Ctx = getGlobalContext();
25 StringRef Source = "; Empty module \n";
26 SMDiagnostic Error;
27 auto Mod = parseAssemblyString(Source, Error, Ctx);
28
29 EXPECT_TRUE(Mod != nullptr);
30 EXPECT_TRUE(Error.getMessage().empty());
31 }
32
33 #ifdef GTEST_HAS_DEATH_TEST
34 #ifndef NDEBUG
35
36 TEST(AsmParserTest, NonNullTerminatedInput) {
37 LLVMContext &Ctx = getGlobalContext();
38 StringRef Source = "; Empty module \n\1\2";
39 SMDiagnostic Error;
40 std::unique_ptr<Module> Mod;
41 EXPECT_DEATH(Mod = parseAssemblyString(Source.substr(0, Source.size() - 2),
42 Error, Ctx),
43 "Buffer is not null terminated!");
44 }
45
46 #endif
47 #endif
48
49 TEST(AsmParserTest, SlotMappingTest) {
50 LLVMContext &Ctx = getGlobalContext();
51 StringRef Source = "@0 = global i32 0\n !0 = !{}\n !42 = !{i32 42}";
52 SMDiagnostic Error;
53 SlotMapping Mapping;
54 auto Mod = parseAssemblyString(Source, Error, Ctx, &Mapping);
55
56 EXPECT_TRUE(Mod != nullptr);
57 EXPECT_TRUE(Error.getMessage().empty());
58
59 ASSERT_EQ(Mapping.GlobalValues.size(), 1u);
60 EXPECT_TRUE(isa<GlobalVariable>(Mapping.GlobalValues[0]));
61
62 EXPECT_EQ(Mapping.MetadataNodes.size(), 2u);
63 EXPECT_EQ(Mapping.MetadataNodes.count(0), 1u);
64 EXPECT_EQ(Mapping.MetadataNodes.count(42), 1u);
65 EXPECT_EQ(Mapping.MetadataNodes.count(1), 0u);
66 }
67
68 TEST(AsmParserTest, TypeAndConstantValueParsing) {
69 LLVMContext &Ctx = getGlobalContext();
70 SMDiagnostic Error;
71 StringRef Source = "define void @test() {\n entry:\n ret void\n}";
72 auto Mod = parseAssemblyString(Source, Error, Ctx);
73 ASSERT_TRUE(Mod != nullptr);
74 auto &M = *Mod;
75
76 const Value *V;
77 V = parseConstantValue("double 3.5", Error, M);
78 ASSERT_TRUE(V);
79 EXPECT_TRUE(V->getType()->isDoubleTy());
80 ASSERT_TRUE(isa<ConstantFP>(V));
81 EXPECT_TRUE(cast<ConstantFP>(V)->isExactlyValue(3.5));
82
83 V = parseConstantValue("i32 42", Error, M);
84 ASSERT_TRUE(V);
85 EXPECT_TRUE(V->getType()->isIntegerTy());
86 ASSERT_TRUE(isa<ConstantInt>(V));
87 EXPECT_TRUE(cast<ConstantInt>(V)->equalsInt(42));
88
89 V = parseConstantValue("<4 x i32> <i32 0, i32 1, i32 2, i32 3>", Error, M);
90 ASSERT_TRUE(V);
91 EXPECT_TRUE(V->getType()->isVectorTy());
92 ASSERT_TRUE(isa<ConstantDataVector>(V));
93
94 V = parseConstantValue("i32 add (i32 1, i32 2)", Error, M);
95 ASSERT_TRUE(V);
96 ASSERT_TRUE(isa<ConstantInt>(V));
97
98 V = parseConstantValue("i8* blockaddress(@test, %entry)", Error, M);
99 ASSERT_TRUE(V);
100 ASSERT_TRUE(isa<BlockAddress>(V));
101
102 V = parseConstantValue("i8** undef", Error, M);
103 ASSERT_TRUE(V);
104 ASSERT_TRUE(isa<UndefValue>(V));
105
106 EXPECT_FALSE(parseConstantValue("duble 3.25", Error, M));
107 EXPECT_EQ(Error.getMessage(), "expected type");
108
109 EXPECT_FALSE(parseConstantValue("i32 3.25", Error, M));
110 EXPECT_EQ(Error.getMessage(), "floating point constant invalid for type");
111
112 EXPECT_FALSE(parseConstantValue("i32* @foo", Error, M));
113 EXPECT_EQ(Error.getMessage(), "expected a constant value");
114
115 EXPECT_FALSE(parseConstantValue("i32 3, ", Error, M));
116 EXPECT_EQ(Error.getMessage(), "expected end of string");
117 }
118
119 TEST(AsmParserTest, TypeAndConstantValueWithSlotMappingParsing) {
120 LLVMContext &Ctx = getGlobalContext();
121 SMDiagnostic Error;
122 StringRef Source =
123 "%st = type { i32, i32 }\n"
124 "@v = common global [50 x %st] zeroinitializer, align 16\n"
125 "%0 = type { i32, i32, i32, i32 }\n"
126 "@g = common global [50 x %0] zeroinitializer, align 16\n"
127 "define void @marker4(i64 %d) {\n"
128 "entry:\n"
129 " %conv = trunc i64 %d to i32\n"
130 " store i32 %conv, i32* getelementptr inbounds "
131 " ([50 x %st], [50 x %st]* @v, i64 0, i64 0, i32 0), align 16\n"
132 " store i32 %conv, i32* getelementptr inbounds "
133 " ([50 x %0], [50 x %0]* @g, i64 0, i64 0, i32 0), align 16\n"
134 " ret void\n"
135 "}";
136 SlotMapping Mapping;
137 auto Mod = parseAssemblyString(Source, Error, Ctx, &Mapping);
138 ASSERT_TRUE(Mod != nullptr);
139 auto &M = *Mod;
140
141 const Value *V;
142 V = parseConstantValue("i32* getelementptr inbounds ([50 x %st], [50 x %st]* "
143 "@v, i64 0, i64 0, i32 0)",
144 Error, M, &Mapping);
145 ASSERT_TRUE(V);
146 ASSERT_TRUE(isa<ConstantExpr>(V));
147
148 V = parseConstantValue("i32* getelementptr inbounds ([50 x %0], [50 x %0]* "
149 "@g, i64 0, i64 0, i32 0)",
150 Error, M, &Mapping);
151 ASSERT_TRUE(V);
152 ASSERT_TRUE(isa<ConstantExpr>(V));
153 }
154
155 } // end anonymous namespace