1 | //===----------- StringTableBuilderTest.cpp -------------------------------===// |
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/MC/StringTableBuilder.h" |
10 | #include "llvm/ADT/SmallString.h" |
11 | #include "llvm/Support/Endian.h" |
12 | #include "gtest/gtest.h" |
13 | #include <string> |
14 | |
15 | using namespace llvm; |
16 | |
17 | namespace { |
18 | |
19 | TEST(StringTableBuilderTest, BasicELF) { |
20 | StringTableBuilder B(StringTableBuilder::ELF); |
21 | |
22 | B.add(S: "foo" ); |
23 | B.add(S: "bar" ); |
24 | B.add(S: "foobar" ); |
25 | |
26 | B.finalize(); |
27 | |
28 | std::string Expected; |
29 | Expected += '\x00'; |
30 | Expected += "foobar" ; |
31 | Expected += '\x00'; |
32 | Expected += "foo" ; |
33 | Expected += '\x00'; |
34 | |
35 | SmallString<64> Data; |
36 | raw_svector_ostream OS(Data); |
37 | B.write(OS); |
38 | |
39 | EXPECT_EQ(Expected, Data); |
40 | EXPECT_EQ(1U, B.getOffset("foobar" )); |
41 | EXPECT_EQ(4U, B.getOffset("bar" )); |
42 | EXPECT_EQ(8U, B.getOffset("foo" )); |
43 | } |
44 | |
45 | TEST(StringTableBuilderTest, BasicWinCOFF) { |
46 | StringTableBuilder B(StringTableBuilder::WinCOFF); |
47 | |
48 | // Strings must be 9 chars or longer to go in the table. |
49 | B.add(S: "hippopotamus" ); |
50 | B.add(S: "pygmy hippopotamus" ); |
51 | B.add(S: "river horse" ); |
52 | |
53 | B.finalize(); |
54 | |
55 | // size_field + "pygmy hippopotamus\0" + "river horse\0" |
56 | uint32_t ExpectedSize = 4 + 19 + 12; |
57 | EXPECT_EQ(ExpectedSize, B.getSize()); |
58 | |
59 | std::string Expected; |
60 | |
61 | ExpectedSize = support::endian::byte_swap<uint32_t, llvm::endianness::little>( |
62 | value: ExpectedSize); |
63 | Expected.append(s: (const char*)&ExpectedSize, n: 4); |
64 | Expected += "pygmy hippopotamus" ; |
65 | Expected += '\x00'; |
66 | Expected += "river horse" ; |
67 | Expected += '\x00'; |
68 | |
69 | SmallString<64> Data; |
70 | raw_svector_ostream OS(Data); |
71 | B.write(OS); |
72 | |
73 | EXPECT_EQ(Expected, Data); |
74 | EXPECT_EQ(4U, B.getOffset("pygmy hippopotamus" )); |
75 | EXPECT_EQ(10U, B.getOffset("hippopotamus" )); |
76 | EXPECT_EQ(23U, B.getOffset("river horse" )); |
77 | } |
78 | |
79 | TEST(StringTableBuilderTest, ELFInOrder) { |
80 | StringTableBuilder B(StringTableBuilder::ELF); |
81 | EXPECT_EQ(1U, B.add("foo" )); |
82 | EXPECT_EQ(5U, B.add("bar" )); |
83 | EXPECT_EQ(9U, B.add("foobar" )); |
84 | |
85 | B.finalizeInOrder(); |
86 | |
87 | std::string Expected; |
88 | Expected += '\x00'; |
89 | Expected += "foo" ; |
90 | Expected += '\x00'; |
91 | Expected += "bar" ; |
92 | Expected += '\x00'; |
93 | Expected += "foobar" ; |
94 | Expected += '\x00'; |
95 | |
96 | SmallString<64> Data; |
97 | raw_svector_ostream OS(Data); |
98 | B.write(OS); |
99 | |
100 | EXPECT_EQ(Expected, Data); |
101 | EXPECT_EQ(1U, B.getOffset("foo" )); |
102 | EXPECT_EQ(5U, B.getOffset("bar" )); |
103 | EXPECT_EQ(9U, B.getOffset("foobar" )); |
104 | } |
105 | |
106 | TEST(StringTableBuilderTest, MachOInOrder) { |
107 | StringTableBuilder B(StringTableBuilder::MachO); |
108 | |
109 | B.add(S: "foo" ); |
110 | B.add(S: "bar" ); |
111 | B.add(S: "fooba" ); |
112 | |
113 | B.finalizeInOrder(); |
114 | |
115 | std::string Expected; |
116 | Expected += '\x00'; |
117 | Expected += "foo" ; |
118 | Expected += '\x00'; |
119 | Expected += "bar" ; |
120 | Expected += '\x00'; |
121 | Expected += "fooba" ; |
122 | Expected += '\x00'; |
123 | |
124 | // Mach-O pads to 4 bytes |
125 | Expected += '\x00'; |
126 | |
127 | SmallString<64> Data; |
128 | raw_svector_ostream OS(Data); |
129 | B.write(OS); |
130 | |
131 | EXPECT_EQ(Expected, Data); |
132 | EXPECT_EQ(1U, B.getOffset("foo" )); |
133 | EXPECT_EQ(5U, B.getOffset("bar" )); |
134 | EXPECT_EQ(9U, B.getOffset("fooba" )); |
135 | } |
136 | |
137 | TEST(StringTableBuilderTest, MachO64InOrder) { |
138 | StringTableBuilder B(StringTableBuilder::MachO64); |
139 | |
140 | B.add(S: "foo" ); |
141 | B.add(S: "bar" ); |
142 | B.add(S: "f" ); |
143 | |
144 | B.finalizeInOrder(); |
145 | |
146 | std::string Expected; |
147 | Expected += '\x00'; |
148 | Expected += "foo" ; |
149 | Expected += '\x00'; |
150 | Expected += "bar" ; |
151 | Expected += '\x00'; |
152 | Expected += "f" ; |
153 | Expected += '\x00'; |
154 | |
155 | // 64 bit Mach-O pads to 8 bytes |
156 | Expected += '\x00'; |
157 | Expected += '\x00'; |
158 | Expected += '\x00'; |
159 | Expected += '\x00'; |
160 | Expected += '\x00'; |
161 | |
162 | SmallString<64> Data; |
163 | raw_svector_ostream OS(Data); |
164 | B.write(OS); |
165 | |
166 | EXPECT_EQ(Expected, Data); |
167 | EXPECT_EQ(1U, B.getOffset("foo" )); |
168 | EXPECT_EQ(5U, B.getOffset("bar" )); |
169 | EXPECT_EQ(9U, B.getOffset("f" )); |
170 | } |
171 | |
172 | TEST(StringTableBuilderTest, MachOLinkedInOrder) { |
173 | StringTableBuilder B(StringTableBuilder::MachOLinked); |
174 | |
175 | B.add(S: "foo" ); |
176 | B.add(S: "bar" ); |
177 | B.add(S: "foob" ); |
178 | |
179 | B.finalizeInOrder(); |
180 | |
181 | std::string Expected; |
182 | Expected += ' '; |
183 | Expected += '\x00'; |
184 | Expected += "foo" ; |
185 | Expected += '\x00'; |
186 | Expected += "bar" ; |
187 | Expected += '\x00'; |
188 | Expected += "foob" ; |
189 | Expected += '\x00'; |
190 | |
191 | // Mach-O pads to 4 bytes |
192 | Expected += '\x00'; |
193 | |
194 | SmallString<64> Data; |
195 | raw_svector_ostream OS(Data); |
196 | B.write(OS); |
197 | |
198 | EXPECT_EQ(Expected, Data); |
199 | EXPECT_EQ(2U, B.getOffset("foo" )); |
200 | EXPECT_EQ(6U, B.getOffset("bar" )); |
201 | EXPECT_EQ(10U, B.getOffset("foob" )); |
202 | } |
203 | |
204 | TEST(StringTableBuilderTest, MachO64LinkedInOrder) { |
205 | StringTableBuilder B(StringTableBuilder::MachO64Linked); |
206 | |
207 | B.add(S: "foo" ); |
208 | B.add(S: "ba" ); |
209 | B.add(S: "f" ); |
210 | |
211 | B.finalizeInOrder(); |
212 | |
213 | std::string Expected; |
214 | Expected += ' '; |
215 | Expected += '\x00'; |
216 | Expected += "foo" ; |
217 | Expected += '\x00'; |
218 | Expected += "ba" ; |
219 | Expected += '\x00'; |
220 | Expected += "f" ; |
221 | Expected += '\x00'; |
222 | |
223 | // 64 bit Mach-O pads to 8 bytes |
224 | Expected += '\x00'; |
225 | Expected += '\x00'; |
226 | Expected += '\x00'; |
227 | Expected += '\x00'; |
228 | Expected += '\x00'; |
229 | |
230 | SmallString<64> Data; |
231 | raw_svector_ostream OS(Data); |
232 | B.write(OS); |
233 | |
234 | EXPECT_EQ(Expected, Data); |
235 | EXPECT_EQ(2U, B.getOffset("foo" )); |
236 | EXPECT_EQ(6U, B.getOffset("ba" )); |
237 | EXPECT_EQ(9U, B.getOffset("f" )); |
238 | } |
239 | } |
240 | |