1 //===-- MangledTest.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 "Plugins/ObjectFile/ELF/ObjectFileELF.h"
10 #include "Plugins/SymbolFile/Symtab/SymbolFileSymtab.h"
11 #include "TestingSupport/SubsystemRAII.h"
12 #include "TestingSupport/TestUtilities.h"
13
14 #include "lldb/Core/Mangled.h"
15 #include "lldb/Core/Module.h"
16 #include "lldb/Core/ModuleSpec.h"
17 #include "lldb/Host/FileSystem.h"
18 #include "lldb/Host/HostInfo.h"
19 #include "lldb/Symbol/SymbolContext.h"
20
21 #include "llvm/Support/FileUtilities.h"
22 #include "llvm/Support/Path.h"
23 #include "llvm/Support/Program.h"
24 #include "llvm/Testing/Support/Error.h"
25
26 #include "gtest/gtest.h"
27
28 using namespace lldb;
29 using namespace lldb_private;
30
TEST(MangledTest,ResultForValidName)31 TEST(MangledTest, ResultForValidName) {
32 ConstString MangledName("_ZN1a1b1cIiiiEEvm");
33 Mangled TheMangled(MangledName);
34 ConstString TheDemangled = TheMangled.GetDemangledName();
35
36 ConstString ExpectedResult("void a::b::c<int, int, int>(unsigned long)");
37 EXPECT_STREQ(ExpectedResult.GetCString(), TheDemangled.GetCString());
38 }
39
TEST(MangledTest,ResultForBlockInvocation)40 TEST(MangledTest, ResultForBlockInvocation) {
41 ConstString MangledName("___Z1fU13block_pointerFviE_block_invoke");
42 Mangled TheMangled(MangledName);
43 ConstString TheDemangled = TheMangled.GetDemangledName();
44
45 ConstString ExpectedResult(
46 "invocation function for block in f(void (int) block_pointer)");
47 EXPECT_STREQ(ExpectedResult.GetCString(), TheDemangled.GetCString());
48 }
49
TEST(MangledTest,EmptyForInvalidName)50 TEST(MangledTest, EmptyForInvalidName) {
51 ConstString MangledName("_ZN1a1b1cmxktpEEvm");
52 Mangled TheMangled(MangledName);
53 ConstString TheDemangled = TheMangled.GetDemangledName();
54
55 EXPECT_STREQ("", TheDemangled.GetCString());
56 }
57
TEST(MangledTest,ResultForValidRustV0Name)58 TEST(MangledTest, ResultForValidRustV0Name) {
59 ConstString mangled_name("_RNvC1a4main");
60 Mangled the_mangled(mangled_name);
61 ConstString the_demangled = the_mangled.GetDemangledName();
62
63 ConstString expected_result("a::main");
64 EXPECT_STREQ(expected_result.GetCString(), the_demangled.GetCString());
65 }
66
TEST(MangledTest,EmptyForInvalidRustV0Name)67 TEST(MangledTest, EmptyForInvalidRustV0Name) {
68 ConstString mangled_name("_RRR");
69 Mangled the_mangled(mangled_name);
70 ConstString the_demangled = the_mangled.GetDemangledName();
71
72 EXPECT_STREQ("", the_demangled.GetCString());
73 }
74
TEST(MangledTest,ResultForValidDLangName)75 TEST(MangledTest, ResultForValidDLangName) {
76 ConstString mangled_name("_Dmain");
77 Mangled the_mangled(mangled_name);
78 ConstString the_demangled = the_mangled.GetDemangledName();
79
80 ConstString expected_result("D main");
81 EXPECT_STREQ(expected_result.GetCString(), the_demangled.GetCString());
82 }
83
TEST(MangledTest,SameForInvalidDLangPrefixedName)84 TEST(MangledTest, SameForInvalidDLangPrefixedName) {
85 ConstString mangled_name("_DDD");
86 Mangled the_mangled(mangled_name);
87 ConstString the_demangled = the_mangled.GetDemangledName();
88
89 EXPECT_STREQ("_DDD", the_demangled.GetCString());
90 }
91
TEST(MangledTest,RecognizeSwiftMangledNames)92 TEST(MangledTest, RecognizeSwiftMangledNames) {
93 llvm::StringRef valid_swift_mangled_names[] = {
94 "_TtC4main7MyClass", // Mangled objc class name
95 "_TtP4main3Foo_", // Mangld objc protocol name
96 "$s4main3BarCACycfC", // Mangled name
97 "_$s4main3BarCACycfC", // Mangled name with leading underscore
98 "$S4main3BarCACycfC", // Older swift mangled name
99 "_$S4main3BarCACycfC", // Older swift mangled name
100 // with leading underscore
101 // Mangled swift filename
102 "@__swiftmacro_4main16FunVariableNames9OptionSetfMm_.swift",
103 };
104
105 for (llvm::StringRef mangled : valid_swift_mangled_names)
106 EXPECT_EQ(Mangled::GetManglingScheme(mangled),
107 Mangled::eManglingSchemeSwift);
108 }
109
TEST(MangledTest,BoolConversionOperator)110 TEST(MangledTest, BoolConversionOperator) {
111 {
112 ConstString MangledName("_ZN1a1b1cIiiiEEvm");
113 Mangled TheMangled(MangledName);
114 EXPECT_EQ(true, bool(TheMangled));
115 EXPECT_EQ(false, !TheMangled);
116 }
117 {
118 ConstString UnmangledName("puts");
119 Mangled TheMangled(UnmangledName);
120 EXPECT_EQ(true, bool(TheMangled));
121 EXPECT_EQ(false, !TheMangled);
122 }
123 {
124 Mangled TheMangled{};
125 EXPECT_EQ(false, bool(TheMangled));
126 EXPECT_EQ(true, !TheMangled);
127 }
128 }
129
TEST(MangledTest,NameIndexes_FindFunctionSymbols)130 TEST(MangledTest, NameIndexes_FindFunctionSymbols) {
131 SubsystemRAII<FileSystem, HostInfo, ObjectFileELF, SymbolFileSymtab>
132 subsystems;
133
134 auto ExpectedFile = TestFile::fromYaml(R"(
135 --- !ELF
136 FileHeader:
137 Class: ELFCLASS64
138 Data: ELFDATA2LSB
139 Type: ET_EXEC
140 Machine: EM_X86_64
141 Sections:
142 - Name: .text
143 Type: SHT_PROGBITS
144 Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
145 AddressAlign: 0x0000000000000010
146 Size: 0x20
147 - Name: .anothertext
148 Type: SHT_PROGBITS
149 Flags: [ SHF_ALLOC, SHF_EXECINSTR ]
150 Address: 0x0000000000000010
151 AddressAlign: 0x0000000000000010
152 Size: 0x40
153 - Name: .data
154 Type: SHT_PROGBITS
155 Flags: [ SHF_WRITE, SHF_ALLOC ]
156 Address: 0x00000000000000A8
157 AddressAlign: 0x0000000000000004
158 Content: '01000000'
159 Symbols:
160 - Name: somedata
161 Type: STT_OBJECT
162 Section: .anothertext
163 Value: 0x0000000000000045
164 Binding: STB_GLOBAL
165 - Name: main
166 Type: STT_FUNC
167 Section: .anothertext
168 Value: 0x0000000000000010
169 Size: 0x000000000000003F
170 Binding: STB_GLOBAL
171 - Name: _Z3foov
172 Type: STT_FUNC
173 Section: .text
174 Size: 0x000000000000000D
175 Binding: STB_GLOBAL
176 - Name: puts@GLIBC_2.5
177 Type: STT_FUNC
178 Section: .text
179 Size: 0x000000000000000D
180 Binding: STB_GLOBAL
181 - Name: puts@GLIBC_2.6
182 Type: STT_FUNC
183 Section: .text
184 Size: 0x000000000000000D
185 Binding: STB_GLOBAL
186 - Name: _Z5annotv@VERSION3
187 Type: STT_FUNC
188 Section: .text
189 Size: 0x000000000000000D
190 Binding: STB_GLOBAL
191 - Name: _ZN1AC2Ev
192 Type: STT_FUNC
193 Section: .text
194 Size: 0x000000000000000D
195 Binding: STB_GLOBAL
196 - Name: _ZN1AD2Ev
197 Type: STT_FUNC
198 Section: .text
199 Size: 0x000000000000000D
200 Binding: STB_GLOBAL
201 - Name: _ZN1A3barEv
202 Type: STT_FUNC
203 Section: .text
204 Size: 0x000000000000000D
205 Binding: STB_GLOBAL
206 - Name: _ZGVZN4llvm4dbgsEvE7thestrm
207 Type: STT_FUNC
208 Section: .text
209 Size: 0x000000000000000D
210 Binding: STB_GLOBAL
211 - Name: _ZZN4llvm4dbgsEvE7thestrm
212 Type: STT_FUNC
213 Section: .text
214 Size: 0x000000000000000D
215 Binding: STB_GLOBAL
216 - Name: _ZTVN5clang4DeclE
217 Type: STT_FUNC
218 Section: .text
219 Size: 0x000000000000000D
220 Binding: STB_GLOBAL
221 - Name: -[ObjCfoo]
222 Type: STT_FUNC
223 Section: .text
224 Size: 0x000000000000000D
225 Binding: STB_GLOBAL
226 - Name: +[B ObjCbar(WithCategory)]
227 Type: STT_FUNC
228 Section: .text
229 Size: 0x000000000000000D
230 Binding: STB_GLOBAL
231 - Name: _Z12undemangableEvx42
232 Type: STT_FUNC
233 Section: .text
234 Size: 0x000000000000000D
235 Binding: STB_GLOBAL
236 ...
237 )");
238 ASSERT_THAT_EXPECTED(ExpectedFile, llvm::Succeeded());
239
240 auto M = std::make_shared<Module>(ExpectedFile->moduleSpec());
241
242 auto Count = [M](const char *Name, FunctionNameType Type) -> int {
243 SymbolContextList SymList;
244 M->FindFunctionSymbols(ConstString(Name), Type, SymList);
245 return SymList.GetSize();
246 };
247
248 // Unmangled
249 EXPECT_EQ(1, Count("main", eFunctionNameTypeFull));
250 EXPECT_EQ(1, Count("main", eFunctionNameTypeBase));
251 EXPECT_EQ(0, Count("main", eFunctionNameTypeMethod));
252
253 // Itanium mangled
254 EXPECT_EQ(1, Count("_Z3foov", eFunctionNameTypeFull));
255 EXPECT_EQ(1, Count("_Z3foov", eFunctionNameTypeBase));
256 EXPECT_EQ(1, Count("foo", eFunctionNameTypeBase));
257 EXPECT_EQ(0, Count("foo", eFunctionNameTypeMethod));
258
259 // Unmangled with linker annotation
260 EXPECT_EQ(1, Count("puts@GLIBC_2.5", eFunctionNameTypeFull));
261 EXPECT_EQ(1, Count("puts@GLIBC_2.6", eFunctionNameTypeFull));
262 EXPECT_EQ(2, Count("puts", eFunctionNameTypeFull));
263 EXPECT_EQ(2, Count("puts", eFunctionNameTypeBase));
264 EXPECT_EQ(0, Count("puts", eFunctionNameTypeMethod));
265
266 // Itanium mangled with linker annotation
267 EXPECT_EQ(1, Count("_Z5annotv@VERSION3", eFunctionNameTypeFull));
268 EXPECT_EQ(1, Count("_Z5annotv", eFunctionNameTypeFull));
269 EXPECT_EQ(1, Count("_Z5annotv", eFunctionNameTypeBase));
270 EXPECT_EQ(0, Count("annot", eFunctionNameTypeBase));
271 EXPECT_EQ(0, Count("annot", eFunctionNameTypeMethod));
272
273 // Itanium mangled ctor A::A()
274 EXPECT_EQ(1, Count("_ZN1AC2Ev", eFunctionNameTypeFull));
275 EXPECT_EQ(1, Count("_ZN1AC2Ev", eFunctionNameTypeBase));
276 EXPECT_EQ(1, Count("A", eFunctionNameTypeMethod));
277 EXPECT_EQ(0, Count("A", eFunctionNameTypeBase));
278
279 // Itanium mangled dtor A::~A()
280 EXPECT_EQ(1, Count("_ZN1AD2Ev", eFunctionNameTypeFull));
281 EXPECT_EQ(1, Count("_ZN1AD2Ev", eFunctionNameTypeBase));
282 EXPECT_EQ(1, Count("~A", eFunctionNameTypeMethod));
283 EXPECT_EQ(0, Count("~A", eFunctionNameTypeBase));
284
285 // Itanium mangled method A::bar()
286 EXPECT_EQ(1, Count("_ZN1A3barEv", eFunctionNameTypeFull));
287 EXPECT_EQ(1, Count("_ZN1A3barEv", eFunctionNameTypeBase));
288 EXPECT_EQ(1, Count("bar", eFunctionNameTypeMethod));
289 EXPECT_EQ(0, Count("bar", eFunctionNameTypeBase));
290
291 // Itanium mangled names that are explicitly excluded from parsing
292 EXPECT_EQ(1, Count("_ZGVZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeFull));
293 EXPECT_EQ(1, Count("_ZGVZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeBase));
294 EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeMethod));
295 EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeBase));
296 EXPECT_EQ(1, Count("_ZZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeFull));
297 EXPECT_EQ(1, Count("_ZZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeBase));
298 EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeMethod));
299 EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeBase));
300 EXPECT_EQ(1, Count("_ZTVN5clang4DeclE", eFunctionNameTypeFull));
301 EXPECT_EQ(1, Count("_ZTVN5clang4DeclE", eFunctionNameTypeBase));
302 EXPECT_EQ(0, Count("Decl", eFunctionNameTypeMethod));
303 EXPECT_EQ(0, Count("Decl", eFunctionNameTypeBase));
304
305 // ObjC mangled static
306 EXPECT_EQ(1, Count("-[ObjCfoo]", eFunctionNameTypeFull));
307 EXPECT_EQ(1, Count("-[ObjCfoo]", eFunctionNameTypeBase));
308 EXPECT_EQ(0, Count("ObjCfoo", eFunctionNameTypeMethod));
309
310 // ObjC mangled method with category
311 EXPECT_EQ(1, Count("+[B ObjCbar(WithCategory)]", eFunctionNameTypeFull));
312 EXPECT_EQ(1, Count("+[B ObjCbar(WithCategory)]", eFunctionNameTypeBase));
313 EXPECT_EQ(0, Count("ObjCbar", eFunctionNameTypeMethod));
314
315 // Invalid things: unable to decode but still possible to find by full name
316 EXPECT_EQ(1, Count("_Z12undemangableEvx42", eFunctionNameTypeFull));
317 EXPECT_EQ(1, Count("_Z12undemangableEvx42", eFunctionNameTypeBase));
318 EXPECT_EQ(0, Count("_Z12undemangableEvx42", eFunctionNameTypeMethod));
319 EXPECT_EQ(0, Count("undemangable", eFunctionNameTypeBase));
320 EXPECT_EQ(0, Count("undemangable", eFunctionNameTypeMethod));
321 }
322