Dynamic Linked Libraries [VC++]

7/28/2019 Dynamic Linked Libraries [VC++]

1/22

Dynamic Link Library(DLL)

Ajay SinghSE Trainee : C++

Nagarro Software Pvt. Ltd.


2/22

Index

Linking & Loading. Static Vs. Dynamic Libraries.

DLLs in VC++.

DLL entry point, DllMain().

Exporting functions from DLL.

Using exported functions from Implicit / Explicit DLL.

Exporting a DLL class

@ Load Time

@ Run Time

Using Vtable.

Using __declspec (dllexport)

Problems with Dynamic DLL


3/22

Linking and Loading

Loading Combining multiple object files and

library modules into a single re-

loadable executable file. (i.e.

Addresses are relative to 0)

Mapping addresses within file tophysical memory addresses.

Resolving names of dynamic library

items.

Linking Combining set of programs, including library routines, to create loadable image. Resolving symbols defined and binding names to addresses.

Generating re-locatable object code (ELF: Addresses relative to 0).


4/22

If several processes call the same object module of ashared library simultaneously,

Dynamic: Only one copy in memory.

Static: Several copies each for a process in memory.

Which one is better, static or dynamic? Construct some programs of different size linked in both

versions to compare:

Executable Size

Loading Time

Running Time

Number of System Calls

Memory Usage

Static vs. Dynamic Linking


5/22

Executable Size (Byte)

Static Dynamic (Loading) Dynamic (Running)

Small 422596 5152 6300

Median 431413 5152 6297

Large 443384 5134 6312

Static

0

2000

4000

6000

8000

0% 30% 60% 90% 100%Percentage of Static Libraries

ExeSize(Bytes)

Loading Time

02000400060008000

100001200014000


LoadingTime(us)

Running Time

05

1015202530


RunningTime(s)


6/22

Running Time

01 0

2 0

3 0

4 0

5 0

6 0

Sm a ll M e di a n La r ge

S t a t i cL o a d i n gR u n n i n g

Loading Time

02 0 0 04 0 0 06 0 0 08 0 0 0

1 0 0 0 01 2 0 0 01 4 0 0 01 6 0 0 0

S m a l l M e d i a n L a r g e

S t a t i cL o a d i n gR u n n i n g


7/22

Number of

System Calls

0

50

10 0

15 0

20 0

Small Median Large

StaticLoadingRunning

Memory Usage(Byte)

0

2 0 0 0

4 0 0 0

6 0 0 0

8 0 0 0

O ne P ro ce ss F iv e D if fP r o g r a m s

F i v eI n s t a n c e s

S t a t i cD y n a m i c


8/22

Static linking VS. Dynamic linking

Dynamic produces smaller executable files.

Dynamic consumes less memory.

But

Dynamic runs more slowly.

Dynamic has more system calls.

Dynamic need more loading time.


9/22

DLLs in VC++ Dynamic-link library (DLL), is Microsoft's implementation of the Shared

Library concept in the MS Windows and OS/2 Operating Systems. Theselibraries usually have file extension as DLL, OCX (for libraries

containing ActiveX controls), or DRV (for legacy System Drivers). The file

formats for DLL is, Portable Executable (PE). DLLs can contain Code, Data and

Resources, in any combination.

Advantages of using DLLs:

Saves memory and reduces swapping.

Upgrades to the DLL are easier.

Provides after-market support..

Supports multi-language programs. Provides a mechanism to extend the MFC library classes.

Eases the creation of international versions (by using Resource DLLs).


10/22

DLL entry point DllMain()DllMain(), An optional entry point into a dynamic-link library (DLL). When the system starts

or terminates a process or thread, it calls the entry-point function for each loaded DLL using

the first thread of the process. The system also calls the entry-point function for a DLL whenit is loaded or unloaded using the LoadLibrary and FreeLibrary functions.

BOOL APIENTRY DllMain(

HMODULE hModule, // Base address of the DLL == HINSTANCE of a DLL.

DWORD ul_reason_for_call, // why the DLL entry-point function is being called

LPVOID lpReserved // Reserved by the System.

)

{

switch (ul_reason_for_call)

{

case DLL_PROCESS_ATTACH: // DLL being loaded into virtual address space.

case DLL_THREAD_ATTACH: // The current process is creating a new thread.

case DLL_THREAD_DETACH:

case DLL_PROCESS_DETACH:

break;

}

return TRUE; // Must return TRUE, else process terminates with an error.

}


11/22

Exporting a function from DLLTestDll.h

#ifdef __cpluscplus // Automatically defined when C+ compiler is used.

