[llvm] r340663 - Add data structure to form equivalence classes of mangled names.
Chandler Carruth via llvm-commits
llvm-commits at lists.llvm.org
Sun Aug 26 01:48:07 PDT 2018
Bots have been broken for a long time now. I'm going to revert this to get
the bots green and Richard can re-land...
On Sat, Aug 25, 2018 at 4:20 PM via llvm-commits <
llvm-commits at lists.llvm.org> wrote:
> Hi Richard, your commit is causing a build failure on the PS4 Windows bot.
> Can you please take a look?
>
>
> http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast/builds/19356/steps/build/logs/stdio
>
> FAILED:
> lib/Support/CMakeFiles/LLVMSupport.dir/ItaniumManglingCanonicalizer.cpp.obj
> C:\PROGRA~2\MICROS~1.0\VC\bin\cl.exe /nologo /TP -DGTEST_HAS_RTTI=0
> -DUNICODE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS
> -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_FILE_OFFSET_BITS=64
> -D_HAS_EXCEPTIONS=0 -D_LARGEFILE_SOURCE -D_SCL_SECURE_NO_DEPRECATE
> -D_SCL_SECURE_NO_WARNINGS -D_UNICODE -D__STDC_CONSTANT_MACROS
> -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Ilib\Support
> -IC:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\lib\Support
> -Iinclude
> -IC:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\include
> /DWIN32 /D_WINDOWS /Zc:inline /Zc:strictStrings /Oi /Zc:rvalueCast /W4
> -wd4141 -wd4146 -wd4180 -wd4244 -wd4258 -wd4267 -wd4291 -wd4345 -wd4351
> -wd4355 -wd4456 -wd4457 -wd4458 -wd4459 -wd4503 -wd4624 -wd4722 -wd4800
> -wd4100 -wd4127 -wd4512 -wd4505 -wd4610 -wd4510 -wd4702 -wd4245 -wd4706
> -wd4310 -wd4701 -wd4703 -wd4389 -wd4611 -wd4805 -wd4204 -wd4577 -wd4091
> -wd4592 -wd4319 -wd4324 -w14062 -we4238 /MD /O2 /Ob2 -UNDEBUG /EHs-c-
> /GR- /showIncludes
> /Folib\Support\CMakeFiles\LLVMSupport.dir\ItaniumManglingCanonicalizer.cpp.obj
> /Fdlib\Support\CMakeFiles\LLVMSupport.dir\LLVMSupport.pdb /FS -c
> C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\lib\Support\ItaniumManglingCanonicalizer.cpp
> C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\lib\Support\ItaniumManglingCanonicalizer.cpp(146):
> error C2910:
> '`anonymous-namespace'::FoldingNodeAllocator::getOrCreateNode': cannot be
> explicitly specialized
>
> Douglas Yung
>
> > -----Original Message-----
> > From: llvm-commits [mailto:llvm-commits-bounces at lists.llvm.org] On
> > Behalf Of Richard Smith via llvm-commits
> > Sent: Friday, August 24, 2018 15:32
> > To: llvm-commits at lists.llvm.org
> > Subject: [llvm] r340663 - Add data structure to form equivalence
> > classes of mangled names.
> >
> > Author: rsmith
> > Date: Fri Aug 24 15:31:51 2018
> > New Revision: 340663
> >
> > URL: http://llvm.org/viewvc/llvm-project?rev=340663&view=rev
> > Log:
> > Add data structure to form equivalence classes of mangled names.
> >
> > Summary:
> > Given a set of equivalent name fragments, this mechanism determines
> > whether two
> > mangled names are equivalent. The intent is to use this for fuzzy
> > matching of
> > profile data against the program after certain refactorings are
> > performed.
> >
> > Reviewers: erik.pilkington, dlj
> >
> > Subscribers: mgorny, llvm-commits
> >
> > Differential Revision: https://reviews.llvm.org/D50935
> >
> > Added:
> > llvm/trunk/include/llvm/Support/ItaniumManglingCanonicalizer.h
> > llvm/trunk/lib/Support/ItaniumManglingCanonicalizer.cpp
> > llvm/trunk/unittests/Support/ItaniumManglingCanonicalizerTest.cpp
> > Modified:
> > llvm/trunk/include/llvm/Demangle/ItaniumDemangle.h
> > llvm/trunk/lib/Support/CMakeLists.txt
> > llvm/trunk/unittests/Support/CMakeLists.txt
> >
> > Modified: llvm/trunk/include/llvm/Demangle/ItaniumDemangle.h
> > URL: http://llvm.org/viewvc/llvm-
> > project/llvm/trunk/include/llvm/Demangle/ItaniumDemangle.h?rev=340663&r
> > 1=340662&r2=340663&view=diff
> > =======================================================================
> > =======
> > --- llvm/trunk/include/llvm/Demangle/ItaniumDemangle.h (original)
> > +++ llvm/trunk/include/llvm/Demangle/ItaniumDemangle.h Fri Aug 24
> > 15:31:51 2018
> > @@ -2160,7 +2160,7 @@ struct Db {
> > ASTAllocator.reset();
> > }
> >
> > - template <class T, class... Args> T *make(Args &&... args) {
> > + template <class T, class... Args> Node *make(Args &&... args) {
> > return ASTAllocator.template
> > makeNode<T>(std::forward<Args>(args)...);
> > }
> >
> > @@ -4948,8 +4948,11 @@ template<typename Alloc> Node *Db<Alloc>
> > // <template-arg> further ahead in the mangled name (currently just
> > conversion
> > // operator types), then we should only look it up in the right
> > context.
> > if (PermitForwardTemplateReferences) {
> > -
> > ForwardTemplateRefs.push_back(make<ForwardTemplateReference>(Index));
> > - return ForwardTemplateRefs.back();
> > + Node *ForwardRef = make<ForwardTemplateReference>(Index);
> > + assert(ForwardRef->getKind() == Node::KForwardTemplateReference);
> > + ForwardTemplateRefs.push_back(
> > + static_cast<ForwardTemplateReference *>(ForwardRef));
> > + return ForwardRef;
> > }
> >
> > if (Index >= TemplateParams.size())
> >
> > Added: llvm/trunk/include/llvm/Support/ItaniumManglingCanonicalizer.h
> > URL: http://llvm.org/viewvc/llvm-
> > project/llvm/trunk/include/llvm/Support/ItaniumManglingCanonicalizer.h?
> > rev=340663&view=auto
> > =======================================================================
> > =======
> > --- llvm/trunk/include/llvm/Support/ItaniumManglingCanonicalizer.h
> > (added)
> > +++ llvm/trunk/include/llvm/Support/ItaniumManglingCanonicalizer.h Fri
> > Aug 24 15:31:51 2018
> > @@ -0,0 +1,87 @@
> > +//===--- ItaniumManglingCanonicalizer.h -------------------------*-
> > C++ -*-===//
> > +//
> > +// The LLVM Compiler Infrastructure
> > +//
> > +// This file is distributed under the University of Illinois Open
> > Source
> > +// License. See LICENSE.TXT for details.
> > +//
> > +//===-----------------------------------------------------------------
> > -----===//
> > +//
> > +// This file defines a class for computing equivalence classes of
> > mangled names
> > +// given a set of equivalences between name fragments.
> > +//
> > +//===-----------------------------------------------------------------
> > -----===//
> > +
> > +#ifndef LLVM_SUPPORT_ITANIUMMANGLINGCANONICALIZER_H
> > +#define LLVM_SUPPORT_ITANIUMMANGLINGCANONICALIZER_H
> > +
> > +#include "llvm/ADT/StringRef.h"
> > +
> > +#include <cstddef>
> > +
> > +namespace llvm {
> > +/// Canonicalizer for mangled names.
> > +///
> > +/// This class allows specifying a list of "equivalent" manglings. For
> > example,
> > +/// you can specify that Ss is equivalent to
> > +/// NSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE
> > +/// and then manglings that refer to libstdc++'s 'std::string' will be
> > +/// considered equivalent to manglings that are the same except that
> > they refer
> > +/// to libc++'s 'std::string'.
> > +///
> > +/// This can be used when data (eg, profiling data) is available for a
> > version
> > +/// of a program built in a different configuration, with
> > correspondingly
> > +/// different manglings.
> > +class ItaniumManglingCanonicalizer {
> > +public:
> > + ItaniumManglingCanonicalizer();
> > + ItaniumManglingCanonicalizer(const ItaniumManglingCanonicalizer &) =
> > delete;
> > + void operator=(const ItaniumManglingCanonicalizer &) = delete;
> > + ~ItaniumManglingCanonicalizer();
> > +
> > + enum class EquivalenceError {
> > + Success,
> > +
> > + /// Both the equivalent manglings have already been used as
> > components of
> > + /// some other mangling we've looked at. It's too late to add this
> > + /// equivalence.
> > + ManglingAlreadyUsed,
> > +
> > + /// The first equivalent mangling is invalid.
> > + InvalidFirstMangling,
> > +
> > + /// The second equivalent mangling is invalid.
> > + InvalidSecondMangling,
> > + };
> > +
> > + enum class FragmentKind {
> > + /// The mangling fragment is a <name> (or a predefined
> > <substitution>).
> > + Name,
> > + /// The mangling fragment is a <type>.
> > + Type,
> > + /// The mangling fragment is an <encoding>.
> > + Encoding,
> > + };
> > +
> > + /// Add an equivalence between \p First and \p Second. Both
> > manglings must
> > + /// live at least as long as the canonicalizer.
> > + EquivalenceError addEquivalence(FragmentKind Kind, StringRef First,
> > + StringRef Second);
> > +
> > + using Key = uintptr_t;
> > +
> > + /// Form a canonical key for the specified mangling. They key will
> > be the
> > + /// same for all equivalent manglings, and different for any two
> > + /// non-equivalent manglings, but is otherwise unspecified.
> > + ///
> > + /// Returns Key() if (and only if) the mangling is not a valid
> > Itanium C++
> > + /// ABI mangling.
> > + Key canonicalize(StringRef Mangling);
> > +
> > +private:
> > + struct Impl;
> > + Impl *P;
> > +};
> > +} // namespace llvm
> > +
> > +#endif // LLVM_SUPPORT_ITANIUMMANGLINGCANONICALIZER_H
> >
> > Modified: llvm/trunk/lib/Support/CMakeLists.txt
> > URL: http://llvm.org/viewvc/llvm-
> > project/llvm/trunk/lib/Support/CMakeLists.txt?rev=340663&r1=340662&r2=3
> > 40663&view=diff
> > =======================================================================
> > =======
> > --- llvm/trunk/lib/Support/CMakeLists.txt (original)
> > +++ llvm/trunk/lib/Support/CMakeLists.txt Fri Aug 24 15:31:51 2018
> > @@ -83,6 +83,7 @@ add_llvm_library(LLVMSupport
> > InitLLVM.cpp
> > IntEqClasses.cpp
> > IntervalMap.cpp
> > + ItaniumManglingCanonicalizer.cpp
> > JamCRC.cpp
> > JSON.cpp
> > KnownBits.cpp
> >
> > Added: llvm/trunk/lib/Support/ItaniumManglingCanonicalizer.cpp
> > URL: http://llvm.org/viewvc/llvm-
> > project/llvm/trunk/lib/Support/ItaniumManglingCanonicalizer.cpp?rev=340
> > 663&view=auto
> > =======================================================================
> > =======
> > --- llvm/trunk/lib/Support/ItaniumManglingCanonicalizer.cpp (added)
> > +++ llvm/trunk/lib/Support/ItaniumManglingCanonicalizer.cpp Fri Aug 24
> > 15:31:51 2018
> > @@ -0,0 +1,307 @@
> > +//===----------------- ItaniumManglingCanonicalizer.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/FoldingSet.h"
> > +#include "llvm/ADT/StringRef.h"
> > +#include "llvm/Demangle/ItaniumDemangle.h"
> > +#include "llvm/Support/Allocator.h"
> > +
> > +#include "llvm/ADT/DenseMap.h"
> > +#include "llvm/ADT/FoldingSet.h"
> > +#include "llvm/ADT/StringRef.h"
> > +
> > +using namespace llvm;
> > +using llvm::itanium_demangle::ForwardTemplateReference;
> > +using llvm::itanium_demangle::Node;
> > +using llvm::itanium_demangle::NodeKind;
> > +
> > +namespace {
> > +struct FoldingSetNodeIDBuilder {
> > + llvm::FoldingSetNodeID &ID;
> > + void operator()(const Node *P) { ID.AddPointer(P); }
> > + void operator()(StringView Str) {
> > + ID.AddString(llvm::StringRef(Str.begin(), Str.size()));
> > + }
> > + template<typename T>
> > + typename std::enable_if<std::is_integral<T>::value ||
> > + std::is_enum<T>::value>::type
> > + operator()(T V) {
> > + ID.AddInteger((unsigned long long)V);
> > + }
> > + void operator()(itanium_demangle::NodeOrString NS) {
> > + if (NS.isNode()) {
> > + ID.AddInteger(0);
> > + (*this)(NS.asNode());
> > + } else if (NS.isString()) {
> > + ID.AddInteger(1);
> > + (*this)(NS.asString());
> > + } else {
> > + ID.AddInteger(2);
> > + }
> > + }
> > + void operator()(itanium_demangle::NodeArray A) {
> > + ID.AddInteger(A.size());
> > + for (const Node *N : A)
> > + (*this)(N);
> > + }
> > +};
> > +
> > +template<typename ...T>
> > +void profileCtor(llvm::FoldingSetNodeID &ID, Node::Kind K, T ...V) {
> > + FoldingSetNodeIDBuilder Builder = {ID};
> > + Builder(K);
> > + int VisitInOrder[] = {
> > + (Builder(V), 0) ...,
> > + 0 // Avoid empty array if there are no arguments.
> > + };
> > + (void)VisitInOrder;
> > +}
> > +
> > +// FIXME: Convert this to a generic lambda when possible.
> > +template<typename NodeT> struct ProfileSpecificNode {
> > + FoldingSetNodeID &ID;
> > + template<typename ...T> void operator()(T ...V) {
> > + profileCtor(ID, NodeKind<NodeT>::Kind, V...);
> > + }
> > +};
> > +
> > +struct ProfileNode {
> > + FoldingSetNodeID &ID;
> > + template<typename NodeT> void operator()(const NodeT *N) {
> > + N->match(ProfileSpecificNode<NodeT>{ID});
> > + }
> > +};
> > +
> > +template<> void ProfileNode::operator()(const ForwardTemplateReference
> > *N) {
> > + llvm_unreachable("should never canonicalize a
> > ForwardTemplateReference");
> > +};
> > +
> > +void profileNode(llvm::FoldingSetNodeID &ID, const Node *N) {
> > + N->visit(ProfileNode{ID});
> > +}
> > +
> > +class FoldingNodeAllocator {
> > + class alignas(alignof(Node *)) NodeHeader : public
> > llvm::FoldingSetNode {
> > + public:
> > + // 'Node' in this context names the injected-class-name of the
> > base class.
> > + itanium_demangle::Node *getNode() {
> > + return reinterpret_cast<itanium_demangle::Node *>(this + 1);
> > + }
> > + void Profile(llvm::FoldingSetNodeID &ID) { profileNode(ID,
> > getNode()); }
> > + };
> > +
> > + BumpPtrAllocator RawAlloc;
> > + llvm::FoldingSet<NodeHeader> Nodes;
> > +
> > +public:
> > + void reset() {}
> > +
> > + template<typename T, typename ...Args>
> > + std::pair<Node*, bool> getOrCreateNode(Args &&...As) {
> > + llvm::FoldingSetNodeID ID;
> > + profileCtor(ID, NodeKind<T>::Kind, As...);
> > +
> > + void *InsertPos;
> > + if (NodeHeader *Existing = Nodes.FindNodeOrInsertPos(ID,
> > InsertPos))
> > + return {static_cast<T*>(Existing->getNode()), false};
> > +
> > + static_assert(alignof(T) <= alignof(NodeHeader),
> > + "underaligned node header for specific node kind");
> > + void *Storage =
> > + RawAlloc.Allocate(sizeof(NodeHeader) + sizeof(T),
> > alignof(NodeHeader));
> > + NodeHeader *New = new (Storage) NodeHeader;
> > + T *Result = new (New->getNode()) T(std::forward<Args>(As)...);
> > + Nodes.InsertNode(New, InsertPos);
> > + return {Result, true};
> > + }
> > +
> > + template<typename T, typename... Args>
> > + Node *makeNode(Args &&...As) {
> > + return getOrCreateNode<T>(std::forward<Args>(As)...).first;
> > + }
> > +
> > + void *allocateNodeArray(size_t sz) {
> > + return RawAlloc.Allocate(sizeof(Node *) * sz, alignof(Node *));
> > + }
> > +};
> > +
> > +// FIXME: Don't canonicalize forward template references for now,
> > because they
> > +// contain state (the resolved template node) that's not known at
> > their point
> > +// of creation.
> > +template<>
> > +std::pair<Node *, bool>
> > +FoldingNodeAllocator::getOrCreateNode<ForwardTemplateReference>(size_t
> > &Index) {
> > + return {new (RawAlloc.Allocate(sizeof(ForwardTemplateReference),
> > + alignof(ForwardTemplateReference)))
> > + ForwardTemplateReference(Index),
> > + true};
> > +}
> > +
> > +class CanonicalizerAllocator : public FoldingNodeAllocator {
> > + Node *MostRecentlyCreated = nullptr;
> > + Node *TrackedNode = nullptr;
> > + bool TrackedNodeIsUsed = false;
> > + llvm::SmallDenseMap<Node*, Node*, 32> Remappings;
> > +
> > + template<typename T, typename ...Args> Node *makeNodeSimple(Args
> > &&...As) {
> > + std::pair<Node *, bool> Result =
> > + getOrCreateNode<T>(std::forward<Args>(As)...);
> > + if (Result.second) {
> > + // Node is new. Make a note of that.
> > + MostRecentlyCreated = Result.first;
> > + } else {
> > + // Node is pre-existing; check if it's in our remapping table.
> > + if (auto *N = Remappings.lookup(Result.first)) {
> > + Result.first = N;
> > + assert(Remappings.find(Result.first) == Remappings.end() &&
> > + "should never need multiple remap steps");
> > + }
> > + if (Result.first == TrackedNode)
> > + TrackedNodeIsUsed = true;
> > + }
> > + return Result.first;
> > + }
> > +
> > + /// Helper to allow makeNode to be partially-specialized on T.
> > + template<typename T> struct MakeNodeImpl {
> > + CanonicalizerAllocator &Self;
> > + template<typename ...Args> Node *make(Args &&...As) {
> > + return Self.makeNodeSimple<T>(std::forward<Args>(As)...);
> > + }
> > + };
> > +
> > +public:
> > + template<typename T, typename ...Args> Node *makeNode(Args &&...As)
> > {
> > + return MakeNodeImpl<T>{*this}.make(std::forward<Args>(As)...);
> > + }
> > +
> > + void reset() { MostRecentlyCreated = nullptr; }
> > +
> > + void addRemapping(Node *A, Node *B) {
> > + // Note, we don't need to check whether B is also remapped,
> > because if it
> > + // was we would have already remapped it when building it.
> > + Remappings.insert(std::make_pair(A, B));
> > + }
> > +
> > + bool isMostRecentlyCreated(Node *N) const { return
> > MostRecentlyCreated == N; }
> > +
> > + void trackUsesOf(Node *N) {
> > + TrackedNode = N;
> > + TrackedNodeIsUsed = false;
> > + }
> > + bool trackedNodeIsUsed() const { return TrackedNodeIsUsed; }
> > +};
> > +
> > +/// Convert St3foo to NSt3fooE so that equivalences naming one also
> > affect the
> > +/// other.
> > +template<>
> > +struct CanonicalizerAllocator::MakeNodeImpl<
> > + itanium_demangle::StdQualifiedName> {
> > + CanonicalizerAllocator &Self;
> > + Node *make(Node *Child) {
> > + Node *StdNamespace =
> > Self.makeNode<itanium_demangle::NameType>("std");
> > + if (!StdNamespace)
> > + return nullptr;
> > + return Self.makeNode<itanium_demangle::NestedName>(StdNamespace,
> > Child);
> > + }
> > +};
> > +
> > +// FIXME: Also expand built-in substitutions?
> > +
> > +using CanonicalizingDemangler =
> > itanium_demangle::Db<CanonicalizerAllocator>;
> > +}
> > +
> > +struct ItaniumManglingCanonicalizer::Impl {
> > + CanonicalizingDemangler Demangler = {nullptr, nullptr};
> > +};
> > +
> > +ItaniumManglingCanonicalizer::ItaniumManglingCanonicalizer() : P(new
> > Impl) {}
> > +ItaniumManglingCanonicalizer::~ItaniumManglingCanonicalizer() { delete
> > P; }
> > +
> > +ItaniumManglingCanonicalizer::EquivalenceError
> > +ItaniumManglingCanonicalizer::addEquivalence(FragmentKind Kind,
> > StringRef First,
> > + StringRef Second) {
> > + auto &Alloc = P->Demangler.ASTAllocator;
> > +
> > + auto Parse = [&](StringRef Str) {
> > + P->Demangler.reset(Str.begin(), Str.end());
> > + Node *N = nullptr;
> > + switch (Kind) {
> > + // A <name>, with minor extensions to allow arbitrary namespace
> > and
> > + // template names that can't easily be written as <name>s.
> > + case FragmentKind::Name:
> > + // Very special case: allow "St" as a shorthand for "3std". It's
> > not
> > + // valid as a <name> mangling, but is nonetheless the most
> > natural
> > + // way to name the 'std' namespace.
> > + if (Str.size() == 2 && P->Demangler.consumeIf("St"))
> > + N = P->Demangler.make<itanium_demangle::NameType>("std");
> > + // We permit substitutions to name templates without their
> > template
> > + // arguments. This mostly just falls out, as almost all template
> > names
> > + // are valid as <name>s, but we also want to parse
> > <substitution>s as
> > + // <name>s, even though they're not.
> > + else if (Str.startswith("S"))
> > + // Parse the substitution and optional following template
> > arguments.
> > + N = P->Demangler.parseType();
> > + else
> > + N = P->Demangler.parseName();
> > + break;
> > +
> > + // A <type>.
> > + case FragmentKind::Type:
> > + N = P->Demangler.parseType();
> > + break;
> > +
> > + // An <encoding>.
> > + case FragmentKind::Encoding:
> > + N = P->Demangler.parseEncoding();
> > + break;
> > + }
> > +
> > + // If we have trailing junk, the mangling is invalid.
> > + if (P->Demangler.numLeft() != 0)
> > + N = nullptr;
> > +
> > + // If any node was created after N, then we cannot safely remap it
> > because
> > + // it might already be in use by another node.
> > + return std::make_pair(N, Alloc.isMostRecentlyCreated(N));
> > + };
> > +
> > + Node *FirstNode, *SecondNode;
> > + bool FirstIsNew, SecondIsNew;
> > +
> > + std::tie(FirstNode, FirstIsNew) = Parse(First);
> > + if (!FirstNode)
> > + return EquivalenceError::InvalidFirstMangling;
> > +
> > + Alloc.trackUsesOf(FirstNode);
> > + std::tie(SecondNode, SecondIsNew) = Parse(Second);
> > + if (!SecondNode)
> > + return EquivalenceError::InvalidSecondMangling;
> > +
> > + // If they're already equivalent, there's nothing to do.
> > + if (FirstNode == SecondNode)
> > + return EquivalenceError::Success;
> > +
> > + if (FirstIsNew && !Alloc.trackedNodeIsUsed())
> > + Alloc.addRemapping(FirstNode, SecondNode);
> > + else if (SecondIsNew)
> > + Alloc.addRemapping(SecondNode, FirstNode);
> > + else
> > + return EquivalenceError::ManglingAlreadyUsed;
> > +
> > + return EquivalenceError::Success;
> > +}
> > +
> > +ItaniumManglingCanonicalizer::Key
> > +ItaniumManglingCanonicalizer::canonicalize(StringRef Mangling) {
> > + P->Demangler.reset(Mangling.begin(), Mangling.end());
> > + return reinterpret_cast<Key>(P->Demangler.parse());
> > +}
> >
> > Modified: llvm/trunk/unittests/Support/CMakeLists.txt
> > URL: http://llvm.org/viewvc/llvm-
> > project/llvm/trunk/unittests/Support/CMakeLists.txt?rev=340663&r1=34066
> > 2&r2=340663&view=diff
> > =======================================================================
> > =======
> > --- llvm/trunk/unittests/Support/CMakeLists.txt (original)
> > +++ llvm/trunk/unittests/Support/CMakeLists.txt Fri Aug 24 15:31:51
> > 2018
> > @@ -31,6 +31,7 @@ add_llvm_unittest(SupportTests
> > FormatVariadicTest.cpp
> > GlobPatternTest.cpp
> > Host.cpp
> > + ItaniumManglingCanonicalizerTest.cpp
> > JSONTest.cpp
> > LEB128Test.cpp
> > LineIteratorTest.cpp
> >
> > Added:
> > llvm/trunk/unittests/Support/ItaniumManglingCanonicalizerTest.cpp
> > URL: http://llvm.org/viewvc/llvm-
> > project/llvm/trunk/unittests/Support/ItaniumManglingCanonicalizerTest.c
> > pp?rev=340663&view=auto
> > =======================================================================
> > =======
> > --- llvm/trunk/unittests/Support/ItaniumManglingCanonicalizerTest.cpp
> > (added)
> > +++ llvm/trunk/unittests/Support/ItaniumManglingCanonicalizerTest.cpp
> > Fri Aug 24 15:31:51 2018
> > @@ -0,0 +1,315 @@
> > +//===-------------- 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 <cstdlib>
> > +#include "llvm/Support/ItaniumManglingCanonicalizer.h"
> > +#include "gtest/gtest.h"
> > +
> > +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::initializer_list<llvm::StringRef>;
> > +
> > +struct Testcase {
> > + // A set of equivalences to register.
> > + std::initializer_list<Equivalence> Equivalences;
> > + // A set of distinct equivalence classes created by registering the
> > + // equivalences.
> > + std::initializer_list<EquivalenceClass> Classes;
> > +};
> > +
> > +static std::initializer_list<Testcase> Testcases = {
> > + // 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_9allocatorIcEEE4sizeE
> > v"},
> > + }
> > + },
> > +
> > + // 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"},
> > + },
> > + {}
> > + },
> > +
> > + // 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"},
> > + }
> > + },
> > +};
> > +
> > +TEST(ItaniumManglingCanonicalizerTest, TestTestcases) {
> > + 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<CanonKey, llvm::StringRef> Found;
> > + for (const auto &Class : Testcase.Classes) {
> > + CanonKey ClassKey = {};
> > + for (llvm::StringRef Str : Class) {
> > + CanonKey ThisKey = 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, 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);
> > +}
> >
> >
> > _______________________________________________
> > llvm-commits mailing list
> > llvm-commits at lists.llvm.org
> > http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20180826/32575e3c/attachment.html>
More information about the llvm-commits
mailing list