World Library  
Flag as Inappropriate
Email this Article

Dynamic loading

Article Id: WHEBN0010131591
Reproduction Date:

Title: Dynamic loading  
Author: World Heritage Encyclopedia
Language: English
Subject: Preference Pane, D-value (transport), Audio plug-in, Library (computing), Dynamic software updating
Publisher: World Heritage Encyclopedia

Dynamic loading

Dynamic loading is a mechanism by which a computer program can, at run time, load a library (or other binary) into memory, retrieve the addresses of functions and variables contained in the library, execute those functions or access those variables, and unload the library from memory. Unlike static linking and loadtime linking, this mechanism allows a computer program to start up in the absence of these libraries, to discover available libraries, and to potentially gain additional functionality.[1][2]


Dynamic loading was a common technique for IBM/360 Operating systems (1960s to, the - still extant - Z/Architecture), particularly for I/O subroutines, and for COBOL and PL/1 runtime libraries. As far as the application programmer is concerned, the loading is largely transparent, since it is mostly handled by the operating system (or its I/O subsystem). The main advantages are:

  • Fixes (patches) to the subsystems fixed all programs at once, without the need to relink them
  • Libraries could be protected from unauthorized modification

IBM's strategic transaction processing system, CICS (1970s onwards) uses dynamic loading extensively both for its kernel and for normal application program loading. Corrections to application programs could be made offline and new copies of changed programs loaded dynamically without needing to restart CICS [3][4](that can, and frequently does, run 24/7).

Shared libraries were added to Unix in the 1980s, but initially without the ability to let a program load additional libraries after startup.[5]


Dynamic loading is most frequently used in implementing software plugins.[1] For example, the Apache Web Server's *.dso "dynamic shared object" plugin files are libraries which are loaded at runtime with dynamic loading.[6] Dynamic loading is also used in implementing computer programs where multiple different libraries may supply the requisite functionality and where the user has the option to select which library or libraries to provide.

In C/C++

Not all systems support dynamic loading. UNIX-like operating systems such as Mac OS X, Linux, and Solaris provide dynamic loading with the C programming language "dl" library. The Windows operating system provides dynamic loading through the Windows API.


Name Standard POSIX/UNIX API Microsoft Windows API
Header file inclusion #include #include
Definitions for header dl

(, libdl.dylib, etc. depending on the OS)

Loading the library dlopen LoadLibrary
Extracting contents dlsym GetProcAddress
Unloading the library dlclose FreeLibrary

Loading the Library

Loading the library is accomplished with LoadLibrary or LoadLibraryEx on Windows and with dlopen on UNIX-like operating systems. Examples follow:

Most UNIX-like operating systems (Linux, *BSD, Solaris, etc.)

