Demangler.cpp

//===--- Demangler.cpp - String to Node-Tree Demangling -------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file implements new Swift de-mangler.
//
//===----------------------------------------------------------------------===//

#include"llvm/Support/Compiler.h"
#include"swift/Demangling/Demangler.h"
#include"DemanglerAssert.h"
#include"swift/Demangling/ManglingMacros.h"
#include"swift/Demangling/ManglingUtils.h"
#include"swift/Demangling/Punycode.h"
#include"swift/Strings.h"
#include<stdio.h>
#include<stdlib.h>

usingnamespaceswift;
usingnamespaceMangle;
using swift::Demangle::FunctionSigSpecializationParamKind;

//////////////////////////////////
// Private utility functions //
//////////////////////////////////

namespace {

staticboolisDeclName(Node::Kind kind) {
switch (kind) {
case Node::Kind::Identifier:
case Node::Kind::LocalDeclName:
case Node::Kind::PrivateDeclName:
case Node::Kind::RelatedEntityDeclName:
case Node::Kind::PrefixOperator:
case Node::Kind::PostfixOperator:
case Node::Kind::InfixOperator:
case Node::Kind::TypeSymbolicReference:
case Node::Kind::ProtocolSymbolicReference:
case Node::Kind::ObjectiveCProtocolSymbolicReference:
returntrue;
default:
returnfalse;
 }
}

staticboolisAnyGeneric(Node::Kind kind) {
switch (kind) {
case Node::Kind::Structure:
case Node::Kind::Class:
case Node::Kind::Enum:
case Node::Kind::Protocol:
case Node::Kind::ProtocolSymbolicReference:
case Node::Kind::ObjectiveCProtocolSymbolicReference:
case Node::Kind::OtherNominalType:
case Node::Kind::TypeAlias:
case Node::Kind::TypeSymbolicReference:
case Node::Kind::BuiltinTupleType:
returntrue;
default:
returnfalse;
 }
}

staticboolisEntity(Node::Kind kind) {
// Also accepts some kind which are not entities.
if (kind == Node::Kind::Type)
returntrue;
returnisContext(kind);
}

staticboolisRequirement(Node::Kind kind) {
switch (kind) {
case Node::Kind::DependentGenericParamPackMarker:
case Node::Kind::DependentGenericParamValueMarker:
case Node::Kind::DependentGenericSameTypeRequirement:
case Node::Kind::DependentGenericSameShapeRequirement:
case Node::Kind::DependentGenericLayoutRequirement:
case Node::Kind::DependentGenericConformanceRequirement:
case Node::Kind::DependentGenericInverseConformanceRequirement:
returntrue;
default:
returnfalse;
 }
}

} // anonymous namespace

//////////////////////////////////
// Public utility functions //
//////////////////////////////////

voidswift::Demangle::failAssert(constchar *file, unsigned line,
 NodePointer node, constchar *expr) {
 std::string treeStr = getNodeTreeAsString(node);

fatal(0,
"%s:%u: assertion failed for Node %p: %s\n"
"%s:%u: Node %p is:\n%s\n",
 file, line, node, expr, file, line, node, treeStr.c_str());
}

boolswift::Demangle::isContext(Node::Kind kind) {
switch (kind) {
#defineNODE(ID)
#defineCONTEXT_NODE(ID) \
case Node::Kind::ID:
#include"swift/Demangling/DemangleNodes.def"
returntrue;
case Node::Kind::BuiltinTupleType:
returntrue;
default:
returnfalse;
 }
}