#define EXPORT extern "C" __declspec (dllexport)

#else

#define EXPORT __declspec (dllexport)

#endif

EXPORT void DllFunction ((LPCWSTR lpMsgText);

TestDll.cpp

EXPORT void DllFunction (LPCWSTR lpMsgText) {

MessageBox (GetActiveWindow (), lpMsgText, _T("DllFunction"), MB_OK);

}

extern C : makes a function-name in C++ have 'C' linkage (compiler does not

mangle the name) so that client code can link to/use function using a 'C'

compatible header file. extern "C" forces a function to have external linkage(cannot make it static).

__declspec (dllexport) : allow the compiler to generate the exported names

automatically and place them in a .lib file. This .lib file can then be used just like

a static .lib to link with a DLL.


12/22

DLL @ Load Time Include header file containing declarations of all exported

functions in DLL.#include "..\\TestDll\\TestDll.h"

#pragma comment (lib, "..\\Debug\\TestDll.lib")

TestDll.lib file can now be used just like a static .lib to link functions

in DLL.

Calling DLL Function:LRESULT CALLBACK WndProc

(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{switch (message)

{

case WM_CREATE:

DllFunction (_T(Creating Your Window));

break;


13/22

DLL @ Run Time LoadLibrary() : Loads the specified module into the address space of the

calling process. The specified module may cause other modules to be loaded.

FreeLibrary() : Frees the loaded dynamic-link library (DLL) module and, if

necessary, decrements its reference count. When the reference count

reaches zero, the module is unloaded from the address space of the calling

process and the handle is no longer valid. Example:

typedef void (CALLBACK* pFnSHOWMSG) (LPCWSTR);

pFnSHOWMSG pfnShowMsg;

Case WM_CREATE:if ((hLibrary = LoadLibrary (_T(TestDll.DLL"))) == NULL) {

MessageBox (hWnd, _T(TestDll.DLL can't be loaded."), 0, MB_ICONERROR);

return -1L;} // else load functions from DLL.

pfnShowMsg = (pFxnSHOWMSG) GetProcAddress(hLibrary, DllFunction);

pfnShowMsg (_T(Its a run-time DLL.));

FreeLibrary (hLibrary);


14/22

TestDll.h#define DllExport __declspec (dllexport)

class DllExport A

{

int m_nNum;

public:

A() : m_nNum (0) {}

A(int n) : m_nNum (n) {}

~A() {}

void SetNum (int n);

int GetNum (void);

};

Exporting a DLL Class @ Load Time

TestDll.cpp

void A::SetNum (int n) { m_nNum = n; }

int A::GetNum (void) { return m_nNum; }

YourApp.hInclude .h and .lib in a normal fashion

#include "..\\TestDll\\TestDll.h"

#pragma comment (lib, "..\\Debug\\TestDll.lib")

We can also locate TestDll.lib in Project Property.

YourApp.cpp

With DLL loaded at load time, use DLL class same

way as youve defined the class in your

application.

Eg.A aObj;

aObj.SetNum (2258);

iClassData = aObj.GetNum ();


15/22

Exporting a DLL Class @ Run Time TestDll.h Approach #1#define DllExport extern "C" __declspec (dllexport)

class CSample{

int m_nNum;

public:

CSample() : m_nNum(0) {}

CSample(int n) : m_nNum(n) {}

virtual ~CSample() {} // All exportable functions are declared to be virtual

virtual void SetNum (int n);

virtual int GetNum (void);

virtual void OverloadedFx(void);

virtual void OverloadedFx (int);

static int m_siData;

int m_iData;

static int GetStaticData(); // { return m_siData; }// fx is inlined.

};

// Now export methods to return CSample objects

extern "C" __declspec (dllexport) CSample* CreateSampleObject_v (void);

extern "C" __declspec (dllexport) CSample* CreateSampleObject_i (int n);


16/22

TestDll.cpp// Functions to export Dll Class objects

extern "C" __declspec (dllexport) CSample* CreateSampleObject_v (void) {

return new CSample();

}

extern "C" __declspec (dllexport) CSample* CreateSampleObject_i (int n) {

return new CSample(n);

}

// Definition for CSample class member functions

void CSample::SetNum (int n) {m_nNum = n; }int CSample::GetNum () { return m_nNum; }

void CSample::OverloadedFx (void) {

MessageBox (GetActiveWindow(), _T("Overloaded Function in Dynamic DLL\n----------\n

CSample::OverloadedFx (void)"),_T("OverloadedFx (void)"), MB_ICONINFORMATION);

}

void CSample::OverloadedFx (int) {

MessageBox (GetActiveWindow(), _T("Overloaded Function is Dynamic DLL\n-----------\nCSample::OverloadedFx (int)"),_T("OverloadedFx (int)"), MB_ICONINFORMATION);

}

// Definition for CSample static Data

int CSample::m_siData = 1234;

int CSample::GetStaticData () { return m_siData; }

Exporting a DLL Class (2)


17/22

YourApp.cppLRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {

HINSTANCE hLibrary;

// pFx : Default CSample Constructor

typedef CSample* (*pFnGET_DEF_OBJ) (void);

pFnGET_DEF_OBJ pfnGetDefObj;

// pFx : Parameterized CSample Constructortypedef CSample* (* pFnGETOBJ) (int);

pFnGETOBJ pfnGetObj;

// Pointers to TestDll Class Objects

CSample* p_vObj;

int iClassData;

switch (message) {

case WM_CREATE:

hLibrary = LoadLibrary (_T(TestDll.DLL));

pfnGetDefObj = (pFnGET_DEF_OBJ) GetProcAddress (hLibrary, CreateSampleObject_v );

Contd



18/22

p_vObj = (pfnGetDefObj )();

// Now all the virtual functions in CSample class are accessible using vptr / vtable.iClassData = p_vObj->GetNum();

p_vObj->SetNum (2258);

// Can use overloaded functions in normal obvious way.

(*p_vObj).OverloadedFx ();

p_vObj->OverloadedFx (1837);

FreeLibrary (hLibrary);

break;

case // Other messages

} // end of switchreturn DefWindowProc (hWnd, message, wParam, lParam);

}

*. Exporting a DLL class using virtual functions creates a basis for COM

(Component Object Model, enable software components to communicate).



19/22

Exporting a DLL Class @ Run TimeApproach#2

TestDll.h

#define DllExport __declspec (dllexport)class DllExport A

{

int m_nNum;

public:

A() : m_nNum (0) {}

A(int n) : m_nNum (n) {}

~A() {}

void SetNum (int n);

int GetNum (void);

};

TestDll.cppvoid A :: SetNum (int n) { m_nNum = n; }

Int A :: GetNum () { return m_nNum; }

TestDll.DEFLIBRARY TestDll

EXPORTS

ConstructAi= ??0A@@QAE@H@ZPRIVATE

ConstructAv= ??0A@@QAE@XZPRIVATE

DestructA= ??1A@@QAE@XZPRIVATE

GetNum= ?GetNum@A@@QAEHXZPRIVATESetNum= ?SetNum@A@@QAEXH@ZPRIVATE

Module DEFinition File provide the linker with

information about exports, attributes, and

other information about the program to be

linked.Dependency Walker is a free utility that scans

any 32-bit or 64-bit Windows module (exe, dll,

ocx, sys, etc.) and builds a hierarchical tree

diagram of all dependent modules. For each

module found, it lists all the functions that are

exported by that module.


20/22

YourApp.cppLRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

HINSTANCE hLibrary;A* pDllClassObj;

// Creating pointer to a member function type

typedef void (A::*pFnConstructorOfAi) (int);

typedef void (A::*pFnConstructorOfAv) ();// i : int, v : void

typedef void (A::*pFnSetNumOfA) (int);

typedef int (A::*pFnGetNumOfA) (void);

switch (message) {

case WM_CREATE:

hLibrary = LoadLibrary (_T(TestDll.DLL));

pDllClassObj = (A*) _alloca (sizeof(A));pFnConstructorOfAv pfnConsDefA = reinterpret_cast

(GetProcAddress (hTestLibrary, " ConstructAv"));

pFnSetNumOfA pfnSetNum = reinterpret_cast

(GetProcAddress (hTestLibrary, " SetNum"));

pDllClassObj->pfnSetNum (2258); // and same way use rest of the class functions



21/22

Problems with:

Overloaded FunctionsSuppose were loading DLL at run-time and have done something like:

#define DllExport __declspec (dllexport)

class DllExportDLLClass { };

We cant export overloaded functions with single name, since .DEF file must

contain unique entries for C++ mangled (decorated) class member functions.

Static Data Member

o A static declared variable seems not to be consistent over DLL boundaries.

o The static member is not accessed directly by code in the calling application, only

through member functions of the class in the dll.

o inline functions accessing the static member: Those functions will be inline

expanded into the calling applications code making the calling application access

the static member directly. That will violate the finding referenced above that

static variables are local to the dll and cannot be referenced from the calling

application.

Exporting a DLL Class @ Run Time


22/22

Thank You!

Dynamic Linked Libraries [VC++]

Documents

Transcript of Dynamic Linked Libraries [VC++]