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