boolswift::Demangle::isFunctionAttr(Node::Kind kind) {
switch (kind) {
case Node::Kind::FunctionSignatureSpecialization:
case Node::Kind::GenericSpecialization:
case Node::Kind::GenericSpecializationPrespecialized:
case Node::Kind::InlinedGenericFunction:
case Node::Kind::GenericSpecializationNotReAbstracted:
case Node::Kind::GenericPartialSpecialization:
case Node::Kind::GenericPartialSpecializationNotReAbstracted:
case Node::Kind::GenericSpecializationInResilienceDomain:
case Node::Kind::ObjCAttribute:
case Node::Kind::NonObjCAttribute:
case Node::Kind::DynamicAttribute:
case Node::Kind::DirectMethodReferenceAttribute:
case Node::Kind::VTableAttribute:
case Node::Kind::PartialApplyForwarder:
case Node::Kind::PartialApplyObjCForwarder:
case Node::Kind::OutlinedVariable:
case Node::Kind::OutlinedReadOnlyObject:
case Node::Kind::OutlinedBridgedMethod:
case Node::Kind::MergedFunction:
case Node::Kind::DistributedThunk:
case Node::Kind::DistributedAccessor:
case Node::Kind::DynamicallyReplaceableFunctionImpl:
case Node::Kind::DynamicallyReplaceableFunctionKey:
case Node::Kind::DynamicallyReplaceableFunctionVar:
case Node::Kind::AsyncFunctionPointer:
case Node::Kind::AsyncAwaitResumePartialFunction:
case Node::Kind::AsyncSuspendResumePartialFunction:
case Node::Kind::AccessibleFunctionRecord:
case Node::Kind::BackDeploymentThunk:
case Node::Kind::BackDeploymentFallback:
case Node::Kind::HasSymbolQuery:
case Node::Kind::CoroFunctionPointer:
case Node::Kind::DefaultOverride:
returntrue;
default:
returnfalse;
 }
}

llvm::StringRef
swift::Demangle::makeSymbolicMangledNameStringRef(constchar *base) {
if (!base)
return {};

auto end = base;
while (*end != '\0') {
// Skip over symbolic references.
if (*end >= '\x01' && *end <= '\x17')
 end += sizeof(uint32_t);
elseif (*end >= '\x18' && *end <= '\x1F')
 end += sizeof(void*);
 ++end;
 }
returnStringRef(base, end - base);
}

intswift::Demangle::getManglingPrefixLength(llvm::StringRef mangledName) {
if (mangledName.empty()) return0;

 llvm::StringRef prefixes[] = {
/*Swift 4*/"_T0",
/*Swift 4.x*/"$S", "_$S",
/*Swift 5+*/"$s", "_$s",
/*Swift 5+ Embedded Swift*/"$e", "_$e",
/*Swift 5+ for filenames*/"@__swiftmacro_",
 };

// Look for any of the known prefixes
for (auto prefix : prefixes) {
if (mangledName.starts_with(prefix))
return prefix.size();
 }

return0;
}

boolswift::Demangle::isSwiftSymbol(llvm::StringRef mangledName) {
if (isOldFunctionTypeMangling(mangledName))
returntrue;

returngetManglingPrefixLength(mangledName) != 0;
}

boolswift::Demangle::isSwiftSymbol(constchar *mangledName) {
 StringRef mangledNameRef(mangledName);
returnisSwiftSymbol(mangledNameRef);
}

boolswift::Demangle::isObjCSymbol(llvm::StringRef mangledName) {
 StringRef nameWithoutPrefix = dropSwiftManglingPrefix(mangledName);
return nameWithoutPrefix.starts_with("So") ||
 nameWithoutPrefix.starts_with("SC");
}

boolswift::Demangle::isOldFunctionTypeMangling(llvm::StringRef mangledName) {
return mangledName.starts_with("_T");
}

llvm::StringRef swift::Demangle::dropSwiftManglingPrefix(StringRef mangledName){
return mangledName.drop_front(getManglingPrefixLength(mangledName));
}

staticboolisAliasNode(Demangle::NodePointer Node) {
if (!Node)
returnfalse;
switch (Node->getKind()) {
case Demangle::Node::Kind::Type:
returnisAliasNode(Node->getChild(0));
case Demangle::Node::Kind::TypeAlias:
returntrue;
default:
returnfalse;
 }
assert(0 && "unknown node kind");
}

boolswift::Demangle::isAlias(llvm::StringRef mangledName) {
 Demangle::Demangler Dem;
returnisAliasNode(Dem.demangleType(mangledName));
}