void* sdl_library = dlopen("", RTLD_LAZY);
if (sdl_library == NULL) {
   // report error ...
} else {
   // use the result in a call to dlsym

Mac OS X

As a UNIX library:

void* sdl_library = dlopen("libsdl.dylib", RTLD_LAZY);
if (sdl_library == NULL) {
   // report error ...
} else {
   // use the result in a call to dlsym

As an OS X Framework:

void* sdl_library = dlopen("/Library/Frameworks/SDL.framework/SDL", RTLD_LAZY);
if (sdl_library == NULL) {
   // report error ...
} else {
   // use the result in a call to dlsym

Or if the framework or bundle contains Objective-C code:

NSBundle *bundle = [NSBundle bundleWithPath:@"/Library/Plugins/Plugin.bundle"];
NSError *err = nil;
if ([bundle loadAndReturnError:&err])
    // Use the classes and functions in the bundle.
    // Handle error.


HMODULE sdl_library = LoadLibrary("SDL.dll");
if (sdl_library == NULL) {
   // report error ...
} else {
   // use the result in a call to GetProcAddress

Extracting Library Contents

Extracting the contents of a dynamically loaded library is achieved with GetProcAddress on Windows and with dlsym on UNIX-like operating systems.

UNIX-like operating systems (Linux, *BSD, Mac OS X, Solaris, etc.)

void* initializer = dlsym(sdl_library,"SDL_Init");
if (initializer == NULL) {
   // report error ...
} else {
   // cast initializer to its proper type and use

On OS X, when using Objective-C bundles, one can also:

Class rootClass = [bundle principalClass]; // Alternatively, NSClassFromString() can be used to obtain a class by name.
if (rootClass)
    id object = [[rootClass alloc] init]; // Use the object.
    // Report error.


FARPROC initializer = GetProcAddress(sdl_library,"SDL_Init");
if (initializer == NULL) {
   // report error ...
} else {
   // cast initializer to its proper type and use

Converting Extracted Library Contents

The result of dlsym() or GetProcAddress() has to be converted to the desired destination before it can be used.


In the Windows case, the conversion is straightforward, since FARPROC is essentially already a function pointer:

typedef INT_PTR (*FARPROC)(void);

This can be problematic when the address of an object is to be retrieved rather than a function. However, usually one wants to extract functions anyway, so this is normally not a problem.

typedef void (*sdl_init_function_type)(void);
sdl_init_function_type init_func = (sdl_init_function_type) initializer;


According to the POSIX specification, the result of dlsym() is a void pointer. However, a function pointer is not required to even have the same size as an object pointer, and therefore a valid conversion between type void* and a pointer to a function may not exist on all platforms.

On most systems in use today, function and object pointers are de facto convertible. The following code snippet demonstrates one workaround which allows to perform the conversion anyway on many systems:

typedef void (*sdl_init_function_type)(void);
sdl_init_function_type init_func = (sdl_init_function_type)initializer;

The above snippet will give a warning on some compilers: warning: dereferencing type-punned pointer will break strict-aliasing rules. Another workaround is:

typedef void (*sdl_init_function_type)(void);
union { sdl_init_function_type func; void * obj; } alias;
alias.obj = initializer;
sdl_init_function_type init_func = alias.func;

which disables the warning even if strict aliasing is in effect. This makes use of the fact that reading from a different union member than the one most recently written to (called "type punning") is common, and explicitly allowed even if strict aliasing is in force, provided the memory is accessed through the union type directly.[7] However, this is not strictly the case here, since the function pointer is copied to be used outside the union.

Solving the function pointer problem on POSIX systems

The fact remains that any conversion between function and object pointers has to be regarded as an (inherently non-portable) implementation extension, and that no "correct" way for a direct conversion exists, since in this regard the POSIX and ISO standards contradict each other.

Because of this problem, the POSIX documentation on dlsym() (issue 6) stated that "a future version may either add a new function to return function pointers, or the current interface may be deprecated in favor of two new functions: one that returns data pointers and the other that returns function pointers".[8] However, the most current version of the standard (issue 7, 2008) simply states that function pointers have to be convertible to void* for POSIX compliance,[9] leaving compiler makers to choose which standard they adhere to.

If the contents of the library can be changed (i.e. in the case of a custom library), in addition to the function itself a pointer to it can be exported. Since a pointer to a function pointer is itself an object pointer, this pointer can always be legally retrieved by call to dlsym() and subsequent conversion. However, this approach requires maintaining separate pointers to all functions that are to be used externally, and the benefits are usually small.

Unloading the Library

Loading a library causes memory to be allocated; the library must be deallocated in order to avoid a memory leak. Additionally, failure to unload a library can prevent filesystem operations on the file which contains the library. Unloading the library is accomplished with FreeLibrary on Windows and with dlclose on UNIX-like operating systems. However, unloading a DLL can lead to program crashes if objects in the main application refer to memory allocated within the DLL. For example, if a DLL introduces a new class and the DLL is closed, further operations on instances of that class from the main application will likely cause a memory access violation. Likewise, if the DLL introduces a factory function for instantiating dynamically loaded classes, calling or dereferencing that function after the DLL is closed leads to undefined behaviour.

UNIX-like operating systems (Linux, *BSD, Mac OS X, Solaris, etc.)




Special Library

Both Windows and UNIX implementations of dynamic loading allow programmers to extract symbols from the currently executing process. In both of these APIs, the currently executing process can be "loaded" such that the result can be used in the same manner as the result from dynamically loading a library with LoadLibrary or dlopen.

UNIX-like operating systems (Linux, *BSD, Mac OS X, Solaris, etc.)

void* this_process = dlopen(NULL,0);


HMODULE this_process;

HMODULE this_process_again = GetModuleHandle(0);

In Java

In the Java programming language, classes can be dynamically loaded using the ClassLoader object. For example:

Class type = ClassLoader.getSystemClassLoader().loadClass(name);
Object obj = type.newInstance();

Similarly, libraries implementing native methods are dynamically loaded using the System.loadLibrary method. There is however no System.unloadLibrary method.

Platforms without dynamic loading

Despite its promulgation in the 1980's through UNIX and Windows, some systems still chose not to add—or even to remove—dynamic loading. For example, Plan 9 from Bell Labs and its successor 9front consider dynamic linking harmful, and purposefully do not support it.

See also

External links

  • General Links
    • Dynamic Loading on Linux4U
    • Dynamic Shared Object (DSO) Support by Apache
    • C++ Dynamic Linking By Example
    • Dynamic Library Loading Example (complete but concise working example)
    • Dynamic Library Programming Topics from Apple Developer Connection (target to Mac OS X)
  • C/C++ UNIX API:
    • dlopen
    • dlsym
    • dlclose
  • C/C++ Windows API:
    • LoadLibrary
    • GetProcAddress
    • FreeLibrary
    • Delay-Loaded DLLs
  • Java API:
    • ClassLoader
    • Class


  1. ^ a b Autoconf, Automake, and Libtool: Dynamic Loading
  2. ^ Linux4U: ELF Dynamic Loading
  3. ^
  4. ^
  5. ^ W. Wilson Ho; Ronald A. Olsson (1991). "An approach to genuine dynamic linking". Software—Practice and Experience 21 (4): 375–390.  
  6. ^ Apache 1.3 Dynamic Shared Object (DSO) Support
  7. ^ GCC 4.3.2 Optimize Options: -fstrict-aliasing
  8. ^ dlopen()POSIX documentation on (issue 6).
  9. ^ dlopen()POSIX documentation on (issue 7)
  • The two subsections 8.1.4 "Dynamic Loading" and 8.1.5 "Dynamic Linking and shared libraries" in Silberschatz, Abraham; Galvin, Peter Baer; Gagne, Greg (2005). Operating System Concepts. J. Wiley & Sons.  
This article was sourced from Creative Commons Attribution-ShareAlike License; additional terms may apply. World Heritage Encyclopedia content is assembled from numerous content providers, Open Access Publishing, and in compliance with The Fair Access to Science and Technology Research Act (FASTR), Wikimedia Foundation, Inc., Public Library of Science, The Encyclopedia of Life, Open Book Publishers (OBP), PubMed, U.S. National Library of Medicine, National Center for Biotechnology Information, U.S. National Library of Medicine, National Institutes of Health (NIH), U.S. Department of Health & Human Services, and, which sources content from all federal, state, local, tribal, and territorial government publication portals (.gov, .mil, .edu). Funding for and content contributors is made possible from the U.S. Congress, E-Government Act of 2002.
Crowd sourced content that is contributed to World Heritage Encyclopedia is peer reviewed and edited by our editorial staff to ensure quality scholarly research articles.
By using this site, you agree to the Terms of Use and Privacy Policy. World Heritage Encyclopedia™ is a registered trademark of the World Public Library Association, a non-profit organization.

Copyright © World Library Foundation. All rights reserved. eBooks from Project Gutenberg are sponsored by the World Library Foundation,
a 501c(4) Member's Support Non-Profit Organization, and is NOT affiliated with any governmental agency or department.