// C++ IA64 / g++ v3 demangler -*- C++ -*-
// Copyright (C) 2003, 2004 Free Software Foundation, Inc.
// Written by Carlo Wood <carlo@alinoe.com>
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
// This file implements demangling of "C++ ABI for Itanium"-mangled symbol
// and type names as described in Revision 1.73 of the C++ ABI as can be found
// at http://www.codesourcery.com/cxx-abi/abi.html#mangling
#ifndef _DEMANGLER_H
#define _DEMANGLER_H 1
#include <vector>
#include <string>
#include <ext/new_allocator.h>
#ifndef _GLIBCXX_DEMANGLER_DEBUG
#define _GLIBCXX_DEMANGLER_CWDEBUG 0
#define _GLIBCXX_DEMANGLER_DEBUG(x)
#define _GLIBCXX_DEMANGLER_DOUT(cntrl, data)
#define _GLIBCXX_DEMANGLER_DOUT_ENTERING(x)
#define _GLIBCXX_DEMANGLER_DOUT_ENTERING2(x)
#define _GLIBCXX_DEMANGLER_DOUT_ENTERING3(x)
#define _GLIBCXX_DEMANGLER_RETURN return M_result
#define _GLIBCXX_DEMANGLER_RETURN2 return M_result
#define _GLIBCXX_DEMANGLER_RETURN3
#define _GLIBCXX_DEMANGLER_FAILURE \
do { M_result = false; return false; } while(0)
#else
#define _GLIBCXX_DEMANGLER_CWDEBUG 1
#endif
namespace __gnu_cxx
{
namespace demangler
{
enum substitution_nt
{
type,
template_template_param,
nested_name_prefix,
nested_name_template_prefix,
unscoped_template_name
};
struct substitution_st
{
int M_start_pos;
substitution_nt M_type;
int M_number_of_prefixes;
substitution_st(int start_pos,
substitution_nt type,
int number_of_prefixes)
: M_start_pos(start_pos), M_type(type),
M_number_of_prefixes(number_of_prefixes)
{ }
};
enum simple_qualifier_nt
{
complex_or_imaginary = 'G',
pointer = 'P',
reference = 'R'
};
enum cv_qualifier_nt
{
cv_qualifier = 'K'
};
enum param_qualifier_nt
{
vendor_extension = 'U',
array = 'A',
pointer_to_member = 'M'
};
template<typename Tp, typename Allocator = __gnu_cxx::new_allocator<Tp> >
class qualifier;
template<typename Tp, typename Allocator = __gnu_cxx::new_allocator<Tp> >
class qualifier_list;
template<typename Tp, typename Allocator = __gnu_cxx::new_allocator<Tp> >
class session;
template<typename Tp, typename Allocator>
class qualifier
{
typedef typename Allocator::template rebind<char>::other
char_Allocator;
typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
string_type;
private:
char M_qualifier1;
char M_qualifier2;
char M_qualifier3;
mutable unsigned char M_cnt;
string_type M_optional_type;
int M_start_pos;
bool M_part_of_substitution;
public:
qualifier(int start_pos,
simple_qualifier_nt simple_qualifier,
int inside_substitution)
: M_qualifier1(simple_qualifier),
M_start_pos(start_pos),
M_part_of_substitution(inside_substitution)
{ }
qualifier(int start_pos,
cv_qualifier_nt,
char const* start,
int count,
int inside_substitution)
: M_qualifier1(start[0]),
M_qualifier2((count > 1) ? start[1] : '\0'),
M_qualifier3((count > 2) ? start[2] : '\0'),
M_start_pos(start_pos),
M_part_of_substitution(inside_substitution)
{ }
qualifier(int start_pos,
param_qualifier_nt param_qualifier,
string_type optional_type,
int inside_substitution)
: M_qualifier1(param_qualifier),
M_optional_type(optional_type),
M_start_pos(start_pos),
M_part_of_substitution(inside_substitution)
{ }
int
get_start_pos(void) const
{ return M_start_pos; }
char
first_qualifier(void) const
{ M_cnt = 1; return M_qualifier1; }
char
next_qualifier(void) const
{
return (++M_cnt == 2) ? M_qualifier2
: ((M_cnt == 3) ? M_qualifier3 : 0);
}
string_type const&
get_optional_type(void) const
{ return M_optional_type; }
bool
part_of_substitution(void) const
{ return M_part_of_substitution; }
#if _GLIBCXX_DEMANGLER_CWDEBUG
friend std::ostream& operator<<(std::ostream& os, qualifier const& qual)
{
os << (char)qual.M_qualifier1;
if (qual.M_qualifier1 == vendor_extension ||
qual.M_qualifier1 == array ||
qual.M_qualifier1 == pointer_to_member)
os << " [" << qual.M_optional_type << ']';
else if (qual.M_qualifier1 == 'K' ||
qual.M_qualifier1 == 'V' ||
qual.M_qualifier1 == 'r')
{
if (qual.M_qualifier2)
{
os << (char)qual.M_qualifier2;
if (qual.M_qualifier3)
os << (char)qual.M_qualifier3;
}
}
return os;
}
#endif
};
template<typename Tp, typename Allocator>
class qualifier_list
{
typedef typename Allocator::template rebind<char>::other
char_Allocator;
typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
string_type;
private:
mutable bool M_printing_suppressed;
typedef qualifier<Tp, Allocator> qual;
typedef typename Allocator::template rebind<qual>::other qual_Allocator;
typedef std::vector<qual, qual_Allocator> qual_vector;
qual_vector M_qualifier_starts;
session<Tp, Allocator>& M_demangler;
void decode_KVrA(string_type& prefix, string_type& postfix, int cvq,
typename qual_vector::
const_reverse_iterator const& iter_array) const;
public:
qualifier_list(session<Tp, Allocator>& demangler_obj)
: M_printing_suppressed(false), M_demangler(demangler_obj)
{ }
void
add_qualifier_start(simple_qualifier_nt simple_qualifier,
int start_pos,
int inside_substitution)
{ M_qualifier_starts.
push_back(qualifier<Tp, Allocator>(start_pos,
simple_qualifier, inside_substitution)); }
void
add_qualifier_start(cv_qualifier_nt cv_qualifier,
int start_pos,
int count,
int inside_substitution)
{ M_qualifier_starts.
push_back(qualifier<Tp, Allocator>(start_pos,
cv_qualifier, &M_demangler.M_str[start_pos],
count, inside_substitution)); }
void
add_qualifier_start(param_qualifier_nt param_qualifier,
int start_pos,
string_type optional_type,
int inside_substitution)
{ M_qualifier_starts.
push_back(qualifier<Tp, Allocator>(start_pos,
param_qualifier, optional_type, inside_substitution)); }
void
decode_qualifiers(string_type& prefix,
string_type& postfix,
bool member_function_pointer_qualifiers) const;
bool
suppressed(void) const
{ return M_printing_suppressed; }
void
printing_suppressed(void)
{ M_printing_suppressed = true; }
size_t
size(void) const
{ return M_qualifier_starts.size(); }
#if _GLIBCXX_DEMANGLER_CWDEBUG
friend std::ostream& operator<<(std::ostream& os, qualifier_list const& list)
{
typename qual_vector::const_iterator
iter = list.M_qualifier_starts.begin();
if (iter != list.M_qualifier_starts.end())
{
os << "{ " << *iter;
while (++iter != list.M_qualifier_starts.end())
os << ", " << *iter;
os << " }";
}
else
os << "{ }";
return os;
}
#endif
};
struct implementation_details
{
private:
unsigned int M_style;
public:
// The following flags change the behaviour of the demangler. The
// default behaviour is that none of these flags is set.
static unsigned int const style_void = 1;
// Default behaviour: int f()
// Use (void) instead of (): int f(void)
static unsigned int const style_literal = 2;
// Default behaviour: (long)13,
// (unsigned long long)19
// Use extensions 'u', 'l' and 'll' for integral
// literals (as in template arguments): 13l, 19ull
static unsigned int const style_literal_int = 4;
// Default behaviour: 4
// Use also an explicit
// cast for int in literals: (int)4
static unsigned int const style_compact_expr_ops = 8;
// Default behaviour: (i) < (3), sizeof (int)
// Don't output spaces around
// operators in expressions: (i)<(3), sizeof(int)
static unsigned int const style_sizeof_typename = 16;
// Default behaviour: sizeof (X::t)
// Put 'typename' infront of <nested-name>
// types inside a 'sizeof': sizeof (typename X::t)
public:
implementation_details(unsigned int style_flags = 0) :
M_style(style_flags) { }
virtual ~implementation_details() { }
bool get_style_void(void) const
{ return (M_style & style_void); }
bool get_style_literal(void) const
{ return (M_style & style_literal); }
bool get_style_literal_int(void) const
{ return (M_style & style_literal_int); }
bool get_style_compact_expr_ops(void) const
{ return (M_style & style_compact_expr_ops); }
bool get_style_sizeof_typename(void) const
{ return (M_style & style_sizeof_typename); }
// This can be overridden by user implementations.
virtual bool decode_real(char* /* output */, unsigned long* /* input */,
size_t /* size_of_real */) const
{ return false; }
};
template<typename Tp, typename Allocator>
class session
{
public:
friend class qualifier_list<Tp, Allocator>;
typedef typename Allocator::template rebind<char>::other
char_Allocator;
typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
string_type;
private:
char const* M_str;
int M_pos;
int M_maxpos;
bool M_result;
int M_inside_template_args;
int M_inside_type;
int M_inside_substitution;
bool M_saw_destructor;
bool M_name_is_cdtor;
bool M_name_is_template;
bool M_name_is_conversion_operator;
bool M_template_args_need_space;
string_type M_function_name;
typedef typename Allocator::template rebind<int>::other
int_Allocator;
typedef typename Allocator::template rebind<substitution_st>::other
subst_Allocator;
std::vector<int, int_Allocator> M_template_arg_pos;
int M_template_arg_pos_offset;
std::vector<substitution_st, subst_Allocator> M_substitutions_pos;
implementation_details const& M_implementation_details;
typedef typename Allocator::template
rebind<qualifier_list<Allocator> >::other qualifier_list_Allocator;
qualifier_list_Allocator M_qualifier_list_alloc;
#if _GLIBCXX_DEMANGLER_CWDEBUG
bool M_inside_add_substitution;
#endif
public:
explicit session(char const* in, int len,
implementation_details const& id = implementation_details())
: M_str(in), M_pos(0), M_maxpos(len - 1), M_result(true),
M_inside_template_args(0), M_inside_type(0),
M_inside_substitution(0), M_saw_destructor(false),
M_name_is_cdtor(false), M_name_is_template(false),
M_name_is_conversion_operator(false),
M_template_args_need_space(false), M_template_arg_pos_offset(0),
M_implementation_details(id)
#if _GLIBCXX_DEMANGLER_CWDEBUG
, M_inside_add_substitution(false)
#endif
{ }
static int
decode_encoding(string_type& output, char const* input, int len,
implementation_details const& id = implementation_details());
bool
decode_type(string_type& output,
qualifier_list<Tp, Allocator>* qualifiers = NULL)
{
string_type postfix;
bool res = decode_type_with_postfix(output, postfix, qualifiers);
output += postfix;
return res;
}
bool
remaining_input_characters(void) const
{ return current() != 0; }
private:
char
current(void) const
{ return (M_pos > M_maxpos) ? 0 : M_str[M_pos]; }
char
next_peek(void) const
{ return (M_pos >= M_maxpos) ? 0 : M_str[M_pos + 1]; }
char
next(void)
{ return (M_pos >= M_maxpos) ? 0 : M_str[++M_pos]; }
char
eat_current(void)
{ return (M_pos > M_maxpos) ? 0 : M_str[M_pos++]; }
void
store(int& saved_pos)
{ saved_pos = M_pos; }
void
restore(int saved_pos)
{ M_pos = saved_pos; M_result = true; }
void
add_substitution(int start_pos,
substitution_nt sub_type,
int number_of_prefixes);
bool decode_type_with_postfix(string_type& prefix,
string_type& postfix, qualifier_list<Tp, Allocator>* qualifiers = NULL);
bool decode_bare_function_type(string_type& output);
bool decode_builtin_type(string_type& output);
bool decode_call_offset(string_type& output);
bool decode_class_enum_type(string_type& output);
bool decode_expression(string_type& output);
bool decode_literal(string_type& output);
bool decode_local_name(string_type& output);
bool decode_name(string_type& output,
string_type& nested_name_qualifiers);
bool decode_nested_name(string_type& output,
string_type& qualifiers);
bool decode_number(string_type& output);
bool decode_operator_name(string_type& output);
bool decode_source_name(string_type& output);
bool decode_substitution(string_type& output,
qualifier_list<Tp, Allocator>* qualifiers = NULL);
bool decode_template_args(string_type& output);
bool decode_template_param(string_type& output,
qualifier_list<Tp, Allocator>* qualifiers = NULL);
bool decode_unqualified_name(string_type& output);
bool decode_unscoped_name(string_type& output);
bool decode_non_negative_decimal_integer(string_type& output);
bool decode_special_name(string_type& output);
bool decode_real(string_type& output, size_t size_of_real);
};
template<typename Tp, typename Allocator>
#if !_GLIBCXX_DEMANGLER_CWDEBUG
inline
#endif
void
session<Tp, Allocator>::add_substitution(int start_pos,
substitution_nt sub_type,
int number_of_prefixes = 0)
{
if (!M_inside_substitution)
{
#if _GLIBCXX_DEMANGLER_CWDEBUG
if (M_inside_add_substitution)
return;
#endif
M_substitutions_pos.
push_back(substitution_st(start_pos,
sub_type, number_of_prefixes));
#if _GLIBCXX_DEMANGLER_CWDEBUG
if (!DEBUGCHANNELS::dc::demangler.is_on())
return;
string_type substitution_name("S");
int n = M_substitutions_pos.size() - 1;
if (n > 0)
substitution_name += (n <= 10) ? (char)(n + '0' - 1)
: (char)(n + 'A' - 11);
substitution_name += '_';
string_type subst;
int saved_pos = M_pos;
M_pos = start_pos;
M_inside_add_substitution = true;
_GLIBCXX_DEMANGLER_DEBUG( dc::demangler.off() );
switch(sub_type)
{
case type:
decode_type(subst);
break;
case template_template_param:
decode_template_param(subst);
break;
case nested_name_prefix:
case nested_name_template_prefix:
for (int cnt = number_of_prefixes; cnt > 0; --cnt)
{
if (current() == 'I')
{
subst += ' ';
decode_template_args(subst);
}
else
{
if (cnt < number_of_prefixes)
subst += "::";
if (current() == 'S')
decode_substitution(subst);
else if (current() == 'T')
decode_template_param(subst);
else
decode_unqualified_name(subst);
}
}
break;
case unscoped_template_name:
decode_unscoped_name(subst);
break;
}
M_pos = saved_pos;
_GLIBCXX_DEMANGLER_DEBUG( dc::demangler.on() );
_GLIBCXX_DEMANGLER_DOUT(dc::demangler,
"Adding substitution " << substitution_name
<< " : " << subst
<< " (from " << location_ct((char*)__builtin_return_address(0)
+ builtin_return_address_offset)
<< " <- " << location_ct((char*)__builtin_return_address(1)
+ builtin_return_address_offset)
<< " <- " << location_ct((char*)__builtin_return_address(2)
+ builtin_return_address_offset)
<< ").");
M_inside_add_substitution = false;
#endif
}
}
// We don't want to depend on locale (or include <cctype> for that matter).
// We also don't want to use "safe-ctype.h" because that headerfile is not
// available to the users.
inline bool isdigit(char c) { return c >= '0' && c <= '9'; }
inline bool islower(char c) { return c >= 'a' && c <= 'z'; }
inline bool isupper(char c) { return c >= 'A' && c <= 'Z'; }
inline char tolower(char c) { return isupper(c) ? c - 'A' + 'a' : c; }
//
// <non-negative decimal integer> ::= 0
// ::= 1|2|3|4|5|6|7|8|9 [<digit>+]
// <digit> ::= 0|1|2|3|4|5|6|7|8|9
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::
decode_non_negative_decimal_integer(string_type& output)
{
char c = current();
if (c == '0')
{
output += '0';
eat_current();
}
else if (!isdigit(c))
M_result = false;
else
{
do
{
output += c;
}
while (isdigit((c = next())));
}
return M_result;
}
// <number> ::= [n] <non-negative decimal integer>
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_number(string_type& output)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_number");
if (current() != 'n')
decode_non_negative_decimal_integer(output);
else
{
output += '-';
eat_current();
decode_non_negative_decimal_integer(output);
}
_GLIBCXX_DEMANGLER_RETURN;
}
// <builtin-type> ::= v # void
// ::= w # wchar_t
// ::= b # bool
// ::= c # char
// ::= a # signed char
// ::= h # unsigned char
// ::= s # short
// ::= t # unsigned short
// ::= i # int
// ::= j # unsigned int
// ::= l # long
// ::= m # unsigned long
// ::= x # long long, __int64
// ::= y # unsigned long long, __int64
// ::= n # __int128
// ::= o # unsigned __int128
// ::= f # float
// ::= d # double
// ::= e # long double, __float80
// ::= g # __float128
// ::= z # ellipsis
// ::= u <source-name> # vendor extended type
//
char const* const builtin_type_c[26] =
{
"signed char", // a
"bool", // b
"char", // c
"double", // d
"long double", // e
"float", // f
"__float128", // g
"unsigned char", // h
"int", // i
"unsigned int", // j
NULL, // k
"long", // l
"unsigned long", // m
"__int128", // n
"unsigned __int128", // o
NULL, // p
NULL, // q
NULL, // r
"short", // s
"unsigned short", // t
NULL, // u
"void", // v
"wchar_t", // w
"long long", // x
"unsigned long long", // y
"..." // z
};
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_builtin_type(string_type& output)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_builtin_type");
char const* bt;
if (!islower(current()) || !(bt = builtin_type_c[current() - 'a']))
_GLIBCXX_DEMANGLER_FAILURE;
output += bt;
eat_current();
_GLIBCXX_DEMANGLER_RETURN;
}
// <class-enum-type> ::= <name>
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_class_enum_type(string_type& output)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_class_enum_type");
string_type nested_name_qualifiers;
if (!decode_name(output, nested_name_qualifiers))
_GLIBCXX_DEMANGLER_FAILURE;
output += nested_name_qualifiers;
_GLIBCXX_DEMANGLER_RETURN;
}
// <substitution> ::=
// S <seq-id> _
// S_
// St # ::std::
// Sa # ::std::allocator
// Sb # ::std::basic_string
// Ss # ::std::basic_string<char, std::char_traits<char>,
// std::allocator<char> >
// Si # ::std::basic_istream<char, std::char_traits<char> >
// So # ::std::basic_ostream<char, std::char_traits<char> >
// Sd # ::std::basic_iostream<char, std::char_traits<char> >
//
// <seq-id> ::=
// 0|1|2|3|4|5|6|7|8|9|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z
// [<seq-id>] # Base 36 number
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_substitution(string_type& output,
qualifier_list<Tp, Allocator>* qualifiers)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_substitution");
unsigned int value = 0;
char c = next();
if (c != '_')
{
switch(c)
{
case 'a':
{
output += "std::allocator";
if (!M_inside_template_args)
{
M_function_name = "allocator";
M_name_is_template = true;
M_name_is_cdtor = false;
M_name_is_conversion_operator = false;
}
eat_current();
if (qualifiers)
qualifiers->printing_suppressed();
_GLIBCXX_DEMANGLER_RETURN;
}
case 'b':
{
output += "std::basic_string";
if (!M_inside_template_args)
{
M_function_name = "basic_string";
M_name_is_template = true;
M_name_is_cdtor = false;
M_name_is_conversion_operator = false;
}
eat_current();
if (qualifiers)
qualifiers->printing_suppressed();
_GLIBCXX_DEMANGLER_RETURN;
}
case 'd':
output += "std::iostream";
if (!M_inside_template_args)
{
M_function_name = "iostream";
M_name_is_template = true;
M_name_is_cdtor = false;
M_name_is_conversion_operator = false;
}
eat_current();
if (qualifiers)
qualifiers->printing_suppressed();
_GLIBCXX_DEMANGLER_RETURN;
case 'i':
output += "std::istream";
if (!M_inside_template_args)
{
M_function_name = "istream";
M_name_is_template = true;
M_name_is_cdtor = false;
M_name_is_conversion_operator = false;
}
eat_current();
if (qualifiers)
qualifiers->printing_suppressed();
_GLIBCXX_DEMANGLER_RETURN;
case 'o':
output += "std::ostream";
if (!M_inside_template_args)
{
M_function_name = "ostream";
M_name_is_template = true;
M_name_is_cdtor = false;
M_name_is_conversion_operator = false;
}
eat_current();
if (qualifiers)
qualifiers->printing_suppressed();
_GLIBCXX_DEMANGLER_RETURN;
case 's':
output += "std::string";
if (!M_inside_template_args)
{
M_function_name = "string";
M_name_is_template = true;
M_name_is_cdtor = false;
M_name_is_conversion_operator = false;
}
eat_current();
if (qualifiers)
qualifiers->printing_suppressed();
_GLIBCXX_DEMANGLER_RETURN;
case 't':
output += "std";
eat_current();
if (qualifiers)
qualifiers->printing_suppressed();
_GLIBCXX_DEMANGLER_RETURN;
default:
for(;; c = next())
{
if (isdigit(c))
value = value * 36 + c - '0';
else if (isupper(c))
value = value * 36 + c - 'A' + 10;
else if (c == '_')
break;
else
_GLIBCXX_DEMANGLER_FAILURE;
}
++value;
break;
}
}
eat_current();
if (value >= M_substitutions_pos.size() ||
M_inside_type > 20) // Rather than core dump.
_GLIBCXX_DEMANGLER_FAILURE;
++M_inside_substitution;
int saved_pos = M_pos;
substitution_st& substitution(M_substitutions_pos[value]);
M_pos = substitution.M_start_pos;
switch(substitution.M_type)
{
case type:
decode_type(output, qualifiers);
break;
case template_template_param:
decode_template_param(output, qualifiers);
break;
case nested_name_prefix:
case nested_name_template_prefix:
for (int cnt = substitution.M_number_of_prefixes; cnt > 0; --cnt)
{
if (current() == 'I')
{
if (M_template_args_need_space)
output += ' ';
M_template_args_need_space = false;
if (!decode_template_args(output))
_GLIBCXX_DEMANGLER_FAILURE;
}
else
{
if (cnt < substitution.M_number_of_prefixes)
output += "::";
if (current() == 'S')
{
if (!decode_substitution(output))
_GLIBCXX_DEMANGLER_FAILURE;
}
else if (!decode_unqualified_name(output))
_GLIBCXX_DEMANGLER_FAILURE;
}
}
if (qualifiers)
qualifiers->printing_suppressed();
break;
case unscoped_template_name:
decode_unscoped_name(output);
if (qualifiers)
qualifiers->printing_suppressed();
break;
}
M_pos = saved_pos;
--M_inside_substitution;
_GLIBCXX_DEMANGLER_RETURN;
}
// <template-param> ::= T_ # first template parameter
// ::= T <parameter-2 non-negative number> _
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_template_param(string_type& output,
qualifier_list<Tp, Allocator>* qualifiers)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_template_parameter");
if (current() != 'T')
_GLIBCXX_DEMANGLER_FAILURE;
unsigned int value = 0;
char c;
if ((c = next()) != '_')
{
while(isdigit(c))
{
value = value * 10 + c - '0';
c = next();
}
++value;
}
if (eat_current() != '_')
_GLIBCXX_DEMANGLER_FAILURE;
value += M_template_arg_pos_offset;
if (value >= M_template_arg_pos.size())
_GLIBCXX_DEMANGLER_FAILURE;
int saved_pos = M_pos;
M_pos = M_template_arg_pos[value];
if (M_inside_type > 20) // Rather than core dump.
_GLIBCXX_DEMANGLER_FAILURE;
++M_inside_substitution;
if (current() == 'X')
{
eat_current();
decode_expression(output);
}
else if (current() == 'L')
decode_literal(output);
else
decode_type(output, qualifiers);
--M_inside_substitution;
M_pos = saved_pos;
_GLIBCXX_DEMANGLER_RETURN;
}
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_real(string_type& output, size_t size_of_real)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_real");
unsigned long words[4]; // 32 bit per long, maximum of 128 bits.
unsigned long* word = &words[0];
int saved_pos;
store(saved_pos);
// The following assumes that leading zeroes are also included in the
// mangled name, I am not sure that is conforming to the C++-ABI, but
// it is what g++ does.
unsigned char nibble, c = current();
for(size_t word_cnt = size_of_real / 4; word_cnt > 0; --word_cnt)
{
for (int nibble_cnt = 0; nibble_cnt < 8; ++nibble_cnt)
{
// Translate character into nibble.
if (c < '0' || c > 'f')
_GLIBCXX_DEMANGLER_FAILURE;
if (c <= '9')
nibble = c - '0';
else if (c >= 'a')
nibble = c - 'a' + 10;
else
_GLIBCXX_DEMANGLER_FAILURE;
// Write nibble into word array.
if (nibble_cnt == 0)
*word = nibble << 28;
else
*word |= (nibble << (28 - 4 * nibble_cnt));
c = next();
}
++word;
}
char buf[24];
if (M_implementation_details.decode_real(buf, words, size_of_real))
{
output += buf;
_GLIBCXX_DEMANGLER_RETURN;
}
restore(saved_pos);
output += '[';
c = current();
for(size_t nibble_cnt = 0; nibble_cnt < 2 * size_of_real; ++nibble_cnt)
{
if (c < '0' || c > 'f' || (c > '9' && c < 'a'))
_GLIBCXX_DEMANGLER_FAILURE;
output += c;
c = next();
}
output += ']';
_GLIBCXX_DEMANGLER_RETURN;
}
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_literal(string_type& output)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_literal");
eat_current(); // Eat the 'L'.
if (current() == '_')
{
if (next() != 'Z')
_GLIBCXX_DEMANGLER_FAILURE;
eat_current();
if ((M_pos += decode_encoding(output, M_str + M_pos,
M_maxpos - M_pos + 1, M_implementation_details)) < 0)
_GLIBCXX_DEMANGLER_FAILURE;
}
else
{
// Special cases
if (current() == 'b')
{
if (next() == '0')
output += "false";
else
output += "true";
eat_current();
_GLIBCXX_DEMANGLER_RETURN;
}
char c = current();
if ((c == 'i' || c == 'j' || c == 'l' ||
c == 'm' || c == 'x' || c == 'y') &&
M_implementation_details.get_style_literal())
eat_current();
else if (c == 'i' &&
!M_implementation_details.get_style_literal_int())
eat_current();
else
{
output += '(';
if (!decode_type(output))
_GLIBCXX_DEMANGLER_FAILURE;
output += ')';
}
if (c >= 'd' && c <= 'g')
{
size_t size_of_real = (c == 'd') ? sizeof(double) :
((c == 'f') ? sizeof(float) :
(c == 'e') ? sizeof(long double) : 16);
if (!decode_real(output, size_of_real))
_GLIBCXX_DEMANGLER_FAILURE;
}
else if (!decode_number(output))
_GLIBCXX_DEMANGLER_FAILURE;
if (M_implementation_details.get_style_literal())
{
if (c == 'j' || c == 'm' || c == 'y')
output += 'u';
if (c == 'l' || c == 'm')
output += 'l';
if (c == 'x' || c == 'y')
output += "ll";
}
}
_GLIBCXX_DEMANGLER_RETURN;
}
// <operator-name> ::=
// nw # new
// na # new[]
// dl # delete
// da # delete[]
// ps # + (unary)
// ng # - (unary)
// ad # & (unary)
// de # * (unary)
// co # ~
// pl # +
// mi # -
// ml # *
// dv # /
// rm # %
// an # &
// or # |
// eo # ^
// aS # =
// pL # +=
// mI # -=
// mL # *=
// dV # /=
// rM # %=
// aN # &=
// oR # |=
// eO # ^=
// ls # <<
// rs # >>
// lS # <<=
// rS # >>=
// eq # ==
// ne # !=
// lt # <
// gt # >
// le # <=
// ge # >=
// nt # !
// aa # &&
// oo # ||
// pp # ++
// mm # --
// cm # ,
// pm # ->*
// pt # ->
// cl # ()
// ix # []
// qu # ?
// st # sizeof (a type)
// sz # sizeof (an expression)
// cv <type> # (cast)
// v <digit> <source-name> # vendor extended operator
//
// Symbol operator codes exist of two characters, we need to find a
// quick hash so that their names can be looked up in a table.
//
// The puzzle :)
// Shift the rows so that there is at most one character per column.
//
// A perfect solution (Oh no, it's THE MATRIX!):
// horizontal
// ....................................... offset + 'a'
// a, a||d|||||||||n||||s|||||||||||||||||||| 0
// c, || |||||||lm o||| |||||||||||||||||||| 0
// d, || a|||e|| l|| ||||||v||||||||||||| 4
// e, || ||| || || |||o|q ||||||||||||| 8
// g, || ||| || || e|| | ||||||||t|||| 15
// i, || ||| || || || | |||||||| |||x 15
// l, |e ||| || st || | |||||||| ||| -2
// m, | |i| lm || | |||||||| ||| -2
// n, a e g t| w |||||||| ||| 1
// o, | ||||o||r ||| 16
// p, | ||lm |p st| 17
// q, | u| | | 6
// r, m s | | 9
// s, t z 12
// .......................................
// ^ ^__ second character
// |___ first character
//
// Putting that solution in tables:
char const offset_table_c [1 + CHAR_MAX - CHAR_MIN ] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
#if (CHAR_MIN < 0)
// Add -CHAR_MIN extra zeroes (128):
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// a b c d e f g h i j k
0, -97, 0, -97, -93, -89, 0, -82, 0, -82, 0, 0,
// l m n o p q r s t u v
-99, -99, -96, -81, -80, -91, -88, -85, 0, 0, 0,
#else
// a b c d e f g h i j k
0, 159, 0, 159, 163, 167, 0, 174, 0, 174, 0, 0,
// l m n o p q r s t u v
157, 157, 160, 175, 176, 165, 168, 171, 0, 0, 0,
#endif
// ... more zeros
};
enum xary_nt {
unary,
binary,
trinary
};
struct entry_st
{
char const* opcode;
char const* symbol_name;
xary_nt type;
};
entry_st const symbol_name_table_c[39] = {
{ "aa", "operator&&", binary },
{ "na", "operator new[]", unary },
{ "le", "operator<=", binary },
{ "ad", "operator&", unary },
{ "da", "operator delete[]", unary },
{ "ne", "operator!=", binary },
{ "mi=", "operator-", binary },
{ "ng", "operator-", unary },
{ "de", "operator*", unary },
{ "ml=", "operator*", binary },
{ "mm", "operator--", unary },
{ "cl", "operator()", unary },
{ "cm", "operator,", binary },
{ "an=", "operator&", binary },
{ "co", "operator~", binary },
{ "dl", "operator delete", unary },
{ "ls=", "operator<<", binary },
{ "lt", "operator<", binary },
{ "as=", "operator", binary },
{ "ge", "operator>=", binary },
{ "nt", "operator!", unary },
{ "rm=", "operator%", binary },
{ "eo=", "operator^", binary },
{ "nw", "operator new", unary },
{ "eq", "operator==", binary },
{ "dv=", "operator/", binary },
{ "qu", "operator?", trinary },
{ "rs=", "operator>>", binary },
{ "pl=", "operator+", binary },
{ "pm", "operator->*", binary },
{ "oo", "operator||", binary },
{ "st", "sizeof", unary },
{ "pp", "operator++", unary },
{ "or=", "operator|", binary },
{ "gt", "operator>", binary },
{ "ps", "operator+", unary },
{ "pt", "operator->", binary },
{ "sz", "sizeof", unary },
{ "ix", "operator[]", unary }
};
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_operator_name(string_type& output)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_operator_name");
char opcode0 = current();
char opcode1 = tolower(next());
register char hash;
if ((hash = offset_table_c[opcode0 - CHAR_MIN]))
{
hash += opcode1;
if (
#if (CHAR_MIN < 0)
hash >= 0 &&
#endif
hash < 39)
{
int index = static_cast<int>(static_cast<unsigned char>(hash));
entry_st entry = symbol_name_table_c[index];
if (entry.opcode[0] == opcode0 && entry.opcode[1] == opcode1
&& (opcode1 == current() || entry.opcode[2] == '='))
{
output += entry.symbol_name;
if (opcode1 != current())
output += '=';
eat_current();
if (hash == 16 || hash == 17)
M_template_args_need_space = true;
_GLIBCXX_DEMANGLER_RETURN;
}
else if (opcode0 == 'c' && opcode1 == 'v') // casting operator
{
eat_current();
output += "operator ";
if (current() == 'T')
{
// This is a templated cast operator.
// It must be of the form "cvT_I...E".
// Let M_template_arg_pos already point
// to the template argument.
M_template_arg_pos_offset = M_template_arg_pos.size();
M_template_arg_pos.push_back(M_pos + 3);
}
if (!decode_type(output))
_GLIBCXX_DEMANGLER_FAILURE;
if (!M_inside_template_args)
M_name_is_conversion_operator = true;
_GLIBCXX_DEMANGLER_RETURN;
}
}
}
_GLIBCXX_DEMANGLER_FAILURE;
}
//
// <expression> ::= <unary operator-name> <expression>
// ::= <binary operator-name> <expression> <expression>
// ::= <trinary operator-name> <expression> <expression> <expression>
// ::= st <type>
// ::= <template-param>
// ::= sr <type> <unqualified-name> # dependent name
// ::= sr <type> <unqualified-name> <template-args> # dependent template-id
// ::= <expr-primary>
//
// <expr-primary> ::= L <type> <value number> E # integer literal
// ::= L <type> <value float> E # floating literal
// ::= L <mangled-name> E # external name
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_expression(string_type& output)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_expression");
if (current() == 'T')
{
if (!decode_template_param(output))
_GLIBCXX_DEMANGLER_FAILURE;
_GLIBCXX_DEMANGLER_RETURN;
}
else if (current() == 'L')
{
if (!decode_literal(output))
_GLIBCXX_DEMANGLER_FAILURE;
if (current() != 'E')
_GLIBCXX_DEMANGLER_FAILURE;
eat_current();
_GLIBCXX_DEMANGLER_RETURN;
}
else if (current() == 's')
{
char opcode1 = next();
if (opcode1 == 't' || opcode1 == 'z')
{
eat_current();
if (M_implementation_details.get_style_compact_expr_ops())
output += "sizeof(";
else
output += "sizeof (";
if (opcode1 == 't')
{
// I cannot think of a mangled name that is valid for both cases
// when just replacing the 't' by a 'z' or vica versa, which
// indicates that there is no ambiguity that dictates the need
// for a seperate "st" case, except to be able catch invalid
// mangled names. However there CAN be ambiguity in the demangled
// name when there are both a type and a symbol of the same name,
// which then leads to different encoding (of course) with
// sizeof (type) or sizeof (expression) respectively, but that
// ambiguity is not per se related to "sizeof" except that that
// is the only place where both a type AND an expression are valid
// in as part of a (template function) type.
//
// Example:
//
// struct B { typedef int t; };
// struct A : public B { static int t[2]; };
// template<int i, int j> struct C { typedef int q; };
// template<int i, typename T>
// void f(typename C<sizeof (typename T::t),
// sizeof (T::t)>::q) { }
// void instantiate() { f<5, A>(0); }
//
// Leads to _Z1fILi5E1AEvN1CIXstN1T1tEEXszsrS2_1tEE1qE which
// demangles as
// void f<5, A>(C<sizeof (T::t), sizeof (T::t)>::q)
//
// This is ambiguity is very unlikely to happen and it is kind
// of fuzzy to detect when adding a 'typename' makes sense.
//
if (M_implementation_details.get_style_sizeof_typename())
{
// We can only get here inside a template parameter,
// so this is syntactically correct if the given type is
// a typedef. The only disadvantage is that it is inconsistent
// with all other places where the 'typename' keyword should be
// used and we don't.
// With this, the above example will demangle as
// void f<5, A>(C<sizeof (typename T::t), sizeof (T::t)>::q)
if (current() == 'N' || // <nested-name>
// This should be a safe bet.
(current() == 'S' &&
next_peek() == 't')) // std::something, guess that
// this involves a typedef.
output += "typename ";
}
if (!decode_type(output))
_GLIBCXX_DEMANGLER_FAILURE;
}
else
{
if (!decode_expression(output))
_GLIBCXX_DEMANGLER_FAILURE;
}
output += ')';
_GLIBCXX_DEMANGLER_RETURN;
}
else if (current() == 'r')
{
eat_current();
if (!decode_type(output))
_GLIBCXX_DEMANGLER_FAILURE;
output += "::";
if (!decode_unqualified_name(output))
_GLIBCXX_DEMANGLER_FAILURE;
if (current() != 'I' || decode_template_args(output))
_GLIBCXX_DEMANGLER_RETURN;
}
}
else
{
char opcode0 = current();
char opcode1 = tolower(next());
register char hash;
if ((hash = offset_table_c[opcode0 - CHAR_MIN]))
{
hash += opcode1;
if (
#if (CHAR_MIN < 0)
hash >= 0 &&
#endif
hash < 39)
{
int index = static_cast<int>(static_cast<unsigned char>(hash));
entry_st entry = symbol_name_table_c[index];
if (entry.opcode[0] == opcode0 && entry.opcode[1] == opcode1
&& (opcode1 == current() || entry.opcode[2] == '='))
{
char const* op = entry.symbol_name + 8; // Skip "operator".
if (*op == ' ') // operator new and delete.
++op;
if (entry.type == unary)
output += op;
bool is_eq = (opcode1 != current());
eat_current();
if (index == 34 && M_inside_template_args) // operator>
output += '(';
output += '(';
if (!decode_expression(output))
_GLIBCXX_DEMANGLER_FAILURE;
output += ')';
if (entry.type != unary)
{
if (!M_implementation_details.get_style_compact_expr_ops())
output += ' ';
output += op;
if (is_eq)
output += '=';
if (!M_implementation_details.get_style_compact_expr_ops())
output += ' ';
output += '(';
if (!decode_expression(output))
_GLIBCXX_DEMANGLER_FAILURE;
output += ')';
if (index == 34 && M_inside_template_args)
output += ')';
if (entry.type == trinary)
{
if (M_implementation_details.get_style_compact_expr_ops())
output += ":(";
else
output += " : (";
if (!decode_expression(output))
_GLIBCXX_DEMANGLER_FAILURE;
output += ')';
}
}
_GLIBCXX_DEMANGLER_RETURN;
}
else if (opcode0 == 'c' &&
opcode1 == 'v') // casting operator.
{
eat_current();
output += '(';
if (!decode_type(output))
_GLIBCXX_DEMANGLER_FAILURE;
output += ")(";
if (!decode_expression(output))
_GLIBCXX_DEMANGLER_FAILURE;
output += ')';
_GLIBCXX_DEMANGLER_RETURN;
}
}
}
}
_GLIBCXX_DEMANGLER_FAILURE;
}
//
// <template-args> ::= I <template-arg>+ E
// <template-arg> ::= <type> # type or template
// ::= L <type> <value number> E # integer literal
// ::= L <type> <value float> E # floating literal
// ::= L <mangled-name> E # external name
// ::= X <expression> E # expression
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_template_args(string_type& output)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_template_args");
if (eat_current() != 'I')
_GLIBCXX_DEMANGLER_FAILURE;
int prev_size = M_template_arg_pos.size();
++M_inside_template_args;
if (M_template_args_need_space)
{
output += ' ';
M_template_args_need_space = false;
}
output += '<';
for(;;)
{
if (M_inside_template_args == 1 && !M_inside_type)
M_template_arg_pos.push_back(M_pos);
if (current() == 'X')
{
eat_current();
if (!decode_expression(output))
_GLIBCXX_DEMANGLER_FAILURE;
if (current() != 'E')
_GLIBCXX_DEMANGLER_FAILURE;
eat_current();
}
else if (current() == 'L')
{
if (!decode_literal(output))
_GLIBCXX_DEMANGLER_FAILURE;
if (current() != 'E')
_GLIBCXX_DEMANGLER_FAILURE;
eat_current();
}
else if (!decode_type(output))
_GLIBCXX_DEMANGLER_FAILURE;
if (current() == 'E')
break;
output += ", ";
}
eat_current();
if (*(output.rbegin()) == '>')
output += ' ';
output += '>';
--M_inside_template_args;
if (!M_inside_template_args && !M_inside_type)
{
M_name_is_template = true;
M_template_arg_pos_offset = prev_size;
}
_GLIBCXX_DEMANGLER_RETURN;
}
// <bare-function-type> ::=
// <signature type>+ # Types are parameter types.
//
// Note that the possible return type of the <bare-function-type>
// has already been eaten before we call this function. This makes
// our <bare-function-type> slightly different from the one in
// the C++-ABI description.
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_bare_function_type(string_type& output)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_bare_function_type");
if (M_saw_destructor)
{
if (eat_current() != 'v' || (current() != 'E' && current() != 0))
_GLIBCXX_DEMANGLER_FAILURE;
output += "()";
M_saw_destructor = false;
_GLIBCXX_DEMANGLER_RETURN;
}
if (current() == 'v' && !M_implementation_details.get_style_void())
{
eat_current();
if (current() != 'E' && current() != 0)
_GLIBCXX_DEMANGLER_FAILURE;
output += "()";
M_saw_destructor = false;
_GLIBCXX_DEMANGLER_RETURN;
}
output += '(';
M_template_args_need_space = false;
if (!decode_type(output)) // Must have at least one parameter.
_GLIBCXX_DEMANGLER_FAILURE;
while (current() != 'E' && current() != 0)
{
output += ", ";
if (!decode_type(output))
_GLIBCXX_DEMANGLER_FAILURE;
}
output += ')';
_GLIBCXX_DEMANGLER_RETURN;
}
// <type> ::=
// <builtin-type> # Starts with a lower case character != r.
// <function-type> # Starts with F
// <class-enum-type> # Starts with N, S, C, D, Z, a digit or a lower
// # case character. Since a lower case character
// # would be an operator name, that would be an
// # error. The S is a substitution or St
// # (::std::). A 'C' would be a constructor and
// # thus also an error.
// <template-param> # Starts with T
// <substitution> # Starts with S
// <template-template-param> <template-args> # Starts with T or S,
// # equivalent with the above.
//
// <array-type> # Starts with A
// <pointer-to-member-type> # Starts with M
// <CV-qualifiers> <type> # Starts with r, V or K
// P <type> # pointer-to # Starts with P
// R <type> # reference-to # Starts with R
// C <type> # complex (C 2000) # Starts with C
// G <type> # imaginary (C 2000)# Starts with G
// U <source-name> <type> # vendor extended type qualifier,
// # starts with U
//
// <template-template-param> ::= <template-param>
// ::= <substitution>
// My own analysis of how to decode qualifiers:
//
// F is a <function-type>, <T> is a <builtin-type>, <class-enum-type>,
// <template-param> or <template-template-param> <template-args>.
// <Q> represents a series of qualifiers (not G or C).
// <C> is an unqualified type.
// <R> is a qualified type.
// <B> is the bare-function-type without return type.
// <I> is the array index.
// Substitutions:
// <Q>M<C><Q2>F<R><B>E ==> R (C::*Q)B Q2 "<C>", "F<R><B>E"
// (<R> and <B> recursive),
// "M<C><Q2>F<R><B>E".
// <Q>F<R><B>E ==> R (Q)B "<R>", "<B>" (<B> recursive)
// and "F<R><B>E".
//
// Note that if <R> has postfix qualifiers (an array or function), then
// those are added AFTER the (member) function type. For example:
// <Q>FPA<R><B>E ==> R (*(Q)B) [], where the PA added the prefix
// "(*" and the postfix ") []".
//
// <Q>G<T> ==> imaginary T Q "<T>", "G<T>" (<T> recursive).
// <Q>C<T> ==> complex T Q "<T>", "C<T>" (<T> recursive).
// <Q><T> ==> T Q "<T>" (<T> recursive).
//
// where <Q> is any of:
//
// <Q>P ==> *Q "P..."
// <Q>R ==> &Q "R..."
// <Q>[K|V|r]+ ==> [ const| volatile| restrict]+Q "KVr..."
// <Q>U<S> ==> SQ "U<S>..."
// <Q>M<C> ==> C::*Q "M<C>..." (<C> recurs.)
// A<I> ==> [I] "A<I>..." (<I> recurs.)
// <Q>A<I> ==> (Q) [I] "A<I>..." (<I> recurs.)
// Note that when <Q> ends on an A<I2> then the brackets are omitted
// and no space is written between the two:
// A<I2>A<I> ==> [I2][I]
// If <Q> ends on [KVr]+, which can happen in combination with
// substitutions only, then special handling is required, see below.
//
// A <substitution> is handled with an input position switch during which
// new substitutions are turned off. Because recursive handling of types
// (and therefore the order in which substitutions must be generated) must
// be done left to right, but the generation of Q needs processing right to
// left, substitutions per <type> are generated by reading the input left
// to right and marking the starts of all substitutions only - implicitly
// finishing them at the end of the type. Then the output and real
// substitutions are generated.
//
// The following comment was for the demangling of g++ version 3.0.x. The
// mangling (and I believe even the ABI description) have been fixed now
// (as of g++ version 3.1).
//
// g++ 3.0.x only:
// The ABI specifies for pointer-to-member function types the format
// <Q>M<T>F<R><B>E. In other words, the qualifier <Q2> (see above) is
// implicitely contained in <T> instead of explicitly part of the M format.
// I am convinced that this is a bug in the ABI. Unfortunately, this is
// how we have to demangle things as it has a direct impact on the order
// in which substitutions are stored. This ill-formed design results in
// rather ill-formed demangler code too however :/
//
// <Q2> is now explicitely part of the M format.
// For some weird reason, g++ (3.2.1) does not add substitutions for
// qualified member function pointers. I think that is another bug.
//
// In the case of
// <Q>A<I>
// where <Q> ends on [K|V|r]+ then that part should be processed as
// if it was behind the A<I> instead of in front of it. This is
// because a constant array of ints is normally always mangled as
// an array of constant ints. KVr qualifiers can end up in front
// of an array when the array is part of a substitution or template
// parameter, but the demangling should still result in the same
// syntax; thus KA2_i (const array of ints) must result in the same
// demangling as A2_Ki (array of const ints). As a result we must
// demangle ...[...[[KVr]+A<I0>][KVr]+A<I1>]...[KVr]+A<In>[KVr]+
// as A<I0>A<I1>...A<In>[KVr]+ where each K, V and r in the series
// collapses to a single character at the right of the string.
// For example:
// VA9_KrA6_KVi --> A9_A6_KVri --> int volatile const restrict [9][6]
// Note that substitutions are still added as usual (the translation
// to A9_A6_KVri does not really happen).
//
// This decoding is achieved by delaying the decoding of any sequence
// of [KVrA]'s and processing them together in the order: first the
// short-circuited KVr part and then the arrays.
static int const cvq_K = 1; // Saw at least one K
static int const cvq_V = 2; // Saw at least one V
static int const cvq_r = 4; // Saw at least one r
static int const cvq_A = 8; // Saw at least one A
static int const cvq_last = 16; // No remaining qualifiers.
static int const cvq_A_cnt = 32; // Bit 5 and higher represent the
// number of A's in the series.
// In the function below, iter_array points to the first (right most)
// A in the series, if any.
template<typename Tp, typename Allocator>
void
qualifier_list<Tp, Allocator>::decode_KVrA(
string_type& prefix, string_type& postfix, int cvq,
typename qual_vector::const_reverse_iterator const& iter_array) const
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING3("decode_KVrA");
if ((cvq & cvq_K))
prefix += " const";
if ((cvq & cvq_V))
prefix += " volatile";
if ((cvq & cvq_r))
prefix += " restrict";
if ((cvq & cvq_A))
{
int n = cvq >> 5;
for (typename qual_vector::
const_reverse_iterator iter = iter_array;
iter != M_qualifier_starts.rend(); ++iter)
{
switch((*iter).first_qualifier())
{
case 'K':
case 'V':
case 'r':
break;
case 'A':
{
string_type index = (*iter).get_optional_type();
if (--n == 0 && (cvq & cvq_last))
postfix = " [" + index + "]" + postfix;
else if (n > 0)
postfix = "[" + index + "]" + postfix;
else
{
prefix += " (";
postfix = ") [" + index + "]" + postfix;
}
break;
}
default:
_GLIBCXX_DEMANGLER_RETURN3;
}
}
}
_GLIBCXX_DEMANGLER_RETURN3;
}
template<typename Tp, typename Allocator>
void
qualifier_list<Tp, Allocator>::decode_qualifiers(
string_type& prefix,
string_type& postfix,
bool member_function_pointer_qualifiers = false) const
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING3("decode_qualifiers");
int cvq = 0;
typename qual_vector::const_reverse_iterator iter_array;
for(typename qual_vector::
const_reverse_iterator iter = M_qualifier_starts.rbegin();
iter != M_qualifier_starts.rend(); ++iter)
{
if (!member_function_pointer_qualifiers
&& !(*iter).part_of_substitution())
{
int saved_inside_substitution = M_demangler.M_inside_substitution;
M_demangler.M_inside_substitution = 0;
M_demangler.add_substitution((*iter).get_start_pos(), type);
M_demangler.M_inside_substitution = saved_inside_substitution;
}
char qualifier_char = (*iter).first_qualifier();
for(; qualifier_char; qualifier_char = (*iter).next_qualifier())
{
switch(qualifier_char)
{
case 'P':
if (cvq)
{
decode_KVrA(prefix, postfix, cvq, iter_array);
cvq = 0;
}
prefix += "*";
break;
case 'R':
if (cvq)
{
decode_KVrA(prefix, postfix, cvq, iter_array);
cvq = 0;
}
prefix += "&";
break;
case 'K':
cvq |= cvq_K;
continue;
case 'V':
cvq |= cvq_V;
continue;
case 'r':
cvq |= cvq_r;
continue;
case 'A':
if (!(cvq & cvq_A))
{
cvq |= cvq_A;
iter_array = iter;
}
cvq += cvq_A_cnt;
break;
case 'M':
if (cvq)
{
decode_KVrA(prefix, postfix, cvq, iter_array);
cvq = 0;
}
prefix += " ";
prefix += (*iter).get_optional_type();
prefix += "::*";
break;
case 'U':
if (cvq)
{
decode_KVrA(prefix, postfix, cvq, iter_array);
cvq = 0;
}
prefix += " ";
prefix += (*iter).get_optional_type();
break;
case 'G': // Only here so we added a substitution.
break;
}
break;
}
}
if (cvq)
decode_KVrA(prefix, postfix, cvq|cvq_last, iter_array);
M_printing_suppressed = false;
_GLIBCXX_DEMANGLER_RETURN3;
}
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_type_with_postfix(
string_type& prefix, string_type& postfix,
qualifier_list<Tp, Allocator>* qualifiers)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING2("decode_type");
++M_inside_type;
bool recursive_template_param_or_substitution_call;
if (!(recursive_template_param_or_substitution_call = qualifiers))
{
qualifier_list<Allocator>* raw_qualifiers = M_qualifier_list_alloc.allocate(1);
qualifiers = new (raw_qualifiers) qualifier_list<Allocator>(*this);
}
// First eat all qualifiers.
bool failure = false;
for(;;) // So we can use 'continue' to eat the next qualifier.
{
int start_pos = M_pos;
switch(current())
{
case 'P':
qualifiers->add_qualifier_start(pointer, start_pos,
M_inside_substitution);
eat_current();
continue;
case 'R':
qualifiers->add_qualifier_start(reference, start_pos,
M_inside_substitution);
eat_current();
continue;
case 'K':
case 'V':
case 'r':
{
char c;
int count = 0;
do
{
++count;
c = next();
}
while(c == 'K' || c == 'V' || c == 'r');
qualifiers->add_qualifier_start(cv_qualifier, start_pos, count,
M_inside_substitution);
continue;
}
case 'U':
{
eat_current();
string_type source_name;
if (!decode_source_name(source_name))
{
failure = true;
break;
}
qualifiers->add_qualifier_start(vendor_extension, start_pos,
source_name, M_inside_substitution);
continue;
}
case 'A':
{
// <array-type> ::= A <positive dimension number> _ <element type>
// ::= A [<dimension expression>] _ <element type>
//
string_type index;
int saved_pos;
store(saved_pos);
if (next() == 'n' || !decode_number(index))
{
restore(saved_pos);
if (next() != '_' && !decode_expression(index))
{
failure = true;
break;
}
}
if (eat_current() != '_')
{
failure = true;
break;
}
qualifiers->add_qualifier_start(array, start_pos, index,
M_inside_substitution);
continue;
}
case 'M':
{
// <pointer-to-member-type> ::= M <class type> <member type>
// <Q>M<C> or <Q>M<C><Q2>F<R><B>E
eat_current();
string_type class_type;
if (!decode_type(class_type)) // Substitution: "<C>".
{
failure = true;
break;
}
char c = current();
if (c == 'F' || c == 'K' || c == 'V' || c == 'r')
// Must be CV-qualifiers and a member function pointer.
{
// <Q>M<C><Q2>F<R><B>E ==> R (C::*Q)B Q2
// substitutions: "<C>", "F<R><B>E" (<R> and <B>
// recursive), "M<C><Q2>F<R><B>E".
int count = 0;
int Q2_start_pos = M_pos;
while(c == 'K' || c == 'V' || c == 'r') // Decode <Q2>.
{
++count;
c = next();
}
qualifier_list<Tp, Allocator> class_type_qualifiers(*this);
if (count)
class_type_qualifiers.
add_qualifier_start(cv_qualifier, Q2_start_pos,
count, M_inside_substitution);
string_type member_function_qualifiers;
// It is unclear why g++ doesn't add a substitution for
// "<Q2>F<R><B>E" as it should I think.
string_type member_function_qualifiers_postfix;
class_type_qualifiers.
decode_qualifiers(member_function_qualifiers,
member_function_qualifiers_postfix, true);
member_function_qualifiers +=
member_function_qualifiers_postfix;
// I don't think this substitution is actually ever used.
int function_pos = M_pos;
if (eat_current() != 'F')
{
failure = true;
break;
}
// Return type.
// Constructors, destructors and conversion operators don't
// have a return type, but seem to never get here.
string_type return_type_postfix;
if (!decode_type_with_postfix(prefix, return_type_postfix))
// substitution: <R> recursive
{
failure = true;
break;
}
prefix += " (";
prefix += class_type;
prefix += "::*";
string_type bare_function_type;
if (!decode_bare_function_type(bare_function_type)
|| eat_current() != 'E') // Substitution: <B> recursive.
{
failure = true;
break;
}
// substitution: "F<R><B>E".
add_substitution(function_pos, type);
// substitution: "M<C><Q2>F<R><B>E".
add_substitution(start_pos, type);
// substitution: all qualified types if any.
qualifiers->decode_qualifiers(prefix, postfix);
postfix += ")";
postfix += bare_function_type;
postfix += member_function_qualifiers;
postfix += return_type_postfix;
goto decode_type_exit;
}
qualifiers->add_qualifier_start(pointer_to_member, start_pos,
class_type, M_inside_substitution);
continue;
}
default:
break;
}
break;
}
if (!failure)
{
// <Q>G<T> ==> imaginary T Q
// substitutions: "<T>", "G<T>" (<T> recursive).
// <Q>C<T> ==> complex T Q
// substitutions: "<T>", "C<T>" (<T> recursive).
if (current() == 'C' || current() == 'G')
{
prefix += current() == 'C' ? "complex " : "imaginary ";
qualifiers->add_qualifier_start(complex_or_imaginary, M_pos,
M_inside_substitution);
eat_current();
}
int start_pos = M_pos;
switch(current())
{
case 'F':
{
// <function-type> ::= F [Y] <bare-function-type> E
//
// Note that g++ never generates the 'Y', but we try to
// demangle it anyway.
bool extern_C = (next() == 'Y');
if (extern_C)
eat_current();
// <Q>F<R><B>E ==> R (Q)B
// substitution: "<R>", "<B>" (<B> recursive) and "F<R><B>E".
// Return type.
string_type return_type_postfix;
if (!decode_type_with_postfix(prefix, return_type_postfix))
// Substitution: "<R>".
{
failure = true;
break;
}
// Only array and function (pointer) types have a postfix.
// In that case we don't want the space but expect something
// like prefix is "int (*" and postfix is ") [1]".
// We do want the space if this pointer is qualified.
if (return_type_postfix.size() == 0 ||
(prefix.size() > 0 && *prefix.rbegin() != '*'))
prefix += ' ';
prefix += '(';
string_type bare_function_type;
if (!decode_bare_function_type(bare_function_type)
// substitution: "<B>" (<B> recursive).
|| eat_current() != 'E')
{
failure = true;
break;
}
add_substitution(start_pos, type); // Substitution: "F<R><B>E".
qualifiers->decode_qualifiers(prefix, postfix);
// substitution: all qualified types, if any.
postfix += ")";
if (extern_C)
postfix += " [extern \"C\"] ";
postfix += bare_function_type;
postfix += return_type_postfix;
break;
}
case 'T':
if (!decode_template_param(prefix, qualifiers))
{
failure = true;
break;
}
if (current() == 'I')
{
add_substitution(start_pos, template_template_param);
// substitution: "<template-template-param>".
if (!decode_template_args(prefix))
{
failure = true;
break;
}
}
if (!recursive_template_param_or_substitution_call
&& qualifiers->suppressed())
{
add_substitution(start_pos, type);
// substitution: "<template-param>" or
// "<template-template-param> <template-args>".
qualifiers->decode_qualifiers(prefix, postfix);
// substitution: all qualified types, if any.
}
break;
case 'S':
if (M_pos >= M_maxpos)
{
failure = true;
break;
}
if (M_str[M_pos + 1] != 't')
{
if (!decode_substitution(prefix, qualifiers))
{
failure = true;
break;
}
if (current() == 'I')
{
if (!decode_template_args(prefix))
{
failure = true;
break;
}
if (!recursive_template_param_or_substitution_call
&& qualifiers->suppressed())
add_substitution(start_pos, type);
// Substitution:
// "<template-template-param> <template-args>".
}
if (!recursive_template_param_or_substitution_call
&& qualifiers->suppressed())
qualifiers->decode_qualifiers(prefix, postfix);
// Substitution: all qualified types, if any.
break;
}
/* Fall-through for St */
case 'N':
case 'Z':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
// <Q><T> ==> T Q
// substitutions: "<T>" (<T> recursive).
if (!decode_class_enum_type(prefix))
{
failure = true;
break;
}
if (!recursive_template_param_or_substitution_call)
{
add_substitution(start_pos, type);
// substitution: "<class-enum-type>".
qualifiers->decode_qualifiers(prefix, postfix);
// substitution: all qualified types, if any.
}
else
qualifiers->printing_suppressed();
break;
default:
// <Q><T> ==> T Q
// substitutions: "<T>" (<T> recursive).
if (!decode_builtin_type(prefix))
{
failure = true;
break;
}
// If decode_type was called from decode_template_param then we
// need to suppress calling qualifiers here in order to get a
// substitution added anyway (for the <template-param>).
if (!recursive_template_param_or_substitution_call)
qualifiers->decode_qualifiers(prefix, postfix);
else
qualifiers->printing_suppressed();
break;
}
}
decode_type_exit:
--M_inside_type;
if (!recursive_template_param_or_substitution_call)
{
qualifiers->~qualifier_list<Allocator>();
M_qualifier_list_alloc.deallocate(qualifiers, 1);
}
if (failure)
_GLIBCXX_DEMANGLER_FAILURE;
_GLIBCXX_DEMANGLER_RETURN2;
}
// <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
// ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
//
// <prefix> ::= <prefix> <unqualified-name>
// ::= <template-prefix> <template-args>
// ::= <template-param>
// ::= # empty
// ::= <substitution>
//
// <template-prefix> ::= <prefix> <template unqualified-name>
// ::= <template-param>
// ::= <substitution>
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_nested_name(string_type& output,
string_type& qualifiers)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_nested_name");
if (current() != 'N' || M_pos >= M_maxpos)
_GLIBCXX_DEMANGLER_FAILURE;
// <CV-qualifiers> ::= [r] [V] [K] # restrict (C99), volatile, const
char const* qualifiers_start = &M_str[M_pos + 1];
for (char c = next(); c == 'K' || c == 'V' || c == 'r'; c = next());
for (char const* qualifier_ptr = &M_str[M_pos - 1];
qualifier_ptr >= qualifiers_start; --qualifier_ptr)
switch(*qualifier_ptr)
{
case 'K':
qualifiers += " const";
break;
case 'V':
qualifiers += " volatile";
break;
case 'r':
qualifiers += " restrict";
break;
}
int number_of_prefixes = 0;
int substitution_start = M_pos;
for(;;)
{
++number_of_prefixes;
if (current() == 'S')
{
if (!decode_substitution(output))
_GLIBCXX_DEMANGLER_FAILURE;
}
else if (current() == 'I')
{
if (!decode_template_args(output))
_GLIBCXX_DEMANGLER_FAILURE;
if (current() != 'E')
{
// substitution: "<template-prefix> <template-args>".
add_substitution(substitution_start, nested_name_prefix,
number_of_prefixes);
}
}
else
{
if (current() == 'T')
{
if (!decode_template_param(output))
_GLIBCXX_DEMANGLER_FAILURE;
}
else if (!decode_unqualified_name(output))
_GLIBCXX_DEMANGLER_FAILURE;
if (current() != 'E')
{
// substitution: "<prefix> <unqualified-name>" or
// "<prefix> <template unqualified-name>".
add_substitution(substitution_start,
(current() == 'I') ? nested_name_template_prefix
: nested_name_prefix,
number_of_prefixes);
}
}
if (current() == 'E')
{
eat_current();
_GLIBCXX_DEMANGLER_RETURN;
}
if (current() != 'I')
output += "::";
else if (M_template_args_need_space)
output += ' ';
M_template_args_need_space = false;
}
_GLIBCXX_DEMANGLER_FAILURE;
}
// <local-name> := Z <function encoding> E <entity name> [<discriminator>]
// := Z <function encoding> E s [<discriminator>]
// <discriminator> := _ <non-negative number>
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_local_name(string_type& output)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_local_name");
if (current() != 'Z' || M_pos >= M_maxpos)
_GLIBCXX_DEMANGLER_FAILURE;
if ((M_pos += decode_encoding(output, M_str + M_pos + 1,
M_maxpos - M_pos, M_implementation_details) + 1) < 0 ||
eat_current() != 'E')
_GLIBCXX_DEMANGLER_FAILURE;
output += "::";
if (current() == 's')
{
eat_current();
output += "string literal";
}
else
{
string_type nested_name_qualifiers;
if (!decode_name(output, nested_name_qualifiers))
_GLIBCXX_DEMANGLER_FAILURE;
output += nested_name_qualifiers;
}
string_type discriminator;
if (current() == '_' && next() != 'n' && !decode_number(discriminator))
_GLIBCXX_DEMANGLER_FAILURE;
_GLIBCXX_DEMANGLER_RETURN;
}
// <source-name> ::= <positive length number> <identifier>
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_source_name(string_type& output)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_source_name");
int length = current() - '0';
if (length < 1 || length > 9)
_GLIBCXX_DEMANGLER_FAILURE;
while(isdigit(next()))
length = 10 * length + current() - '0';
char const* ptr = &M_str[M_pos];
if (length > 11 && !strncmp(ptr, "_GLOBAL_", 8) && ptr[9] == 'N'
&& ptr[8] == ptr[10])
{
output += "(anonymous namespace)";
if ((M_pos += length) > M_maxpos + 1)
_GLIBCXX_DEMANGLER_FAILURE;
}
else
while(length--)
{
if (current() == 0)
_GLIBCXX_DEMANGLER_FAILURE;
output += eat_current();
}
_GLIBCXX_DEMANGLER_RETURN;
}
// <unqualified-name> ::= <operator-name> # Starts with lower case.
// ::= <ctor-dtor-name> # Starts with 'C' or 'D'.
// ::= <source-name> # Starts with a digit.
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_unqualified_name(string_type& output)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_unqualified_name");
if (M_inside_template_args)
{
if (!decode_source_name(output))
_GLIBCXX_DEMANGLER_FAILURE;
}
else if (isdigit(current()))
{
bool recursive_unqualified_name = (&M_function_name == &output);
// This can be a recursive call when we are decoding
// an <operator-name> that is a cast operator for a some
// <unqualified-name>; for example "operator Foo()".
// In that case this is thus not a ctor or dtor and we
// are not interested in updating M_function_name.
if (!recursive_unqualified_name)
M_function_name.clear();
M_name_is_template = false;
M_name_is_cdtor = false;
M_name_is_conversion_operator = false;
if (!decode_source_name(M_function_name))
_GLIBCXX_DEMANGLER_FAILURE;
if (!recursive_unqualified_name)
output += M_function_name;
}
else if (islower(current()))
{
M_function_name.clear();
M_name_is_template = false;
M_name_is_cdtor = false;
M_name_is_conversion_operator = false;
if (!decode_operator_name(M_function_name))
_GLIBCXX_DEMANGLER_FAILURE;
output += M_function_name;
}
else if (current() == 'C' || current() == 'D')
{
// <ctor-dtor-name> ::=
// C1 # complete object (in-charge) constructor
// C2 # base object (not-in-charge) constructor
// C3 # complete object (in-charge) allocating constructor
// D0 # deleting (in-charge) destructor
// D1 # complete object (in-charge) destructor
// D2 # base object (not-in-charge) destructor
//
if (current() == 'C')
{
char c = next();
if (c < '1' || c > '3')
_GLIBCXX_DEMANGLER_FAILURE;
}
else
{
char c = next();
if (c < '0' || c > '2')
_GLIBCXX_DEMANGLER_FAILURE;
output += '~';
M_saw_destructor = true;
}
M_name_is_cdtor = true;
eat_current();
output += M_function_name;
}
else
_GLIBCXX_DEMANGLER_FAILURE;
_GLIBCXX_DEMANGLER_RETURN;
}
// <unscoped-name> ::=
// <unqualified-name> # Starts not with an 'S'
// St <unqualified-name> # ::std::
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_unscoped_name(string_type& output)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_unscoped_name");
if (current() == 'S')
{
if (next() != 't')
_GLIBCXX_DEMANGLER_FAILURE;
eat_current();
output += "std::";
}
decode_unqualified_name(output);
_GLIBCXX_DEMANGLER_RETURN;
}
// <name> ::=
// <nested-name> # Starts with 'N'
// <unscoped-template-name> <template-args> # idem
// <local-name> # Starts with 'Z'
// <unscoped-name> # Starts with 'S', 'C', 'D',
// # a digit or a lower case
// # character.
//
// <unscoped-template-name> ::= <unscoped-name>
// ::= <substitution>
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_name(string_type& output,
string_type& nested_name_qualifiers)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_name");
int substitution_start = M_pos;
if (current() == 'S' && (M_pos >= M_maxpos || M_str[M_pos + 1] != 't'))
{
if (!decode_substitution(output))
_GLIBCXX_DEMANGLER_FAILURE;
}
else if (current() == 'N')
{
decode_nested_name(output, nested_name_qualifiers);
_GLIBCXX_DEMANGLER_RETURN;
}
else if (current() == 'Z')
{
decode_local_name(output);
_GLIBCXX_DEMANGLER_RETURN;
}
else if (!decode_unscoped_name(output))
_GLIBCXX_DEMANGLER_FAILURE;
if (current() == 'I')
{
// Must have been an <unscoped-template-name>.
add_substitution(substitution_start, unscoped_template_name);
if (!decode_template_args(output))
_GLIBCXX_DEMANGLER_FAILURE;
}
M_template_args_need_space = false;
_GLIBCXX_DEMANGLER_RETURN;
}
// <call-offset> ::= h <nv-offset> _
// ::= v <v-offset> _
// <nv-offset> ::= <offset number>
// non-virtual base override
//
// <v-offset> ::= <offset number> _ <virtual offset number>
// virtual base override, with vcall offset
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_call_offset(string_type&
#if _GLIBCXX_DEMANGLER_CWDEBUG
output
#endif
)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_call_offset");
if (current() == 'h')
{
string_type dummy;
eat_current();
if (decode_number(dummy) && current() == '_')
{
eat_current();
_GLIBCXX_DEMANGLER_RETURN;
}
}
else if (current() == 'v')
{
string_type dummy;
eat_current();
if (decode_number(dummy) && current() == '_')
{
eat_current();
if (decode_number(dummy) && current() == '_')
{
eat_current();
_GLIBCXX_DEMANGLER_RETURN;
}
}
}
_GLIBCXX_DEMANGLER_FAILURE;
}
//
// <special-name> ::=
// TV <type> # virtual table
// TT <type> # VTT structure (construction
// vtable index).
// TI <type> # typeinfo structure
// TS <type> # typeinfo name (null-terminated
// byte string).
// GV <object name> # Guard variable for one-time
// initialization of static objects in
// a local scope.
// T <call-offset> <base encoding># base is the nominal target function
// of thunk.
// Tc <call-offset> <call-offset> <base encoding> # base is the nominal
// target function of thunk; first
// call-offset is 'this' adjustment;
// second call-offset is result
// adjustment
//
template<typename Tp, typename Allocator>
bool
session<Tp, Allocator>::decode_special_name(string_type& output)
{
_GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_special_name");
if (current() == 'G')
{
if (next() != 'V')
_GLIBCXX_DEMANGLER_FAILURE;
output += "guard variable for ";
string_type nested_name_qualifiers;
eat_current();
if (!decode_name(output, nested_name_qualifiers))
_GLIBCXX_DEMANGLER_FAILURE;
output += nested_name_qualifiers;
_GLIBCXX_DEMANGLER_RETURN;
}
else if (current() != 'T')
_GLIBCXX_DEMANGLER_FAILURE;
switch(next())
{
case 'V':
output += "vtable for ";
eat_current();
decode_type(output);
_GLIBCXX_DEMANGLER_RETURN;
case 'T':
output += "VTT for ";
eat_current();
decode_type(output);
_GLIBCXX_DEMANGLER_RETURN;
case 'I':
output += "typeinfo for ";
eat_current();
decode_type(output);
_GLIBCXX_DEMANGLER_RETURN;
case 'S':
output += "typeinfo name for ";
eat_current();
decode_type(output);
_GLIBCXX_DEMANGLER_RETURN;
case 'c':
output += "covariant return thunk to ";
if (!decode_call_offset(output)
|| !decode_call_offset(output)
|| (M_pos += decode_encoding(output, M_str + M_pos,
M_maxpos - M_pos + 1, M_implementation_details)) < 0)
_GLIBCXX_DEMANGLER_FAILURE;
_GLIBCXX_DEMANGLER_RETURN;
case 'C': // GNU extension?
{
string_type first;
output += "construction vtable for ";
eat_current();
if (!decode_type(first))
_GLIBCXX_DEMANGLER_FAILURE;
while(isdigit(current()))
eat_current();
if (eat_current() != '_')
_GLIBCXX_DEMANGLER_FAILURE;
if (!decode_type(output))
_GLIBCXX_DEMANGLER_FAILURE;
output += "-in-";
output += first;
_GLIBCXX_DEMANGLER_RETURN;
}
default:
if (current() == 'v')
output += "virtual thunk to ";
else
output += "non-virtual thunk to ";
if (!decode_call_offset(output)
|| (M_pos += decode_encoding(output, M_str + M_pos,
M_maxpos - M_pos + 1, M_implementation_details)) < 0)
_GLIBCXX_DEMANGLER_FAILURE;
_GLIBCXX_DEMANGLER_RETURN;
}
}
// <encoding> ::=
// <function name> <bare-function-type> # Starts with 'C', 'D', 'N',
// 'S', a digit or a lower case
// character.
// <data name> # Idem.
// <special-name> # Starts with 'T' or 'G'.
template<typename Tp, typename Allocator>
int
session<Tp, Allocator>::decode_encoding(string_type& output,
char const* in, int len, implementation_details const& id)
{
#if _GLIBCXX_DEMANGLER_CWDEBUG
_GLIBCXX_DEMANGLER_DOUT(dc::demangler,
"Output thus far: \"" << output << '"');
string_type input(in, len > 0x40000000 ? strlen(in) : len);
_GLIBCXX_DEMANGLER_DOUT(
dc::demangler, "Entering decode_encoding(\"" << input << "\")");
#endif
if (len <= 0)
return INT_MIN;
session<Tp, Allocator> demangler_session(in, len, id);
string_type nested_name_qualifiers;
int saved_pos;
demangler_session.store(saved_pos);
if (demangler_session.decode_special_name(output))
return demangler_session.M_pos;
demangler_session.restore(saved_pos);
string_type name;
if (!demangler_session.decode_name(name, nested_name_qualifiers))
return INT_MIN;
if (demangler_session.current() == 0
|| demangler_session.current() == 'E')
{
output += name;
output += nested_name_qualifiers;
return demangler_session.M_pos;
}
// Must have been a <function name>.
string_type return_type_postfix;
if (demangler_session.M_name_is_template
&& !(demangler_session.M_name_is_cdtor
|| demangler_session.M_name_is_conversion_operator))
{
// Return type of function
if (!demangler_session.decode_type_with_postfix(output,
return_type_postfix))
return INT_MIN;
output += ' ';
}
output += name;
if (!demangler_session.decode_bare_function_type(output))
return INT_MIN;
output += nested_name_qualifiers;
output += return_type_postfix;
return demangler_session.M_pos;
}
} // namespace demangler
// Public interface
template<typename Tp, typename Allocator>
struct demangle
{
typedef typename Allocator::template rebind<char>::other char_Allocator;
typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
string_type;
static string_type symbol(char const* in,
demangler::implementation_details const& id);
static string_type type(char const* in,
demangler::implementation_details const& id);
};
// demangle::symbol()
//
// Demangle `input' which should be a mangled function name as for
// instance returned by nm(1).
template<typename Tp, typename Allocator>
typename demangle<Tp, Allocator>::string_type
demangle<Tp, Allocator>::symbol(char const* input,
demangler::implementation_details const& id)
{
// <mangled-name> ::= _Z <encoding>
// <mangled-name> ::= _GLOBAL_ _<type>_ <disambiguation part>
// <type> can be I or D (GNU extension)
typedef demangler::session<Tp, Allocator> demangler_type;
string_type result;
bool failure = (input[0] != '_');
if (!failure)
{
if (input[1] == 'G')
{
if (!strncmp(input, "_GLOBAL__", 9)
&& (input[9] == 'D' || input[9] == 'I')
&& input[10] == '_')
{
if (input[9] == 'D')
result.assign("global destructors keyed to ", 28);
else
result.assign("global constructors keyed to ", 29);
// Output the disambiguation part as-is.
result += input + 11;
}
else
failure = true;
}
else if (input[1] == 'Z')
{
int cnt =
demangler_type::decode_encoding(result, input + 2, INT_MAX, id);
if (cnt < 0 || input[cnt + 2] != 0)
failure = true;
}
else
failure = true;
}
// Failure to demangle, return the mangled name.
if (failure)
result.assign(input, strlen(input));
return result;
}
// demangle::type()
// Demangle `input' which must be a zero terminated mangled type
// name as for instance returned by std::type_info::name().
template<typename Tp, typename Allocator>
typename demangle<Tp, Allocator>::string_type
demangle<Tp, Allocator>::type(char const* input,
demangler::implementation_details const& id)
{
std::basic_string<char, std::char_traits<char>, Allocator> result;
if (input == NULL)
result = "(null)";
else
{
demangler::session<Tp, Allocator> demangler_session(input, INT_MAX, id);
if (!demangler_session.decode_type(result)
|| demangler_session.remaining_input_characters())
{
// Failure to demangle, return the mangled name.
result = input;
}
}
return result;
}
} // namespace __gnu_cxx
#endif // __DEMANGLE_H
Charlie Root