Global DLL Import of Functions

[ahagley]

The problem:
1) I'm not a programmer, most of the time I'm a physicist, but I do numerical simulation.

2) I have a DLL that I want to use functions from. I have the .h file associated with the DLL, but no .def or library that I can use for static linking.

I am trying to implement the GMP (GNU multiprecision library) in a large simulation code that I’ve been running on a PC, written in standard C. I’ve been using MetroWerks CodeWarrior IDE for the compiling and debugging.

The libraries are actually from the GNU project, but unfortunately, only the unix versions of the static library are available, and I’ve not managed to find a way to convert them for use in CodeWarrior. I did manage to find a version of the DLL (used by both Maple and Matlab), and a DLL viewer that lets me look at what routines are in the DLL. Using the GMP manual, I was able to get the function definitions. With this data, I’m trying to import the functions in GMP.dll into the simulation code.

I tested the routines by writing a small piece of code that imported the functions as shown below. In this simple routine I could load and execute the functions. The problem is that I want to use the functions in MANY routines distributed in six other files in the simulation code. I would like to import the functions from the DLL so that they are global in scope.

I can link the functions successfully using the following code, inside main.c,

(only one function is shown for brevity..)

#include <gmp.h>
 
typedef void     (*importFunction ) (unsigned long int);        // mpf_set_default_prec 
..
..
int main(void)
{
..
..
importFunction mpf_set_default_prec; //---line(1)
//
// Load the DLL
//          
HINSTANCE hinstLib = LoadLibrary("gmp.dll");
 if(hinstLib == NULL)
 {
            printf("ERROR: unable to load gmp.dll\n");
            return  1;
 }
 
 
 mpf_set_default_prec = ((importFunction)GetProcAddress(hinstLib, "__gmpf_set_default_prec"));
 ..
}

My question is this. The above code works, but only allows me to define the function in the present routine. I want to use the imported functions in several function in my code.

When I try to make the definition of mpf_set_default_prec global, by moving line 1 outside the definition of main, I get the following error,

Error : identifier '__gmpf_set_default_prec(unsigned long)' redeclared
was declared as: 'void (unsigned long)'
now declared as: 'void (*)(unsigned long)'
main.c line 17 importFunction mpf_set_default_prec;

Error : not an lvalue
main.c line 44 mpf_set_default_prec = ((importFunction)GetProcAddress(hinstLib, "__gmpf_set_default_prec"));

So, do I have to link to the DLL and load the functions within it inside each function that I want to use the imported functions in? Or is there some way to link to the library once and make the function available globally?

Any help would be very greatly appreciated.

Andre

[RedSon]

Thanks for editing your code to only display the relevant parts, but in the future please enclose your posted code in [code] tags (See How to Ask a Question).

This makes it easier for our Experts to read and understand it. Failing to do so creates extra work for the moderators, thus wasting resources, otherwise available to answer the members' questions.

Please use [code] tags in future.

MODERATOR

[weaknessforcats]

mpf_set_default_prec = ((importFunction)GetProcAddress(hinstLib, "__gmpf_set_default_prec"));
..

What I recommend is to declare a function pointer with the same name as the function in the DLL. Function pointers have to be declared with the same arguments and return types as the actual function.

You could declare these function pointers globally so they would be accessible anywhere in the program.

Take the function "__gmpf_set_default_prec" that you used to call GetProcAddress(). GetProcAddress() returns a FARPROC so your code should look like:

FARPROC fp = GetProcAddress(hinstLib, "__gmpf_set_default_prec"));
 

Next, you typecast fp so you can assign it to the correct function pointer. For this example I will assume this function has and int and a double argument and returns a double (I realize I am making this up for purposes of illustration).

//
//Declare a global function pointer:
//to a function that has and int and a double argument
//and returns a double.
//Give it the name of the actual function in the dll.
double (*__gmpf_set_default_prec)(int, double);
 
int main()
{
     //do the load library, etc;
 
FARPROC fp;
//
//Get the address of the function from the DLL
fp = GetProcAddress(hinstLib, "__gmpf_set_default_prec"));
//
//Then typecast the FARPROC to your function pointer
//
__gmpf_set_default_prec = double (*)(int, double)fp;
 
//Now the address of __gmpf_set_default_prec() inside the DLL is also inside
//the function pointer __gmpf_set_default_prec.
 
//From here on you call the function using the function pointer:
 
double result = __gmpf_set_default_prec(3, 1.5);
 
//And it looks like you called the function directly.
 
}
 

[ahagley]

What I recommend is to declare a function pointer with the same name as the function in the DLL. Function pointers have to be declared with the same arguments and return types as the actual function.

You could declare these function pointers globally so they would be accessible anywhere in the program.

Take the function "__gmpf_set_default_prec" that you used to call GetProcAddress(). GetProcAddress() returns a FARPROC so your code should look like:

FARPROC fp = GetProcAddress(hinstLib, "__gmpf_set_default_prec"));
 

Next, you typecast fp so you can assign it to the correct function pointer. For this example I will assume this function has and int and a double argument and returns a double (I realize I am making this up for purposes of illustration).