staticboolisClassNode(Demangle::NodePointer Node) {
if (!Node)
returnfalse;
switch (Node->getKind()) {
case Demangle::Node::Kind::Type:
returnisClassNode(Node->getChild(0));
case Demangle::Node::Kind::Class:
case Demangle::Node::Kind::BoundGenericClass:
returntrue;
default:
returnfalse;
 }
assert(0 && "unknown node kind");
}

boolswift::Demangle::isClass(llvm::StringRef mangledName) {
 Demangle::Demangler Dem;
returnisClassNode(Dem.demangleType(mangledName));
}

staticboolisEnumNode(Demangle::NodePointer Node) {
if (!Node)
returnfalse;
switch (Node->getKind()) {
case Demangle::Node::Kind::Type:
returnisEnumNode(Node->getChild(0));
case Demangle::Node::Kind::Enum:
case Demangle::Node::Kind::BoundGenericEnum:
returntrue;
default:
returnfalse;
 }
assert(0 && "unknown node kind");
}

boolswift::Demangle::isEnum(llvm::StringRef mangledName) {
 Demangle::Demangler Dem;
returnisEnumNode(Dem.demangleType(mangledName));
}

staticboolisProtocolNode(Demangle::NodePointer Node) {
if (!Node)
returnfalse;
switch (Node->getKind()) {
case Demangle::Node::Kind::Type:
returnisProtocolNode(Node->getChild(0));
case Demangle::Node::Kind::Protocol:
case Demangle::Node::Kind::ProtocolSymbolicReference:
case Demangle::Node::Kind::ObjectiveCProtocolSymbolicReference:
returntrue;
default:
returnfalse;
 }
assert(0 && "unknown node kind");
}

boolswift::Demangle::isProtocol(llvm::StringRef mangledName) {
 Demangle::Demangler Dem;
returnisProtocolNode(Dem.demangleType(dropSwiftManglingPrefix(mangledName)));
}

staticboolisStructNode(Demangle::NodePointer Node) {
if (!Node)
returnfalse;
switch (Node->getKind()) {
case Demangle::Node::Kind::Type:
returnisStructNode(Node->getChild(0));
case Demangle::Node::Kind::Structure:
case Demangle::Node::Kind::BoundGenericStructure:
returntrue;
default:
returnfalse;
 }
assert(0 && "unknown node kind");
}

boolswift::Demangle::isStruct(llvm::StringRef mangledName) {
 Demangle::Demangler Dem;
returnisStructNode(Dem.demangleType(mangledName));
}

std::string swift::Demangle::mangledNameForTypeMetadataAccessor(
 StringRef moduleName, StringRef typeName, Node::Kind typeKind,
 Mangle::ManglingFlavor Flavor) {
usingnamespaceDemangle;

// kind=Global
// kind=NominalTypeDescriptor
// kind=Type
// kind=Structure|Enum|Class
// kind=Module, text=moduleName
// kind=Identifier, text=typeName
 Demangle::Demangler D;
auto *global = D.createNode(Node::Kind::Global);
 {
auto *nominalDescriptor =
 D.createNode(Node::Kind::TypeMetadataAccessFunction);
 {
auto *type = D.createNode(Node::Kind::Type);
 {
auto *module = D.createNode(Node::Kind::Module, moduleName);
auto *identifier = D.createNode(Node::Kind::Identifier, typeName);
auto *structNode = D.createNode(typeKind);
 structNode->addChild(module, D);
 structNode->addChild(identifier, D);
 type->addChild(structNode, D);
 }
 nominalDescriptor->addChild(type, D);
 }
 global->addChild(nominalDescriptor, D);
 }

auto mangleResult = mangleNode(global, Flavor);
assert(mangleResult.isSuccess());
return mangleResult.result();
}

usingnamespaceswift;
usingnamespaceDemangle;

//////////////////////////////////
// Node member functions //
//////////////////////////////////

