replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[demangler] Modernize the rest of the demangler. 

llvm-svn: 326797
This commit is contained in:
Erik Pilkington 2018-03-06 14:21:10 +00:00
parent 4352d7221c
commit 98e7036587
2 changed files with 295 additions and 463 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

755
libcxxabi/src/cxa_demangle.cpp
View File

@ -2002,6 +2002,8 @@ struct Db {
BumpPointerAllocator ASTAllocator; BumpPointerAllocator ASTAllocator;
Db(const char *First_, const char *Last_) : First(First_), Last(Last_) {}
template <class T, class... Args> T *make(Args &&... args) { template <class T, class... Args> T *make(Args &&... args) {
return new (ASTAllocator.allocate(sizeof(T))) return new (ASTAllocator.allocate(sizeof(T)))
T(std::forward<Args>(args)...); T(std::forward<Args>(args)...);
@ -2054,6 +2056,12 @@ struct Db {
bool parsePositiveInteger(size_t *Out); bool parsePositiveInteger(size_t *Out);
StringView parseBareSourceName(); StringView parseBareSourceName();
bool parseSeqId(size_t *Out);
Node *parseSubstitution();
Node *parseTemplateParam();
Node *parseTemplateArgs();
Node *parseTemplateArg();
/// Parse the <expr> production. /// Parse the <expr> production.
Node *parseExpr(); Node *parseExpr();
Node *parsePrefixExpr(StringView Kind); Node *parsePrefixExpr(StringView Kind);
@ -2109,66 +2117,11 @@ struct Db {
Node *parseUnresolvedType(); Node *parseUnresolvedType();
Node *parseDestructorName(); Node *parseDestructorName();
// FIXME: remove this when all the parse_* functions have been rewritten. /// Top-level entry point into the parser.
template <const char *(*parse_fn)(const char *, const char *, Db &)> Node *parse();
Node *legacyParse() {
size_t BeforeType = Names.size();
const char *OrigFirst = First;
const char *T = parse_fn(First, Last, *this);
if (T == OrigFirst || BeforeType + 1 != Names.size())
return nullptr;
First = T;
Node *R = Names.back();
Names.pop_back();
return R;
}
}; };
const char *parse_expression(const char *first, const char *last, Db &db) {
db.First = first;
db.Last = last;
Node *R = db.parseExpr();
if (R == nullptr)
return first;
db.Names.push_back(R);
return db.First;
}
const char *parse_expr_primary(const char *first, const char *last, Db &db) {
db.First = first;
db.Last = last;
Node *R = db.parseExprPrimary();
if (R == nullptr)
return first;
db.Names.push_back(R);
return db.First;
}
const char *parse_type(const char *first, const char *last, Db &db) {
db.First = first;
db.Last = last;
Node *R = db.parseType();
if (R == nullptr)
return first;
db.Names.push_back(R);
return db.First;
}
const char *parse_encoding(const char *first, const char *last, Db &db) {
db.First = first;
db.Last = last;
Node *R = db.parseEncoding();
if (R == nullptr)
return first;
db.Names.push_back(R);
return db.First;
}
const char* parse_discriminator(const char* first, const char* last); const char* parse_discriminator(const char* first, const char* last);
const char *parse_template_args(const char *first, const char *last, Db &db);
const char *parse_template_param(const char *, const char *, Db &);
const char *parse_substitution(const char *, const char *, Db &);
// <name> ::= <nested-name> // N // <name> ::= <nested-name> // N
// ::= <local-name> # See Scope Encoding below // Z // ::= <local-name> # See Scope Encoding below // Z
@ -2187,10 +2140,12 @@ Node *Db::parseName(NameState *State) {
// ::= <unscoped-template-name> <template-args> // ::= <unscoped-template-name> <template-args>
if (look() == 'S' && look(1) != 't') { if (look() == 'S' && look(1) != 't') {
Node *S = legacyParse<parse_substitution>(); Node *S = parseSubstitution();
if (S == nullptr)
return nullptr;
if (look() != 'I') if (look() != 'I')
return nullptr; return nullptr;
Node *TA = legacyParse<parse_template_args>(); Node *TA = parseTemplateArgs();
if (TA == nullptr) if (TA == nullptr)
return nullptr; return nullptr;
if (State) State->EndsWithTemplateArgs = true; if (State) State->EndsWithTemplateArgs = true;
@ -2203,7 +2158,7 @@ Node *Db::parseName(NameState *State) {
// ::= <unscoped-template-name> <template-args> // ::= <unscoped-template-name> <template-args>
if (look() == 'I') { if (look() == 'I') {
Subs.push_back(N); Subs.push_back(N);
Node *TA = legacyParse<parse_template_args>(); Node *TA = parseTemplateArgs();
if (TA == nullptr) if (TA == nullptr)
return nullptr; return nullptr;
if (State) State->EndsWithTemplateArgs = true; if (State) State->EndsWithTemplateArgs = true;
@ -2693,7 +2648,7 @@ Node *Db::parseNestedName(NameState *State) {
// ::= <template-param> // ::= <template-param>
if (look() == 'T') { if (look() == 'T') {
Node *TP = legacyParse<parse_template_param>(); Node *TP = parseTemplateParam();
if (TP == nullptr) if (TP == nullptr)
return nullptr; return nullptr;
PushComponent(TP); PushComponent(TP);
@ -2703,7 +2658,7 @@ Node *Db::parseNestedName(NameState *State) {
// ::= <template-prefix> <template-args> // ::= <template-prefix> <template-args>
if (look() == 'I') { if (look() == 'I') {
Node *TA = legacyParse<parse_template_args>(); Node *TA = parseTemplateArgs();
if (TA == nullptr || SoFar == nullptr) if (TA == nullptr || SoFar == nullptr)
return nullptr; return nullptr;
SoFar = make<NameWithTemplateArgs>(SoFar, TA); SoFar = make<NameWithTemplateArgs>(SoFar, TA);
@ -2724,7 +2679,7 @@ Node *Db::parseNestedName(NameState *State) {
// ::= <substitution> // ::= <substitution>
if (look() == 'S' && look(1) != 't') { if (look() == 'S' && look(1) != 't') {
Node *S = legacyParse<parse_substitution>(); Node *S = parseSubstitution();
if (S == nullptr) if (S == nullptr)
return nullptr; return nullptr;
PushComponent(S); PushComponent(S);
@ -2769,7 +2724,7 @@ Node *Db::parseSimpleId() {
if (SN == nullptr) if (SN == nullptr)
return nullptr; return nullptr;
if (look() == 'I') { if (look() == 'I') {
Node *TA = legacyParse<parse_template_args>(); Node *TA = parseTemplateArgs();
if (TA == nullptr) if (TA == nullptr)
return nullptr; return nullptr;
return make<NameWithTemplateArgs>(SN, TA); return make<NameWithTemplateArgs>(SN, TA);
@ -2795,7 +2750,7 @@ Node *Db::parseDestructorName() {
// ::= <substitution> // ::= <substitution>
Node *Db::parseUnresolvedType() { Node *Db::parseUnresolvedType() {
if (look() == 'T') { if (look() == 'T') {
Node *TP = legacyParse<parse_template_param>(); Node *TP = parseTemplateParam();
if (TP == nullptr) if (TP == nullptr)
return nullptr; return nullptr;
Subs.push_back(TP); Subs.push_back(TP);
@ -2808,7 +2763,7 @@ Node *Db::parseUnresolvedType() {
Subs.push_back(DT); Subs.push_back(DT);
return DT; return DT;
} }
return legacyParse<parse_substitution>(); return parseSubstitution();
} }
// <base-unresolved-name> ::= <simple-id> # unresolved name // <base-unresolved-name> ::= <simple-id> # unresolved name
@ -2831,7 +2786,7 @@ Node *Db::parseBaseUnresolvedName() {
if (Oper == nullptr) if (Oper == nullptr)
return nullptr; return nullptr;
if (look() == 'I') { if (look() == 'I') {
Node *TA = legacyParse<parse_template_args>(); Node *TA = parseTemplateArgs();
if (TA == nullptr) if (TA == nullptr)
return nullptr; return nullptr;
return make<NameWithTemplateArgs>(Oper, TA); return make<NameWithTemplateArgs>(Oper, TA);
@ -2861,7 +2816,7 @@ Node *Db::parseUnresolvedName() {
return nullptr; return nullptr;
if (look() == 'I') { if (look() == 'I') {
Node *TA = legacyParse<parse_template_args>(); Node *TA = parseTemplateArgs();
if (TA == nullptr) if (TA == nullptr)
return nullptr; return nullptr;
SoFar = make<NameWithTemplateArgs>(SoFar, TA); SoFar = make<NameWithTemplateArgs>(SoFar, TA);
@ -2914,7 +2869,7 @@ Node *Db::parseUnresolvedName() {
return nullptr; return nullptr;
if (look() == 'I') { if (look() == 'I') {
Node *TA = legacyParse<parse_template_args>(); Node *TA = parseTemplateArgs();
if (TA == nullptr) if (TA == nullptr)
return nullptr; return nullptr;
SoFar = make<NameWithTemplateArgs>(SoFar, TA); SoFar = make<NameWithTemplateArgs>(SoFar, TA);
@ -3436,7 +3391,7 @@ Node *Db::parseType() {
break; break;
} }
Result = legacyParse<parse_template_param>(); Result = parseTemplateParam();
if (Result == nullptr) if (Result == nullptr)
return nullptr; return nullptr;
@ -3451,7 +3406,7 @@ Node *Db::parseType() {
// parse them, take the second production. // parse them, take the second production.
if (TryToParseTemplateArgs && look() == 'I') { if (TryToParseTemplateArgs && look() == 'I') {
Node *TA = legacyParse<parse_template_args>(); Node *TA = parseTemplateArgs();
if (TA == nullptr) if (TA == nullptr)
return nullptr; return nullptr;
Result = make<NameWithTemplateArgs>(Result, TA); Result = make<NameWithTemplateArgs>(Result, TA);
@ -3506,7 +3461,7 @@ Node *Db::parseType() {
// ::= <substitution> # See Compression below // ::= <substitution> # See Compression below
case 'S': { case 'S': {
if (look(1) && look(1) != 't') { if (look(1) && look(1) != 't') {
Node *Sub = legacyParse<parse_substitution>(); Node *Sub = parseSubstitution();
if (Sub == nullptr) if (Sub == nullptr)
return nullptr; return nullptr;
@ -3521,7 +3476,7 @@ Node *Db::parseType() {
// parse them, take the second production. // parse them, take the second production.
if (TryToParseTemplateArgs && look() == 'I') { if (TryToParseTemplateArgs && look() == 'I') {
Node *TA = legacyParse<parse_template_args>(); Node *TA = parseTemplateArgs();
if (TA == nullptr) if (TA == nullptr)
return nullptr; return nullptr;
Result = make<NameWithTemplateArgs>(Sub, TA); Result = make<NameWithTemplateArgs>(Sub, TA);
@ -3872,7 +3827,7 @@ Node *Db::parseExpr() {
case 'L': case 'L':
return parseExprPrimary(); return parseExprPrimary();
case 'T': case 'T':
return legacyParse<parse_template_param>(); return parseTemplateParam();
case 'f': case 'f':
return parseFunctionParam(); return parseFunctionParam();
case 'a': case 'a':
@ -4244,7 +4199,7 @@ Node *Db::parseExpr() {
case 'Z': case 'Z':
First += 2; First += 2;
if (look() == 'T') { if (look() == 'T') {
Node *R = legacyParse<parse_template_param>(); Node *R = parseTemplateParam();
if (R == nullptr) if (R == nullptr)
return nullptr; return nullptr;
return make<SizeofParamPackExpr>(R); return make<SizeofParamPackExpr>(R);
@ -4572,6 +4527,28 @@ template <class Float> Node *Db::parseFloatingLiteral() {
return make<FloatExpr<Float>>(Data); return make<FloatExpr<Float>>(Data);
} }
// <seq-id> ::= <0-9A-Z>+
bool Db::parseSeqId(size_t *Out) {
if (!(look() >= '0' && look() <= '9') &&
!(look() >= 'A' && look() <= 'Z'))
return true;
size_t Id = 0;
while (true) {
if (look() >= '0' && look() <= '9') {
Id *= 36;
Id += static_cast<size_t>(look() - '0');
} else if (look() >= 'A' && look() <= 'Z') {
Id *= 36;
Id += static_cast<size_t>(look() - 'A') + 10;
} else {
*Out = Id;
return false;
}
++First;
}
}
// <substitution> ::= S <seq-id> _ // <substitution> ::= S <seq-id> _
// ::= S_ // ::= S_
// <substitution> ::= Sa # ::std::allocator // <substitution> ::= Sa # ::std::allocator
@ -4582,243 +4559,172 @@ template <class Float> Node *Db::parseFloatingLiteral() {
// <substitution> ::= Si # ::std::basic_istream<char, std::char_traits<char> > // <substitution> ::= Si # ::std::basic_istream<char, std::char_traits<char> >
// <substitution> ::= So # ::std::basic_ostream<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> > // <substitution> ::= Sd # ::std::basic_iostream<char, std::char_traits<char> >
Node *Db::parseSubstitution() {
if (!consumeIf('S'))
return nullptr;
const char* if (std::islower(look())) {
parse_substitution(const char* first, const char* last, Db& db) Node *SpecialSub;
{ switch (look()) {
if (last - first >= 2) case 'a':
{ ++First;
if (*first == 'S') SpecialSub = make<SpecialSubstitution>(SpecialSubKind::allocator);
{ break;
switch (first[1]) case 'b':
{ ++First;
case 'a': SpecialSub = make<SpecialSubstitution>(SpecialSubKind::basic_string);
db.Names.push_back( break;
db.make<SpecialSubstitution>( case 's':
SpecialSubKind::allocator)); ++First;
first += 2; SpecialSub = make<SpecialSubstitution>(SpecialSubKind::string);
break; break;
case 'b': case 'i':
db.Names.push_back( ++First;
db.make<SpecialSubstitution>(SpecialSubKind::basic_string)); SpecialSub = make<SpecialSubstitution>(SpecialSubKind::istream);
first += 2; break;
break; case 'o':
case 's': ++First;
db.Names.push_back( SpecialSub = make<SpecialSubstitution>(SpecialSubKind::ostream);
db.make<SpecialSubstitution>( break;
SpecialSubKind::string)); case 'd':
first += 2; ++First;
break; SpecialSub = make<SpecialSubstitution>(SpecialSubKind::iostream);
case 'i': break;
db.Names.push_back(db.make<SpecialSubstitution>(SpecialSubKind::istream)); default:
first += 2; return nullptr;
break;
case 'o':
db.Names.push_back(db.make<SpecialSubstitution>(SpecialSubKind::ostream));
first += 2;
break;
case 'd':
db.Names.push_back(db.make<SpecialSubstitution>(SpecialSubKind::iostream));
first += 2;
break;
case '_':
if (!db.Subs.empty())
{
db.Names.push_back(db.Subs[0]);
first += 2;
}
break;
default:
if (std::isdigit(first[1]) || std::isupper(first[1]))
{
size_t sub = 0;
const char* t = first+1;
if (std::isdigit(*t))
sub = static_cast<size_t>(*t - '0');
else
sub = static_cast<size_t>(*t - 'A') + 10;
for (++t; t != last && (std::isdigit(*t) || std::isupper(*t)); ++t)
{
sub *= 36;
if (std::isdigit(*t))
sub += static_cast<size_t>(*t - '0');
else
sub += static_cast<size_t>(*t - 'A') + 10;
}
if (t == last || *t != '_')
return first;
++sub;
if (sub < db.Subs.size())
{
db.Names.push_back(db.Subs[sub]);
first = t+1;
}
}
break;
}
}
} }
return first; // 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);
if (WithTags != SpecialSub) {
Subs.push_back(WithTags);
SpecialSub = WithTags;
}
return SpecialSub;
}
// ::= S_
if (consumeIf('_')) {
if (Subs.empty())
return nullptr;
return Subs[0];
}
// ::= S <seq-id> _
size_t Index = 0;
if (parseSeqId(&Index))
return nullptr;
++Index;
if (!consumeIf('_') || Index >= Subs.size())
return nullptr;
return Subs[Index];
} }
// <template-param> ::= T_ # first template parameter // <template-param> ::= T_ # first template parameter
// ::= T <parameter-2 non-negative number> _ // ::= T <parameter-2 non-negative number> _
Node *Db::parseTemplateParam() {
if (!consumeIf('T'))
return nullptr;
const char* if (consumeIf('_')) {
parse_template_param(const char* first, const char* last, Db& db) if (TemplateParams.empty()) {
{ FixForwardReferences = true;
if (last - first >= 2) return make<NameType>("FORWARD_REFERENCE");
{
if (*first == 'T')
{
if (first[1] == '_')
{
if (!db.TemplateParams.empty())
{
db.Names.push_back(db.TemplateParams[0]);
first += 2;
}
else
{
db.Names.push_back(db.make<NameType>("T_"));
first += 2;
db.FixForwardReferences = true;
}
}
else if (isdigit(first[1]))
{
const char* t = first+1;
size_t sub = static_cast<size_t>(*t - '0');
for (++t; t != last && isdigit(*t); ++t)
{
sub *= 10;
sub += static_cast<size_t>(*t - '0');
}
if (t == last || *t != '_')
return first;
++sub;
if (sub < db.TemplateParams.size())
{
db.Names.push_back(db.TemplateParams[sub]);
first = t+1;
}
else
{
db.Names.push_back(
db.make<NameType>(StringView(first, t + 1)));
first = t+1;
db.FixForwardReferences = true;
}
}
}
} }
return first; return TemplateParams[0];
}
size_t Index;
if (parsePositiveInteger(&Index))
return nullptr;
++Index;
if (!consumeIf('_'))
return nullptr;
if (Index >= TemplateParams.size()) {
FixForwardReferences = true;
return make<NameType>("FORWARD_REFERENCE");
}
return TemplateParams[Index];
} }
// <template-arg> ::= <type> # type or template // <template-arg> ::= <type> # type or template
// ::= X <expression> E # expression // ::= X <expression> E # expression
// ::= <expr-primary> # simple expressions // ::= <expr-primary> # simple expressions
// ::= J <template-arg>* E # argument pack // ::= J <template-arg>* E # argument pack
// ::= LZ <encoding> E # extension // ::= LZ <encoding> E # extension
const char* Node *Db::parseTemplateArg() {
parse_template_arg(const char* first, const char* last, Db& db) switch (look()) {
{ case 'X': {
if (first != last) ++First;
{ Node *Arg = parseExpr();
const char* t; if (Arg == nullptr || !consumeIf('E'))
switch (*first) return nullptr;
{ return Arg;
case 'X': }
t = parse_expression(first+1, last, db); case 'J': {
if (t != first+1) ++First;
{ size_t ArgsBegin = Names.size();
if (t != last && *t == 'E') while (!consumeIf('E')) {
first = t+1; Node *Arg = parseTemplateArg();
} if (Arg == nullptr)
break; return nullptr;
case 'J': { Names.push_back(Arg);
t = first+1;
if (t == last)
return first;
size_t ArgsBegin = db.Names.size();
while (*t != 'E')
{
const char* t1 = parse_template_arg(t, last, db);
if (t1 == t)
return first;
t = t1;
}
NodeArray Args = db.popTrailingNodeArray(ArgsBegin);
db.Names.push_back(db.make<TemplateArgumentPack>(Args));
first = t+1;
break;
}
case 'L':
// <expr-primary> or LZ <encoding> E
if (first+1 != last && first[1] == 'Z')
{
t = parse_encoding(first+2, last, db);
if (t != first+2 && t != last && *t == 'E')
first = t+1;
}
else
first = parse_expr_primary(first, last, db);
break;
default:
// <type>
first = parse_type(first, last, db);
break;
}
} }
return first; NodeArray Args = popTrailingNodeArray(ArgsBegin);
return make<TemplateArgumentPack>(Args);
}
case 'L': {
// ::= LZ <encoding> E # extension
if (look(1) == 'Z') {
First += 2;
Node *Arg = parseEncoding();
if (Arg == nullptr || !consumeIf('E'))
return nullptr;
return Arg;
}
// ::= <expr-primary> # simple expressions
return parseExprPrimary();
}
default:
return parseType();
}
} }
// <template-args> ::= I <template-arg>* E // <template-args> ::= I <template-arg>* E
// extension, the abi says <template-arg>+ // extension, the abi says <template-arg>+
const char* Node *Db::parseTemplateArgs() {
parse_template_args(const char* first, const char* last, Db& db) if (!consumeIf('I'))
{ return nullptr;
if (last - first >= 2 && *first == 'I')
{ // <template-params> refer to the innermost <template-args>. Clear out any
if (db.TagTemplates) // outer args that we may have inserted into TemplateParams.
db.TemplateParams.clear(); if (TagTemplates)
const char* t = first+1; TemplateParams.clear();
size_t begin_idx = db.Names.size();
while (*t != 'E') size_t ArgsBegin = Names.size();
{ while (!consumeIf('E')) {
if (db.TagTemplates) if (TagTemplates) {
{ auto OldParams = std::move(TemplateParams);
auto TmpParams = std::move(db.TemplateParams); Node *Arg = parseTemplateArg();
size_t k0 = db.Names.size(); TemplateParams = std::move(OldParams);
const char* t1 = parse_template_arg(t, last, db); if (Arg == nullptr)
size_t k1 = db.Names.size(); return nullptr;
db.TemplateParams = std::move(TmpParams); Names.push_back(Arg);
if (t1 == t || t1 == last || k0 + 1 != k1) Node *TableEntry = Arg;
return first; if (Arg->getKind() == Node::KTemplateArgumentPack) {
Node *TableEntry = db.Names.back(); TableEntry = make<ParameterPack>(
if (TableEntry->getKind() == Node::KTemplateArgumentPack) static_cast<TemplateArgumentPack*>(TableEntry)->getElements());
TableEntry = db.make<ParameterPack>( }
static_cast<TemplateArgumentPack*>(TableEntry) TemplateParams.push_back(TableEntry);
->getElements()); } else {
db.TemplateParams.push_back(TableEntry); Node *Arg = parseTemplateArg();
t = t1; if (Arg == nullptr)
continue; return nullptr;
} Names.push_back(Arg);
size_t k0 = db.Names.size();
const char* t1 = parse_template_arg(t, last, db);
size_t k1 = db.Names.size();
if (t1 == t || t1 == last || k0 > k1)
return first;
t = t1;
}
if (begin_idx > db.Names.size())
return first;
first = t + 1;
auto *tp = db.make<TemplateArgs>(
db.popTrailingNodeArray(begin_idx));
db.Names.push_back(tp);
} }
return first; }
return make<TemplateArgs>(popTrailingNodeArray(ArgsBegin));
} }
// <discriminator> := _ <non-negative number> # when number < 10 // <discriminator> := _ <non-negative number> # when number < 10
@ -4859,183 +4765,106 @@ parse_discriminator(const char* first, const char* last)
return first; return first;
} }
// _block_invoke // <mangled-name> ::= _Z <encoding>
// _block_invoke<decimal-digit>+
// _block_invoke_<decimal-digit>+
const char*
parse_block_invoke(const char* first, const char* last, Db& db)
{
if (last - first >= 13)
{
// FIXME: strcmp?
const char test[] = "_block_invoke";
const char* t = first;
for (int i = 0; i < 13; ++i, ++t)
{
if (*t != test[i])
return first;
}
if (t != last)
{
if (*t == '_')
{
// must have at least 1 decimal digit
if (++t == last || !std::isdigit(*t))
return first;
++t;
}
// parse zero or more digits
while (t != last && isdigit(*t))
++t;
}
if (db.Names.empty())
return first;
db.Names.back() =
db.make<SpecialName>("invocation function for block in ",
db.Names.back());
first = t;
}
return first;
}
// extension
// <dot-suffix> := .<anything and everything>
const char*
parse_dot_suffix(const char* first, const char* last, Db& db)
{
if (first != last && *first == '.')
{
if (db.Names.empty())
return first;
db.Names.back() =
db.make<DotSuffix>(db.Names.back(), StringView(first, last));
first = last;
}
return first;
}
enum {
unknown_error = -4,
invalid_args = -3,
invalid_mangled_name,
memory_alloc_failure,
success
};
// <block-involcaton-function> ___Z<encoding>_block_invoke
// <block-involcaton-function> ___Z<encoding>_block_invoke<decimal-digit>+
// <block-involcaton-function> ___Z<encoding>_block_invoke_<decimal-digit>+
// <mangled-name> ::= _Z<encoding>
// ::= <type> // ::= <type>
void // extension ::= ___Z <encoding> _block_invoke
demangle(const char* first, const char* last, Db& db, int& status) // extension ::= ___Z <encoding> _block_invoke<decimal-digit>+
{ // extension ::= ___Z <encoding> _block_invoke_<decimal-digit>+
if (first >= last) Node *Db::parse() {
{ if (consumeIf("_Z")) {
status = invalid_mangled_name; Node *Encoding = parseEncoding();
return; if (Encoding == nullptr)
return nullptr;
if (look() == '.') {
Encoding = make<DotSuffix>(Encoding, StringView(First, Last));
First = Last;
} }
if (*first == '_') if (numLeft() != 0)
{ return nullptr;
if (last - first >= 4) return Encoding;
{ }
if (first[1] == 'Z')
{
const char* t = parse_encoding(first+2, last, db);
if (t != first+2 && t != last && *t == '.')
t = parse_dot_suffix(t, last, db);
if (t != last)
status = invalid_mangled_name;
}
else if (first[1] == '_' && first[2] == '_' && first[3] == 'Z')
{
const char* t = parse_encoding(first+4, last, db);
if (t != first+4 && t != last)
{
const char* t1 = parse_block_invoke(t, last, db);
if (t1 != last)
status = invalid_mangled_name;
}
else
status = invalid_mangled_name;
}
else
status = invalid_mangled_name;
}
else
status = invalid_mangled_name;
}
else
{
const char* t = parse_type(first, last, db);
if (t != last)
status = invalid_mangled_name;
}
if (status == success && db.Names.empty())
status = invalid_mangled_name;
}
if (consumeIf("___Z")) {
Node *Encoding = parseEncoding();
if (Encoding == nullptr || !consumeIf("_block_invoke"))
return nullptr;
consumeIf('_');
if (parseNumber().empty())
return nullptr;
if (numLeft() != 0)
return nullptr;
return make<SpecialName>("invocation function for block in ", Encoding);
}
Node *Ty = parseType();
if (numLeft() != 0)
return nullptr;
return Ty;
}
} // unnamed namespace } // unnamed namespace
enum {
unknown_error = -4,
invalid_args = -3,
invalid_mangled_name = -2,
memory_alloc_failure = -1,
success = 0,
};
namespace __cxxabiv1 { namespace __cxxabiv1 {
extern "C" _LIBCXXABI_FUNC_VIS char * extern "C" _LIBCXXABI_FUNC_VIS char *
__cxa_demangle(const char *mangled_name, char *buf, size_t *n, int *status) { __cxa_demangle(const char *MangledName, char *Buf, size_t *N, int *Status) {
if (mangled_name == nullptr || (buf != nullptr && n == nullptr)) if (MangledName == nullptr || (Buf != nullptr && N == nullptr)) {
{ if (Status)
if (status) *Status = invalid_args;
*status = invalid_args; return nullptr;
return nullptr; }
size_t BufSize = Buf != nullptr ? *N : 0;
int InternalStatus = success;
size_t MangledNameLength = std::strlen(MangledName);
Db Parser(MangledName, MangledName + MangledNameLength);
Node *AST = Parser.parse();
if (AST == nullptr)
InternalStatus = invalid_mangled_name;
if (InternalStatus == success && Parser.FixForwardReferences &&
!Parser.TemplateParams.empty()) {
Parser.FixForwardReferences = false;
Parser.TagTemplates = false;
Parser.Names.clear();
Parser.Subs.clear();
Parser.First = MangledName;
Parser.Last = MangledName + MangledNameLength;
AST = Parser.parse();
if (AST == nullptr || Parser.FixForwardReferences)
InternalStatus = invalid_mangled_name;
}
if (InternalStatus == success && AST->containsUnexpandedParameterPack())
InternalStatus = invalid_mangled_name;
if (InternalStatus == success) {
if (Buf == nullptr) {
BufSize = 1024;
Buf = static_cast<char*>(std::malloc(BufSize));
} }
size_t internal_size = buf != nullptr ? *n : 0; if (Buf) {
Db db; OutputStream Stream(Buf, BufSize);
int internal_status = success; AST->print(Stream);
size_t len = std::strlen(mangled_name); Stream += '\0';
demangle(mangled_name, mangled_name + len, db, if (N != nullptr)
internal_status); *N = Stream.getCurrentPosition();
Buf = Stream.getBuffer();
} else
InternalStatus = memory_alloc_failure;
}
if (internal_status == success && db.FixForwardReferences && if (Status)
!db.TemplateParams.empty()) *Status = InternalStatus;
{ return InternalStatus == success ? Buf : nullptr;
db.FixForwardReferences = false;
db.TagTemplates = false;
db.Names.clear();
db.Subs.clear();
demangle(mangled_name, mangled_name + len, db, internal_status);
if (db.FixForwardReferences)
internal_status = invalid_mangled_name;
}
if (internal_status == success &&
db.Names.back()->containsUnexpandedParameterPack())
internal_status = invalid_mangled_name;
if (internal_status == success)
{
if (!buf)
{
internal_size = 1024;
buf = static_cast<char*>(std::malloc(internal_size));
}
if (buf)
{
OutputStream s(buf, internal_size);
db.Names.back()->print(s);
s += '\0';
if (n) *n = s.getCurrentPosition();
buf = s.getBuffer();
}
else
internal_status = memory_alloc_failure;
}
else
buf = nullptr;
if (status)
*status = internal_status;
return buf;
} }
} // __cxxabiv1 } // __cxxabiv1

3
libcxxabi/test/test_demangle.pass.cpp
View File

@ -29713,6 +29713,9 @@ const char* cases[][2] =
{"_ZNKR4llvm8OptionalINS_11MCFixupKindEEdeEv", "llvm::Optional<llvm::MCFixupKind>::operator*() const &"}, {"_ZNKR4llvm8OptionalINS_11MCFixupKindEEdeEv", "llvm::Optional<llvm::MCFixupKind>::operator*() const &"},
{"_ZZL23isValidCoroutineContextRN5clang4SemaENS_14SourceLocationEN4llvm9StringRefEENK3$_4clEZL23isValidCoroutineContextS1_S2_S4_E15InvalidFuncDiag", "isValidCoroutineContext(clang::Sema&, clang::SourceLocation, llvm::StringRef)::$_4::operator()(isValidCoroutineContext(clang::Sema&, clang::SourceLocation, llvm::StringRef)::InvalidFuncDiag) const"}, {"_ZZL23isValidCoroutineContextRN5clang4SemaENS_14SourceLocationEN4llvm9StringRefEENK3$_4clEZL23isValidCoroutineContextS1_S2_S4_E15InvalidFuncDiag", "isValidCoroutineContext(clang::Sema&, clang::SourceLocation, llvm::StringRef)::$_4::operator()(isValidCoroutineContext(clang::Sema&, clang::SourceLocation, llvm::StringRef)::InvalidFuncDiag) const"},
// ABI tags can apply to built-in substitutions.
{"_Z1fSsB1XS_", "f(std::string[abi:X], std::string[abi:X])"},
}; };
const unsigned N = sizeof(cases) / sizeof(cases[0]); const unsigned N = sizeof(cases) / sizeof(cases[0]);