1 //===-- MangledTest.cpp -----------------------------------------*- C++ -*-===//
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/SymbolVendor/ELF/SymbolVendorELF.h"
11 #include "TestingSupport/TestUtilities.h"
12 
13 #include "lldb/Core/Mangled.h"
14 #include "lldb/Core/Module.h"
15 #include "lldb/Core/ModuleSpec.h"
16 #include "lldb/Host/FileSystem.h"
17 #include "lldb/Host/HostInfo.h"
18 #include "lldb/Symbol/SymbolContext.h"
19 
20 #include "llvm/Support/FileUtilities.h"
21 #include "llvm/Support/Path.h"
22 #include "llvm/Support/Program.h"
23 
24 #include "gtest/gtest.h"
25 
26 using namespace lldb;
27 using namespace lldb_private;
28 
29 TEST(MangledTest, ResultForValidName) {
30   ConstString MangledName("_ZN1a1b1cIiiiEEvm");
31   bool IsMangled = true;
32 
33   Mangled TheMangled(MangledName, IsMangled);
34   ConstString TheDemangled =
35       TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
36 
37   ConstString ExpectedResult("void a::b::c<int, int, int>(unsigned long)");
38   EXPECT_STREQ(ExpectedResult.GetCString(), TheDemangled.GetCString());
39 }
40 
41 TEST(MangledTest, EmptyForInvalidName) {
42   ConstString MangledName("_ZN1a1b1cmxktpEEvm");
43   bool IsMangled = true;
44 
45   Mangled TheMangled(MangledName, IsMangled);
46   ConstString TheDemangled =
47       TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
48 
49   EXPECT_STREQ("", TheDemangled.GetCString());
50 }
51 
52 #define ASSERT_NO_ERROR(x)                                                     \
53   if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
54     llvm::SmallString<128> MessageStorage;                                     \
55     llvm::raw_svector_ostream Message(MessageStorage);                         \
56     Message << #x ": did not return errc::success.\n"                          \
57             << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"          \
58             << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n";      \
59     GTEST_FATAL_FAILURE_(MessageStorage.c_str());                              \
60   } else {                                                                     \
61   }
62 
63 TEST(MangledTest, NameIndexes_FindFunctionSymbols) {
64   FileSystem::Initialize();
65   HostInfo::Initialize();
66   ObjectFileELF::Initialize();
67   SymbolVendorELF::Initialize();
68 
69   std::string Yaml = GetInputFilePath("mangled-function-names.yaml");
70   llvm::SmallString<128> Obj;
71   ASSERT_NO_ERROR(llvm::sys::fs::createTemporaryFile(
72       "mangled-function-names-%%%%%%", "obj", Obj));
73 
74   llvm::FileRemover Deleter(Obj);
75   llvm::StringRef Args[] = {YAML2OBJ, Yaml};
76   llvm::StringRef ObjRef = Obj;
77   const llvm::Optional<llvm::StringRef> redirects[] = {llvm::None, ObjRef,
78                                                        llvm::None};
79   ASSERT_EQ(0,
80             llvm::sys::ExecuteAndWait(YAML2OBJ, Args, llvm::None, redirects));
81   uint64_t Size;
82   ASSERT_NO_ERROR(llvm::sys::fs::file_size(Obj, Size));
83   ASSERT_GT(Size, 0u);
84 
85   ModuleSpec Spec{FileSpec(Obj)};
86   Spec.GetSymbolFileSpec().SetFile(Obj, FileSpec::Style::native);
87   auto M = std::make_shared<Module>(Spec);
88 
89   auto Count = [M](const char *Name, FunctionNameType Type) -> int {
90     SymbolContextList SymList;
91     return M->FindFunctionSymbols(ConstString(Name), Type, SymList);
92   };
93 
94   // Unmangled
95   EXPECT_EQ(1, Count("main", eFunctionNameTypeFull));
96   EXPECT_EQ(1, Count("main", eFunctionNameTypeBase));
97   EXPECT_EQ(0, Count("main", eFunctionNameTypeMethod));
98 
99   // Itanium mangled
100   EXPECT_EQ(1, Count("_Z3foov", eFunctionNameTypeFull));
101   EXPECT_EQ(1, Count("_Z3foov", eFunctionNameTypeBase));
102   EXPECT_EQ(1, Count("foo", eFunctionNameTypeBase));
103   EXPECT_EQ(0, Count("foo", eFunctionNameTypeMethod));
104 
105   // Unmangled with linker annotation
106   EXPECT_EQ(1, Count("puts@GLIBC_2.5", eFunctionNameTypeFull));
107   EXPECT_EQ(1, Count("puts@GLIBC_2.6", eFunctionNameTypeFull));
108   EXPECT_EQ(2, Count("puts", eFunctionNameTypeFull));
109   EXPECT_EQ(2, Count("puts", eFunctionNameTypeBase));
110   EXPECT_EQ(0, Count("puts", eFunctionNameTypeMethod));
111 
112   // Itanium mangled with linker annotation
113   EXPECT_EQ(1, Count("_Z5annotv@VERSION3", eFunctionNameTypeFull));
114   EXPECT_EQ(1, Count("_Z5annotv", eFunctionNameTypeFull));
115   EXPECT_EQ(1, Count("_Z5annotv", eFunctionNameTypeBase));
116   EXPECT_EQ(0, Count("annot", eFunctionNameTypeBase));
117   EXPECT_EQ(0, Count("annot", eFunctionNameTypeMethod));
118 
119   // Itanium mangled ctor A::A()
120   EXPECT_EQ(1, Count("_ZN1AC2Ev", eFunctionNameTypeFull));
121   EXPECT_EQ(1, Count("_ZN1AC2Ev", eFunctionNameTypeBase));
122   EXPECT_EQ(1, Count("A", eFunctionNameTypeMethod));
123   EXPECT_EQ(0, Count("A", eFunctionNameTypeBase));
124 
125   // Itanium mangled dtor A::~A()
126   EXPECT_EQ(1, Count("_ZN1AD2Ev", eFunctionNameTypeFull));
127   EXPECT_EQ(1, Count("_ZN1AD2Ev", eFunctionNameTypeBase));
128   EXPECT_EQ(1, Count("~A", eFunctionNameTypeMethod));
129   EXPECT_EQ(0, Count("~A", eFunctionNameTypeBase));
130 
131   // Itanium mangled method A::bar()
132   EXPECT_EQ(1, Count("_ZN1A3barEv", eFunctionNameTypeFull));
133   EXPECT_EQ(1, Count("_ZN1A3barEv", eFunctionNameTypeBase));
134   EXPECT_EQ(1, Count("bar", eFunctionNameTypeMethod));
135   EXPECT_EQ(0, Count("bar", eFunctionNameTypeBase));
136 
137   // Itanium mangled names that are explicitly excluded from parsing
138   EXPECT_EQ(1, Count("_ZGVZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeFull));
139   EXPECT_EQ(1, Count("_ZGVZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeBase));
140   EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeMethod));
141   EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeBase));
142   EXPECT_EQ(1, Count("_ZZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeFull));
143   EXPECT_EQ(1, Count("_ZZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeBase));
144   EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeMethod));
145   EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeBase));
146   EXPECT_EQ(1, Count("_ZTVN5clang4DeclE", eFunctionNameTypeFull));
147   EXPECT_EQ(1, Count("_ZTVN5clang4DeclE", eFunctionNameTypeBase));
148   EXPECT_EQ(0, Count("Decl", eFunctionNameTypeMethod));
149   EXPECT_EQ(0, Count("Decl", eFunctionNameTypeBase));
150 
151   // ObjC mangled static
152   EXPECT_EQ(1, Count("-[ObjCfoo]", eFunctionNameTypeFull));
153   EXPECT_EQ(1, Count("-[ObjCfoo]", eFunctionNameTypeBase));
154   EXPECT_EQ(0, Count("ObjCfoo", eFunctionNameTypeMethod));
155 
156   // ObjC mangled method with category
157   EXPECT_EQ(1, Count("+[B ObjCbar(WithCategory)]", eFunctionNameTypeFull));
158   EXPECT_EQ(1, Count("+[B ObjCbar(WithCategory)]", eFunctionNameTypeBase));
159   EXPECT_EQ(0, Count("ObjCbar", eFunctionNameTypeMethod));
160 
161   // Invalid things: unable to decode but still possible to find by full name
162   EXPECT_EQ(1, Count("_Z12undemangableEvx42", eFunctionNameTypeFull));
163   EXPECT_EQ(1, Count("_Z12undemangableEvx42", eFunctionNameTypeBase));
164   EXPECT_EQ(0, Count("_Z12undemangableEvx42", eFunctionNameTypeMethod));
165   EXPECT_EQ(0, Count("undemangable", eFunctionNameTypeBase));
166   EXPECT_EQ(0, Count("undemangable", eFunctionNameTypeMethod));
167 
168   SymbolVendorELF::Terminate();
169   ObjectFileELF::Terminate();
170   HostInfo::Terminate();
171   FileSystem::Terminate();
172 }
173