voidNode::addChild(NodePointer Child, NodeFactory &Factory) {
DEMANGLER_ALWAYS_ASSERT(Child, this);
switch (NodePayloadKind) {
case PayloadKind::None:
 InlineChildren[0] = Child;
 InlineChildren[1] = nullptr;
 NodePayloadKind = PayloadKind::OneChild;
break;
case PayloadKind::OneChild:
assert(!InlineChildren[1]);
 InlineChildren[1] = Child;
 NodePayloadKind = PayloadKind::TwoChildren;
break;
case PayloadKind::TwoChildren: {
 NodePointer Child0 = InlineChildren[0];
 NodePointer Child1 = InlineChildren[1];
 Children.Nodes = nullptr;
 Children.Number = 0;
 Children.Capacity = 0;
 Factory.Reallocate(Children.Nodes, Children.Capacity, 3);
assert(Children.Capacity >= 3);
 Children.Nodes[0] = Child0;
 Children.Nodes[1] = Child1;
 Children.Nodes[2] = Child;
 Children.Number = 3;
 NodePayloadKind = PayloadKind::ManyChildren;
break;
 }
case PayloadKind::ManyChildren:
if (Children.Number >= Children.Capacity) {
 Factory.Reallocate(Children.Nodes, Children.Capacity, 1);
 }
assert(Children.Number < Children.Capacity);
 Children.Nodes[Children.Number++] = Child;
break;
default:
assert(false && "cannot add child");
 }
}

voidNode::removeChildAt(unsigned Pos) {
switch (NodePayloadKind) {
case PayloadKind::OneChild:
assert(Pos == 0);
 NodePayloadKind = PayloadKind::None;
break;
case PayloadKind::TwoChildren: {
assert(Pos < 2);
if (Pos == 0)
 InlineChildren[0] = InlineChildren[1];
 NodePayloadKind = PayloadKind::OneChild;
break;
 }
case PayloadKind::ManyChildren:
for (unsigned i = Pos, n = Children.Number - 1; i != n; ++i) {
 Children.Nodes[i] = Children.Nodes[i + 1];
 }
 --Children.Number;
break;
default:
assert(false && "cannot remove child");
 }
}

voidNode::replaceChild(unsigned Pos, NodePointer Child) {
switch (NodePayloadKind) {
case PayloadKind::OneChild:
assert(Pos == 0);
 InlineChildren[0] = Child;
break;
case PayloadKind::TwoChildren:
assert(Pos < 2);
 InlineChildren[Pos] = Child;
break;
case PayloadKind::ManyChildren:
 Children.Nodes[Pos] = Child;
break;
default:
assert(false && "cannot remove child");
 }
}

voidNode::reverseChildren(size_t StartingAt) {
assert(StartingAt <= getNumChildren());
switch (NodePayloadKind) {
case PayloadKind::TwoChildren:
if (StartingAt == 0)
std::swap(InlineChildren[0], InlineChildren[1]);
break;
case PayloadKind::ManyChildren:
std::reverse(Children.Nodes + StartingAt,
 Children.Nodes + Children.Number);
break;
default:
break;
 }
}

Node* Node::findByKind(Node::Kind kind, int maxDepth) {
if (getKind() == kind)
returnthis;

if (maxDepth <= 0)
returnnullptr;

for (auto node : *this)
if (auto matchingChild = node->findByKind(kind, maxDepth - 1))
return matchingChild;

returnnullptr;
}

//////////////////////////////////
// NodeFactory member functions //
//////////////////////////////////

voidNodeFactory::freeSlabs(AllocatedSlab *slab) {
while (slab) {
 AllocatedSlab *prev = slab->Previous;
free(slab);
 slab = prev;
 }
}

voidNodeFactory::clear() {
assert(!isBorrowed);
if (CurrentSlab) {
#ifdef NODE_FACTORY_DEBUGGING
fprintf(stderr, "%s## clear: allocated memory = %zu\n", indent().c_str(), allocatedMemory);
#endif

freeSlabs(CurrentSlab->Previous);

// Recycle the last allocated slab.
// Note that the size of the last slab is at least as big as all previous
// slabs combined. Therefore it's not worth the effort of reusing all slabs.
// The slab size also stays the same. So at some point the demangling
// process converges to a single large slab across repeated demangle-clear
// cycles.
 CurrentSlab->Previous = nullptr;
 CurPtr = (char *)(CurrentSlab + 1);
#ifdef NODE_FACTORY_DEBUGGING
 allocatedMemory = 0;
#endif
 }
}

