llvm-project/llvm/unittests/Support/ItaniumManglingCanonicalize...

378 lines
13 KiB
C++
Raw Normal View History

//===-------------- ItaniumManglingCanonicalizerTest.cpp ------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/ItaniumManglingCanonicalizer.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
#include "gtest/gtest.h"
#include <cstdlib>
#include <map>
#include <vector>
using namespace llvm;
namespace {
using EquivalenceError = llvm::ItaniumManglingCanonicalizer::EquivalenceError;
using FragmentKind = llvm::ItaniumManglingCanonicalizer::FragmentKind;
struct Equivalence {
FragmentKind Kind;
llvm::StringRef First;
llvm::StringRef Second;
};
// A set of manglings that should all be considered equivalent.
using EquivalenceClass = std::vector<llvm::StringRef>;
struct Testcase {
// A set of equivalences to register.
std::vector<Equivalence> Equivalences;
// A set of distinct equivalence classes created by registering the
// equivalences.
std::vector<EquivalenceClass> Classes;
};
// A function that returns a set of test cases.
static std::vector<Testcase> getTestcases() {
return {
// Three different manglings for std::string (old libstdc++, new libstdc++,
// libc++).
{
{
{FragmentKind::Type, "Ss",
"NSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE"},
{FragmentKind::Type, "Ss",
"NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"},
},
{
{"_Z1fv"},
{"_Z1fSs",
"_Z1fNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE",
"_Z1fNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"},
{"_ZNKSs4sizeEv",
"_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv",
"_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4sizeEv"},
}
},
// Check that substitutions are properly handled.
{
{
// ::X <-> ::N::X<int>
{FragmentKind::Type, "1X", "N1N1XIiEE"},
// ::T<T<int, int>, T<int, int>> <-> T<int>
{FragmentKind::Type, "1TIS_IiiES0_E", "1TIiE"},
// A::B::foo <-> AB::foo
{FragmentKind::Name, "N1A1B3fooE", "N2AB3fooE"},
},
{
{"_Z1f1XPS_RS_", "_Z1fN1N1XIiEEPS1_RS1_"},
{"_ZN1A1B3fooE1TIS1_IiiES2_EPS3_RS3_", "_ZN2AB3fooE1TIiEPS1_RS1_"},
}
},
// Check that nested equivalences are properly handled.
{
{
// std::__1::char_traits == std::__cxx11::char_traits
// (Note that this is unused and should make no difference,
// but it should not cause us to fail to match up the cases
// below.)
{FragmentKind::Name,
"NSt3__111char_traitsE",
"NSt7__cxx1111char_traitsE"},
// std::__1::allocator == std::allocator
{FragmentKind::Name,
"NSt3__19allocatorE",
"Sa"}, // "Sa" is not strictly a <name> but we accept it as one.
// std::__1::vector == std::vector
{FragmentKind::Name,
"St6vector",
"NSt3__16vectorE"},
// std::__1::basic_string<
// char
// std::__1::char_traits<char>,
// std::__1::allocator<char>> ==
// std::__cxx11::basic_string<
// char,
// std::char_traits<char>,
// std::allocator<char>>
{FragmentKind::Type,
"NSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE",
"NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"},
// X<A> <-> X<B>
{FragmentKind::Type, "1XI1AE", "1XI1BE"},
// X <-> Y
{FragmentKind::Name, "1X", "1Y"},
},
{
// f(std::string)
{"_Z1fNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE",
"_Z1fNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"},
// f(std::vector<int>)
{"_Z1fSt6vectorIiSaIiEE", "_Z1fNSt3__16vectorIiNS_9allocatorIiEEEE"},
// f(X<A>), f(X<B>), f(Y<A>), f(Y<B>)
{"_Z1f1XI1AE", "_Z1f1XI1BE", "_Z1f1YI1AE", "_Z1f1YI1BE"},
// f(X<C>), f(Y<C>)
{"_Z1f1XI1CE", "_Z1f1YI1CE"},
}
},
// Check namespace equivalences.
{
{
// std::__1 == std::__cxx11
{FragmentKind::Name, "St3__1", "St7__cxx11"},
// std::__1::allocator == std::allocator
{FragmentKind::Name, "NSt3__19allocatorE", "Sa"},
// std::vector == std::__1::vector
{FragmentKind::Name, "St6vector", "NSt3__16vectorE"},
// std::__cxx11::char_traits == std::char_traits
// (This indirectly means that std::__1::char_traits == std::char_traits,
// due to the std::__cxx11 == std::__1 equivalence, which is what we rely
// on below.)
{FragmentKind::Name, "NSt7__cxx1111char_traitsE", "St11char_traits"},
},
{
// f(std::foo)
{"_Z1fNSt7__cxx113fooE",
"_Z1fNSt3__13fooE"},
// f(std::string)
{"_Z1fNSt7__cxx1111char_traitsIcEE",
"_Z1fNSt3__111char_traitsIcEE",
"_Z1fSt11char_traitsIcE"},
// f(std::string)
{"_Z1fNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE",
"_Z1fNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"},
// f(std::vector<int>)
{"_Z1fSt6vectorIiSaIiEE", "_Z1fNSt3__16vectorIiNS_9allocatorIiEEEE"},
}
},
// Check namespace equivalences for namespace 'std'. We support using 'St'
// for this, despite it not technically being a <name>.
{
{
// std::__1 == std
{FragmentKind::Name, "St3__1", "St"},
// std::__1 == std::__cxx11
{FragmentKind::Name, "St3__1", "St7__cxx11"},
// FIXME: Should a 'std' equivalence also cover the predefined
// substitutions?
// std::__1::allocator == std::allocator
{FragmentKind::Name, "NSt3__19allocatorE", "Sa"},
},
{
{"_Z1fSt3foo", "_Z1fNSt3__13fooE", "_Z1fNSt7__cxx113fooE"},
{"_Z1fNSt3bar3bazE", "_Z1fNSt3__13bar3bazE"},
// f(std::string)
{"_Z1fNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE",
"_Z1fNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE"},
// f(std::vector<int>)
{"_Z1fSt6vectorIiSaIiEE", "_Z1fNSt3__16vectorIiNS_9allocatorIiEEEE"},
}
},
// Check mutually-recursive equivalences.
{
{
{FragmentKind::Type, "1A", "1B"},
{FragmentKind::Type, "1A", "1C"},
{FragmentKind::Type, "1D", "1B"},
{FragmentKind::Type, "1C", "1E"},
},
{
{"_Z1f1A", "_Z1f1B", "_Z1f1C", "_Z1f1D", "_Z1f1E"},
{"_Z1f1F"},
}
},
// Check <encoding>s.
{
{
{FragmentKind::Encoding, "1fv", "1gv"},
},
{
// f(void) -> g(void)
{"_Z1fv", "_Z1gv"},
// static local 'n' in f(void) -> static local 'n' in g(void)
{"_ZZ1fvE1n", "_ZZ1gvE1n"},
}
},
// Corner case: the substitution can appear within its own expansion.
{
{
// X <-> Y<X>
{FragmentKind::Type, "1X", "1YI1XE"},
// A<B> <-> B
{FragmentKind::Type, "1AI1BE", "1B"},
},
{
// f(X) == f(Y<X>) == f(Y<Y<X>>) == f(Y<Y<Y<X>>>)
{"_Z1f1X", "_Z1f1YI1XE", "_Z1f1YIS_I1XEE", "_Z1f1YIS_IS_I1XEEE"},
// f(B) == f(A<B>) == f(A<A<B>>) == f(A<A<A<B>>>)
{"_Z1f1B", "_Z1f1AI1BE", "_Z1f1AIS_I1BEE", "_Z1f1AIS_IS_I1BEEE"},
}
},
// Redundant equivalences are accepted (and have no effect).
{
{
{FragmentKind::Name, "3std", "St"},
{FragmentKind::Name, "1X", "1Y"},
{FragmentKind::Name, "N1X1ZE", "N1Y1ZE"},
},
{}
},
// Check that ctor and dtor variants are considered distinct.
{
{},
{{"_ZN1XC1Ev"}, {"_ZN1XC2Ev"}, {"_ZN1XD1Ev"}, {"_ZN1XD2Ev"}}
},
// Ensure array types with and without bounds are handled properly.
{
{
{FragmentKind::Type, "A_i", "A1_f"},
},
{
{"_Z1fRA_i", "_Z1fRA_i", "_Z1fRA1_f"},
{"_Z1fRA1_i"}, {"_Z1fRA_f"},
}
},
};
}
// A function to get a set of test cases for forward template references.
static std::vector<Testcase> getForwardTemplateReferenceTestcases() {
return {
// ForwardTemplateReference does not support canonicalization.
// FIXME: We should consider ways of fixing this, perhaps by eliminating
// the ForwardTemplateReference node with a tree transformation.
{
{
// X::operator T() <with T = A> == Y::operator T() <with T = A>
{FragmentKind::Encoding, "N1XcvT_I1AEEv", "N1YcvT_I1AEEv"},
// A == B
{FragmentKind::Name, "1A", "1B"},
},
{
// All combinations result in unique equivalence classes.
{"_ZN1XcvT_I1AEEv"},
{"_ZN1XcvT_I1BEEv"},
{"_ZN1YcvT_I1AEEv"},
{"_ZN1YcvT_I1BEEv"},
// Even giving the same string twice gives a new class.
{"_ZN1XcvT_I1AEEv"},
}
},
};
}
template<bool CanonicalizeFirst>
static void testTestcases(ArrayRef<Testcase> Testcases) {
for (const auto &Testcase : Testcases) {
llvm::ItaniumManglingCanonicalizer Canonicalizer;
for (const auto &Equiv : Testcase.Equivalences) {
auto Result =
Canonicalizer.addEquivalence(Equiv.Kind, Equiv.First, Equiv.Second);
EXPECT_EQ(Result, EquivalenceError::Success)
<< "couldn't add equivalence between " << Equiv.First << " and "
<< Equiv.Second;
}
using CanonKey = llvm::ItaniumManglingCanonicalizer::Key;
std::map<const EquivalenceClass*, CanonKey> Keys;
if (CanonicalizeFirst)
for (const auto &Class : Testcase.Classes)
Keys.insert({&Class, Canonicalizer.canonicalize(*Class.begin())});
std::map<CanonKey, llvm::StringRef> Found;
for (const auto &Class : Testcase.Classes) {
CanonKey ClassKey = Keys[&Class];
for (llvm::StringRef Str : Class) {
// Force a copy to be made when calling lookup to test that it doesn't
// retain any part of the provided string.
CanonKey ThisKey = CanonicalizeFirst
? Canonicalizer.lookup(std::string(Str))
: Canonicalizer.canonicalize(Str);
EXPECT_NE(ThisKey, CanonKey()) << "couldn't canonicalize " << Str;
if (ClassKey) {
EXPECT_EQ(ThisKey, ClassKey)
<< Str << " not in the same class as " << *Class.begin();
} else {
ClassKey = ThisKey;
}
}
EXPECT_TRUE(Found.insert({ClassKey, *Class.begin()}).second)
<< *Class.begin() << " is in the same class as " << Found[ClassKey];
}
}
}
TEST(ItaniumManglingCanonicalizerTest, TestCanonicalize) {
testTestcases<false>(getTestcases());
}
TEST(ItaniumManglingCanonicalizerTest, TestLookup) {
testTestcases<true>(getTestcases());
}
TEST(ItaniumManglingCanonicalizerTest, TestForwardTemplateReference) {
// lookup(...) after canonicalization (intentionally) returns different
// values for this testcase.
testTestcases<false>(getForwardTemplateReferenceTestcases());
}
TEST(ItaniumManglingCanonicalizerTest, TestInvalidManglings) {
llvm::ItaniumManglingCanonicalizer Canonicalizer;
EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "", "1X"),
EquivalenceError::InvalidFirstMangling);
EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1X", "1ab"),
EquivalenceError::InvalidSecondMangling);
EXPECT_EQ(Canonicalizer.canonicalize("_Z3fooE"),
llvm::ItaniumManglingCanonicalizer::Key());
EXPECT_EQ(Canonicalizer.canonicalize("foo"),
llvm::ItaniumManglingCanonicalizer::Key());
// A reference to a template parameter ('T_' etc) cannot appear in a <name>,
// because we don't have template arguments to bind to it. (The arguments in
// an 'I ... E' construct in the <name> aren't registered as
// backreferenceable arguments in this sense, because they're not part of
// the template argument list of an <encoding>.
EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Name, "N1XcvT_I1AEE",
"1f"),
EquivalenceError::InvalidFirstMangling);
}
TEST(ItaniumManglingCanonicalizerTest, TestBadEquivalenceOrder) {
llvm::ItaniumManglingCanonicalizer Canonicalizer;
EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "N1P1XE", "N1Q1XE"),
EquivalenceError::Success);
EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1P", "1Q"),
EquivalenceError::ManglingAlreadyUsed);
EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "N1C1XE", "N1A1YE"),
EquivalenceError::Success);
EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1A", "1B"),
EquivalenceError::Success);
EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1C", "1D"),
EquivalenceError::Success);
EXPECT_EQ(Canonicalizer.addEquivalence(FragmentKind::Type, "1B", "1D"),
EquivalenceError::ManglingAlreadyUsed);
}
} // end anonymous namespace