blob: af2816caf057c256a4804bf26334ae84df0dc73b [file] [log] [blame]
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <assert.h>
#include <cctype>
#include <stack>
#include <string>
#include <vector>
#include "Demangler.h"
constexpr const char* Demangler::kTypes[];
constexpr const char* Demangler::kDTypes[];
constexpr const char* Demangler::kSTypes[];
void Demangler::Save(const std::string& str, bool is_name) {
saves_.push_back(str);
last_save_name_ = is_name;
}
std::string Demangler::GetArgumentsString() {
size_t num_args = cur_state_.args.size();
std::string arg_str;
if (num_args > 0) {
arg_str = cur_state_.args[0];
for (size_t i = 1; i < num_args; i++) {
arg_str += ", " + cur_state_.args[i];
}
}
return arg_str;
}
const char* Demangler::AppendOperatorString(const char* name) {
const char* oper = nullptr;
switch (*name) {
case 'a':
name++;
switch (*name) {
case 'a':
oper = "operator&&";
break;
case 'd':
case 'n':
oper = "operator&";
break;
case 'N':
oper = "operator&=";
break;
case 'S':
oper = "operator=";
break;
}
break;
case 'c':
name++;
switch (*name) {
case 'l':
oper = "operator()";
break;
case 'm':
oper = "operator,";
break;
case 'o':
oper = "operator~";
break;
}
break;
case 'd':
name++;
switch (*name) {
case 'a':
oper = "operator delete[]";
break;
case 'e':
oper = "operator*";
break;
case 'l':
oper = "operator delete";
break;
case 'v':
oper = "operator/";
break;
case 'V':
oper = "operator/=";
break;
}
break;
case 'e':
name++;
switch (*name) {
case 'o':
oper = "operator^";
break;
case 'O':
oper = "operator^=";
break;
case 'q':
oper = "operator==";
break;
}
break;
case 'g':
name++;
switch (*name) {
case 'e':
oper = "operator>=";
break;
case 't':
oper = "operator>";
break;
}
break;
case 'i':
name++;
switch (*name) {
case 'x':
oper = "operator[]";
break;
}
break;
case 'l':
name++;
switch (*name) {
case 'e':
oper = "operator<=";
break;
case 's':
oper = "operator<<";
break;
case 'S':
oper = "operator<<=";
break;
case 't':
oper = "operator<";
break;
}
break;
case 'm':
name++;
switch (*name) {
case 'i':
oper = "operator-";
break;
case 'I':
oper = "operator-=";
break;
case 'l':
oper = "operator*";
break;
case 'L':
oper = "operator*=";
break;
case 'm':
oper = "operator--";
break;
}
break;
case 'n':
name++;
switch (*name) {
case 'a':
oper = "operator new[]";
break;
case 'e':
oper = "operator!=";
break;
case 'g':
oper = "operator-";
break;
case 't':
oper = "operator!";
break;
case 'w':
oper = "operator new";
break;
}
break;
case 'o':
name++;
switch (*name) {
case 'o':
oper = "operator||";
break;
case 'r':
oper = "operator|";
break;
case 'R':
oper = "operator|=";
break;
}
break;
case 'p':
name++;
switch (*name) {
case 'm':
oper = "operator->*";
break;
case 'l':
oper = "operator+";
break;
case 'L':
oper = "operator+=";
break;
case 'p':
oper = "operator++";
break;
case 's':
oper = "operator+";
break;
case 't':
oper = "operator->";
break;
}
break;
case 'q':
name++;
switch (*name) {
case 'u':
oper = "operator?";
break;
}
break;
case 'r':
name++;
switch (*name) {
case 'm':
oper = "operator%";
break;
case 'M':
oper = "operator%=";
break;
case 's':
oper = "operator>>";
break;
case 'S':
oper = "operator>>=";
break;
}
break;
}
if (oper == nullptr) {
return nullptr;
}
AppendCurrent(oper);
cur_state_.last_save = oper;
return name + 1;
}
const char* Demangler::GetStringFromLength(const char* name, std::string* str) {
assert(std::isdigit(*name));
size_t length = *name - '0';
name++;
while (*name != '\0' && std::isdigit(*name)) {
length = length * 10 + *name - '0';
name++;
}
std::string read_str;
while (*name != '\0' && length != 0) {
read_str += *name;
name++;
length--;
}
if (length != 0) {
return nullptr;
}
// Special replacement of _GLOBAL__N_1 to (anonymous namespace).
if (read_str == "_GLOBAL__N_1") {
*str += "(anonymous namespace)";
} else {
*str += read_str;
}
return name;
}
void Demangler::AppendCurrent(const std::string& str) {
if (!cur_state_.str.empty()) {
cur_state_.str += "::";
}
cur_state_.str += str;
}
void Demangler::AppendCurrent(const char* str) {
if (!cur_state_.str.empty()) {
cur_state_.str += "::";
}
cur_state_.str += str;
}
const char* Demangler::ParseS(const char* name) {
if (std::islower(*name)) {
const char* type = kSTypes[*name - 'a'];
if (type == nullptr) {
return nullptr;
}
AppendCurrent(type);
return name + 1;
}
if (saves_.empty()) {
return nullptr;
}
if (*name == '_') {
last_save_name_ = false;
AppendCurrent(saves_[0]);
return name + 1;
}
bool isdigit = std::isdigit(*name);
if (!isdigit && !std::isupper(*name)) {
return nullptr;
}
size_t index;
if (isdigit) {
index = *name - '0' + 1;
} else {
index = *name - 'A' + 11;
}
name++;
if (*name != '_') {
return nullptr;
}
if (index >= saves_.size()) {
return nullptr;
}
last_save_name_ = false;
AppendCurrent(saves_[index]);
return name + 1;
}
const char* Demangler::ParseT(const char* name) {
if (template_saves_.empty()) {
return nullptr;
}
if (*name == '_') {
last_save_name_ = false;
AppendCurrent(template_saves_[0]);
return name + 1;
}
// Need to get the total number.
char* end;
unsigned long int index = strtoul(name, &end, 10) + 1;
if (name == end || *end != '_') {
return nullptr;
}
if (index >= template_saves_.size()) {
return nullptr;
}
last_save_name_ = false;
AppendCurrent(template_saves_[index]);
return end + 1;
}
const char* Demangler::ParseFunctionName(const char* name) {
if (*name == 'E') {
if (parse_funcs_.empty()) {
return nullptr;
}
parse_func_ = parse_funcs_.back();
parse_funcs_.pop_back();
// Remove the last saved part so that the full function name is not saved.
// But only if the last save was not something like a substitution.
if (!saves_.empty() && last_save_name_) {
saves_.pop_back();
}
function_name_ += cur_state_.str;
while (!cur_state_.suffixes.empty()) {
function_suffix_ += cur_state_.suffixes.back();
cur_state_.suffixes.pop_back();
}
cur_state_.Clear();
return name + 1;
}
if (*name == 'I') {
state_stack_.push(cur_state_);
cur_state_.Clear();
parse_funcs_.push_back(parse_func_);
parse_func_ = &Demangler::ParseFunctionNameTemplate;
return name + 1;
}
return ParseComplexString(name);
}
const char* Demangler::ParseFunctionNameTemplate(const char* name) {
if (*name == 'E' && name[1] == 'E') {
// Only consider this a template with saves if it is right before
// the end of the name.
template_found_ = true;
template_saves_ = cur_state_.args;
}
return ParseTemplateArgumentsComplex(name);
}
const char* Demangler::ParseComplexArgument(const char* name) {
if (*name == 'E') {
if (parse_funcs_.empty()) {
return nullptr;
}
parse_func_ = parse_funcs_.back();
parse_funcs_.pop_back();
AppendArgument(cur_state_.str);
cur_state_.str.clear();
return name + 1;
}
return ParseComplexString(name);
}
void Demangler::FinalizeTemplate() {
std::string arg_str(GetArgumentsString());
cur_state_ = state_stack_.top();
state_stack_.pop();
cur_state_.str += '<' + arg_str + '>';
}
const char* Demangler::ParseComplexString(const char* name) {
if (*name == 'S') {
name++;
if (*name == 't') {
AppendCurrent("std");
return name + 1;
}
return ParseS(name);
}
if (*name == 'L') {
name++;
if (!std::isdigit(*name)) {
return nullptr;
}
}
if (std::isdigit(*name)) {
std::string str;
name = GetStringFromLength(name, &str);
if (name == nullptr) {
return name;
}
AppendCurrent(str);
Save(cur_state_.str, true);
cur_state_.last_save = std::move(str);
return name;
}
if (*name == 'D') {
name++;
if (saves_.empty() || (*name != '0' && *name != '1' && *name != '2'
&& *name != '5')) {
return nullptr;
}
last_save_name_ = false;
AppendCurrent("~" + cur_state_.last_save);
return name + 1;
}
if (*name == 'C') {
name++;
if (saves_.empty() || (*name != '1' && *name != '2' && *name != '3'
&& *name != '5')) {
return nullptr;
}
last_save_name_ = false;
AppendCurrent(cur_state_.last_save);
return name + 1;
}
if (*name == 'K') {
cur_state_.suffixes.push_back(" const");
return name + 1;
}
if (*name == 'V') {
cur_state_.suffixes.push_back(" volatile");
return name + 1;
}
if (*name == 'I') {
// Save the current argument state.
state_stack_.push(cur_state_);
cur_state_.Clear();
parse_funcs_.push_back(parse_func_);
parse_func_ = &Demangler::ParseTemplateArgumentsComplex;
return name + 1;
}
name = AppendOperatorString(name);
if (name != nullptr) {
Save(cur_state_.str, true);
}
return name;
}
void Demangler::AppendArgument(const std::string& str) {
std::string arg(str);
while (!cur_state_.suffixes.empty()) {
arg += cur_state_.suffixes.back();
cur_state_.suffixes.pop_back();
Save(arg, false);
}
cur_state_.args.push_back(arg);
}
const char* Demangler::ParseFunctionArgument(const char* name) {
if (*name == 'E') {
// The first argument is the function modifier.
// The second argument is the function type.
// The third argument is the return type of the function.
// The rest of the arguments are the function arguments.
size_t num_args = cur_state_.args.size();
if (num_args < 4) {
return nullptr;
}
std::string function_modifier = cur_state_.args[0];
std::string function_type = cur_state_.args[1];
std::string str = cur_state_.args[2] + ' ';
if (!cur_state_.args[1].empty()) {
str += '(' + cur_state_.args[1] + ')';
}
if (num_args == 4 && cur_state_.args[3] == "void") {
str += "()";
} else {
str += '(' + cur_state_.args[3];
for (size_t i = 4; i < num_args; i++) {
str += ", " + cur_state_.args[i];
}
str += ')';
}
str += cur_state_.args[0];
cur_state_ = state_stack_.top();
state_stack_.pop();
cur_state_.args.emplace_back(std::move(str));
parse_func_ = parse_funcs_.back();
parse_funcs_.pop_back();
return name + 1;
}
return ParseArguments(name);
}
const char* Demangler::ParseArguments(const char* name) {
switch (*name) {
case 'P':
cur_state_.suffixes.push_back("*");
return name + 1;
case 'R':
// This should always be okay because the string is guaranteed to have
// at least two characters before this. A mangled string always starts
// with _Z.
if (name[-1] != 'R') {
// Multiple 'R's in a row only add a single &.
cur_state_.suffixes.push_back("&");
}
return name + 1;
case 'K':
case 'V': {
const char* suffix;
if (*name == 'K') {
suffix = " const";
} else {
suffix = " volatile";
}
if (!cur_state_.suffixes.empty() && (name[-1] == 'K' || name[-1] == 'V')) {
// Special case, const/volatile apply as a single entity.
size_t index = cur_state_.suffixes.size();
cur_state_.suffixes[index-1].insert(0, suffix);
} else {
cur_state_.suffixes.push_back(suffix);
}
return name + 1;
}
case 'F': {
std::string function_modifier;
std::string function_type;
if (!cur_state_.suffixes.empty()) {
// If the first element starts with a ' ', then this modifies the
// function itself.
if (cur_state_.suffixes.back()[0] == ' ') {
function_modifier = cur_state_.suffixes.back();
cur_state_.suffixes.pop_back();
}
while (!cur_state_.suffixes.empty()) {
function_type += cur_state_.suffixes.back();
cur_state_.suffixes.pop_back();
}
}
state_stack_.push(cur_state_);
cur_state_.Clear();
// The function parameter has this format:
// First argument is the function modifier.
// Second argument is the function type.
// Third argument will be the return function type but has not
// been parsed yet.
// Any other parameters are the arguments to the function. There
// must be at least one or this isn't valid.
cur_state_.args.push_back(function_modifier);
cur_state_.args.push_back(function_type);
parse_funcs_.push_back(parse_func_);
parse_func_ = &Demangler::ParseFunctionArgument;
return name + 1;
}
case 'N':
parse_funcs_.push_back(parse_func_);
parse_func_ = &Demangler::ParseComplexArgument;
return name + 1;
case 'S':
name++;
if (*name == 't') {
cur_state_.str = "std::";
return name + 1;
}
name = ParseS(name);
if (name == nullptr) {
return nullptr;
}
AppendArgument(cur_state_.str);
cur_state_.str.clear();
return name;
case 'D':
name++;
if (*name >= 'a' && *name <= 'z') {
const char* arg = Demangler::kDTypes[*name - 'a'];
if (arg == nullptr) {
return nullptr;
}
AppendArgument(arg);
return name + 1;
}
return nullptr;
case 'I':
// Save the current argument state.
state_stack_.push(cur_state_);
cur_state_.Clear();
parse_funcs_.push_back(parse_func_);
parse_func_ = &Demangler::ParseTemplateArguments;
return name + 1;
case 'v':
AppendArgument("void");
return name + 1;
default:
if (*name >= 'a' && *name <= 'z') {
const char* arg = Demangler::kTypes[*name - 'a'];
if (arg == nullptr) {
return nullptr;
}
AppendArgument(arg);
return name + 1;
} else if (std::isdigit(*name)) {
std::string arg = cur_state_.str;
name = GetStringFromLength(name, &arg);
if (name == nullptr) {
return nullptr;
}
Save(arg, true);
if (*name == 'I') {
// There is one case where this argument is not complete, and that's
// where this is a template argument.
cur_state_.str = arg;
} else {
AppendArgument(arg);
cur_state_.str.clear();
}
return name;
}
}
return nullptr;
}
const char* Demangler::ParseTemplateLiteral(const char* name) {
if (*name == 'E') {
parse_func_ = parse_funcs_.back();
parse_funcs_.pop_back();
return name + 1;
}
// Only understand boolean values with 0 or 1.
if (*name == 'b') {
name++;
if (*name == '0') {
AppendArgument("false");
cur_state_.str.clear();
} else if (*name == '1') {
AppendArgument("true");
cur_state_.str.clear();
} else {
return nullptr;
}
return name + 1;
}
return nullptr;
}
const char* Demangler::ParseTemplateArgumentsComplex(const char* name) {
if (*name == 'E') {
if (parse_funcs_.empty()) {
return nullptr;
}
parse_func_ = parse_funcs_.back();
parse_funcs_.pop_back();
FinalizeTemplate();
Save(cur_state_.str, false);
return name + 1;
} else if (*name == 'L') {
// Literal value for a template.
parse_funcs_.push_back(parse_func_);
parse_func_ = &Demangler::ParseTemplateLiteral;
return name + 1;
}
return ParseArguments(name);
}
const char* Demangler::ParseTemplateArguments(const char* name) {
if (*name == 'E') {
if (parse_funcs_.empty()) {
return nullptr;
}
parse_func_ = parse_funcs_.back();
parse_funcs_.pop_back();
FinalizeTemplate();
AppendArgument(cur_state_.str);
cur_state_.str.clear();
return name + 1;
} else if (*name == 'L') {
// Literal value for a template.
parse_funcs_.push_back(parse_func_);
parse_func_ = &Demangler::ParseTemplateLiteral;
return name + 1;
}
return ParseArguments(name);
}
const char* Demangler::ParseFunctionTemplateArguments(const char* name) {
if (*name == 'E') {
parse_func_ = parse_funcs_.back();
parse_funcs_.pop_back();
function_name_ += '<' + GetArgumentsString() + '>';
template_found_ = true;
template_saves_ = cur_state_.args;
cur_state_.Clear();
return name + 1;
}
return ParseTemplateArgumentsComplex(name);
}
const char* Demangler::FindFunctionName(const char* name) {
if (*name == 'T') {
// non-virtual thunk, verify that it matches one of these patterns:
// Thn[0-9]+_
// Th[0-9]+_
// Thn_
// Th_
name++;
if (*name != 'h') {
return nullptr;
}
name++;
if (*name == 'n') {
name++;
}
while (std::isdigit(*name)) {
name++;
}
if (*name != '_') {
return nullptr;
}
function_name_ = "non-virtual thunk to ";
return name + 1;
}
if (*name == 'N') {
parse_funcs_.push_back(&Demangler::ParseArgumentsAtTopLevel);
parse_func_ = &Demangler::ParseFunctionName;
return name + 1;
}
if (std::isdigit(*name)) {
name = GetStringFromLength(name, &function_name_);
} else if (*name == 'L' && std::isdigit(name[1])) {
name = GetStringFromLength(name + 1, &function_name_);
} else {
name = AppendOperatorString(name);
function_name_ = cur_state_.str;
}
cur_state_.Clear();
// Check for a template argument, which will still be part of the function
// name.
if (name != nullptr && *name == 'I') {
parse_funcs_.push_back(&Demangler::ParseArgumentsAtTopLevel);
parse_func_ = &Demangler::ParseFunctionTemplateArguments;
return name + 1;
}
parse_func_ = &Demangler::ParseArgumentsAtTopLevel;
return name;
}
const char* Demangler::ParseArgumentsAtTopLevel(const char* name) {
// At the top level is the only place where T is allowed.
if (*name == 'T') {
name++;
name = ParseT(name);
if (name == nullptr) {
return nullptr;
}
AppendArgument(cur_state_.str);
cur_state_.str.clear();
return name;
}
return Demangler::ParseArguments(name);
}
std::string Demangler::Parse(const char* name, size_t max_length) {
if (name[0] == '\0' || name[0] != '_' || name[1] == '\0' || name[1] != 'Z') {
// Name is not mangled.
return name;
}
Clear();
parse_func_ = &Demangler::FindFunctionName;
parse_funcs_.push_back(&Demangler::Fail);
const char* cur_name = name + 2;
while (cur_name != nullptr && *cur_name != '\0'
&& static_cast<size_t>(cur_name - name) < max_length) {
cur_name = (this->*parse_func_)(cur_name);
}
if (cur_name == nullptr || *cur_name != '\0' || function_name_.empty() ||
!cur_state_.suffixes.empty()) {
return name;
}
std::string return_type;
if (template_found_) {
// Only a single argument with a template is not allowed.
if (cur_state_.args.size() == 1) {
return name;
}
// If there are at least two arguments, this template has a return type.
if (cur_state_.args.size() > 1) {
// The first argument will be the return value.
return_type = cur_state_.args[0] + ' ';
cur_state_.args.erase(cur_state_.args.begin());
}
}
std::string arg_str;
if (cur_state_.args.size() == 1 && cur_state_.args[0] == "void") {
// If the only argument is void, then don't print any args.
arg_str = "()";
} else {
arg_str = GetArgumentsString();
if (!arg_str.empty()) {
arg_str = '(' + arg_str + ')';
}
}
return return_type + function_name_ + arg_str + function_suffix_;
}
std::string demangle(const char* name) {
Demangler demangler;
return demangler.Parse(name);
}