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/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   const 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   const 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   HostInfo::Initialize();
65   ObjectFileELF::Initialize();
66   SymbolVendorELF::Initialize();
67 
68   std::string Yaml = GetInputFilePath("mangled-function-names.yaml");
69   llvm::SmallString<128> Obj;
70   ASSERT_NO_ERROR(llvm::sys::fs::createTemporaryFile(
71       "mangled-function-names-%%%%%%", "obj", Obj));
72 
73   llvm::FileRemover Deleter(Obj);
74   llvm::StringRef Args[] = {YAML2OBJ, Yaml};
75   llvm::StringRef ObjRef = Obj;
76   const llvm::Optional<llvm::StringRef> redirects[] = {llvm::None, ObjRef,
77                                                        llvm::None};
78   ASSERT_EQ(0,
79             llvm::sys::ExecuteAndWait(YAML2OBJ, Args, llvm::None, redirects));
80   uint64_t Size;
81   ASSERT_NO_ERROR(llvm::sys::fs::file_size(Obj, Size));
82   ASSERT_GT(Size, 0u);
83 
84   ModuleSpec Spec{FileSpec(Obj, false)};
85   Spec.GetSymbolFileSpec().SetFile(Obj, false, FileSpec::Style::native);
86   auto M = std::make_shared<Module>(Spec);
87 
88   auto Count = [M](const char *Name, FunctionNameType Type) -> int {
89     SymbolContextList SymList;
90     return M->FindFunctionSymbols(ConstString(Name), Type, SymList);
91   };
92 
93   // Unmangled
94   EXPECT_EQ(1, Count("main", eFunctionNameTypeFull));
95   EXPECT_EQ(1, Count("main", eFunctionNameTypeBase));
96   EXPECT_EQ(0, Count("main", eFunctionNameTypeMethod));
97 
98   // Itanium mangled
99   EXPECT_EQ(1, Count("_Z3foov", eFunctionNameTypeFull));
100   EXPECT_EQ(1, Count("_Z3foov", eFunctionNameTypeBase));
101   EXPECT_EQ(1, Count("foo", eFunctionNameTypeBase));
102   EXPECT_EQ(0, Count("foo", eFunctionNameTypeMethod));
103 
104   // Unmangled with linker annotation
105   EXPECT_EQ(1, Count("puts@GLIBC_2.5", eFunctionNameTypeFull));
106   EXPECT_EQ(1, Count("puts@GLIBC_2.6", eFunctionNameTypeFull));
107   EXPECT_EQ(2, Count("puts", eFunctionNameTypeFull));
108   EXPECT_EQ(2, Count("puts", eFunctionNameTypeBase));
109   EXPECT_EQ(0, Count("puts", eFunctionNameTypeMethod));
110 
111   // Itanium mangled with linker annotation
112   EXPECT_EQ(1, Count("_Z5annotv@VERSION3", eFunctionNameTypeFull));
113   EXPECT_EQ(1, Count("_Z5annotv", eFunctionNameTypeFull));
114   EXPECT_EQ(1, Count("_Z5annotv", eFunctionNameTypeBase));
115   EXPECT_EQ(0, Count("annot", eFunctionNameTypeBase));
116   EXPECT_EQ(0, Count("annot", eFunctionNameTypeMethod));
117 
118   // Itanium mangled ctor A::A()
119   EXPECT_EQ(1, Count("_ZN1AC2Ev", eFunctionNameTypeFull));
120   EXPECT_EQ(1, Count("_ZN1AC2Ev", eFunctionNameTypeBase));
121   EXPECT_EQ(1, Count("A", eFunctionNameTypeMethod));
122   EXPECT_EQ(0, Count("A", eFunctionNameTypeBase));
123 
124   // Itanium mangled dtor A::~A()
125   EXPECT_EQ(1, Count("_ZN1AD2Ev", eFunctionNameTypeFull));
126   EXPECT_EQ(1, Count("_ZN1AD2Ev", eFunctionNameTypeBase));
127   EXPECT_EQ(1, Count("~A", eFunctionNameTypeMethod));
128   EXPECT_EQ(0, Count("~A", eFunctionNameTypeBase));
129 
130   // Itanium mangled method A::bar()
131   EXPECT_EQ(1, Count("_ZN1A3barEv", eFunctionNameTypeFull));
132   EXPECT_EQ(1, Count("_ZN1A3barEv", eFunctionNameTypeBase));
133   EXPECT_EQ(1, Count("bar", eFunctionNameTypeMethod));
134   EXPECT_EQ(0, Count("bar", eFunctionNameTypeBase));
135 
136   // Itanium mangled names that are explicitly excluded from parsing
137   EXPECT_EQ(1, Count("_ZGVZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeFull));
138   EXPECT_EQ(1, Count("_ZGVZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeBase));
139   EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeMethod));
140   EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeBase));
141   EXPECT_EQ(1, Count("_ZZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeFull));
142   EXPECT_EQ(1, Count("_ZZN4llvm4dbgsEvE7thestrm", eFunctionNameTypeBase));
143   EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeMethod));
144   EXPECT_EQ(0, Count("dbgs", eFunctionNameTypeBase));
145   EXPECT_EQ(1, Count("_ZTVN5clang4DeclE", eFunctionNameTypeFull));
146   EXPECT_EQ(1, Count("_ZTVN5clang4DeclE", eFunctionNameTypeBase));
147   EXPECT_EQ(0, Count("Decl", eFunctionNameTypeMethod));
148   EXPECT_EQ(0, Count("Decl", eFunctionNameTypeBase));
149 
150   // ObjC mangled static
151   EXPECT_EQ(1, Count("-[ObjCfoo]", eFunctionNameTypeFull));
152   EXPECT_EQ(1, Count("-[ObjCfoo]", eFunctionNameTypeBase));
153   EXPECT_EQ(0, Count("ObjCfoo", eFunctionNameTypeMethod));
154 
155   // ObjC mangled method with category
156   EXPECT_EQ(1, Count("+[B ObjCbar(WithCategory)]", eFunctionNameTypeFull));
157   EXPECT_EQ(1, Count("+[B ObjCbar(WithCategory)]", eFunctionNameTypeBase));
158   EXPECT_EQ(0, Count("ObjCbar", eFunctionNameTypeMethod));
159 
160   // Invalid things: unable to decode but still possible to find by full name
161   EXPECT_EQ(1, Count("_Z12undemangableEvx42", eFunctionNameTypeFull));
162   EXPECT_EQ(1, Count("_Z12undemangableEvx42", eFunctionNameTypeBase));
163   EXPECT_EQ(0, Count("_Z12undemangableEvx42", eFunctionNameTypeMethod));
164   EXPECT_EQ(0, Count("undemangable", eFunctionNameTypeBase));
165   EXPECT_EQ(0, Count("undemangable", eFunctionNameTypeMethod));
166 
167   SymbolVendorELF::Terminate();
168   ObjectFileELF::Terminate();
169   HostInfo::Terminate();
170 }
171