NodeFactory::Checkpoint NodeFactory::pushCheckpoint() const {
return {CurrentSlab, CurPtr, End};
}

voidNodeFactory::popCheckpoint(NodeFactory::Checkpoint checkpoint) {
if (checkpoint.Slab == CurrentSlab) {
if (checkpoint.CurPtr > CurPtr) {
fatal(0,
"Popping checkpoint {%p, %p, %p} that is after the current "
"pointer.\n",
 checkpoint.Slab, checkpoint.CurPtr, checkpoint.End);
 }
if (checkpoint.End != End) {
fatal(0,
"Popping checkpoint {%p, %p, %p} with End that does not match "
"current End %p.\n",
 checkpoint.Slab, checkpoint.CurPtr, checkpoint.End, End);
 }
#ifndef NDEBUG
// Scribble the newly freed area.
memset(checkpoint.CurPtr, 0xaa, CurPtr - checkpoint.CurPtr);
#endif
 CurPtr = checkpoint.CurPtr;
 } else {
// We may want to keep using the current slab rather than destroying
// it, since over time this allows us to converge on a steady state
// with no allocation activity (see the comment above in
// NodeFactory::clear). Keep using the current slab if the free space in the
// checkpoint's slab is less than 1/16th of the current slab's space. We
// won't repeatedly allocate and deallocate the current slab. The size
// doubles each time so we'll quickly pass the threshold.
 AllocatedSlab *savedSlab = nullptr;
if (CurrentSlab) {
size_t checkpointSlabFreeSpace = checkpoint.End - checkpoint.CurPtr;
size_t currentSlabSize = End - (char *)(CurrentSlab + 1);
if (currentSlabSize / 16 > checkpointSlabFreeSpace) {
 savedSlab = CurrentSlab;
 CurrentSlab = CurrentSlab->Previous;
// No need to save End, as it will still be in place later.
 }
 }

// Free all slabs (possibly except the one we saved) until we find the end
// or we find the checkpoint.
while (CurrentSlab && checkpoint.Slab != CurrentSlab) {
auto Slab = CurrentSlab;
 CurrentSlab = CurrentSlab->Previous;
free(Slab);
 }

// If we ran to the end and the checkpoint actually has a slab pointer, then
// the checkpoint is invalid.
if (!CurrentSlab && checkpoint.Slab) {
fatal(0,
"Popping checkpoint {%p, %p, %p} with slab that is not within "
"the allocator's slab chain.\n",
 checkpoint.Slab, checkpoint.CurPtr, checkpoint.End);
 }

if (savedSlab) {
// Reinstall the saved slab.
 savedSlab->Previous = CurrentSlab;
 CurrentSlab = savedSlab;
 CurPtr = (char *)(CurrentSlab + 1);
// End is still valid from before.
 } else {
// Set CurPtr and End to match the checkpoint's position.
 CurPtr = checkpoint.CurPtr;
 End = checkpoint.End;
 }

#ifndef NDEBUG
// Scribble the now freed end of the slab.
if (CurPtr)
memset(CurPtr, 0xaa, End - CurPtr);
#endif
 }
}

NodePointer NodeFactory::createNode(Node::Kind K) {
returnnew (Allocate<Node>()) Node(K);
}
NodePointer NodeFactory::createNode(Node::Kind K, Node::IndexType Index) {
returnnew (Allocate<Node>()) Node(K, Index);
}
NodePointer NodeFactory::createNodeWithAllocatedText(Node::Kind K,
 llvm::StringRef Text) {
returnnew (Allocate<Node>()) Node(K, Text);
}
NodePointer NodeFactory::createNode(Node::Kind K, const CharVector &Text) {
returncreateNodeWithAllocatedText(K, Text.str());
}
NodePointer NodeFactory::createNode(Node::Kind K, constchar *Text) {
returnnew (Allocate<Node>()) Node(K, llvm::StringRef(Text));
}

#ifdef NODE_FACTORY_DEBUGGING
int NodeFactory::nestingLevel = 0;
#endif

