Is there a way to find the C++ mangled name to use in GetProcAddress?

Question

The common "solution" to use GetProcAddress with C++ is "extern "C", but that breaks overloading. Name mangling allows multiple functions to co-exist, as long as their signature differs. But is there a way to find these mangled names for GetProcAddress?

Answer 1

I can't quite fathom why you'd ever want/need a constexpr version of MSalters' solution, but here it is, complete with namespace mangling. Use as

using F = int(double*);
constexpr auto f = mangled::name<F>([]{ return "foo::bar::frobnicate"; });
constexpr const char* cstr = f.data();

where F is the function signature and foo::bar::frobnicate is the (possibly qualified) name of the function.

#include<string_view>
#include<array>

namespace mangled
{
    namespace detail
    {
        template<typename F>
        inline constexpr std::string_view suffix()
        {
            auto str = std::string_view(__FUNCDNAME__);
            return str.substr(14, str.size() - 87);
        }
        
        template<typename L>
        struct constexpr_string
        {
            constexpr constexpr_string(L) {}
            static constexpr std::string_view data = L{}();
        };

        template<typename Name>
        inline constexpr int qualifiers()
        {
            int i = -2, count = -1;
            while(i != std::string_view::npos)
            {
                i = Name::data.find("::", i + 2);
                count++;
            }
            return count;
        }

        template<typename Name>
        inline constexpr auto split()
        {
            std::array<std::string_view, qualifiers<Name>() + 1> arr = {};
            int prev = -2;
            for(int i = arr.size() - 1; i > 0; i--)
            {
                int cur = Name::data.find("::", prev + 2);
                arr[i] = Name::data.substr(prev + 2, cur - prev - 2);
                prev = cur;
            }
            arr[0] = Name::data.substr(prev + 2);
            return arr;
        }

        template<typename F, typename Name>
        struct name_builder
        {
            static constexpr auto suf = detail::suffix<F>();
            static constexpr auto toks = split<Name>();
            static constexpr auto len = Name::data.size() + suf.size() - toks.size() + 6;
            static constexpr auto str = [] {
                std::array<char, len> arr = {};
                arr[0] = '?';
                int i = 1;
                for(int t = 0; t < toks.size(); t++)
                {
                    if(t > 0)
                        arr[i++] = '@';
                    for(auto c : toks[t])
                        arr[i++] = c;
                }

                arr[i++] = '@';
                arr[i++] = '@';
                arr[i++] = 'Y';

                for(auto c : suf)
                    arr[i++] = c;
                
                return arr;
            }();
        };
    }

    template<typename F, typename LambdaString>
    inline constexpr std::string_view name(LambdaString)
    {
        using Cs = detail::constexpr_string<LambdaString>;
        using N = detail::name_builder<F, Cs>;
        return {N::str.data(), N::len};
    }
}

GodBolt

Answer 2

The VC++ compiler knows its own name mangling scheme, so why not use that? Inside template<typename T> T GetProcAddress(HMODULE h, const char* name), the macro __FUNCDNAME__ contains the mangled name of GetProcAddress. That includes the T part. So, inside GetProcAddress<void(*)(int), we have a substring with the mangled name of void(*)(int). From that, we can trivially derive the mangled name of void foo(int);

This code relies on the VC++ macro __FUNCDNAME__. For MinGW you'd need to base this on __PRETTY_FUNCTION__ instead.

FARPROC GetProcAddress_CppImpl(HMODULE h, const char* name, std::string const& Signature)
{
    // The signature of T appears twice in the signature of T GetProcAddress<T>(HMODULE, const char*) 
    size_t len = Signature.find("@@YA");
    std::string templateParam = Signature.substr(0, len);
    std::string returnType    = Signature.substr(len+4);
    returnType.resize(templateParam.size()); // Strip off our own arguments (HMODULE and const char*)
    assert(templateParam == returnType); 
    // templateParam and returnType are _pointers_ to functions (P6), so adjust to function type (Y)
    std::string funName = "?" + std::string(name) + "@@Y" + templateParam.substr(2);
    return ::GetProcAddress(h, funName.c_str());
}

template <typename T>
T GetProcAddress(HMODULE h, const char* name)
{
    // Get our own signature. We use `const char* name` to keep it simple.
    std::string Signature = __FUNCDNAME__ + 18; // Ignore prefix "??$GetProcAddress@"
    return reinterpret_cast<T>(GetProcAddress_CppImpl(h, name, Signature));
}

// Showing the result

struct Dummy { };

__declspec(dllexport) void foo( const char* s)
{
    std::cout << s;
}

__declspec(dllexport) void foo( int i, Dummy )
{
    std::cout << "Overloaded foo(), got " << i << std::endl;
}

__declspec(dllexport) void foo( std::string const& s )
{
    std::cout << "Overloaded foo(), got " << s << std::endl;
}

__declspec(dllexport) int foo( std::map<std::string, double> volatile& )
{
    std::cout << "Overloaded foo(), complex type\n";
    return 42;
}

int main()
{
    HMODULE h = GetModuleHandleW(0);
    foo("Hello, ");
    auto pFoo1 = GetProcAddress<void (*)( const char*)>(h, "foo");
    // This templated version of GetProcAddress is typesafe: You can't pass 
    // a float to pFoo1. That is a compile-time error.
    pFoo1(" world\n");
    auto pFoo2 = GetProcAddress<void (*)( int, Dummy )>(h, "foo");
    pFoo2(42, Dummy()); // Again, typesafe.
    auto pFoo3 = GetProcAddress<void (*)( std::string const& )>(h, "foo");
    pFoo3("std::string overload\n");
    auto pFoo4 = GetProcAddress<int (*)( std::map<std::string, double> volatile& )>(h, "foo");
    // pFoo4 != NULL, this overload exists.
    auto pFoo5 = GetProcAddress<void (*)( float )>(h, "foo");
    // pFoo5==NULL - no such overload.
}

Answer 3

It's impossible to do it just by using GetProcAddress. However, one way to do it would be to enumerate all the exported functions for that particular module, and do a pattern matching to find all the mangled names.

More specifically, refer to this answer here. The only change you will need to make would be to pass in TRUE for MappedAsImage parameter and the return value of GetModuleHandle for Base parameter to ImageDirectoryEntryToData function call.

void EnumerateExportedFunctions(HMODULE hModule, vector<string>& slListOfDllFunctions)
{
    DWORD *dNameRVAs(0);
    _IMAGE_EXPORT_DIRECTORY *ImageExportDirectory;
    unsigned long cDirSize;
    _LOADED_IMAGE LoadedImage;
    string sName;
    slListOfDllFunctions.clear();

    ImageExportDirectory = (_IMAGE_EXPORT_DIRECTORY*)
        ImageDirectoryEntryToData(hModule,
        TRUE, IMAGE_DIRECTORY_ENTRY_EXPORT, &cDirSize);
    if (ImageExportDirectory != NULL)
    {
        dNameRVAs = (DWORD *)ImageRvaToVa(LoadedImage.FileHeader, 
            LoadedImage.MappedAddress,
        ImageExportDirectory->AddressOfNames, NULL);
        for(size_t i = 0; i < ImageExportDirectory->NumberOfNames; i++)
        {
            sName = (char *)ImageRvaToVa(LoadedImage.FileHeader, 
                    LoadedImage.MappedAddress,
                   dNameRVAs[i], NULL);
         slListOfDllFunctions.push_back(sName);
        }
    }
}

Answer 4

Use dumpbin /exports 'file.dll' to get the decorated / undecorated name of all the symbols.