unittests/Demangle/PartialDemangleTest.cpp

   1 //===----------------------- PartialDemangleTest.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 <cstdlib>
  10 #include "llvm/Demangle/Demangle.h"
  11 #include "gtest/gtest.h"
  12
  13 struct ChoppedName {
  14   const char *Mangled;
  15   const char *ContextName, *BaseName, *ReturnType, *Params;
  16 };
  17
  18 static ChoppedName NamesToTest[] = {
  19   {"_Z1fv", "", "f", "", "()"},
  20   {"_ZN1a1b1cIiiiEEvm", "a::b", "c", "void", "(unsigned long)"},
  21   {"_ZZ5OuterIiEivEN5Inner12inner_memberEv",
  22    "int Outer<int>()::Inner", "inner_member", "", "()"},
  23   {"_Z1fIiEPFvvEv", "", "f", "void (*)()", "()"},
  24   {"_ZN1S1fIiEEvv", "S", "f", "void", "()"},
  25
  26   // Call operator for a lambda in f().
  27   {"_ZZ1fvENK3$_0clEi", "f()::$_0", "operator()", "", "(int)"},
  28
  29   // A call operator for a lambda in a lambda in f().
  30   {"_ZZZ1fvENK3$_0clEvENKUlvE_clEv",
  31    "f()::$_0::operator()() const::'lambda'()", "operator()", "", "()"},
  32
  33   {"_ZZN1S1fEiiEd0_NKUlvE_clEv",
  34    "S::f(int, int)::'lambda'()", "operator()", "", "()"},
  35
  36   {"_ZN1Scv7MuncherIJDpPT_EEIJFivEA_iEEEv",
  37    "S", "operator Muncher<int (*)(), int (*) []>", "", "()"},
  38
  39   // Attributes.
  40   {"_ZN5test4IdE1fEUa9enable_ifIXeqfL0p_Li1EEXeqfL0p0_Li2EEEi",
  41    "test4<double>", "f", "", "(int)"},
  42   {"_ZN1SC2B8ctor_tagEv", "S", "S", "", "()"},
  43   {"_ZN1S1fB4MERPIiEEvv", "S", "f", "void", "()"},
  44
  45   {"_ZNSsC1EmcRKSaIcE",
  46    "std::basic_string<char, std::char_traits<char>, std::allocator<char> >",
  47    "basic_string", "", "(unsigned long, char, std::allocator<char> const&)"},
  48   {"_ZNSsixEm", "std::string", "operator[]", "", "(unsigned long)"},
  49   {"_ZSt17__throw_bad_allocv", "std", "__throw_bad_alloc", "", "()"},
  50
  51   {"_ZN1AI1BEC2Ev", "A<B>", "A", "", "()"},
  52   {"_ZN1AI1BED2Ev", "A<B>", "~A", "", "()"},
  53   {"_ZN1AI1BECI24BaseEi", "A<B>", "A", "", "(int)"},
  54   {"_ZNKR1AI1BE1fIiEEiv", "A<B>", "f", "int", "()"},
  55
  56   {"_ZN1SIJicfEE3mfnIJjcdEEEvicfDpT_", "S<int, char, float>",
  57    "mfn", "void", "(int, char, float, unsigned int, char, double)"},
  58 };
  59
  60 TEST(PartialDemanglerTest, TestNameChopping) {
  61   size_t Size = 1;
  62   char *Buf = static_cast<char *>(std::malloc(Size));
  63
  64   llvm::ItaniumPartialDemangler D;
  65
  66   for (ChoppedName &N : NamesToTest) {
  67     EXPECT_FALSE(D.partialDemangle(N.Mangled));
  68     EXPECT_TRUE(D.isFunction());
  69     EXPECT_FALSE(D.isData());
  70     EXPECT_FALSE(D.isSpecialName());
  71
  72     Buf = D.getFunctionDeclContextName(Buf, &Size);
  73     EXPECT_STREQ(Buf, N.ContextName);
  74
  75     Buf = D.getFunctionBaseName(Buf, &Size);
  76     EXPECT_STREQ(Buf, N.BaseName);
  77
  78     Buf = D.getFunctionReturnType(Buf, &Size);
  79     EXPECT_STREQ(Buf, N.ReturnType);
  80
  81     Buf = D.getFunctionParameters(Buf, &Size);
  82     EXPECT_STREQ(Buf, N.Params);
  83   }
  84
  85   std::free(Buf);
  86 }
  87
  88 TEST(PartialDemanglerTest, TestNameMeta) {
  89   llvm::ItaniumPartialDemangler Demangler;
  90
  91   EXPECT_FALSE(Demangler.partialDemangle("_ZNK1f1gEv"));
  92   EXPECT_TRUE(Demangler.isFunction());
  93   EXPECT_TRUE(Demangler.hasFunctionQualifiers());
  94   EXPECT_FALSE(Demangler.isSpecialName());
  95   EXPECT_FALSE(Demangler.isData());
  96
  97   EXPECT_FALSE(Demangler.partialDemangle("_Z1fv"));
  98   EXPECT_FALSE(Demangler.hasFunctionQualifiers());
  99
 100   EXPECT_FALSE(Demangler.partialDemangle("_ZTV1S"));
 101   EXPECT_TRUE(Demangler.isSpecialName());
 102   EXPECT_FALSE(Demangler.isData());
 103   EXPECT_FALSE(Demangler.isFunction());
 104
 105   EXPECT_FALSE(Demangler.partialDemangle("_ZN1aDC1a1b1cEE"));
 106   EXPECT_FALSE(Demangler.isFunction());
 107   EXPECT_FALSE(Demangler.isSpecialName());
 108   EXPECT_TRUE(Demangler.isData());
 109 }
 110
 111 TEST(PartialDemanglerTest, TestCtorOrDtor) {
 112   static const char *Pos[] = {
 113       "_ZN1AC1Ev",        // A::A()
 114       "_ZN1AC1IiEET_",    // A::A<int>(int)
 115       "_ZN1AD2Ev",        // A::~A()
 116       "_ZN1BIiEC1IcEET_", // B<int>::B<char>(char)
 117       "_ZN1AC1B1TEv",     // A::A[abi:T]()
 118       "_ZNSt1AD2Ev",      // std::A::~A()
 119       "_ZN2ns1AD1Ev",      // ns::A::~A()
 120   };
 121   static const char *Neg[] = {
 122       "_Z1fv",
 123       "_ZN1A1gIiEEvT_", // void A::g<int>(int)
 124   };
 125
 126   llvm::ItaniumPartialDemangler D;
 127   for (const char *N : Pos) {
 128     EXPECT_FALSE(D.partialDemangle(N));
 129     EXPECT_TRUE(D.isCtorOrDtor());
 130   }
 131   for (const char *N : Neg) {
 132     EXPECT_FALSE(D.partialDemangle(N));
 133     EXPECT_FALSE(D.isCtorOrDtor());
 134   }
 135 }
 136
 137 TEST(PartialDemanglerTest, TestMisc) {
 138   llvm::ItaniumPartialDemangler D1, D2;
 139
 140   EXPECT_FALSE(D1.partialDemangle("_Z1fv"));
 141   EXPECT_FALSE(D2.partialDemangle("_Z1g"));
 142   std::swap(D1, D2);
 143   EXPECT_FALSE(D1.isFunction());
 144   EXPECT_TRUE(D2.isFunction());
 145
 146   EXPECT_TRUE(D1.partialDemangle("Not a mangled name!"));
 147 }
 148
 149 TEST(PartialDemanglerTest, TestPrintCases) {
 150   llvm::ItaniumPartialDemangler D;
 151
 152   const size_t OriginalSize = 4;
 153   char *Buf = static_cast<char *>(std::malloc(OriginalSize));
 154   const char *OriginalBuf = Buf;
 155
 156   // Default success case: Result fits into the given buffer.
 157   // Res points to Buf. N returns string size including null termination.
 158   {
 159     EXPECT_FALSE(D.partialDemangle("_ZN1a1bEv"));
 160
 161     size_t N = OriginalSize;
 162     char *Res = D.getFunctionDeclContextName(Buf, &N);
 163     EXPECT_STREQ("a", Res);
 164     EXPECT_EQ(OriginalBuf, Res);
 165     EXPECT_EQ(strlen(Res) + 1, N);
 166   }
 167
 168   // Realloc success case: Result does not fit into the given buffer.
 169   // Res points to the new or extended buffer. N returns string size
 170   // including null termination. Buf was extended or freed.
 171   {
 172     EXPECT_FALSE(D.partialDemangle("_ZN1a1b1cIiiiEEvm"));
 173
 174     size_t N = OriginalSize;
 175     char *Res = D.finishDemangle(Buf, &N);
 176     EXPECT_STREQ("void a::b::c<int, int, int>(unsigned long)", Res);
 177     EXPECT_EQ(strlen(Res) + 1, N);
 178     Buf = Res;
 179   }
 180
 181   // Failure case: a::c is not a function.
 182   // Res is nullptr. N remains unchanged.
 183   {
 184     EXPECT_FALSE(D.partialDemangle("_ZN1a1cE"));
 185
 186     size_t N = OriginalSize;
 187     char *Res = D.getFunctionName(Buf, &N);
 188     EXPECT_EQ(nullptr, Res);
 189     EXPECT_EQ(OriginalSize, N);
 190   }
 191
 192   std::free(Buf);
 193 }