// Fast integer formatting
namespace {

// Format an unsigned integer into a buffer
template <typename U,
typename std::enable_if<std::is_unsigned<U>::value, bool>::type = true>
size_tint2str(U n, char *buf) {
// The easy case is zero
if (n == 0) {
 *buf++ = '0';
 *buf++ = '\0';
return1;
 }

// Do the digits one a time (for really high speed we could do these in
// chunks, but that's probably not necessary here.)
char *ptr = buf;
while (n) {
char digit = '0' + (n % 10);
 n /= 10;
 *ptr++ = digit;
 }
size_t len = ptr - buf;

// Terminate the string
 *ptr = '\0';

// Now reverse the digits
while (buf < ptr) {
char tmp = *--ptr;
 *ptr = *buf;
 *buf++ = tmp;
 }

return len;
}

// Deal with negative numbers
template <typename S,
typename std::enable_if<std::is_signed<S>::value, bool>::type = true>
size_tint2str(S n, char *buf) {
using U = typename std::make_unsigned<S>::type;

if (n < 0) {
 *buf++ = '-';
returnint2str(static_cast<U>(-n), buf);
 }
returnint2str(static_cast<U>(n), buf);
}

} // namespace

//////////////////////////////////
// CharVector member functions //
//////////////////////////////////

voidCharVector::append(StringRef Rhs, NodeFactory &Factory) {
if (NumElems + Rhs.size() > Capacity)
 Factory.Reallocate(Elems, Capacity, /*Growth*/ Rhs.size());
memcpy(Elems + NumElems, Rhs.data(), Rhs.size());
 NumElems += Rhs.size();
assert(NumElems <= Capacity);
}

voidCharVector::append(int Number, NodeFactory &Factory) {
constint MaxIntPrintSize = 11;
if (NumElems + MaxIntPrintSize > Capacity)
 Factory.Reallocate(Elems, Capacity, /*Growth*/ MaxIntPrintSize);
int Length = int2str(Number, Elems + NumElems);
assert(Length > 0 && Length < MaxIntPrintSize);
 NumElems += Length;
}

voidCharVector::append(unsignedlonglong Number, NodeFactory &Factory) {
constint MaxPrintSize = 21;
if (NumElems + MaxPrintSize > Capacity)
 Factory.Reallocate(Elems, Capacity, /*Growth*/ MaxPrintSize);
int Length = int2str(Number, Elems + NumElems);
assert(Length > 0 && Length < MaxPrintSize);
 NumElems += Length;
}

//////////////////////////////////
// Demangler member functions //
//////////////////////////////////

voidDemangler::clear() {
 NodeStack.free();
 Substitutions.free();
NodeFactory::clear();
}

Demangler::DemangleInitRAII::DemangleInitRAII(Demangler &Dem,
 StringRef MangledName,
 std::function<SymbolicReferenceResolver_t> TheSymbolicReferenceResolver)
// Save the current demangler state so we can restore it.
 : Dem(Dem),
 NodeStack(Dem.NodeStack), Substitutions(Dem.Substitutions),
 NumWords(Dem.NumWords), Text(Dem.Text), Pos(Dem.Pos),
 SymbolicReferenceResolver(std::move(Dem.SymbolicReferenceResolver))
{
// Reset the demangler state for a nested job.
 Dem.NodeStack.init(Dem, 16);
 Dem.Substitutions.init(Dem, 16);
 Dem.NumWords = 0;
 Dem.Text = MangledName;
 Dem.Pos = 0;
 Dem.SymbolicReferenceResolver = std::move(TheSymbolicReferenceResolver);
}

Demangler::DemangleInitRAII::~DemangleInitRAII() {
// Restore the saved state.
 Dem.NodeStack = NodeStack;
 Dem.Substitutions = Substitutions;
 Dem.NumWords = NumWords;
 Dem.Text = Text;
 Dem.Pos = Pos;
 Dem.SymbolicReferenceResolver = std::move(SymbolicReferenceResolver);
}

