On windows, why are there different addresses for the same module?

Question

I read that on windows, modules of an executable are mapped in the same address space. I don't understand why

typedef int (__stdcall *fptr)();

int     main(void)
{

    HINSTANCE   h;
    fptr        f;
    std::stringstream oss;

    h = LoadLibrary("test.dll");
    if (! h)
        return EXIT_FAILURE;
    f = (fptr)GetProcAddress(h, "function");
    if (! f)
        return EXIT_FAILURE;

    oss << (DWORD *)f;
    std::cout <<"main: "<< oss << std::endl;

    _getch();
    return EXIT_SUCCESS;
}

and

extern "C" {
    void __declspec(dllexport) function() {
        return ;
    }
}

int     main(HMODULE m)
{
    std::stringstream oss;  

    oss << (DWORD *)function;

    std::cout << "dll: " << oss << std::endl;
}

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        main(hModule);
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

yields this result:

> "test.exe"
dll: 007BFDB8
main: 0039F944

Also, the address 007BFD88 can not be accessed from the main process. Why are the two addresses different ?

Answer 1

The fundamental rule is that DLL are allways loaded in the address space of the process that uses it. So your function pointer must be the same.

It's the same address on both sides:

I tried your code snippet with a small variant. In the DLL's main(), I've used:

    std::cout << "f in dll: " << (DWORD *)function << std::endl;

And in the programme's main(), I've used:

    std::cout << "f in main: " << (DWORD *)f << std::endl;

Exactly the same address comes out ! Allways !

What's the problem with your code ?

In your code snippet, you don't cout the function address directly, but you use oss:

std::stringstream oss;
oss << (DWORD *)function;
std::cout << "f in dll: " << oss << std::endl;  // ??? 

On my compiler (MSVC13), I get a compilation error for oss. I don't know why it works for you, but I suspect that you print the address of your stringstream and not its content. As oss is a local variable, it has a different address in both functions and hence the cause of you worries.

Try the alternative:

    std::cout << "f in dll: " << oss.str() << std::endl;

and you'll get again the same result (address printed out) on both sides.

On GCC your code compiles but doesn't produce the result that you expect as this online snippet shows.

Additional remarks

If the same DLL function would have different addresses, it would mean that you are in presence of two different processes, each with it's own address space.

When you make use of the optional DllMain() entry point, and call a (non exported) main() function there, it could give the impression of a distinct process, but that's really not the case.

I'd also like to add that function pointers are function poitners. There is no black magic with it. Two pointers of exactly the same type, pointing to exactly the same function, will have exactly the same address. Here the normative reference in the C++ standard:

5.10/1: Two pointers of the same type compare equal if and only if they are both null, both point to the same function, or both represent the same address.

Answer 2

address 007BFD88 does not have to be the address of an exported function from a DLL (which GetProcAddress() returns); it is just a function pointer. Function pointers in C/C++ have a few interesting properties, check this out: Why do function pointer definitions work with any number of ampersands '&' or asterisks '*'?