Is There an Online Name Demangler for C++

Is there an online name demangler for C++?

I have created such an online serivice: https://demangler.com

This is a gcc c++ symbol demangler. You just copy a stack trace, or the output of nm into a text box, and it will return the output with the names demangled.

@Update: It now demangles MSVC and Java symbols also.

C++ name mangling decoder for g++?

You can use c++filt to demangle c++ symbols. For instance

$ c++filt -n _Z1fv
f()

Is there a simple way to have ld output demangled funtion names?

ld (The GNU Linker) is able to demangle C++ function names. ld documentation on demangling from it's man page: (available here online)

       --demangle[=style]
       --no-demangle
           These options control whether to demangle symbol names in error
           messages and other output.  When the linker is told to demangle,
           it tries to present symbol names in a readable fashion: it strips
           leading underscores if they are used by the object file format,
           and converts C++ mangled symbol names into user readable names.
           Different compilers have different mangling styles.  The optional
           demangling style argument can be used to choose an appropriate
           demangling style for your compiler.  The linker will demangle by
           default unless the environment variable COLLECT_NO_DEMANGLE is
           set.  These options may be used to override the default.

Let's see an example:

void foo();
void foo(int);
int main() {
    foo();
    foo(5);
}

This is a simple valid code. This will compile but fail to link successfully because there is no implementation of foo() and foo(int) here. Now we'll compile it with the following command:

g++ main.cpp -c -o main.o

It will compile successfully. Now let's try to link it with demangling disabled with the following command:

g++ main.o -Wl,--no-demangle

It should show linking errors with some weird mangled name like this:

main.o: In function `main':
main.cpp:(.text+0x5): undefined reference to `_Z3foov'
main.cpp:(.text+0xf): undefined reference to `_Z3fooi'
collect2: error: ld returned 1 exit status

See live on Coliru

Now let's try to link with demangling enabled with the following command:

g++ main.o -Wl,--demangle

We'll get errors with demangled function names with their arguments like this:

main.o: In function `main':
main.cpp:(.text+0x5): undefined reference to `foo()'
main.cpp:(.text+0xf): undefined reference to `foo(int)'
collect2: error: ld returned 1 exit status

See live on Coliru

Here -Wl means arguments to linker.

As far as I know, g++ enables demangling automatically.

c++filt does not demangle typeid name

You need to use c++filt -t for types so the following should work:

./shape | c++filt -t

the man page for c++filt says the following for -t:

Attempt to demangle types as well as function names. This is disabled by default since mangled types are normally only used internally in the compiler, and they can be confused with non-mangled names. For example, a function called "a" treated as a mangled type name would be demangled to "signed char".

Function to mangle/demangle functions

Use the c++filt command line tool to demangle the name.

Why prevent Name-mangling C files

1. c++ compiler may not do name mangling on .c files, but it definitely would mangle those included by .cpp files, so in header files it is needed
2. you can simply use extern "C"{ file content here }, this can be easily done in many tools.

---

I write a cmd script (.bat) for you

WARNING : this would overwrite existing files, make a backup!

@ECHO OFF
for /R %%f in (*.c,*.h) do (
   @echo extern "C" { > temp
   @echo. >> temp
   @type %%f >> temp
   @echo. >> temp   
   @echo } >> temp
   @type temp > %%f
   @echo processed %%f
)

Is it possible to demangle C++ symbols by hand?

The symbol looks like one produced by clang or gcc. Both of these compilers use an ABI based on the Itanium ABI. This document includes a section on demangling describing how external symbols are constructed. If you internalize the corresponding rules, you should be able to demangle the names.

I couldn't locate the document on the original site and off-hand I don't know where the official document lives.

How to unmangle mangled names of C++ lambdas?

You can use GCC's special abi::__cxa_demangle function:

#include <memory>
#include <cstdlib>
#include <cxxabi.h>
#include <iostream>

// delete malloc'd memory
struct malloc_deleter
{
    void operator()(void* p) const { std::free(p); }
};

// custom smart pointer for c-style strings allocated with std::malloc
using cstring_uptr = std::unique_ptr<char, malloc_deleter>;

int main()
{
    // special function to de-mangle names
    int error;
    cstring_uptr name(abi::__cxa_demangle(typeid([]{}).name(), 0, 0, &error));

    if(!error)
        std::cout << name.get() << '\n';
    else if(error == -1)
        std::cerr << "memory allocation failed" << '\n';
    else if(error == -2)
        std::cerr << "not a valid mangled name" << '\n';
    else if(error == -3)
        std::cerr << "bad argument" << '\n';
}

Output:

main::{lambda()#1}

According to The Documentation this function returns a c-style zero-terminated string allocated using std::malloc which the caller needs to free using std::free. This example uses a smart pointer to free the returned string automatically at the end of the scope.

---

Related Topics