//
//Declare a global function pointer:
//to a function that has and int and a double argument
//and returns a double.
//Give it the name of the actual function in the dll.
double (*__gmpf_set_default_prec)(int, double);
 
int main()
{
     //do the load library, etc;
 
FARPROC fp;
//
//Get the address of the function from the DLL
fp = GetProcAddress(hinstLib, "__gmpf_set_default_prec"));
//
//Then typecast the FARPROC to your function pointer
//
__gmpf_set_default_prec = double (*)(int, double)fp;
 
//Now the address of __gmpf_set_default_prec() inside the DLL is also inside
//the function pointer __gmpf_set_default_prec.
 
//From here on you call the function using the function pointer:
 
double result = __gmpf_set_default_prec(3, 1.5);
 
//And it looks like you called the function directly.
 
}
 

This almost works.
I had to remove the definititions in the header file to prevent redefinitions, but I was able to get the functions working in the routine main.

I still have a problem however. If I try to use the global function pointers in other code files I get either a "Access Violation at address xxxx".

It seems that I'm not actually getting a global definition of the functions. If I write another function in the main.c file, it can access the functions imported from the library properly. If I move that same function to another file, compile and link, I get the error.

If I use a function prototype in the other file, I get multiple definitions of the pointer and the same error...

How do I fix this?

Thanks,
Andre

[weaknessforcats]

OK, here's what I did:

1) I created a source file with this code:

#include <iostream>
using namespace std;
 
extern void (__stdcall *__gmpf_set_default_prec)(int arg);
 
void TestCase()
{
    cout << "Entering TestCase()" << endl;
    __gmpf_set_default_prec(25);
     cout << "Leaving TestCase()" << endl;
 
}
 

I made up that your function has an int argument.

As you can see I have an extern to a a function pointer that:
1) must be an __stdcall
2) takes an int argument
3) happens to be the same name as the function in the dll.

In the main() (in another source file) I load the library and use GetProcAddress to find the function in the dll, typecast the return from GetProcAddress to the function pointer and then call the function.

Afterwards I call the same function in the TestCase() function in the other file.
Here is my main():

using namespace std;
 
void (__stdcall *__gmpf_set_default_prec)(int arg);
void (__stdcall *DisplayFromDll)();
void TestCase();
 
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
 
 
    cout << "Calling functions from a dll" << endl;
 
    //First, load the dll into memory
    //C:\Scratch\Instructor\Debug
    HMODULE theDll = LoadLibrary(TEXT("C:\\Scratch\\Instructor\\Debug\\ADll.dll"));
    if (!theDll)
    {
        cout << "The dll failed to load" << endl;
        return 1;
    }
 
    //Second, get the address of the desried function from the dll
    FARPROC addr = GetProcAddress(theDll, "__gmpf_set_default_prec");
    if (!addr)
    {
 
        //Look up the error in the system errors list
        unsigned int what = GetLastError();
        if (what == ERROR_PROC_NOT_FOUND)
        {
            cout << "Function not found in the dll" << endl;
        }
        else
        {
            cout << "Error: " << what << endl;
        }
        return 2;
    }
    cout << "The function has been located in the dll" << endl;
    //Declare a function pointer that can accept the address of the function.
    //You will need to know the function prototype to do this.
    //Dll function prototypes should be provided by the vendor of the dll
    //Type-cast the address returned from GetProcAddress to the function pointer type
    __gmpf_set_default_prec = reinterpret_cast<void (__stdcall *)(int)>  (addr);
 
    //Now use the function pointer to call the function:
    __gmpf_set_default_prec(3);
 
    TestCase();
 
    //Finally, unload the dll from memory
    FreeLibrary(theDll);
 
    return 0;
}
 

The function pointer is gloabal so the TestCase in the other file can access it.

As far as the DLL goes, this is the DEF file:

;BEGIN ADLL.DEF FILE
;This DEF file is required becuase the argument to GetProcAddress()
;for the function is a C-string and it will never be equal to the
;C++ mangled name for the function
;This DEF file maps the mangled name to a name that can be used with GetProcAddress()
;Note also: Change project settings in Visual Studio to send the LINK this def file.
;Visual Studio.NET: Project Properties/Linker/Input/Module Definition File/...Path to the def file\Adll.def
LIBRARY ADll 
EXPORTS 
;Exported Name    C++ Mangled Name
AreaOfSquare   =  ?AreaOfSquare@@YGHHH@Z
DisplayFromDll =  ?DisplayFromDll@@YGXXZ
__gmpf_set_default_prec = ?__gmpf_set_default_prec@@YGXH@Z
;END DEF FILE 
 

The DLL itself is:

#include <iostream>
using namespace std;
 
void __stdcall DisplayFromDll()
{
    cout << "This function was called from ADLL.dll" << endl;
}
 
int __stdcall AreaOfSquare (int len, int wid)
{
    return len * wid;
}
void __stdcall __gmpf_set_default_prec(int arg)
{
        cout << "Hello! The magic number is " << arg << endl;
}
 

The only stumbling block I had was failing to followe the instruction in the def file to add the path top the def file as a module definition for the linker. After I did that, then everything works.