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
15using namespace llvm;
16
17namespace {
18
19TEST(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
45TEST(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
79TEST(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
106TEST(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
137TEST(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
172TEST(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
204TEST(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

source code of llvm/unittests/MC/StringTableBuilderTest.cpp