NodePointer Demangler::demangleSymbol(StringRef MangledName,
 std::function<SymbolicReferenceResolver_t> Resolver) {
 DemangleInitRAII state(*this, MangledName, std::move(Resolver));

#if SWIFT_SUPPORT_OLD_MANGLING
// Demangle old-style class and protocol names, which are still used in the
// ObjC metadata.
if (nextIf("_Tt"))
returndemangleOldSymbolAsNode(Text, *this);
#endif

unsigned PrefixLength = getManglingPrefixLength(MangledName);
if (PrefixLength == 0)
returnnullptr;

if (MangledName.starts_with(MANGLING_PREFIX_EMBEDDED_STR))
 Flavor = ManglingFlavor::Embedded;

 IsOldFunctionTypeMangling = isOldFunctionTypeMangling(MangledName);
 Pos += PrefixLength;

// If any other prefixes are accepted, please update Mangler::verify.

if (!parseAndPushNodes())
returnnullptr;

 NodePointer topLevel = createNode(Node::Kind::Global);

 NodePointer suffix = popNode(Node::Kind::Suffix);

 NodePointer Parent = topLevel;
while (NodePointer FuncAttr = popNode(isFunctionAttr)) {
 Parent->addChild(FuncAttr, *this);
if (FuncAttr->getKind() == Node::Kind::PartialApplyForwarder ||
 FuncAttr->getKind() == Node::Kind::PartialApplyObjCForwarder)
 Parent = FuncAttr;
 }
for (Node *Nd : NodeStack) {
switch (Nd->getKind()) {
case Node::Kind::Type:
 Parent->addChild(Nd->getFirstChild(), *this);
break;
default:
 Parent->addChild(Nd, *this);
break;
 }
 }
if (suffix)
 topLevel->addChild(suffix, *this);

if (topLevel->getNumChildren() == 0)
returnnullptr;

return topLevel;
}

NodePointer Demangler::demangleType(StringRef MangledName,
 std::function<SymbolicReferenceResolver_t> Resolver) {
 DemangleInitRAII state(*this, MangledName, std::move(Resolver));

if (!parseAndPushNodes())
returnnullptr;

 NodePointer Result = popNode();

// The result is only valid if it was the only node on the stack.
if (popNode())
returnnullptr;

return Result;
}

boolDemangler::parseAndPushNodes() {
constauto textSize = Text.size();
while (Pos < textSize) {
// Programs may look up a type by NUL-terminated name with an excessive
// length. Keep them working by returning success if we encounter a NUL in
// the middle of the string where an operator is expected.
if (peekChar() == '\0')
returntrue;

 NodePointer Node = demangleOperator();
if (!Node)
returnfalse;
pushNode(Node);
 }
returntrue;
}

NodePointer Demangler::addChild(NodePointer Parent, NodePointer Child) {
if (!Parent || !Child)
returnnullptr;
 Parent->addChild(Child, *this);
return Parent;
}

NodePointer Demangler::createWithChild(Node::Kind kind,
 NodePointer Child) {
if (!Child)
returnnullptr;
 NodePointer Nd = createNode(kind);
 Nd->addChild(Child, *this);
return Nd;
}

NodePointer Demangler::createType(NodePointer Child) {
returncreateWithChild(Node::Kind::Type, Child);
}

NodePointer Demangler::Demangler::createWithChildren(Node::Kind kind,
 NodePointer Child1, NodePointer Child2) {
if (!Child1 || !Child2)
returnnullptr;
 NodePointer Nd = createNode(kind);
 Nd->addChild(Child1, *this);
 Nd->addChild(Child2, *this);
return Nd;
}

NodePointer Demangler::createWithChildren(Node::Kind kind,
 NodePointer Child1,
 NodePointer Child2,
 NodePointer Child3) {
if (!Child1 || !Child2 || !Child3)
returnnullptr;
 NodePointer Nd = createNode(kind);
 Nd->addChild(Child1, *this);
 Nd->addChild(Child2, *this);
 Nd->addChild(Child3, *this);
return Nd;
}

NodePointer Demangler::createWithChildren(Node::Kind kind, NodePointer Child1,
 NodePointer Child2,
 NodePointer Child3,
 NodePointer Child4) {
if (!Child1 || !Child2 || !Child3 || !Child4)
returnnullptr;
 NodePointer Nd = createNode(kind);
 Nd->addChild(Child1, *this);
 Nd->addChild(Child2, *this);
 Nd->addChild(Child3, *this);
 Nd->addChild(Child4, *this);
return Nd;
}

