Update prebuilt Clang to match Android kernel.
Bug: 132428451
Change-Id: I8f6e2cb23f381fc0c02ddea99b867e58e925e5be
diff --git a/linux-x64/clang/include/llvm/Demangle/Compiler.h b/linux-x64/clang/include/llvm/Demangle/Compiler.h
deleted file mode 100644
index 248d6e3..0000000
--- a/linux-x64/clang/include/llvm/Demangle/Compiler.h
+++ /dev/null
@@ -1,93 +0,0 @@
-//===--- Compiler.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 contains a variety of feature test macros copied from
-// include/llvm/Support/Compiler.h so that LLVMDemangle does not need to take
-// a dependency on LLVMSupport.
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_DEMANGLE_COMPILER_H
-#define LLVM_DEMANGLE_COMPILER_H
-
-#ifdef _MSC_VER
-// snprintf is implemented in VS 2015
-#if _MSC_VER < 1900
-#define snprintf _snprintf_s
-#endif
-#endif
-
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#ifndef __has_cpp_attribute
-#define __has_cpp_attribute(x) 0
-#endif
-
-#ifndef __has_attribute
-#define __has_attribute(x) 0
-#endif
-
-#ifndef __has_builtin
-#define __has_builtin(x) 0
-#endif
-
-#ifndef LLVM_GNUC_PREREQ
-#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
-#define LLVM_GNUC_PREREQ(maj, min, patch) \
- ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \
- ((maj) << 20) + ((min) << 10) + (patch))
-#elif defined(__GNUC__) && defined(__GNUC_MINOR__)
-#define LLVM_GNUC_PREREQ(maj, min, patch) \
- ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
-#else
-#define LLVM_GNUC_PREREQ(maj, min, patch) 0
-#endif
-#endif
-
-#if __has_attribute(used) || LLVM_GNUC_PREREQ(3, 1, 0)
-#define LLVM_ATTRIBUTE_USED __attribute__((__used__))
-#else
-#define LLVM_ATTRIBUTE_USED
-#endif
-
-#if __has_builtin(__builtin_unreachable) || LLVM_GNUC_PREREQ(4, 5, 0)
-#define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable()
-#elif defined(_MSC_VER)
-#define LLVM_BUILTIN_UNREACHABLE __assume(false)
-#endif
-
-#if __has_attribute(noinline) || LLVM_GNUC_PREREQ(3, 4, 0)
-#define LLVM_ATTRIBUTE_NOINLINE __attribute__((noinline))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_NOINLINE __declspec(noinline)
-#else
-#define LLVM_ATTRIBUTE_NOINLINE
-#endif
-
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
-#else
-#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE
-#endif
-
-#if __cplusplus > 201402L && __has_cpp_attribute(fallthrough)
-#define LLVM_FALLTHROUGH [[fallthrough]]
-#elif __has_cpp_attribute(gnu::fallthrough)
-#define LLVM_FALLTHROUGH [[gnu::fallthrough]]
-#elif !__cplusplus
-// Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious
-// error when __has_cpp_attribute is given a scoped attribute in C mode.
-#define LLVM_FALLTHROUGH
-#elif __has_cpp_attribute(clang::fallthrough)
-#define LLVM_FALLTHROUGH [[clang::fallthrough]]
-#else
-#define LLVM_FALLTHROUGH
-#endif
-
-#endif
diff --git a/linux-x64/clang/include/llvm/Demangle/Demangle.h b/linux-x64/clang/include/llvm/Demangle/Demangle.h
index b9b4d15..6fea7ef 100644
--- a/linux-x64/clang/include/llvm/Demangle/Demangle.h
+++ b/linux-x64/clang/include/llvm/Demangle/Demangle.h
@@ -1,9 +1,8 @@
//===--- Demangle.h ---------------------------------------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
@@ -11,6 +10,7 @@
#define LLVM_DEMANGLE_DEMANGLE_H
#include <cstddef>
+#include <string>
namespace llvm {
/// This is a llvm local version of __cxa_demangle. Other than the name and
@@ -31,16 +31,18 @@
char *itaniumDemangle(const char *mangled_name, char *buf, size_t *n,
int *status);
-/// Calls the callback \c Callback with \c Ctx as an argument whenever a type is
-/// encountered. Returns true if \c MangledName couldn't be parsed.
-bool itaniumFindTypesInMangledName(const char *MangledName, void *Ctx,
- void (*Callback)(void *, const char *));
-
enum MSDemangleFlags { MSDF_None = 0, MSDF_DumpBackrefs = 1 << 0 };
char *microsoftDemangle(const char *mangled_name, char *buf, size_t *n,
int *status, MSDemangleFlags Flags = MSDF_None);
+/// Attempt to demangle a string using different demangling schemes.
+/// The function uses heuristics to determine which demangling scheme to use.
+/// \param MangledName - reference to string to demangle.
+/// \returns - the demangled string, or a copy of the input string if no
+/// demangling occurred.
+std::string demangle(const std::string &MangledName);
+
/// "Partial" demangler. This supports demangling a string into an AST
/// (typically an intermediate stage in itaniumDemangle) and querying certain
/// properties or partially printing the demangled name.
diff --git a/linux-x64/clang/include/llvm/Demangle/DemangleConfig.h b/linux-x64/clang/include/llvm/Demangle/DemangleConfig.h
new file mode 100644
index 0000000..73f89d3
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Demangle/DemangleConfig.h
@@ -0,0 +1,99 @@
+//===--- DemangleConfig.h ---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains a variety of feature test macros copied from
+// include/llvm/Support/Compiler.h so that LLVMDemangle does not need to take
+// a dependency on LLVMSupport.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEMANGLE_COMPILER_H
+#define LLVM_DEMANGLE_COMPILER_H
+
+#ifdef _MSC_VER
+// snprintf is implemented in VS 2015
+#if _MSC_VER < 1900
+#define snprintf _snprintf_s
+#endif
+#endif
+
+#ifndef __has_feature
+#define __has_feature(x) 0
+#endif
+
+#ifndef __has_cpp_attribute
+#define __has_cpp_attribute(x) 0
+#endif
+
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#endif
+
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+
+#ifndef DEMANGLE_GNUC_PREREQ
+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
+#define DEMANGLE_GNUC_PREREQ(maj, min, patch) \
+ ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \
+ ((maj) << 20) + ((min) << 10) + (patch))
+#elif defined(__GNUC__) && defined(__GNUC_MINOR__)
+#define DEMANGLE_GNUC_PREREQ(maj, min, patch) \
+ ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
+#else
+#define DEMANGLE_GNUC_PREREQ(maj, min, patch) 0
+#endif
+#endif
+
+#if __has_attribute(used) || DEMANGLE_GNUC_PREREQ(3, 1, 0)
+#define DEMANGLE_ATTRIBUTE_USED __attribute__((__used__))
+#else
+#define DEMANGLE_ATTRIBUTE_USED
+#endif
+
+#if __has_builtin(__builtin_unreachable) || DEMANGLE_GNUC_PREREQ(4, 5, 0)
+#define DEMANGLE_UNREACHABLE __builtin_unreachable()
+#elif defined(_MSC_VER)
+#define DEMANGLE_UNREACHABLE __assume(false)
+#else
+#define DEMANGLE_UNREACHABLE
+#endif
+
+#if __has_attribute(noinline) || DEMANGLE_GNUC_PREREQ(3, 4, 0)
+#define DEMANGLE_ATTRIBUTE_NOINLINE __attribute__((noinline))
+#elif defined(_MSC_VER)
+#define DEMANGLE_ATTRIBUTE_NOINLINE __declspec(noinline)
+#else
+#define DEMANGLE_ATTRIBUTE_NOINLINE
+#endif
+
+#if !defined(NDEBUG)
+#define DEMANGLE_DUMP_METHOD DEMANGLE_ATTRIBUTE_NOINLINE DEMANGLE_ATTRIBUTE_USED
+#else
+#define DEMANGLE_DUMP_METHOD DEMANGLE_ATTRIBUTE_NOINLINE
+#endif
+
+#if __cplusplus > 201402L && __has_cpp_attribute(fallthrough)
+#define DEMANGLE_FALLTHROUGH [[fallthrough]]
+#elif __has_cpp_attribute(gnu::fallthrough)
+#define DEMANGLE_FALLTHROUGH [[gnu::fallthrough]]
+#elif !__cplusplus
+// Workaround for llvm.org/PR23435, since clang 3.6 and below emit a spurious
+// error when __has_cpp_attribute is given a scoped attribute in C mode.
+#define DEMANGLE_FALLTHROUGH
+#elif __has_cpp_attribute(clang::fallthrough)
+#define DEMANGLE_FALLTHROUGH [[clang::fallthrough]]
+#else
+#define DEMANGLE_FALLTHROUGH
+#endif
+
+#define DEMANGLE_NAMESPACE_BEGIN namespace llvm { namespace itanium_demangle {
+#define DEMANGLE_NAMESPACE_END } }
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Demangle/ItaniumDemangle.h b/linux-x64/clang/include/llvm/Demangle/ItaniumDemangle.h
index bc60bc3..df06aa6 100644
--- a/linux-x64/clang/include/llvm/Demangle/ItaniumDemangle.h
+++ b/linux-x64/clang/include/llvm/Demangle/ItaniumDemangle.h
@@ -1,23 +1,26 @@
//===------------------------- ItaniumDemangle.h ----------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
+//===----------------------------------------------------------------------===//
+//
+// Generic itanium demangler library. This file has two byte-per-byte identical
+// copies in the source tree, one in libcxxabi, and the other in llvm.
//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_DEMANGLE_ITANIUMDEMANGLE_H
-#define LLVM_DEMANGLE_ITANIUMDEMANGLE_H
+#ifndef DEMANGLE_ITANIUMDEMANGLE_H
+#define DEMANGLE_ITANIUMDEMANGLE_H
// FIXME: (possibly) incomplete list of features that clang mangles that this
// file does not yet support:
// - C++ modules TS
-#include "llvm/Demangle/Compiler.h"
-#include "llvm/Demangle/StringView.h"
-#include "llvm/Demangle/Utility.h"
-
+#include "DemangleConfig.h"
+#include "StringView.h"
+#include "Utility.h"
#include <cassert>
#include <cctype>
#include <cstdio>
@@ -95,8 +98,8 @@
X(BracedExpr) \
X(BracedRangeExpr)
-namespace llvm {
-namespace itanium_demangle {
+DEMANGLE_NAMESPACE_BEGIN
+
// Base class of all AST nodes. The AST is built by the parser, then is
// traversed by the printLeft/Right functions to produce a demangled string.
class Node {
@@ -194,7 +197,7 @@
virtual ~Node() = default;
#ifndef NDEBUG
- LLVM_DUMP_METHOD void dump() const;
+ DEMANGLE_DUMP_METHOD void dump() const;
#endif
};
@@ -1278,7 +1281,7 @@
case SpecialSubKind::iostream:
return StringView("basic_iostream");
}
- LLVM_BUILTIN_UNREACHABLE;
+ DEMANGLE_UNREACHABLE;
}
void printLeft(OutputStream &S) const override {
@@ -1330,7 +1333,7 @@
case SpecialSubKind::iostream:
return StringView("iostream");
}
- LLVM_BUILTIN_UNREACHABLE;
+ DEMANGLE_UNREACHABLE;
}
void printLeft(OutputStream &S) const override {
@@ -2134,8 +2137,7 @@
}
};
-template <typename Alloc>
-struct Db {
+template <typename Derived, typename Alloc> struct AbstractManglingParser {
const char *First;
const char *Last;
@@ -2158,16 +2160,16 @@
// conversion operator's type, and are resolved in the enclosing <encoding>.
PODSmallVector<ForwardTemplateReference *, 4> ForwardTemplateRefs;
- void (*TypeCallback)(void *, const char *) = nullptr;
- void *TypeCallbackContext = nullptr;
-
bool TryToParseTemplateArgs = true;
bool PermitForwardTemplateReferences = false;
bool ParsingLambdaParams = false;
Alloc ASTAllocator;
- Db(const char *First_, const char *Last_) : First(First_), Last(Last_) {}
+ AbstractManglingParser(const char *First_, const char *Last_)
+ : First(First_), Last(Last_) {}
+
+ Derived &getDerived() { return static_cast<Derived &>(*this); }
void reset(const char *First_, const char *Last_) {
First = First_;
@@ -2274,7 +2276,7 @@
FunctionRefQual ReferenceQualifier = FrefQualNone;
size_t ForwardTemplateRefsBegin;
- NameState(Db *Enclosing)
+ NameState(AbstractManglingParser *Enclosing)
: ForwardTemplateRefsBegin(Enclosing->ForwardTemplateRefs.size()) {}
};
@@ -2324,35 +2326,36 @@
//
// <unscoped-template-name> ::= <unscoped-name>
// ::= <substitution>
-template<typename Alloc> Node *Db<Alloc>::parseName(NameState *State) {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseName(NameState *State) {
consumeIf('L'); // extension
if (look() == 'N')
- return parseNestedName(State);
+ return getDerived().parseNestedName(State);
if (look() == 'Z')
- return parseLocalName(State);
+ return getDerived().parseLocalName(State);
// ::= <unscoped-template-name> <template-args>
if (look() == 'S' && look(1) != 't') {
- Node *S = parseSubstitution();
+ Node *S = getDerived().parseSubstitution();
if (S == nullptr)
return nullptr;
if (look() != 'I')
return nullptr;
- Node *TA = parseTemplateArgs(State != nullptr);
+ Node *TA = getDerived().parseTemplateArgs(State != nullptr);
if (TA == nullptr)
return nullptr;
if (State) State->EndsWithTemplateArgs = true;
return make<NameWithTemplateArgs>(S, TA);
}
- Node *N = parseUnscopedName(State);
+ Node *N = getDerived().parseUnscopedName(State);
if (N == nullptr)
return nullptr;
// ::= <unscoped-template-name> <template-args>
if (look() == 'I') {
Subs.push_back(N);
- Node *TA = parseTemplateArgs(State != nullptr);
+ Node *TA = getDerived().parseTemplateArgs(State != nullptr);
if (TA == nullptr)
return nullptr;
if (State) State->EndsWithTemplateArgs = true;
@@ -2365,10 +2368,11 @@
// <local-name> := Z <function encoding> E <entity name> [<discriminator>]
// := Z <function encoding> E s [<discriminator>]
// := Z <function encoding> Ed [ <parameter number> ] _ <entity name>
-template<typename Alloc> Node *Db<Alloc>::parseLocalName(NameState *State) {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseLocalName(NameState *State) {
if (!consumeIf('Z'))
return nullptr;
- Node *Encoding = parseEncoding();
+ Node *Encoding = getDerived().parseEncoding();
if (Encoding == nullptr || !consumeIf('E'))
return nullptr;
@@ -2384,13 +2388,13 @@
parseNumber(true);
if (!consumeIf('_'))
return nullptr;
- Node *N = parseName(State);
+ Node *N = getDerived().parseName(State);
if (N == nullptr)
return nullptr;
return make<LocalName>(Encoding, N);
}
- Node *Entity = parseName(State);
+ Node *Entity = getDerived().parseName(State);
if (Entity == nullptr)
return nullptr;
First = parse_discriminator(First, Last);
@@ -2400,14 +2404,16 @@
// <unscoped-name> ::= <unqualified-name>
// ::= St <unqualified-name> # ::std::
// extension ::= StL<unqualified-name>
-template<typename Alloc> Node *Db<Alloc>::parseUnscopedName(NameState *State) {
- if (consumeIf("StL") || consumeIf("St")) {
- Node *R = parseUnqualifiedName(State);
- if (R == nullptr)
- return nullptr;
- return make<StdQualifiedName>(R);
- }
- return parseUnqualifiedName(State);
+template <typename Derived, typename Alloc>
+Node *
+AbstractManglingParser<Derived, Alloc>::parseUnscopedName(NameState *State) {
+ if (consumeIf("StL") || consumeIf("St")) {
+ Node *R = getDerived().parseUnqualifiedName(State);
+ if (R == nullptr)
+ return nullptr;
+ return make<StdQualifiedName>(R);
+ }
+ return getDerived().parseUnqualifiedName(State);
}
// <unqualified-name> ::= <operator-name> [abi-tags]
@@ -2415,27 +2421,28 @@
// ::= <source-name>
// ::= <unnamed-type-name>
// ::= DC <source-name>+ E # structured binding declaration
-template<typename Alloc>
-Node *Db<Alloc>::parseUnqualifiedName(NameState *State) {
+template <typename Derived, typename Alloc>
+Node *
+AbstractManglingParser<Derived, Alloc>::parseUnqualifiedName(NameState *State) {
// <ctor-dtor-name>s are special-cased in parseNestedName().
Node *Result;
if (look() == 'U')
- Result = parseUnnamedTypeName(State);
+ Result = getDerived().parseUnnamedTypeName(State);
else if (look() >= '1' && look() <= '9')
- Result = parseSourceName(State);
+ Result = getDerived().parseSourceName(State);
else if (consumeIf("DC")) {
size_t BindingsBegin = Names.size();
do {
- Node *Binding = parseSourceName(State);
+ Node *Binding = getDerived().parseSourceName(State);
if (Binding == nullptr)
return nullptr;
Names.push_back(Binding);
} while (!consumeIf('E'));
Result = make<StructuredBindingName>(popTrailingNodeArray(BindingsBegin));
} else
- Result = parseOperatorName(State);
+ Result = getDerived().parseOperatorName(State);
if (Result != nullptr)
- Result = parseAbiTags(Result);
+ Result = getDerived().parseAbiTags(Result);
return Result;
}
@@ -2445,7 +2452,9 @@
// <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
//
// <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters
-template<typename Alloc> Node *Db<Alloc>::parseUnnamedTypeName(NameState *) {
+template <typename Derived, typename Alloc>
+Node *
+AbstractManglingParser<Derived, Alloc>::parseUnnamedTypeName(NameState *) {
if (consumeIf("Ut")) {
StringView Count = parseNumber();
if (!consumeIf('_'))
@@ -2458,7 +2467,7 @@
if (!consumeIf("vE")) {
size_t ParamsBegin = Names.size();
do {
- Node *P = parseType();
+ Node *P = getDerived().parseType();
if (P == nullptr)
return nullptr;
Names.push_back(P);
@@ -2470,11 +2479,18 @@
return nullptr;
return make<ClosureTypeName>(Params, Count);
}
+ if (consumeIf("Ub")) {
+ (void)parseNumber();
+ if (!consumeIf('_'))
+ return nullptr;
+ return make<NameType>("'block-literal'");
+ }
return nullptr;
}
// <source-name> ::= <positive length number> <identifier>
-template<typename Alloc> Node *Db<Alloc>::parseSourceName(NameState *) {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseSourceName(NameState *) {
size_t Length = 0;
if (parsePositiveInteger(&Length))
return nullptr;
@@ -2538,7 +2554,9 @@
// ::= rS # >>=
// ::= ss # <=> C++2a
// ::= v <digit> <source-name> # vendor extended operator
-template<typename Alloc> Node *Db<Alloc>::parseOperatorName(NameState *State) {
+template <typename Derived, typename Alloc>
+Node *
+AbstractManglingParser<Derived, Alloc>::parseOperatorName(NameState *State) {
switch (look()) {
case 'a':
switch (look(1)) {
@@ -2578,7 +2596,7 @@
SwapAndRestore<bool> SavePermit(PermitForwardTemplateReferences,
PermitForwardTemplateReferences ||
State != nullptr);
- Node* Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return nullptr;
if (State) State->CtorDtorConversion = true;
@@ -2642,7 +2660,7 @@
// ::= li <source-name> # operator ""
case 'i': {
First += 2;
- Node *SN = parseSourceName(State);
+ Node *SN = getDerived().parseSourceName(State);
if (SN == nullptr)
return nullptr;
return make<LiteralOperator>(SN);
@@ -2763,7 +2781,7 @@
case 'v':
if (std::isdigit(look(1))) {
First += 2;
- Node *SN = parseSourceName(State);
+ Node *SN = getDerived().parseSourceName(State);
if (SN == nullptr)
return nullptr;
return make<ConversionOperatorType>(SN);
@@ -2781,8 +2799,10 @@
// ::= D1 # complete object destructor
// ::= D2 # base object destructor
// extension ::= D5 # ?
-template<typename Alloc>
-Node *Db<Alloc>::parseCtorDtorName(Node *&SoFar, NameState *State) {
+template <typename Derived, typename Alloc>
+Node *
+AbstractManglingParser<Derived, Alloc>::parseCtorDtorName(Node *&SoFar,
+ NameState *State) {
if (SoFar->getKind() == Node::KSpecialSubstitution) {
auto SSK = static_cast<SpecialSubstitution *>(SoFar)->SSK;
switch (SSK) {
@@ -2793,6 +2813,7 @@
SoFar = make<ExpandedSpecialSubstitution>(SSK);
if (!SoFar)
return nullptr;
+ break;
default:
break;
}
@@ -2806,7 +2827,7 @@
++First;
if (State) State->CtorDtorConversion = true;
if (IsInherited) {
- if (parseName(State) == nullptr)
+ if (getDerived().parseName(State) == nullptr)
return nullptr;
}
return make<CtorDtorName>(SoFar, false, Variant);
@@ -2840,7 +2861,9 @@
// <template-prefix> ::= <prefix> <template unqualified-name>
// ::= <template-param>
// ::= <substitution>
-template<typename Alloc> Node *Db<Alloc>::parseNestedName(NameState *State) {
+template <typename Derived, typename Alloc>
+Node *
+AbstractManglingParser<Derived, Alloc>::parseNestedName(NameState *State) {
if (!consumeIf('N'))
return nullptr;
@@ -2881,7 +2904,7 @@
// ::= <template-param>
if (look() == 'T') {
- if (!PushComponent(parseTemplateParam()))
+ if (!PushComponent(getDerived().parseTemplateParam()))
return nullptr;
Subs.push_back(SoFar);
continue;
@@ -2889,7 +2912,7 @@
// ::= <template-prefix> <template-args>
if (look() == 'I') {
- Node *TA = parseTemplateArgs(State != nullptr);
+ Node *TA = getDerived().parseTemplateArgs(State != nullptr);
if (TA == nullptr || SoFar == nullptr)
return nullptr;
SoFar = make<NameWithTemplateArgs>(SoFar, TA);
@@ -2902,7 +2925,7 @@
// ::= <decltype>
if (look() == 'D' && (look(1) == 't' || look(1) == 'T')) {
- if (!PushComponent(parseDecltype()))
+ if (!PushComponent(getDerived().parseDecltype()))
return nullptr;
Subs.push_back(SoFar);
continue;
@@ -2910,7 +2933,7 @@
// ::= <substitution>
if (look() == 'S' && look(1) != 't') {
- Node *S = parseSubstitution();
+ Node *S = getDerived().parseSubstitution();
if (!PushComponent(S))
return nullptr;
if (SoFar != S)
@@ -2922,9 +2945,9 @@
if (look() == 'C' || (look() == 'D' && look(1) != 'C')) {
if (SoFar == nullptr)
return nullptr;
- if (!PushComponent(parseCtorDtorName(SoFar, State)))
+ if (!PushComponent(getDerived().parseCtorDtorName(SoFar, State)))
return nullptr;
- SoFar = parseAbiTags(SoFar);
+ SoFar = getDerived().parseAbiTags(SoFar);
if (SoFar == nullptr)
return nullptr;
Subs.push_back(SoFar);
@@ -2932,7 +2955,7 @@
}
// ::= <prefix> <unqualified-name>
- if (!PushComponent(parseUnqualifiedName(State)))
+ if (!PushComponent(getDerived().parseUnqualifiedName(State)))
return nullptr;
Subs.push_back(SoFar);
}
@@ -2945,12 +2968,13 @@
}
// <simple-id> ::= <source-name> [ <template-args> ]
-template<typename Alloc> Node *Db<Alloc>::parseSimpleId() {
- Node *SN = parseSourceName(/*NameState=*/nullptr);
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseSimpleId() {
+ Node *SN = getDerived().parseSourceName(/*NameState=*/nullptr);
if (SN == nullptr)
return nullptr;
if (look() == 'I') {
- Node *TA = parseTemplateArgs();
+ Node *TA = getDerived().parseTemplateArgs();
if (TA == nullptr)
return nullptr;
return make<NameWithTemplateArgs>(SN, TA);
@@ -2960,12 +2984,13 @@
// <destructor-name> ::= <unresolved-type> # e.g., ~T or ~decltype(f())
// ::= <simple-id> # e.g., ~A<2*N>
-template<typename Alloc> Node *Db<Alloc>::parseDestructorName() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseDestructorName() {
Node *Result;
if (std::isdigit(look()))
- Result = parseSimpleId();
+ Result = getDerived().parseSimpleId();
else
- Result = parseUnresolvedType();
+ Result = getDerived().parseUnresolvedType();
if (Result == nullptr)
return nullptr;
return make<DtorName>(Result);
@@ -2974,22 +2999,23 @@
// <unresolved-type> ::= <template-param>
// ::= <decltype>
// ::= <substitution>
-template<typename Alloc> Node *Db<Alloc>::parseUnresolvedType() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseUnresolvedType() {
if (look() == 'T') {
- Node *TP = parseTemplateParam();
+ Node *TP = getDerived().parseTemplateParam();
if (TP == nullptr)
return nullptr;
Subs.push_back(TP);
return TP;
}
if (look() == 'D') {
- Node *DT = parseDecltype();
+ Node *DT = getDerived().parseDecltype();
if (DT == nullptr)
return nullptr;
Subs.push_back(DT);
return DT;
}
- return parseSubstitution();
+ return getDerived().parseSubstitution();
}
// <base-unresolved-name> ::= <simple-id> # unresolved name
@@ -2999,20 +3025,21 @@
// ::= on <operator-name> <template-args> # unresolved operator template-id
// ::= dn <destructor-name> # destructor or pseudo-destructor;
// # e.g. ~X or ~X<N-1>
-template<typename Alloc> Node *Db<Alloc>::parseBaseUnresolvedName() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseBaseUnresolvedName() {
if (std::isdigit(look()))
- return parseSimpleId();
+ return getDerived().parseSimpleId();
if (consumeIf("dn"))
- return parseDestructorName();
+ return getDerived().parseDestructorName();
consumeIf("on");
- Node *Oper = parseOperatorName(/*NameState=*/nullptr);
+ Node *Oper = getDerived().parseOperatorName(/*NameState=*/nullptr);
if (Oper == nullptr)
return nullptr;
if (look() == 'I') {
- Node *TA = parseTemplateArgs();
+ Node *TA = getDerived().parseTemplateArgs();
if (TA == nullptr)
return nullptr;
return make<NameWithTemplateArgs>(Oper, TA);
@@ -3031,18 +3058,19 @@
// (ignored) ::= srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name>
//
// <unresolved-qualifier-level> ::= <simple-id>
-template<typename Alloc> Node *Db<Alloc>::parseUnresolvedName() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseUnresolvedName() {
Node *SoFar = nullptr;
// srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name>
// srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name>
if (consumeIf("srN")) {
- SoFar = parseUnresolvedType();
+ SoFar = getDerived().parseUnresolvedType();
if (SoFar == nullptr)
return nullptr;
if (look() == 'I') {
- Node *TA = parseTemplateArgs();
+ Node *TA = getDerived().parseTemplateArgs();
if (TA == nullptr)
return nullptr;
SoFar = make<NameWithTemplateArgs>(SoFar, TA);
@@ -3051,7 +3079,7 @@
}
while (!consumeIf('E')) {
- Node *Qual = parseSimpleId();
+ Node *Qual = getDerived().parseSimpleId();
if (Qual == nullptr)
return nullptr;
SoFar = make<QualifiedName>(SoFar, Qual);
@@ -3059,7 +3087,7 @@
return nullptr;
}
- Node *Base = parseBaseUnresolvedName();
+ Node *Base = getDerived().parseBaseUnresolvedName();
if (Base == nullptr)
return nullptr;
return make<QualifiedName>(SoFar, Base);
@@ -3069,7 +3097,7 @@
// [gs] <base-unresolved-name> # x or (with "gs") ::x
if (!consumeIf("sr")) {
- SoFar = parseBaseUnresolvedName();
+ SoFar = getDerived().parseBaseUnresolvedName();
if (SoFar == nullptr)
return nullptr;
if (Global)
@@ -3080,7 +3108,7 @@
// [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name>
if (std::isdigit(look())) {
do {
- Node *Qual = parseSimpleId();
+ Node *Qual = getDerived().parseSimpleId();
if (Qual == nullptr)
return nullptr;
if (SoFar)
@@ -3096,12 +3124,12 @@
// sr <unresolved-type> <base-unresolved-name>
// sr <unresolved-type> <template-args> <base-unresolved-name>
else {
- SoFar = parseUnresolvedType();
+ SoFar = getDerived().parseUnresolvedType();
if (SoFar == nullptr)
return nullptr;
if (look() == 'I') {
- Node *TA = parseTemplateArgs();
+ Node *TA = getDerived().parseTemplateArgs();
if (TA == nullptr)
return nullptr;
SoFar = make<NameWithTemplateArgs>(SoFar, TA);
@@ -3112,7 +3140,7 @@
assert(SoFar != nullptr);
- Node *Base = parseBaseUnresolvedName();
+ Node *Base = getDerived().parseBaseUnresolvedName();
if (Base == nullptr)
return nullptr;
return make<QualifiedName>(SoFar, Base);
@@ -3120,7 +3148,8 @@
// <abi-tags> ::= <abi-tag> [<abi-tags>]
// <abi-tag> ::= B <source-name>
-template<typename Alloc> Node *Db<Alloc>::parseAbiTags(Node *N) {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseAbiTags(Node *N) {
while (consumeIf('B')) {
StringView SN = parseBareSourceName();
if (SN.empty())
@@ -3133,8 +3162,9 @@
}
// <number> ::= [n] <non-negative decimal integer>
-template<typename Alloc>
-StringView Db<Alloc>::parseNumber(bool AllowNegative) {
+template <typename Alloc, typename Derived>
+StringView
+AbstractManglingParser<Alloc, Derived>::parseNumber(bool AllowNegative) {
const char *Tmp = First;
if (AllowNegative)
consumeIf('n');
@@ -3146,7 +3176,8 @@
}
// <positive length number> ::= [0-9]*
-template<typename Alloc> bool Db<Alloc>::parsePositiveInteger(size_t *Out) {
+template <typename Alloc, typename Derived>
+bool AbstractManglingParser<Alloc, Derived>::parsePositiveInteger(size_t *Out) {
*Out = 0;
if (look() < '0' || look() > '9')
return true;
@@ -3157,7 +3188,8 @@
return false;
}
-template<typename Alloc> StringView Db<Alloc>::parseBareSourceName() {
+template <typename Alloc, typename Derived>
+StringView AbstractManglingParser<Alloc, Derived>::parseBareSourceName() {
size_t Int = 0;
if (parsePositiveInteger(&Int) || numLeft() < Int)
return StringView();
@@ -3174,7 +3206,8 @@
//
// <ref-qualifier> ::= R # & ref-qualifier
// <ref-qualifier> ::= O # && ref-qualifier
-template<typename Alloc> Node *Db<Alloc>::parseFunctionType() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseFunctionType() {
Qualifiers CVQuals = parseCVQualifiers();
Node *ExceptionSpec = nullptr;
@@ -3183,7 +3216,7 @@
if (!ExceptionSpec)
return nullptr;
} else if (consumeIf("DO")) {
- Node *E = parseExpr();
+ Node *E = getDerived().parseExpr();
if (E == nullptr || !consumeIf('E'))
return nullptr;
ExceptionSpec = make<NoexceptSpec>(E);
@@ -3192,7 +3225,7 @@
} else if (consumeIf("Dw")) {
size_t SpecsBegin = Names.size();
while (!consumeIf('E')) {
- Node *T = parseType();
+ Node *T = getDerived().parseType();
if (T == nullptr)
return nullptr;
Names.push_back(T);
@@ -3208,7 +3241,7 @@
if (!consumeIf('F'))
return nullptr;
consumeIf('Y'); // extern "C"
- Node *ReturnType = parseType();
+ Node *ReturnType = getDerived().parseType();
if (ReturnType == nullptr)
return nullptr;
@@ -3227,7 +3260,7 @@
ReferenceQualifier = FrefQualRValue;
break;
}
- Node *T = parseType();
+ Node *T = getDerived().parseType();
if (T == nullptr)
return nullptr;
Names.push_back(T);
@@ -3243,7 +3276,8 @@
// ::= Dv [<dimension expression>] _ <element type>
// <extended element type> ::= <element type>
// ::= p # AltiVec vector pixel
-template<typename Alloc> Node *Db<Alloc>::parseVectorType() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseVectorType() {
if (!consumeIf("Dv"))
return nullptr;
if (look() >= '1' && look() <= '9') {
@@ -3252,24 +3286,24 @@
return nullptr;
if (consumeIf('p'))
return make<PixelVectorType>(DimensionNumber);
- Node *ElemType = parseType();
+ Node *ElemType = getDerived().parseType();
if (ElemType == nullptr)
return nullptr;
return make<VectorType>(ElemType, DimensionNumber);
}
if (!consumeIf('_')) {
- Node *DimExpr = parseExpr();
+ Node *DimExpr = getDerived().parseExpr();
if (!DimExpr)
return nullptr;
if (!consumeIf('_'))
return nullptr;
- Node *ElemType = parseType();
+ Node *ElemType = getDerived().parseType();
if (!ElemType)
return nullptr;
return make<VectorType>(ElemType, DimExpr);
}
- Node *ElemType = parseType();
+ Node *ElemType = getDerived().parseType();
if (!ElemType)
return nullptr;
return make<VectorType>(ElemType, StringView());
@@ -3277,12 +3311,13 @@
// <decltype> ::= Dt <expression> E # decltype of an id-expression or class member access (C++0x)
// ::= DT <expression> E # decltype of an expression (C++0x)
-template<typename Alloc> Node *Db<Alloc>::parseDecltype() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseDecltype() {
if (!consumeIf('D'))
return nullptr;
if (!consumeIf('t') && !consumeIf('T'))
return nullptr;
- Node *E = parseExpr();
+ Node *E = getDerived().parseExpr();
if (E == nullptr)
return nullptr;
if (!consumeIf('E'))
@@ -3292,7 +3327,8 @@
// <array-type> ::= A <positive dimension number> _ <element type>
// ::= A [<dimension expression>] _ <element type>
-template<typename Alloc> Node *Db<Alloc>::parseArrayType() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseArrayType() {
if (!consumeIf('A'))
return nullptr;
@@ -3303,7 +3339,7 @@
if (!consumeIf('_'))
return nullptr;
} else if (!consumeIf('_')) {
- Node *DimExpr = parseExpr();
+ Node *DimExpr = getDerived().parseExpr();
if (DimExpr == nullptr)
return nullptr;
if (!consumeIf('_'))
@@ -3311,20 +3347,21 @@
Dimension = DimExpr;
}
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return nullptr;
return make<ArrayType>(Ty, Dimension);
}
// <pointer-to-member-type> ::= M <class type> <member type>
-template<typename Alloc> Node *Db<Alloc>::parsePointerToMemberType() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parsePointerToMemberType() {
if (!consumeIf('M'))
return nullptr;
- Node *ClassType = parseType();
+ Node *ClassType = getDerived().parseType();
if (ClassType == nullptr)
return nullptr;
- Node *MemberType = parseType();
+ Node *MemberType = getDerived().parseType();
if (MemberType == nullptr)
return nullptr;
return make<PointerToMemberType>(ClassType, MemberType);
@@ -3334,7 +3371,8 @@
// ::= Ts <name> # dependent elaborated type specifier using 'struct' or 'class'
// ::= Tu <name> # dependent elaborated type specifier using 'union'
// ::= Te <name> # dependent elaborated type specifier using 'enum'
-template<typename Alloc> Node *Db<Alloc>::parseClassEnumType() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseClassEnumType() {
StringView ElabSpef;
if (consumeIf("Ts"))
ElabSpef = "struct";
@@ -3343,7 +3381,7 @@
else if (consumeIf("Te"))
ElabSpef = "enum";
- Node *Name = parseName();
+ Node *Name = getDerived().parseName();
if (Name == nullptr)
return nullptr;
@@ -3356,7 +3394,8 @@
// <qualified-type> ::= <qualifiers> <type>
// <qualifiers> ::= <extended-qualifier>* <CV-qualifiers>
// <extended-qualifier> ::= U <source-name> [<template-args>] # vendor extended type qualifier
-template<typename Alloc> Node *Db<Alloc>::parseQualifiedType() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseQualifiedType() {
if (consumeIf('U')) {
StringView Qual = parseBareSourceName();
if (Qual.empty())
@@ -3375,20 +3414,20 @@
}
if (Proto.empty())
return nullptr;
- Node *Child = parseQualifiedType();
+ Node *Child = getDerived().parseQualifiedType();
if (Child == nullptr)
return nullptr;
return make<ObjCProtoName>(Child, Proto);
}
- Node *Child = parseQualifiedType();
+ Node *Child = getDerived().parseQualifiedType();
if (Child == nullptr)
return nullptr;
return make<VendorExtQualType>(Child, Qual);
}
Qualifiers Quals = parseCVQualifiers();
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return nullptr;
if (Quals != QualNone)
@@ -3416,12 +3455,10 @@
//
// <objc-name> ::= <k0 number> objcproto <k1 number> <identifier> # k0 = 9 + <number of digits in k1> + k1
// <objc-type> ::= <source-name> # PU<11+>objcproto 11objc_object<source-name> 11objc_object -> id<source-name>
-template<typename Alloc> Node *Db<Alloc>::parseType() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseType() {
Node *Result = nullptr;
- if (TypeCallback != nullptr)
- TypeCallback(TypeCallbackContext, First);
-
switch (look()) {
// ::= <qualified-type>
case 'r':
@@ -3436,13 +3473,13 @@
(look(AfterQuals) == 'D' &&
(look(AfterQuals + 1) == 'o' || look(AfterQuals + 1) == 'O' ||
look(AfterQuals + 1) == 'w' || look(AfterQuals + 1) == 'x'))) {
- Result = parseFunctionType();
+ Result = getDerived().parseFunctionType();
break;
}
- LLVM_FALLTHROUGH;
+ DEMANGLE_FALLTHROUGH;
}
case 'U': {
- Result = parseQualifiedType();
+ Result = getDerived().parseQualifiedType();
break;
}
// <builtin-type> ::= v # void
@@ -3580,18 +3617,18 @@
// ::= <decltype>
case 't':
case 'T': {
- Result = parseDecltype();
+ Result = getDerived().parseDecltype();
break;
}
// extension ::= <vector-type> # <vector-type> starts with Dv
case 'v': {
- Result = parseVectorType();
+ Result = getDerived().parseVectorType();
break;
}
// ::= Dp <type> # pack expansion (C++0x)
case 'p': {
First += 2;
- Node *Child = parseType();
+ Node *Child = getDerived().parseType();
if (!Child)
return nullptr;
Result = make<ParameterPackExpansion>(Child);
@@ -3603,34 +3640,34 @@
case 'w':
// Transaction safe function type.
case 'x':
- Result = parseFunctionType();
+ Result = getDerived().parseFunctionType();
break;
}
break;
// ::= <function-type>
case 'F': {
- Result = parseFunctionType();
+ Result = getDerived().parseFunctionType();
break;
}
// ::= <array-type>
case 'A': {
- Result = parseArrayType();
+ Result = getDerived().parseArrayType();
break;
}
// ::= <pointer-to-member-type>
case 'M': {
- Result = parsePointerToMemberType();
+ Result = getDerived().parsePointerToMemberType();
break;
}
// ::= <template-param>
case 'T': {
// This could be an elaborate type specifier on a <class-enum-type>.
if (look(1) == 's' || look(1) == 'u' || look(1) == 'e') {
- Result = parseClassEnumType();
+ Result = getDerived().parseClassEnumType();
break;
}
- Result = parseTemplateParam();
+ Result = getDerived().parseTemplateParam();
if (Result == nullptr)
return nullptr;
@@ -3645,7 +3682,7 @@
// parse them, take the second production.
if (TryToParseTemplateArgs && look() == 'I') {
- Node *TA = parseTemplateArgs();
+ Node *TA = getDerived().parseTemplateArgs();
if (TA == nullptr)
return nullptr;
Result = make<NameWithTemplateArgs>(Result, TA);
@@ -3655,7 +3692,7 @@
// ::= P <type> # pointer
case 'P': {
++First;
- Node *Ptr = parseType();
+ Node *Ptr = getDerived().parseType();
if (Ptr == nullptr)
return nullptr;
Result = make<PointerType>(Ptr);
@@ -3664,7 +3701,7 @@
// ::= R <type> # l-value reference
case 'R': {
++First;
- Node *Ref = parseType();
+ Node *Ref = getDerived().parseType();
if (Ref == nullptr)
return nullptr;
Result = make<ReferenceType>(Ref, ReferenceKind::LValue);
@@ -3673,7 +3710,7 @@
// ::= O <type> # r-value reference (C++11)
case 'O': {
++First;
- Node *Ref = parseType();
+ Node *Ref = getDerived().parseType();
if (Ref == nullptr)
return nullptr;
Result = make<ReferenceType>(Ref, ReferenceKind::RValue);
@@ -3682,7 +3719,7 @@
// ::= C <type> # complex pair (C99)
case 'C': {
++First;
- Node *P = parseType();
+ Node *P = getDerived().parseType();
if (P == nullptr)
return nullptr;
Result = make<PostfixQualifiedType>(P, " complex");
@@ -3691,7 +3728,7 @@
// ::= G <type> # imaginary (C99)
case 'G': {
++First;
- Node *P = parseType();
+ Node *P = getDerived().parseType();
if (P == nullptr)
return P;
Result = make<PostfixQualifiedType>(P, " imaginary");
@@ -3700,7 +3737,7 @@
// ::= <substitution> # See Compression below
case 'S': {
if (look(1) && look(1) != 't') {
- Node *Sub = parseSubstitution();
+ Node *Sub = getDerived().parseSubstitution();
if (Sub == nullptr)
return nullptr;
@@ -3715,7 +3752,7 @@
// parse them, take the second production.
if (TryToParseTemplateArgs && look() == 'I') {
- Node *TA = parseTemplateArgs();
+ Node *TA = getDerived().parseTemplateArgs();
if (TA == nullptr)
return nullptr;
Result = make<NameWithTemplateArgs>(Sub, TA);
@@ -3726,11 +3763,11 @@
// substitution table.
return Sub;
}
- LLVM_FALLTHROUGH;
+ DEMANGLE_FALLTHROUGH;
}
// ::= <class-enum-type>
default: {
- Result = parseClassEnumType();
+ Result = getDerived().parseClassEnumType();
break;
}
}
@@ -3743,24 +3780,28 @@
return Result;
}
-template<typename Alloc> Node *Db<Alloc>::parsePrefixExpr(StringView Kind) {
- Node *E = parseExpr();
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parsePrefixExpr(StringView Kind) {
+ Node *E = getDerived().parseExpr();
if (E == nullptr)
return nullptr;
return make<PrefixExpr>(Kind, E);
}
-template<typename Alloc> Node *Db<Alloc>::parseBinaryExpr(StringView Kind) {
- Node *LHS = parseExpr();
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseBinaryExpr(StringView Kind) {
+ Node *LHS = getDerived().parseExpr();
if (LHS == nullptr)
return nullptr;
- Node *RHS = parseExpr();
+ Node *RHS = getDerived().parseExpr();
if (RHS == nullptr)
return nullptr;
return make<BinaryExpr>(LHS, Kind, RHS);
}
-template<typename Alloc> Node *Db<Alloc>::parseIntegerLiteral(StringView Lit) {
+template <typename Derived, typename Alloc>
+Node *
+AbstractManglingParser<Derived, Alloc>::parseIntegerLiteral(StringView Lit) {
StringView Tmp = parseNumber(true);
if (!Tmp.empty() && consumeIf('E'))
return make<IntegerLiteral>(Lit, Tmp);
@@ -3768,7 +3809,8 @@
}
// <CV-Qualifiers> ::= [r] [V] [K]
-template<typename Alloc> Qualifiers Db<Alloc>::parseCVQualifiers() {
+template <typename Alloc, typename Derived>
+Qualifiers AbstractManglingParser<Alloc, Derived>::parseCVQualifiers() {
Qualifiers CVR = QualNone;
if (consumeIf('r'))
CVR |= QualRestrict;
@@ -3783,7 +3825,8 @@
// ::= fp <top-level CV-Qualifiers> <parameter-2 non-negative number> _ # L == 0, second and later parameters
// ::= fL <L-1 non-negative number> p <top-level CV-Qualifiers> _ # L > 0, first parameter
// ::= fL <L-1 non-negative number> p <top-level CV-Qualifiers> <parameter-2 non-negative number> _ # L > 0, second and later parameters
-template<typename Alloc> Node *Db<Alloc>::parseFunctionParam() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseFunctionParam() {
if (consumeIf("fp")) {
parseCVQualifiers();
StringView Num = parseNumber();
@@ -3810,26 +3853,27 @@
// [gs] na <expression>* _ <type> E # new[] (expr-list) type
// [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init)
// <initializer> ::= pi <expression>* E # parenthesized initialization
-template<typename Alloc> Node *Db<Alloc>::parseNewExpr() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseNewExpr() {
bool Global = consumeIf("gs");
bool IsArray = look(1) == 'a';
if (!consumeIf("nw") && !consumeIf("na"))
return nullptr;
size_t Exprs = Names.size();
while (!consumeIf('_')) {
- Node *Ex = parseExpr();
+ Node *Ex = getDerived().parseExpr();
if (Ex == nullptr)
return nullptr;
Names.push_back(Ex);
}
NodeArray ExprList = popTrailingNodeArray(Exprs);
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return Ty;
if (consumeIf("pi")) {
size_t InitsBegin = Names.size();
while (!consumeIf('E')) {
- Node *Init = parseExpr();
+ Node *Init = getDerived().parseExpr();
if (Init == nullptr)
return Init;
Names.push_back(Init);
@@ -3843,13 +3887,14 @@
// cv <type> <expression> # conversion with one argument
// cv <type> _ <expression>* E # conversion with a different number of arguments
-template<typename Alloc> Node *Db<Alloc>::parseConversionExpr() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseConversionExpr() {
if (!consumeIf("cv"))
return nullptr;
Node *Ty;
{
SwapAndRestore<bool> SaveTemp(TryToParseTemplateArgs, false);
- Ty = parseType();
+ Ty = getDerived().parseType();
}
if (Ty == nullptr)
@@ -3858,7 +3903,7 @@
if (consumeIf('_')) {
size_t ExprsBegin = Names.size();
while (!consumeIf('E')) {
- Node *E = parseExpr();
+ Node *E = getDerived().parseExpr();
if (E == nullptr)
return E;
Names.push_back(E);
@@ -3867,7 +3912,7 @@
return make<ConversionExpr>(Ty, Exprs);
}
- Node *E[1] = {parseExpr()};
+ Node *E[1] = {getDerived().parseExpr()};
if (E[0] == nullptr)
return nullptr;
return make<ConversionExpr>(Ty, makeNodeArray(E, E + 1));
@@ -3879,13 +3924,14 @@
// ::= L <nullptr type> E # nullptr literal (i.e., "LDnE")
// FIXME: ::= L <type> <real-part float> _ <imag-part float> E # complex floating point literal (C 2000)
// ::= L <mangled-name> E # external name
-template<typename Alloc> Node *Db<Alloc>::parseExprPrimary() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseExprPrimary() {
if (!consumeIf('L'))
return nullptr;
switch (look()) {
case 'w':
++First;
- return parseIntegerLiteral("wchar_t");
+ return getDerived().parseIntegerLiteral("wchar_t");
case 'b':
if (consumeIf("b0E"))
return make<BoolExpr>(0);
@@ -3894,55 +3940,55 @@
return nullptr;
case 'c':
++First;
- return parseIntegerLiteral("char");
+ return getDerived().parseIntegerLiteral("char");
case 'a':
++First;
- return parseIntegerLiteral("signed char");
+ return getDerived().parseIntegerLiteral("signed char");
case 'h':
++First;
- return parseIntegerLiteral("unsigned char");
+ return getDerived().parseIntegerLiteral("unsigned char");
case 's':
++First;
- return parseIntegerLiteral("short");
+ return getDerived().parseIntegerLiteral("short");
case 't':
++First;
- return parseIntegerLiteral("unsigned short");
+ return getDerived().parseIntegerLiteral("unsigned short");
case 'i':
++First;
- return parseIntegerLiteral("");
+ return getDerived().parseIntegerLiteral("");
case 'j':
++First;
- return parseIntegerLiteral("u");
+ return getDerived().parseIntegerLiteral("u");
case 'l':
++First;
- return parseIntegerLiteral("l");
+ return getDerived().parseIntegerLiteral("l");
case 'm':
++First;
- return parseIntegerLiteral("ul");
+ return getDerived().parseIntegerLiteral("ul");
case 'x':
++First;
- return parseIntegerLiteral("ll");
+ return getDerived().parseIntegerLiteral("ll");
case 'y':
++First;
- return parseIntegerLiteral("ull");
+ return getDerived().parseIntegerLiteral("ull");
case 'n':
++First;
- return parseIntegerLiteral("__int128");
+ return getDerived().parseIntegerLiteral("__int128");
case 'o':
++First;
- return parseIntegerLiteral("unsigned __int128");
+ return getDerived().parseIntegerLiteral("unsigned __int128");
case 'f':
++First;
- return parseFloatingLiteral<float>();
+ return getDerived().template parseFloatingLiteral<float>();
case 'd':
++First;
- return parseFloatingLiteral<double>();
+ return getDerived().template parseFloatingLiteral<double>();
case 'e':
++First;
- return parseFloatingLiteral<long double>();
+ return getDerived().template parseFloatingLiteral<long double>();
case '_':
if (consumeIf("_Z")) {
- Node *R = parseEncoding();
+ Node *R = getDerived().parseEncoding();
if (R != nullptr && consumeIf('E'))
return R;
}
@@ -3953,7 +3999,7 @@
return nullptr;
default: {
// might be named type
- Node *T = parseType();
+ Node *T = getDerived().parseType();
if (T == nullptr)
return nullptr;
StringView N = parseNumber();
@@ -3973,45 +4019,46 @@
// ::= di <field source-name> <braced-expression> # .name = expr
// ::= dx <index expression> <braced-expression> # [expr] = expr
// ::= dX <range begin expression> <range end expression> <braced-expression>
-template<typename Alloc> Node *Db<Alloc>::parseBracedExpr() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseBracedExpr() {
if (look() == 'd') {
switch (look(1)) {
case 'i': {
First += 2;
- Node *Field = parseSourceName(/*NameState=*/nullptr);
+ Node *Field = getDerived().parseSourceName(/*NameState=*/nullptr);
if (Field == nullptr)
return nullptr;
- Node *Init = parseBracedExpr();
+ Node *Init = getDerived().parseBracedExpr();
if (Init == nullptr)
return nullptr;
return make<BracedExpr>(Field, Init, /*isArray=*/false);
}
case 'x': {
First += 2;
- Node *Index = parseExpr();
+ Node *Index = getDerived().parseExpr();
if (Index == nullptr)
return nullptr;
- Node *Init = parseBracedExpr();
+ Node *Init = getDerived().parseBracedExpr();
if (Init == nullptr)
return nullptr;
return make<BracedExpr>(Index, Init, /*isArray=*/true);
}
case 'X': {
First += 2;
- Node *RangeBegin = parseExpr();
+ Node *RangeBegin = getDerived().parseExpr();
if (RangeBegin == nullptr)
return nullptr;
- Node *RangeEnd = parseExpr();
+ Node *RangeEnd = getDerived().parseExpr();
if (RangeEnd == nullptr)
return nullptr;
- Node *Init = parseBracedExpr();
+ Node *Init = getDerived().parseBracedExpr();
if (Init == nullptr)
return nullptr;
return make<BracedRangeExpr>(RangeBegin, RangeEnd, Init);
}
}
}
- return parseExpr();
+ return getDerived().parseExpr();
}
// (not yet in the spec)
@@ -4019,7 +4066,8 @@
// ::= fR <binary-operator-name> <expression> <expression>
// ::= fl <binary-operator-name> <expression>
// ::= fr <binary-operator-name> <expression>
-template<typename Alloc> Node *Db<Alloc>::parseFoldExpr() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseFoldExpr() {
if (!consumeIf('f'))
return nullptr;
@@ -4069,11 +4117,11 @@
else if (consumeIf("rS")) OperatorName = ">>=";
else return nullptr;
- Node *Pack = parseExpr(), *Init = nullptr;
+ Node *Pack = getDerived().parseExpr(), *Init = nullptr;
if (Pack == nullptr)
return nullptr;
if (HasInitializer) {
- Init = parseExpr();
+ Init = getDerived().parseExpr();
if (Init == nullptr)
return nullptr;
}
@@ -4128,49 +4176,50 @@
// ::= fl <binary-operator-name> <expression>
// ::= fr <binary-operator-name> <expression>
// ::= <expr-primary>
-template<typename Alloc> Node *Db<Alloc>::parseExpr() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseExpr() {
bool Global = consumeIf("gs");
if (numLeft() < 2)
return nullptr;
switch (*First) {
case 'L':
- return parseExprPrimary();
+ return getDerived().parseExprPrimary();
case 'T':
- return parseTemplateParam();
+ return getDerived().parseTemplateParam();
case 'f': {
// Disambiguate a fold expression from a <function-param>.
if (look(1) == 'p' || (look(1) == 'L' && std::isdigit(look(2))))
- return parseFunctionParam();
- return parseFoldExpr();
+ return getDerived().parseFunctionParam();
+ return getDerived().parseFoldExpr();
}
case 'a':
switch (First[1]) {
case 'a':
First += 2;
- return parseBinaryExpr("&&");
+ return getDerived().parseBinaryExpr("&&");
case 'd':
First += 2;
- return parsePrefixExpr("&");
+ return getDerived().parsePrefixExpr("&");
case 'n':
First += 2;
- return parseBinaryExpr("&");
+ return getDerived().parseBinaryExpr("&");
case 'N':
First += 2;
- return parseBinaryExpr("&=");
+ return getDerived().parseBinaryExpr("&=");
case 'S':
First += 2;
- return parseBinaryExpr("=");
+ return getDerived().parseBinaryExpr("=");
case 't': {
First += 2;
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return nullptr;
return make<EnclosingExpr>("alignof (", Ty, ")");
}
case 'z': {
First += 2;
- Node *Ty = parseExpr();
+ Node *Ty = getDerived().parseExpr();
if (Ty == nullptr)
return nullptr;
return make<EnclosingExpr>("alignof (", Ty, ")");
@@ -4182,10 +4231,10 @@
// cc <type> <expression> # const_cast<type>(expression)
case 'c': {
First += 2;
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return Ty;
- Node *Ex = parseExpr();
+ Node *Ex = getDerived().parseExpr();
if (Ex == nullptr)
return Ex;
return make<CastExpr>("const_cast", Ty, Ex);
@@ -4193,12 +4242,12 @@
// cl <expression>+ E # call
case 'l': {
First += 2;
- Node *Callee = parseExpr();
+ Node *Callee = getDerived().parseExpr();
if (Callee == nullptr)
return Callee;
size_t ExprsBegin = Names.size();
while (!consumeIf('E')) {
- Node *E = parseExpr();
+ Node *E = getDerived().parseExpr();
if (E == nullptr)
return E;
Names.push_back(E);
@@ -4207,104 +4256,104 @@
}
case 'm':
First += 2;
- return parseBinaryExpr(",");
+ return getDerived().parseBinaryExpr(",");
case 'o':
First += 2;
- return parsePrefixExpr("~");
+ return getDerived().parsePrefixExpr("~");
case 'v':
- return parseConversionExpr();
+ return getDerived().parseConversionExpr();
}
return nullptr;
case 'd':
switch (First[1]) {
case 'a': {
First += 2;
- Node *Ex = parseExpr();
+ Node *Ex = getDerived().parseExpr();
if (Ex == nullptr)
return Ex;
return make<DeleteExpr>(Ex, Global, /*is_array=*/true);
}
case 'c': {
First += 2;
- Node *T = parseType();
+ Node *T = getDerived().parseType();
if (T == nullptr)
return T;
- Node *Ex = parseExpr();
+ Node *Ex = getDerived().parseExpr();
if (Ex == nullptr)
return Ex;
return make<CastExpr>("dynamic_cast", T, Ex);
}
case 'e':
First += 2;
- return parsePrefixExpr("*");
+ return getDerived().parsePrefixExpr("*");
case 'l': {
First += 2;
- Node *E = parseExpr();
+ Node *E = getDerived().parseExpr();
if (E == nullptr)
return E;
return make<DeleteExpr>(E, Global, /*is_array=*/false);
}
case 'n':
- return parseUnresolvedName();
+ return getDerived().parseUnresolvedName();
case 's': {
First += 2;
- Node *LHS = parseExpr();
+ Node *LHS = getDerived().parseExpr();
if (LHS == nullptr)
return nullptr;
- Node *RHS = parseExpr();
+ Node *RHS = getDerived().parseExpr();
if (RHS == nullptr)
return nullptr;
return make<MemberExpr>(LHS, ".*", RHS);
}
case 't': {
First += 2;
- Node *LHS = parseExpr();
+ Node *LHS = getDerived().parseExpr();
if (LHS == nullptr)
return LHS;
- Node *RHS = parseExpr();
+ Node *RHS = getDerived().parseExpr();
if (RHS == nullptr)
return nullptr;
return make<MemberExpr>(LHS, ".", RHS);
}
case 'v':
First += 2;
- return parseBinaryExpr("/");
+ return getDerived().parseBinaryExpr("/");
case 'V':
First += 2;
- return parseBinaryExpr("/=");
+ return getDerived().parseBinaryExpr("/=");
}
return nullptr;
case 'e':
switch (First[1]) {
case 'o':
First += 2;
- return parseBinaryExpr("^");
+ return getDerived().parseBinaryExpr("^");
case 'O':
First += 2;
- return parseBinaryExpr("^=");
+ return getDerived().parseBinaryExpr("^=");
case 'q':
First += 2;
- return parseBinaryExpr("==");
+ return getDerived().parseBinaryExpr("==");
}
return nullptr;
case 'g':
switch (First[1]) {
case 'e':
First += 2;
- return parseBinaryExpr(">=");
+ return getDerived().parseBinaryExpr(">=");
case 't':
First += 2;
- return parseBinaryExpr(">");
+ return getDerived().parseBinaryExpr(">");
}
return nullptr;
case 'i':
switch (First[1]) {
case 'x': {
First += 2;
- Node *Base = parseExpr();
+ Node *Base = getDerived().parseExpr();
if (Base == nullptr)
return nullptr;
- Node *Index = parseExpr();
+ Node *Index = getDerived().parseExpr();
if (Index == nullptr)
return Index;
return make<ArraySubscriptExpr>(Base, Index);
@@ -4313,7 +4362,7 @@
First += 2;
size_t InitsBegin = Names.size();
while (!consumeIf('E')) {
- Node *E = parseBracedExpr();
+ Node *E = getDerived().parseBracedExpr();
if (E == nullptr)
return nullptr;
Names.push_back(E);
@@ -4326,37 +4375,37 @@
switch (First[1]) {
case 'e':
First += 2;
- return parseBinaryExpr("<=");
+ return getDerived().parseBinaryExpr("<=");
case 's':
First += 2;
- return parseBinaryExpr("<<");
+ return getDerived().parseBinaryExpr("<<");
case 'S':
First += 2;
- return parseBinaryExpr("<<=");
+ return getDerived().parseBinaryExpr("<<=");
case 't':
First += 2;
- return parseBinaryExpr("<");
+ return getDerived().parseBinaryExpr("<");
}
return nullptr;
case 'm':
switch (First[1]) {
case 'i':
First += 2;
- return parseBinaryExpr("-");
+ return getDerived().parseBinaryExpr("-");
case 'I':
First += 2;
- return parseBinaryExpr("-=");
+ return getDerived().parseBinaryExpr("-=");
case 'l':
First += 2;
- return parseBinaryExpr("*");
+ return getDerived().parseBinaryExpr("*");
case 'L':
First += 2;
- return parseBinaryExpr("*=");
+ return getDerived().parseBinaryExpr("*=");
case 'm':
First += 2;
if (consumeIf('_'))
- return parsePrefixExpr("--");
- Node *Ex = parseExpr();
+ return getDerived().parsePrefixExpr("--");
+ Node *Ex = getDerived().parseExpr();
if (Ex == nullptr)
return nullptr;
return make<PostfixExpr>(Ex, "--");
@@ -4366,19 +4415,19 @@
switch (First[1]) {
case 'a':
case 'w':
- return parseNewExpr();
+ return getDerived().parseNewExpr();
case 'e':
First += 2;
- return parseBinaryExpr("!=");
+ return getDerived().parseBinaryExpr("!=");
case 'g':
First += 2;
- return parsePrefixExpr("-");
+ return getDerived().parsePrefixExpr("-");
case 't':
First += 2;
- return parsePrefixExpr("!");
+ return getDerived().parsePrefixExpr("!");
case 'x':
First += 2;
- Node *Ex = parseExpr();
+ Node *Ex = getDerived().parseExpr();
if (Ex == nullptr)
return Ex;
return make<EnclosingExpr>("noexcept (", Ex, ")");
@@ -4387,47 +4436,47 @@
case 'o':
switch (First[1]) {
case 'n':
- return parseUnresolvedName();
+ return getDerived().parseUnresolvedName();
case 'o':
First += 2;
- return parseBinaryExpr("||");
+ return getDerived().parseBinaryExpr("||");
case 'r':
First += 2;
- return parseBinaryExpr("|");
+ return getDerived().parseBinaryExpr("|");
case 'R':
First += 2;
- return parseBinaryExpr("|=");
+ return getDerived().parseBinaryExpr("|=");
}
return nullptr;
case 'p':
switch (First[1]) {
case 'm':
First += 2;
- return parseBinaryExpr("->*");
+ return getDerived().parseBinaryExpr("->*");
case 'l':
First += 2;
- return parseBinaryExpr("+");
+ return getDerived().parseBinaryExpr("+");
case 'L':
First += 2;
- return parseBinaryExpr("+=");
+ return getDerived().parseBinaryExpr("+=");
case 'p': {
First += 2;
if (consumeIf('_'))
- return parsePrefixExpr("++");
- Node *Ex = parseExpr();
+ return getDerived().parsePrefixExpr("++");
+ Node *Ex = getDerived().parseExpr();
if (Ex == nullptr)
return Ex;
return make<PostfixExpr>(Ex, "++");
}
case 's':
First += 2;
- return parsePrefixExpr("+");
+ return getDerived().parsePrefixExpr("+");
case 't': {
First += 2;
- Node *L = parseExpr();
+ Node *L = getDerived().parseExpr();
if (L == nullptr)
return nullptr;
- Node *R = parseExpr();
+ Node *R = getDerived().parseExpr();
if (R == nullptr)
return nullptr;
return make<MemberExpr>(L, "->", R);
@@ -4437,13 +4486,13 @@
case 'q':
if (First[1] == 'u') {
First += 2;
- Node *Cond = parseExpr();
+ Node *Cond = getDerived().parseExpr();
if (Cond == nullptr)
return nullptr;
- Node *LHS = parseExpr();
+ Node *LHS = getDerived().parseExpr();
if (LHS == nullptr)
return nullptr;
- Node *RHS = parseExpr();
+ Node *RHS = getDerived().parseExpr();
if (RHS == nullptr)
return nullptr;
return make<ConditionalExpr>(Cond, LHS, RHS);
@@ -4453,59 +4502,59 @@
switch (First[1]) {
case 'c': {
First += 2;
- Node *T = parseType();
+ Node *T = getDerived().parseType();
if (T == nullptr)
return T;
- Node *Ex = parseExpr();
+ Node *Ex = getDerived().parseExpr();
if (Ex == nullptr)
return Ex;
return make<CastExpr>("reinterpret_cast", T, Ex);
}
case 'm':
First += 2;
- return parseBinaryExpr("%");
+ return getDerived().parseBinaryExpr("%");
case 'M':
First += 2;
- return parseBinaryExpr("%=");
+ return getDerived().parseBinaryExpr("%=");
case 's':
First += 2;
- return parseBinaryExpr(">>");
+ return getDerived().parseBinaryExpr(">>");
case 'S':
First += 2;
- return parseBinaryExpr(">>=");
+ return getDerived().parseBinaryExpr(">>=");
}
return nullptr;
case 's':
switch (First[1]) {
case 'c': {
First += 2;
- Node *T = parseType();
+ Node *T = getDerived().parseType();
if (T == nullptr)
return T;
- Node *Ex = parseExpr();
+ Node *Ex = getDerived().parseExpr();
if (Ex == nullptr)
return Ex;
return make<CastExpr>("static_cast", T, Ex);
}
case 'p': {
First += 2;
- Node *Child = parseExpr();
+ Node *Child = getDerived().parseExpr();
if (Child == nullptr)
return nullptr;
return make<ParameterPackExpansion>(Child);
}
case 'r':
- return parseUnresolvedName();
+ return getDerived().parseUnresolvedName();
case 't': {
First += 2;
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return Ty;
return make<EnclosingExpr>("sizeof (", Ty, ")");
}
case 'z': {
First += 2;
- Node *Ex = parseExpr();
+ Node *Ex = getDerived().parseExpr();
if (Ex == nullptr)
return Ex;
return make<EnclosingExpr>("sizeof (", Ex, ")");
@@ -4513,12 +4562,12 @@
case 'Z':
First += 2;
if (look() == 'T') {
- Node *R = parseTemplateParam();
+ Node *R = getDerived().parseTemplateParam();
if (R == nullptr)
return nullptr;
return make<SizeofParamPackExpr>(R);
} else if (look() == 'f') {
- Node *FP = parseFunctionParam();
+ Node *FP = getDerived().parseFunctionParam();
if (FP == nullptr)
return nullptr;
return make<EnclosingExpr>("sizeof... (", FP, ")");
@@ -4528,7 +4577,7 @@
First += 2;
size_t ArgsBegin = Names.size();
while (!consumeIf('E')) {
- Node *Arg = parseTemplateArg();
+ Node *Arg = getDerived().parseTemplateArg();
if (Arg == nullptr)
return nullptr;
Names.push_back(Arg);
@@ -4544,26 +4593,26 @@
switch (First[1]) {
case 'e': {
First += 2;
- Node *Ex = parseExpr();
+ Node *Ex = getDerived().parseExpr();
if (Ex == nullptr)
return Ex;
return make<EnclosingExpr>("typeid (", Ex, ")");
}
case 'i': {
First += 2;
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return Ty;
return make<EnclosingExpr>("typeid (", Ty, ")");
}
case 'l': {
First += 2;
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return nullptr;
size_t InitsBegin = Names.size();
while (!consumeIf('E')) {
- Node *E = parseBracedExpr();
+ Node *E = getDerived().parseBracedExpr();
if (E == nullptr)
return nullptr;
Names.push_back(E);
@@ -4575,7 +4624,7 @@
return make<NameType>("throw");
case 'w': {
First += 2;
- Node *Ex = parseExpr();
+ Node *Ex = getDerived().parseExpr();
if (Ex == nullptr)
return nullptr;
return make<ThrowExpr>(Ex);
@@ -4591,7 +4640,7 @@
case '7':
case '8':
case '9':
- return parseUnresolvedName();
+ return getDerived().parseUnresolvedName();
}
return nullptr;
}
@@ -4604,7 +4653,8 @@
//
// <v-offset> ::= <offset number> _ <virtual offset number>
// # virtual base override, with vcall offset
-template<typename Alloc> bool Db<Alloc>::parseCallOffset() {
+template <typename Alloc, typename Derived>
+bool AbstractManglingParser<Alloc, Derived>::parseCallOffset() {
// Just scan through the call offset, we never add this information into the
// output.
if (consumeIf('h'))
@@ -4633,14 +4683,15 @@
// ::= GR <object name> <seq-id> _ # Subsequent temporaries
// extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first
// extension ::= GR <object name> # reference temporary for object
-template<typename Alloc> Node *Db<Alloc>::parseSpecialName() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseSpecialName() {
switch (look()) {
case 'T':
switch (look(1)) {
// TV <type> # virtual table
case 'V': {
First += 2;
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return nullptr;
return make<SpecialName>("vtable for ", Ty);
@@ -4648,7 +4699,7 @@
// TT <type> # VTT structure (construction vtable index)
case 'T': {
First += 2;
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return nullptr;
return make<SpecialName>("VTT for ", Ty);
@@ -4656,7 +4707,7 @@
// TI <type> # typeinfo structure
case 'I': {
First += 2;
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return nullptr;
return make<SpecialName>("typeinfo for ", Ty);
@@ -4664,7 +4715,7 @@
// TS <type> # typeinfo name (null-terminated byte string)
case 'S': {
First += 2;
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return nullptr;
return make<SpecialName>("typeinfo name for ", Ty);
@@ -4674,7 +4725,7 @@
First += 2;
if (parseCallOffset() || parseCallOffset())
return nullptr;
- Node *Encoding = parseEncoding();
+ Node *Encoding = getDerived().parseEncoding();
if (Encoding == nullptr)
return nullptr;
return make<SpecialName>("covariant return thunk to ", Encoding);
@@ -4683,12 +4734,12 @@
// # construction vtable for second-in-first
case 'C': {
First += 2;
- Node *FirstType = parseType();
+ Node *FirstType = getDerived().parseType();
if (FirstType == nullptr)
return nullptr;
if (parseNumber(true).empty() || !consumeIf('_'))
return nullptr;
- Node *SecondType = parseType();
+ Node *SecondType = getDerived().parseType();
if (SecondType == nullptr)
return nullptr;
return make<CtorVtableSpecialName>(SecondType, FirstType);
@@ -4696,7 +4747,7 @@
// TW <object name> # Thread-local wrapper
case 'W': {
First += 2;
- Node *Name = parseName();
+ Node *Name = getDerived().parseName();
if (Name == nullptr)
return nullptr;
return make<SpecialName>("thread-local wrapper routine for ", Name);
@@ -4704,7 +4755,7 @@
// TH <object name> # Thread-local initialization
case 'H': {
First += 2;
- Node *Name = parseName();
+ Node *Name = getDerived().parseName();
if (Name == nullptr)
return nullptr;
return make<SpecialName>("thread-local initialization routine for ", Name);
@@ -4715,7 +4766,7 @@
bool IsVirt = look() == 'v';
if (parseCallOffset())
return nullptr;
- Node *BaseEncoding = parseEncoding();
+ Node *BaseEncoding = getDerived().parseEncoding();
if (BaseEncoding == nullptr)
return nullptr;
if (IsVirt)
@@ -4729,7 +4780,7 @@
// GV <object name> # Guard variable for one-time initialization
case 'V': {
First += 2;
- Node *Name = parseName();
+ Node *Name = getDerived().parseName();
if (Name == nullptr)
return nullptr;
return make<SpecialName>("guard variable for ", Name);
@@ -4739,7 +4790,7 @@
// GR <object name> <seq-id> _ # Subsequent temporaries
case 'R': {
First += 2;
- Node *Name = parseName();
+ Node *Name = getDerived().parseName();
if (Name == nullptr)
return nullptr;
size_t Count;
@@ -4756,9 +4807,10 @@
// <encoding> ::= <function name> <bare-function-type>
// ::= <data name>
// ::= <special-name>
-template<typename Alloc> Node *Db<Alloc>::parseEncoding() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseEncoding() {
if (look() == 'G' || look() == 'T')
- return parseSpecialName();
+ return getDerived().parseSpecialName();
auto IsEndOfEncoding = [&] {
// The set of chars that can potentially follow an <encoding> (none of which
@@ -4768,7 +4820,7 @@
};
NameState NameInfo(this);
- Node *Name = parseName(&NameInfo);
+ Node *Name = getDerived().parseName(&NameInfo);
if (Name == nullptr)
return nullptr;
@@ -4782,7 +4834,7 @@
if (consumeIf("Ua9enable_ifI")) {
size_t BeforeArgs = Names.size();
while (!consumeIf('E')) {
- Node *Arg = parseTemplateArg();
+ Node *Arg = getDerived().parseTemplateArg();
if (Arg == nullptr)
return nullptr;
Names.push_back(Arg);
@@ -4794,7 +4846,7 @@
Node *ReturnType = nullptr;
if (!NameInfo.CtorDtorConversion && NameInfo.EndsWithTemplateArgs) {
- ReturnType = parseType();
+ ReturnType = getDerived().parseType();
if (ReturnType == nullptr)
return nullptr;
}
@@ -4806,7 +4858,7 @@
size_t ParamsBegin = Names.size();
do {
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (Ty == nullptr)
return nullptr;
Names.push_back(Ty);
@@ -4852,9 +4904,9 @@
static constexpr const char *spec = "%LaL";
};
-template<typename Alloc>
-template<class Float>
-Node *Db<Alloc>::parseFloatingLiteral() {
+template <typename Alloc, typename Derived>
+template <class Float>
+Node *AbstractManglingParser<Alloc, Derived>::parseFloatingLiteral() {
const size_t N = FloatData<Float>::mangled_size;
if (numLeft() <= N)
return nullptr;
@@ -4869,7 +4921,8 @@
}
// <seq-id> ::= <0-9A-Z>+
-template<typename Alloc> bool Db<Alloc>::parseSeqId(size_t *Out) {
+template <typename Alloc, typename Derived>
+bool AbstractManglingParser<Alloc, Derived>::parseSeqId(size_t *Out) {
if (!(look() >= '0' && look() <= '9') &&
!(look() >= 'A' && look() <= 'Z'))
return true;
@@ -4900,7 +4953,8 @@
// <substitution> ::= Si # ::std::basic_istream<char, std::char_traits<char> >
// <substitution> ::= So # ::std::basic_ostream<char, std::char_traits<char> >
// <substitution> ::= Sd # ::std::basic_iostream<char, std::char_traits<char> >
-template<typename Alloc> Node *Db<Alloc>::parseSubstitution() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseSubstitution() {
if (!consumeIf('S'))
return nullptr;
@@ -4939,7 +4993,7 @@
// Itanium C++ ABI 5.1.2: If a name that would use a built-in <substitution>
// has ABI tags, the tags are appended to the substitution; the result is a
// substitutable component.
- Node *WithTags = parseAbiTags(SpecialSub);
+ Node *WithTags = getDerived().parseAbiTags(SpecialSub);
if (WithTags != SpecialSub) {
Subs.push_back(WithTags);
SpecialSub = WithTags;
@@ -4966,7 +5020,8 @@
// <template-param> ::= T_ # first template parameter
// ::= T <parameter-2 non-negative number> _
-template<typename Alloc> Node *Db<Alloc>::parseTemplateParam() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParam() {
if (!consumeIf('T'))
return nullptr;
@@ -5007,11 +5062,12 @@
// ::= <expr-primary> # simple expressions
// ::= J <template-arg>* E # argument pack
// ::= LZ <encoding> E # extension
-template<typename Alloc> Node *Db<Alloc>::parseTemplateArg() {
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parseTemplateArg() {
switch (look()) {
case 'X': {
++First;
- Node *Arg = parseExpr();
+ Node *Arg = getDerived().parseExpr();
if (Arg == nullptr || !consumeIf('E'))
return nullptr;
return Arg;
@@ -5020,7 +5076,7 @@
++First;
size_t ArgsBegin = Names.size();
while (!consumeIf('E')) {
- Node *Arg = parseTemplateArg();
+ Node *Arg = getDerived().parseTemplateArg();
if (Arg == nullptr)
return nullptr;
Names.push_back(Arg);
@@ -5032,23 +5088,24 @@
// ::= LZ <encoding> E # extension
if (look(1) == 'Z') {
First += 2;
- Node *Arg = parseEncoding();
+ Node *Arg = getDerived().parseEncoding();
if (Arg == nullptr || !consumeIf('E'))
return nullptr;
return Arg;
}
// ::= <expr-primary> # simple expressions
- return parseExprPrimary();
+ return getDerived().parseExprPrimary();
}
default:
- return parseType();
+ return getDerived().parseType();
}
}
// <template-args> ::= I <template-arg>* E
// extension, the abi says <template-arg>+
-template <typename Alloc>
-Node *Db<Alloc>::parseTemplateArgs(bool TagTemplates) {
+template <typename Derived, typename Alloc>
+Node *
+AbstractManglingParser<Derived, Alloc>::parseTemplateArgs(bool TagTemplates) {
if (!consumeIf('I'))
return nullptr;
@@ -5061,7 +5118,7 @@
while (!consumeIf('E')) {
if (TagTemplates) {
auto OldParams = std::move(TemplateParams);
- Node *Arg = parseTemplateArg();
+ Node *Arg = getDerived().parseTemplateArg();
TemplateParams = std::move(OldParams);
if (Arg == nullptr)
return nullptr;
@@ -5075,7 +5132,7 @@
}
TemplateParams.push_back(TableEntry);
} else {
- Node *Arg = parseTemplateArg();
+ Node *Arg = getDerived().parseTemplateArg();
if (Arg == nullptr)
return nullptr;
Names.push_back(Arg);
@@ -5089,9 +5146,10 @@
// extension ::= ___Z <encoding> _block_invoke
// extension ::= ___Z <encoding> _block_invoke<decimal-digit>+
// extension ::= ___Z <encoding> _block_invoke_<decimal-digit>+
-template<typename Alloc> Node *Db<Alloc>::parse() {
- if (consumeIf("_Z")) {
- Node *Encoding = parseEncoding();
+template <typename Derived, typename Alloc>
+Node *AbstractManglingParser<Derived, Alloc>::parse() {
+ if (consumeIf("_Z") || consumeIf("__Z")) {
+ Node *Encoding = getDerived().parseEncoding();
if (Encoding == nullptr)
return nullptr;
if (look() == '.') {
@@ -5103,8 +5161,8 @@
return Encoding;
}
- if (consumeIf("___Z")) {
- Node *Encoding = parseEncoding();
+ if (consumeIf("___Z") || consumeIf("____Z")) {
+ Node *Encoding = getDerived().parseEncoding();
if (Encoding == nullptr || !consumeIf("_block_invoke"))
return nullptr;
bool RequireNumber = consumeIf('_');
@@ -5117,13 +5175,18 @@
return make<SpecialName>("invocation function for block in ", Encoding);
}
- Node *Ty = parseType();
+ Node *Ty = getDerived().parseType();
if (numLeft() != 0)
return nullptr;
return Ty;
}
-} // namespace itanium_demangle
-} // namespace llvm
+template <typename Alloc>
+struct ManglingParser : AbstractManglingParser<ManglingParser<Alloc>, Alloc> {
+ using AbstractManglingParser<ManglingParser<Alloc>,
+ Alloc>::AbstractManglingParser;
+};
-#endif // LLVM_DEMANGLE_ITANIUMDEMANGLE_H
+DEMANGLE_NAMESPACE_END
+
+#endif // DEMANGLE_ITANIUMDEMANGLE_H
diff --git a/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangle.h b/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangle.h
new file mode 100644
index 0000000..a23e327
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangle.h
@@ -0,0 +1,275 @@
+//===------------------------- MicrosoftDemangle.h --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEMANGLE_MICROSOFT_DEMANGLE_H
+#define LLVM_DEMANGLE_MICROSOFT_DEMANGLE_H
+
+#include "llvm/Demangle/DemangleConfig.h"
+#include "llvm/Demangle/MicrosoftDemangleNodes.h"
+#include "llvm/Demangle/StringView.h"
+#include "llvm/Demangle/Utility.h"
+
+#include <utility>
+
+namespace llvm {
+namespace ms_demangle {
+// This memory allocator is extremely fast, but it doesn't call dtors
+// for allocated objects. That means you can't use STL containers
+// (such as std::vector) with this allocator. But it pays off --
+// the demangler is 3x faster with this allocator compared to one with
+// STL containers.
+constexpr size_t AllocUnit = 4096;
+
+class ArenaAllocator {
+ struct AllocatorNode {
+ uint8_t *Buf = nullptr;
+ size_t Used = 0;
+ size_t Capacity = 0;
+ AllocatorNode *Next = nullptr;
+ };
+
+ void addNode(size_t Capacity) {
+ AllocatorNode *NewHead = new AllocatorNode;
+ NewHead->Buf = new uint8_t[Capacity];
+ NewHead->Next = Head;
+ NewHead->Capacity = Capacity;
+ Head = NewHead;
+ NewHead->Used = 0;
+ }
+
+public:
+ ArenaAllocator() { addNode(AllocUnit); }
+
+ ~ArenaAllocator() {
+ while (Head) {
+ assert(Head->Buf);
+ delete[] Head->Buf;
+ AllocatorNode *Next = Head->Next;
+ delete Head;
+ Head = Next;
+ }
+ }
+
+ char *allocUnalignedBuffer(size_t Length) {
+ uint8_t *Buf = Head->Buf + Head->Used;
+
+ Head->Used += Length;
+ if (Head->Used > Head->Capacity) {
+ // It's possible we need a buffer which is larger than our default unit
+ // size, so we need to be careful to add a node with capacity that is at
+ // least as large as what we need.
+ addNode(std::max(AllocUnit, Length));
+ Head->Used = Length;
+ Buf = Head->Buf;
+ }
+
+ return reinterpret_cast<char *>(Buf);
+ }
+
+ template <typename T, typename... Args> T *allocArray(size_t Count) {
+
+ size_t Size = Count * sizeof(T);
+ assert(Head && Head->Buf);
+
+ size_t P = (size_t)Head->Buf + Head->Used;
+ uintptr_t AlignedP =
+ (((size_t)P + alignof(T) - 1) & ~(size_t)(alignof(T) - 1));
+ uint8_t *PP = (uint8_t *)AlignedP;
+ size_t Adjustment = AlignedP - P;
+
+ Head->Used += Size + Adjustment;
+ if (Head->Used < Head->Capacity)
+ return new (PP) T[Count]();
+
+ addNode(AllocUnit);
+ Head->Used = Size;
+ return new (Head->Buf) T[Count]();
+ }
+
+ template <typename T, typename... Args> T *alloc(Args &&... ConstructorArgs) {
+
+ size_t Size = sizeof(T);
+ assert(Head && Head->Buf);
+
+ size_t P = (size_t)Head->Buf + Head->Used;
+ uintptr_t AlignedP =
+ (((size_t)P + alignof(T) - 1) & ~(size_t)(alignof(T) - 1));
+ uint8_t *PP = (uint8_t *)AlignedP;
+ size_t Adjustment = AlignedP - P;
+
+ Head->Used += Size + Adjustment;
+ if (Head->Used < Head->Capacity)
+ return new (PP) T(std::forward<Args>(ConstructorArgs)...);
+
+ addNode(AllocUnit);
+ Head->Used = Size;
+ return new (Head->Buf) T(std::forward<Args>(ConstructorArgs)...);
+ }
+
+private:
+ AllocatorNode *Head = nullptr;
+};
+
+struct BackrefContext {
+ static constexpr size_t Max = 10;
+
+ TypeNode *FunctionParams[Max];
+ size_t FunctionParamCount = 0;
+
+ // The first 10 BackReferences in a mangled name can be back-referenced by
+ // special name @[0-9]. This is a storage for the first 10 BackReferences.
+ NamedIdentifierNode *Names[Max];
+ size_t NamesCount = 0;
+};
+
+enum class QualifierMangleMode { Drop, Mangle, Result };
+
+enum NameBackrefBehavior : uint8_t {
+ NBB_None = 0, // don't save any names as backrefs.
+ NBB_Template = 1 << 0, // save template instanations.
+ NBB_Simple = 1 << 1, // save simple names.
+};
+
+enum class FunctionIdentifierCodeGroup { Basic, Under, DoubleUnder };
+
+// Demangler class takes the main role in demangling symbols.
+// It has a set of functions to parse mangled symbols into Type instances.
+// It also has a set of functions to convert Type instances to strings.
+class Demangler {
+public:
+ Demangler() = default;
+ virtual ~Demangler() = default;
+
+ // You are supposed to call parse() first and then check if error is true. If
+ // it is false, call output() to write the formatted name to the given stream.
+ SymbolNode *parse(StringView &MangledName);
+
+ TagTypeNode *parseTagUniqueName(StringView &MangledName);
+
+ // True if an error occurred.
+ bool Error = false;
+
+ void dumpBackReferences();
+
+private:
+ SymbolNode *demangleEncodedSymbol(StringView &MangledName,
+ QualifiedNameNode *QN);
+
+ VariableSymbolNode *demangleVariableEncoding(StringView &MangledName,
+ StorageClass SC);
+ FunctionSymbolNode *demangleFunctionEncoding(StringView &MangledName);
+
+ Qualifiers demanglePointerExtQualifiers(StringView &MangledName);
+
+ // Parser functions. This is a recursive-descent parser.
+ TypeNode *demangleType(StringView &MangledName, QualifierMangleMode QMM);
+ PrimitiveTypeNode *demanglePrimitiveType(StringView &MangledName);
+ CustomTypeNode *demangleCustomType(StringView &MangledName);
+ TagTypeNode *demangleClassType(StringView &MangledName);
+ PointerTypeNode *demanglePointerType(StringView &MangledName);
+ PointerTypeNode *demangleMemberPointerType(StringView &MangledName);
+ FunctionSignatureNode *demangleFunctionType(StringView &MangledName,
+ bool HasThisQuals);
+
+ ArrayTypeNode *demangleArrayType(StringView &MangledName);
+
+ NodeArrayNode *demangleTemplateParameterList(StringView &MangledName);
+ NodeArrayNode *demangleFunctionParameterList(StringView &MangledName);
+
+ std::pair<uint64_t, bool> demangleNumber(StringView &MangledName);
+ uint64_t demangleUnsigned(StringView &MangledName);
+ int64_t demangleSigned(StringView &MangledName);
+
+ void memorizeString(StringView s);
+ void memorizeIdentifier(IdentifierNode *Identifier);
+
+ /// Allocate a copy of \p Borrowed into memory that we own.
+ StringView copyString(StringView Borrowed);
+
+ QualifiedNameNode *demangleFullyQualifiedTypeName(StringView &MangledName);
+ QualifiedNameNode *demangleFullyQualifiedSymbolName(StringView &MangledName);
+
+ IdentifierNode *demangleUnqualifiedTypeName(StringView &MangledName,
+ bool Memorize);
+ IdentifierNode *demangleUnqualifiedSymbolName(StringView &MangledName,
+ NameBackrefBehavior NBB);
+
+ QualifiedNameNode *demangleNameScopeChain(StringView &MangledName,
+ IdentifierNode *UnqualifiedName);
+ IdentifierNode *demangleNameScopePiece(StringView &MangledName);
+
+ NamedIdentifierNode *demangleBackRefName(StringView &MangledName);
+ IdentifierNode *demangleTemplateInstantiationName(StringView &MangledName,
+ NameBackrefBehavior NBB);
+ IdentifierNode *demangleFunctionIdentifierCode(StringView &MangledName);
+ IdentifierNode *
+ demangleFunctionIdentifierCode(StringView &MangledName,
+ FunctionIdentifierCodeGroup Group);
+ StructorIdentifierNode *demangleStructorIdentifier(StringView &MangledName,
+ bool IsDestructor);
+ ConversionOperatorIdentifierNode *
+ demangleConversionOperatorIdentifier(StringView &MangledName);
+ LiteralOperatorIdentifierNode *
+ demangleLiteralOperatorIdentifier(StringView &MangledName);
+
+ SymbolNode *demangleSpecialIntrinsic(StringView &MangledName);
+ SpecialTableSymbolNode *
+ demangleSpecialTableSymbolNode(StringView &MangledName,
+ SpecialIntrinsicKind SIK);
+ LocalStaticGuardVariableNode *
+ demangleLocalStaticGuard(StringView &MangledName);
+ VariableSymbolNode *demangleUntypedVariable(ArenaAllocator &Arena,
+ StringView &MangledName,
+ StringView VariableName);
+ VariableSymbolNode *
+ demangleRttiBaseClassDescriptorNode(ArenaAllocator &Arena,
+ StringView &MangledName);
+ FunctionSymbolNode *demangleInitFiniStub(StringView &MangledName,
+ bool IsDestructor);
+
+ NamedIdentifierNode *demangleSimpleName(StringView &MangledName,
+ bool Memorize);
+ NamedIdentifierNode *demangleAnonymousNamespaceName(StringView &MangledName);
+ NamedIdentifierNode *demangleLocallyScopedNamePiece(StringView &MangledName);
+ EncodedStringLiteralNode *demangleStringLiteral(StringView &MangledName);
+ FunctionSymbolNode *demangleVcallThunkNode(StringView &MangledName);
+
+ StringView demangleSimpleString(StringView &MangledName, bool Memorize);
+
+ FuncClass demangleFunctionClass(StringView &MangledName);
+ CallingConv demangleCallingConvention(StringView &MangledName);
+ StorageClass demangleVariableStorageClass(StringView &MangledName);
+ bool demangleThrowSpecification(StringView &MangledName);
+ wchar_t demangleWcharLiteral(StringView &MangledName);
+ uint8_t demangleCharLiteral(StringView &MangledName);
+
+ std::pair<Qualifiers, bool> demangleQualifiers(StringView &MangledName);
+
+ // Memory allocator.
+ ArenaAllocator Arena;
+
+ // A single type uses one global back-ref table for all function params.
+ // This means back-refs can even go "into" other types. Examples:
+ //
+ // // Second int* is a back-ref to first.
+ // void foo(int *, int*);
+ //
+ // // Second int* is not a back-ref to first (first is not a function param).
+ // int* foo(int*);
+ //
+ // // Second int* is a back-ref to first (ALL function types share the same
+ // // back-ref map.
+ // using F = void(*)(int*);
+ // F G(int *);
+ BackrefContext Backrefs;
+};
+
+} // namespace ms_demangle
+} // namespace llvm
+
+#endif // LLVM_DEMANGLE_MICROSOFT_DEMANGLE_H
diff --git a/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangleNodes.h b/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangleNodes.h
new file mode 100644
index 0000000..b478418
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Demangle/MicrosoftDemangleNodes.h
@@ -0,0 +1,624 @@
+//===- MicrosoftDemangleNodes.h ---------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the AST nodes used in the MSVC demangler.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_MICROSOFTDEMANGLENODES_H
+#define LLVM_SUPPORT_MICROSOFTDEMANGLENODES_H
+
+#include "llvm/Demangle/DemangleConfig.h"
+#include "llvm/Demangle/StringView.h"
+#include <array>
+
+namespace llvm {
+namespace itanium_demangle {
+class OutputStream;
+}
+}
+
+using llvm::itanium_demangle::OutputStream;
+using llvm::itanium_demangle::StringView;
+
+namespace llvm {
+namespace ms_demangle {
+
+// Storage classes
+enum Qualifiers : uint8_t {
+ Q_None = 0,
+ Q_Const = 1 << 0,
+ Q_Volatile = 1 << 1,
+ Q_Far = 1 << 2,
+ Q_Huge = 1 << 3,
+ Q_Unaligned = 1 << 4,
+ Q_Restrict = 1 << 5,
+ Q_Pointer64 = 1 << 6
+};
+
+enum class StorageClass : uint8_t {
+ None,
+ PrivateStatic,
+ ProtectedStatic,
+ PublicStatic,
+ Global,
+ FunctionLocalStatic,
+};
+
+enum class PointerAffinity { None, Pointer, Reference, RValueReference };
+enum class FunctionRefQualifier { None, Reference, RValueReference };
+
+// Calling conventions
+enum class CallingConv : uint8_t {
+ None,
+ Cdecl,
+ Pascal,
+ Thiscall,
+ Stdcall,
+ Fastcall,
+ Clrcall,
+ Eabi,
+ Vectorcall,
+ Regcall,
+};
+
+enum class ReferenceKind : uint8_t { None, LValueRef, RValueRef };
+
+enum OutputFlags {
+ OF_Default = 0,
+ OF_NoCallingConvention = 1,
+ OF_NoTagSpecifier = 2,
+};
+
+// Types
+enum class PrimitiveKind {
+ Void,
+ Bool,
+ Char,
+ Schar,
+ Uchar,
+ Char16,
+ Char32,
+ Short,
+ Ushort,
+ Int,
+ Uint,
+ Long,
+ Ulong,
+ Int64,
+ Uint64,
+ Wchar,
+ Float,
+ Double,
+ Ldouble,
+ Nullptr,
+};
+
+enum class CharKind {
+ Char,
+ Char16,
+ Char32,
+ Wchar,
+};
+
+enum class IntrinsicFunctionKind : uint8_t {
+ None,
+ New, // ?2 # operator new
+ Delete, // ?3 # operator delete
+ Assign, // ?4 # operator=
+ RightShift, // ?5 # operator>>
+ LeftShift, // ?6 # operator<<
+ LogicalNot, // ?7 # operator!
+ Equals, // ?8 # operator==
+ NotEquals, // ?9 # operator!=
+ ArraySubscript, // ?A # operator[]
+ Pointer, // ?C # operator->
+ Dereference, // ?D # operator*
+ Increment, // ?E # operator++
+ Decrement, // ?F # operator--
+ Minus, // ?G # operator-
+ Plus, // ?H # operator+
+ BitwiseAnd, // ?I # operator&
+ MemberPointer, // ?J # operator->*
+ Divide, // ?K # operator/
+ Modulus, // ?L # operator%
+ LessThan, // ?M operator<
+ LessThanEqual, // ?N operator<=
+ GreaterThan, // ?O operator>
+ GreaterThanEqual, // ?P operator>=
+ Comma, // ?Q operator,
+ Parens, // ?R operator()
+ BitwiseNot, // ?S operator~
+ BitwiseXor, // ?T operator^
+ BitwiseOr, // ?U operator|
+ LogicalAnd, // ?V operator&&
+ LogicalOr, // ?W operator||
+ TimesEqual, // ?X operator*=
+ PlusEqual, // ?Y operator+=
+ MinusEqual, // ?Z operator-=
+ DivEqual, // ?_0 operator/=
+ ModEqual, // ?_1 operator%=
+ RshEqual, // ?_2 operator>>=
+ LshEqual, // ?_3 operator<<=
+ BitwiseAndEqual, // ?_4 operator&=
+ BitwiseOrEqual, // ?_5 operator|=
+ BitwiseXorEqual, // ?_6 operator^=
+ VbaseDtor, // ?_D # vbase destructor
+ VecDelDtor, // ?_E # vector deleting destructor
+ DefaultCtorClosure, // ?_F # default constructor closure
+ ScalarDelDtor, // ?_G # scalar deleting destructor
+ VecCtorIter, // ?_H # vector constructor iterator
+ VecDtorIter, // ?_I # vector destructor iterator
+ VecVbaseCtorIter, // ?_J # vector vbase constructor iterator
+ VdispMap, // ?_K # virtual displacement map
+ EHVecCtorIter, // ?_L # eh vector constructor iterator
+ EHVecDtorIter, // ?_M # eh vector destructor iterator
+ EHVecVbaseCtorIter, // ?_N # eh vector vbase constructor iterator
+ CopyCtorClosure, // ?_O # copy constructor closure
+ LocalVftableCtorClosure, // ?_T # local vftable constructor closure
+ ArrayNew, // ?_U operator new[]
+ ArrayDelete, // ?_V operator delete[]
+ ManVectorCtorIter, // ?__A managed vector ctor iterator
+ ManVectorDtorIter, // ?__B managed vector dtor iterator
+ EHVectorCopyCtorIter, // ?__C EH vector copy ctor iterator
+ EHVectorVbaseCopyCtorIter, // ?__D EH vector vbase copy ctor iterator
+ VectorCopyCtorIter, // ?__G vector copy constructor iterator
+ VectorVbaseCopyCtorIter, // ?__H vector vbase copy constructor iterator
+ ManVectorVbaseCopyCtorIter, // ?__I managed vector vbase copy constructor
+ CoAwait, // ?__L co_await
+ Spaceship, // operator<=>
+ MaxIntrinsic
+};
+
+enum class SpecialIntrinsicKind {
+ None,
+ Vftable,
+ Vbtable,
+ Typeof,
+ VcallThunk,
+ LocalStaticGuard,
+ StringLiteralSymbol,
+ UdtReturning,
+ Unknown,
+ DynamicInitializer,
+ DynamicAtexitDestructor,
+ RttiTypeDescriptor,
+ RttiBaseClassDescriptor,
+ RttiBaseClassArray,
+ RttiClassHierarchyDescriptor,
+ RttiCompleteObjLocator,
+ LocalVftable,
+ LocalStaticThreadGuard,
+};
+
+// Function classes
+enum FuncClass : uint16_t {
+ FC_None = 0,
+ FC_Public = 1 << 0,
+ FC_Protected = 1 << 1,
+ FC_Private = 1 << 2,
+ FC_Global = 1 << 3,
+ FC_Static = 1 << 4,
+ FC_Virtual = 1 << 5,
+ FC_Far = 1 << 6,
+ FC_ExternC = 1 << 7,
+ FC_NoParameterList = 1 << 8,
+ FC_VirtualThisAdjust = 1 << 9,
+ FC_VirtualThisAdjustEx = 1 << 10,
+ FC_StaticThisAdjust = 1 << 11,
+};
+
+enum class TagKind { Class, Struct, Union, Enum };
+
+enum class NodeKind {
+ Unknown,
+ Md5Symbol,
+ PrimitiveType,
+ FunctionSignature,
+ Identifier,
+ NamedIdentifier,
+ VcallThunkIdentifier,
+ LocalStaticGuardIdentifier,
+ IntrinsicFunctionIdentifier,
+ ConversionOperatorIdentifier,
+ DynamicStructorIdentifier,
+ StructorIdentifier,
+ LiteralOperatorIdentifier,
+ ThunkSignature,
+ PointerType,
+ TagType,
+ ArrayType,
+ Custom,
+ IntrinsicType,
+ NodeArray,
+ QualifiedName,
+ TemplateParameterReference,
+ EncodedStringLiteral,
+ IntegerLiteral,
+ RttiBaseClassDescriptor,
+ LocalStaticGuardVariable,
+ FunctionSymbol,
+ VariableSymbol,
+ SpecialTableSymbol
+};
+
+struct Node {
+ explicit Node(NodeKind K) : Kind(K) {}
+ virtual ~Node() = default;
+
+ NodeKind kind() const { return Kind; }
+
+ virtual void output(OutputStream &OS, OutputFlags Flags) const = 0;
+
+ std::string toString(OutputFlags Flags = OF_Default) const;
+
+private:
+ NodeKind Kind;
+};
+
+struct TypeNode;
+struct PrimitiveTypeNode;
+struct FunctionSignatureNode;
+struct IdentifierNode;
+struct NamedIdentifierNode;
+struct VcallThunkIdentifierNode;
+struct IntrinsicFunctionIdentifierNode;
+struct LiteralOperatorIdentifierNode;
+struct ConversionOperatorIdentifierNode;
+struct StructorIdentifierNode;
+struct ThunkSignatureNode;
+struct PointerTypeNode;
+struct ArrayTypeNode;
+struct CustomNode;
+struct TagTypeNode;
+struct IntrinsicTypeNode;
+struct NodeArrayNode;
+struct QualifiedNameNode;
+struct TemplateParameterReferenceNode;
+struct EncodedStringLiteralNode;
+struct IntegerLiteralNode;
+struct RttiBaseClassDescriptorNode;
+struct LocalStaticGuardVariableNode;
+struct SymbolNode;
+struct FunctionSymbolNode;
+struct VariableSymbolNode;
+struct SpecialTableSymbolNode;
+
+struct TypeNode : public Node {
+ explicit TypeNode(NodeKind K) : Node(K) {}
+
+ virtual void outputPre(OutputStream &OS, OutputFlags Flags) const = 0;
+ virtual void outputPost(OutputStream &OS, OutputFlags Flags) const = 0;
+
+ void output(OutputStream &OS, OutputFlags Flags) const override {
+ outputPre(OS, Flags);
+ outputPost(OS, Flags);
+ }
+
+ void outputQuals(bool SpaceBefore, bool SpaceAfter) const;
+
+ Qualifiers Quals = Q_None;
+};
+
+struct PrimitiveTypeNode : public TypeNode {
+ explicit PrimitiveTypeNode(PrimitiveKind K)
+ : TypeNode(NodeKind::PrimitiveType), PrimKind(K) {}
+
+ void outputPre(OutputStream &OS, OutputFlags Flags) const;
+ void outputPost(OutputStream &OS, OutputFlags Flags) const {}
+
+ PrimitiveKind PrimKind;
+};
+
+struct FunctionSignatureNode : public TypeNode {
+ explicit FunctionSignatureNode(NodeKind K) : TypeNode(K) {}
+ FunctionSignatureNode() : TypeNode(NodeKind::FunctionSignature) {}
+
+ void outputPre(OutputStream &OS, OutputFlags Flags) const override;
+ void outputPost(OutputStream &OS, OutputFlags Flags) const override;
+
+ // Valid if this FunctionTypeNode is the Pointee of a PointerType or
+ // MemberPointerType.
+ PointerAffinity Affinity = PointerAffinity::None;
+
+ // The function's calling convention.
+ CallingConv CallConvention = CallingConv::None;
+
+ // Function flags (gloabl, public, etc)
+ FuncClass FunctionClass = FC_Global;
+
+ FunctionRefQualifier RefQualifier = FunctionRefQualifier::None;
+
+ // The return type of the function.
+ TypeNode *ReturnType = nullptr;
+
+ // True if this is a C-style ... varargs function.
+ bool IsVariadic = false;
+
+ // Function parameters
+ NodeArrayNode *Params = nullptr;
+
+ // True if the function type is noexcept
+ bool IsNoexcept = false;
+};
+
+struct IdentifierNode : public Node {
+ explicit IdentifierNode(NodeKind K) : Node(K) {}
+
+ NodeArrayNode *TemplateParams = nullptr;
+
+protected:
+ void outputTemplateParameters(OutputStream &OS, OutputFlags Flags) const;
+};
+
+struct VcallThunkIdentifierNode : public IdentifierNode {
+ VcallThunkIdentifierNode() : IdentifierNode(NodeKind::VcallThunkIdentifier) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ uint64_t OffsetInVTable = 0;
+};
+
+struct DynamicStructorIdentifierNode : public IdentifierNode {
+ DynamicStructorIdentifierNode()
+ : IdentifierNode(NodeKind::DynamicStructorIdentifier) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ VariableSymbolNode *Variable = nullptr;
+ QualifiedNameNode *Name = nullptr;
+ bool IsDestructor = false;
+};
+
+struct NamedIdentifierNode : public IdentifierNode {
+ NamedIdentifierNode() : IdentifierNode(NodeKind::NamedIdentifier) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ StringView Name;
+};
+
+struct IntrinsicFunctionIdentifierNode : public IdentifierNode {
+ explicit IntrinsicFunctionIdentifierNode(IntrinsicFunctionKind Operator)
+ : IdentifierNode(NodeKind::IntrinsicFunctionIdentifier),
+ Operator(Operator) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ IntrinsicFunctionKind Operator;
+};
+
+struct LiteralOperatorIdentifierNode : public IdentifierNode {
+ LiteralOperatorIdentifierNode()
+ : IdentifierNode(NodeKind::LiteralOperatorIdentifier) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ StringView Name;
+};
+
+struct LocalStaticGuardIdentifierNode : public IdentifierNode {
+ LocalStaticGuardIdentifierNode()
+ : IdentifierNode(NodeKind::LocalStaticGuardIdentifier) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ uint32_t ScopeIndex = 0;
+};
+
+struct ConversionOperatorIdentifierNode : public IdentifierNode {
+ ConversionOperatorIdentifierNode()
+ : IdentifierNode(NodeKind::ConversionOperatorIdentifier) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ // The type that this operator converts too.
+ TypeNode *TargetType = nullptr;
+};
+
+struct StructorIdentifierNode : public IdentifierNode {
+ StructorIdentifierNode() : IdentifierNode(NodeKind::StructorIdentifier) {}
+ explicit StructorIdentifierNode(bool IsDestructor)
+ : IdentifierNode(NodeKind::StructorIdentifier),
+ IsDestructor(IsDestructor) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ // The name of the class that this is a structor of.
+ IdentifierNode *Class = nullptr;
+ bool IsDestructor = false;
+};
+
+struct ThunkSignatureNode : public FunctionSignatureNode {
+ ThunkSignatureNode() : FunctionSignatureNode(NodeKind::ThunkSignature) {}
+
+ void outputPre(OutputStream &OS, OutputFlags Flags) const override;
+ void outputPost(OutputStream &OS, OutputFlags Flags) const override;
+
+ struct ThisAdjustor {
+ uint32_t StaticOffset = 0;
+ int32_t VBPtrOffset = 0;
+ int32_t VBOffsetOffset = 0;
+ int32_t VtordispOffset = 0;
+ };
+
+ ThisAdjustor ThisAdjust;
+};
+
+struct PointerTypeNode : public TypeNode {
+ PointerTypeNode() : TypeNode(NodeKind::PointerType) {}
+ void outputPre(OutputStream &OS, OutputFlags Flags) const override;
+ void outputPost(OutputStream &OS, OutputFlags Flags) const override;
+
+ // Is this a pointer, reference, or rvalue-reference?
+ PointerAffinity Affinity = PointerAffinity::None;
+
+ // If this is a member pointer, this is the class that the member is in.
+ QualifiedNameNode *ClassParent = nullptr;
+
+ // Represents a type X in "a pointer to X", "a reference to X", or
+ // "rvalue-reference to X"
+ TypeNode *Pointee = nullptr;
+};
+
+struct TagTypeNode : public TypeNode {
+ explicit TagTypeNode(TagKind Tag) : TypeNode(NodeKind::TagType), Tag(Tag) {}
+
+ void outputPre(OutputStream &OS, OutputFlags Flags) const;
+ void outputPost(OutputStream &OS, OutputFlags Flags) const;
+
+ QualifiedNameNode *QualifiedName = nullptr;
+ TagKind Tag;
+};
+
+struct ArrayTypeNode : public TypeNode {
+ ArrayTypeNode() : TypeNode(NodeKind::ArrayType) {}
+
+ void outputPre(OutputStream &OS, OutputFlags Flags) const;
+ void outputPost(OutputStream &OS, OutputFlags Flags) const;
+
+ void outputDimensionsImpl(OutputStream &OS, OutputFlags Flags) const;
+ void outputOneDimension(OutputStream &OS, OutputFlags Flags, Node *N) const;
+
+ // A list of array dimensions. e.g. [3,4,5] in `int Foo[3][4][5]`
+ NodeArrayNode *Dimensions = nullptr;
+
+ // The type of array element.
+ TypeNode *ElementType = nullptr;
+};
+
+struct IntrinsicNode : public TypeNode {
+ IntrinsicNode() : TypeNode(NodeKind::IntrinsicType) {}
+ void output(OutputStream &OS, OutputFlags Flags) const override {}
+};
+
+struct CustomTypeNode : public TypeNode {
+ CustomTypeNode() : TypeNode(NodeKind::Custom) {}
+
+ void outputPre(OutputStream &OS, OutputFlags Flags) const override;
+ void outputPost(OutputStream &OS, OutputFlags Flags) const override;
+
+ IdentifierNode *Identifier;
+};
+
+struct NodeArrayNode : public Node {
+ NodeArrayNode() : Node(NodeKind::NodeArray) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ void output(OutputStream &OS, OutputFlags Flags, StringView Separator) const;
+
+ Node **Nodes = 0;
+ size_t Count = 0;
+};
+
+struct QualifiedNameNode : public Node {
+ QualifiedNameNode() : Node(NodeKind::QualifiedName) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ NodeArrayNode *Components = nullptr;
+
+ IdentifierNode *getUnqualifiedIdentifier() {
+ Node *LastComponent = Components->Nodes[Components->Count - 1];
+ return static_cast<IdentifierNode *>(LastComponent);
+ }
+};
+
+struct TemplateParameterReferenceNode : public Node {
+ TemplateParameterReferenceNode()
+ : Node(NodeKind::TemplateParameterReference) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ SymbolNode *Symbol = nullptr;
+
+ int ThunkOffsetCount = 0;
+ std::array<int64_t, 3> ThunkOffsets;
+ PointerAffinity Affinity = PointerAffinity::None;
+ bool IsMemberPointer = false;
+};
+
+struct IntegerLiteralNode : public Node {
+ IntegerLiteralNode() : Node(NodeKind::IntegerLiteral) {}
+ IntegerLiteralNode(uint64_t Value, bool IsNegative)
+ : Node(NodeKind::IntegerLiteral), Value(Value), IsNegative(IsNegative) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ uint64_t Value = 0;
+ bool IsNegative = false;
+};
+
+struct RttiBaseClassDescriptorNode : public IdentifierNode {
+ RttiBaseClassDescriptorNode()
+ : IdentifierNode(NodeKind::RttiBaseClassDescriptor) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ uint32_t NVOffset = 0;
+ int32_t VBPtrOffset = 0;
+ uint32_t VBTableOffset = 0;
+ uint32_t Flags = 0;
+};
+
+struct SymbolNode : public Node {
+ explicit SymbolNode(NodeKind K) : Node(K) {}
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+ QualifiedNameNode *Name = nullptr;
+};
+
+struct SpecialTableSymbolNode : public SymbolNode {
+ explicit SpecialTableSymbolNode()
+ : SymbolNode(NodeKind::SpecialTableSymbol) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+ QualifiedNameNode *TargetName = nullptr;
+ Qualifiers Quals;
+};
+
+struct LocalStaticGuardVariableNode : public SymbolNode {
+ LocalStaticGuardVariableNode()
+ : SymbolNode(NodeKind::LocalStaticGuardVariable) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ bool IsVisible = false;
+};
+
+struct EncodedStringLiteralNode : public SymbolNode {
+ EncodedStringLiteralNode() : SymbolNode(NodeKind::EncodedStringLiteral) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ StringView DecodedString;
+ bool IsTruncated = false;
+ CharKind Char = CharKind::Char;
+};
+
+struct VariableSymbolNode : public SymbolNode {
+ VariableSymbolNode() : SymbolNode(NodeKind::VariableSymbol) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ StorageClass SC = StorageClass::None;
+ TypeNode *Type = nullptr;
+};
+
+struct FunctionSymbolNode : public SymbolNode {
+ FunctionSymbolNode() : SymbolNode(NodeKind::FunctionSymbol) {}
+
+ void output(OutputStream &OS, OutputFlags Flags) const override;
+
+ FunctionSignatureNode *Signature = nullptr;
+};
+
+} // namespace ms_demangle
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/Demangle/StringView.h b/linux-x64/clang/include/llvm/Demangle/StringView.h
index a89deda..ceb6c79 100644
--- a/linux-x64/clang/include/llvm/Demangle/StringView.h
+++ b/linux-x64/clang/include/llvm/Demangle/StringView.h
@@ -1,22 +1,25 @@
//===--- StringView.h -------------------------------------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+//===----------------------------------------------------------------------===//
//
+// FIXME: Use std::string_view instead when we support C++17.
//
-// This file contains a limited version of LLVM's StringView class. It is
-// copied here so that LLVMDemangle need not take a dependency on LLVMSupport.
//===----------------------------------------------------------------------===//
-#ifndef LLVM_DEMANGLE_STRINGVIEW_H
-#define LLVM_DEMANGLE_STRINGVIEW_H
+#ifndef DEMANGLE_STRINGVIEW_H
+#define DEMANGLE_STRINGVIEW_H
+#include "DemangleConfig.h"
#include <algorithm>
#include <cassert>
#include <cstring>
+DEMANGLE_NAMESPACE_BEGIN
+
class StringView {
const char *First;
const char *Last;
@@ -43,7 +46,7 @@
if (FindBegin < size()) {
// Just forward to memchr, which is faster than a hand-rolled loop.
if (const void *P = ::memchr(First + FindBegin, C, size() - FindBegin))
- return static_cast<const char *>(P) - First;
+ return size_t(static_cast<const char *>(P) - First);
}
return npos;
}
@@ -118,4 +121,6 @@
std::equal(LHS.begin(), LHS.end(), RHS.begin());
}
+DEMANGLE_NAMESPACE_END
+
#endif
diff --git a/linux-x64/clang/include/llvm/Demangle/Utility.h b/linux-x64/clang/include/llvm/Demangle/Utility.h
index da4a0c0..ec23859 100644
--- a/linux-x64/clang/include/llvm/Demangle/Utility.h
+++ b/linux-x64/clang/include/llvm/Demangle/Utility.h
@@ -1,25 +1,27 @@
//===--- Utility.h ----------------------------------------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+//===----------------------------------------------------------------------===//
//
+// Provide some utility classes for use in the demangler(s).
//
-// This file contains several utility classes used by the demangle library.
//===----------------------------------------------------------------------===//
-#ifndef LLVM_DEMANGLE_UTILITY_H
-#define LLVM_DEMANGLE_UTILITY_H
+#ifndef DEMANGLE_UTILITY_H
+#define DEMANGLE_UTILITY_H
#include "StringView.h"
-
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <iterator>
#include <limits>
+DEMANGLE_NAMESPACE_BEGIN
+
// Stream that AST nodes write their string representation into after the AST
// has been parsed.
class OutputStream {
@@ -175,13 +177,15 @@
if (Buf == nullptr) {
Buf = static_cast<char *>(std::malloc(InitSize));
if (Buf == nullptr)
- return true;
+ return false;
BufferSize = InitSize;
} else
BufferSize = *N;
S.reset(Buf, BufferSize);
- return false;
+ return true;
}
+DEMANGLE_NAMESPACE_END
+
#endif