NodePointer Demangler::changeKind(NodePointer Node, Node::Kind NewKind) {
if (!Node)
returnnullptr;
 NodePointer NewNode = nullptr;
if (Node->hasText()) {
 NewNode = createNodeWithAllocatedText(NewKind, Node->getText());
 } elseif (Node->hasIndex()) {
 NewNode = createNode(NewKind, Node->getIndex());
 } else {
 NewNode = createNode(NewKind);
 }
for (NodePointer Child : *Node) {
 NewNode->addChild(Child, *this);
 }
return NewNode;
}

NodePointer Demangler::demangleTypeMangling() {
auto Type = popNode(Node::Kind::Type);
auto LabelList = popFunctionParamLabels(Type);
auto TypeMangling = createNode(Node::Kind::TypeMangling);

addChild(TypeMangling, LabelList);
 TypeMangling = addChild(TypeMangling, Type);
return TypeMangling;
}

NodePointer Demangler::demangleSymbolicReference(unsignedchar rawKind) {
// The symbolic reference is a 4-byte machine integer encoded in the following
// four bytes.
if (Pos + 4 > Text.size())
returnnullptr;
constvoid *at = Text.data() + Pos;
int32_t value;
memcpy(&value, at, 4);
 Pos += 4;

// Map the encoded kind to a specific kind and directness.
 SymbolicReferenceKind kind;
 Directness direct;
switch (rawKind) {
case0x01:
 kind = SymbolicReferenceKind::Context;
 direct = Directness::Direct;
break;
case0x02:
 kind = SymbolicReferenceKind::Context;
 direct = Directness::Indirect;
break;
case0x09:
 kind = SymbolicReferenceKind::AccessorFunctionReference;
 direct = Directness::Direct;
break;
case0x0a:
 kind = SymbolicReferenceKind::UniqueExtendedExistentialTypeShape;
 direct = Directness::Direct;
break;
case0x0b:
 kind = SymbolicReferenceKind::NonUniqueExtendedExistentialTypeShape;
 direct = Directness::Direct;
break;
case0x0c:
 kind = SymbolicReferenceKind::ObjectiveCProtocol;
 direct = Directness::Direct;
break;
// These are all currently reserved but unused.
case0x03: // direct to protocol conformance descriptor
case0x04: // indirect to protocol conformance descriptor
case0x05: // direct to associated conformance descriptor
case0x06: // indirect to associated conformance descriptor
case0x07: // direct to associated conformance access function
case0x08: // indirect to associated conformance access function
default:
returnnullptr;
 }

// Use the resolver, if any, to produce the demangling tree the symbolic
// reference represents.
 NodePointer resolved = nullptr;
if (SymbolicReferenceResolver)
 resolved = SymbolicReferenceResolver(kind, direct, value, at);

// With no resolver, or a resolver that failed, refuse to demangle further.
if (!resolved)
returnnullptr;

// Types register as substitutions even when symbolically referenced.
// OOPS: Except for opaque type references!
if ((kind == SymbolicReferenceKind::Context ||
 kind == SymbolicReferenceKind::ObjectiveCProtocol) &&
 resolved->getKind() !=
 Node::Kind::OpaqueTypeDescriptorSymbolicReference &&
 resolved->getKind() != Node::Kind::OpaqueReturnTypeOf)
addSubstitution(resolved);
return resolved;
}

NodePointer Demangler::demangleTypeAnnotation() {
switch (nextChar()) {
case'a':
returncreateNode(Node::Kind::AsyncAnnotation);
case'A':
returncreateNode(Node::Kind::IsolatedAnyFunctionType);
case'b':
returncreateNode(Node::Kind::ConcurrentFunctionType);
case'c':
returncreateWithChild(
 Node::Kind::GlobalActorFunctionType, popTypeAndGetChild());
case'C':
returncreateNode(Node::Kind::NonIsolatedCallerFunctionType);
case'i':
returncreateType(
createWithChild(Node::Kind::Isolated, popTypeAndGetChild()));
case'j':
returndemangleDifferentiableFunctionType();
case'k':