macOS Dynamic Libraries

From Free Pascal wiki
Revision as of 07:13, 29 April 2020 by Trev (talk | contribs) (→‎Overview: Expanded on use of dynamic libraries.)
Jump to navigationJump to search


There are two important factors which determine the performance of applications: their launch times and their memory footprints. Reducing the size of an executable file and minimizing its memory use once launched make an application launch faster and use less memory. Using dynamic libraries instead of static libraries reduces the executable file size of an application. Dynamic libraries also allow applications to delay loading libraries with special functionality until they’re needed instead of loading them at launch time. This feature contributes further to reduced launch times and efficient memory use. Another reason to use dynamic libraries is so that you can share code among multiple applications thereby saving the memory (and to a lesser extent, disk space) that would otherwise be used for multiple copies of the library code.

Static vs Dynamic


Note: Dynamic libraries are also known as dynamic shared libraries, shared objects, or dynamically linked libraries.
Static libraries are also known as static archive libraries and static linked shared libraries.

Most of an application's functionality is implemented in libraries of executable code. When an application's source code is compiled into object code and linked with a static library, the object code and library code that the application uses is copied into the executable file that is loaded into memory in its entirety at runtime. The kind of library that becomes part of an application's executable is known as a static library. Static libraries are collections or archives of object files.

A better approach is for an application to load code into its address space when it’s actually needed, either at launch time or at runtime. The type of library that provides this flexibility is called a dynamic library. Dynamic libraries are not statically linked into the executable and therefore do not become part of the executable. Instead, dynamic libraries can be loaded (and linked) into an application either when the application is launched or as it runs.

Example dynamic library


library TestLibrary;
{$mode objfpc} {$H+}

  // needed for UpperCase

// library subroutine
function cvtString(strIn : string) : PChar; cdecl;
    cvtString := PChar(UpperCase(strIn));

// exported subroutine(s)


 fpc test.pas

which produces the dynamic library file named libtest.dylib.

Example application to load dynamic library


Program dynlibdemo;
{$mode objfpc}{$H+}


   // definition of the subroutine to be called as defined in the dynamic library to be loaded
   TcvtString = function(strToConvert : string) : PChar;  cdecl;

   // create suitable variable for the dynamic library subroutine
   cvtString : TcvtString;

   // create a handle for the dynamic library
   LibHandle : TLibHandle;

   // load and get the dynamic library handle
   LibHandle := LoadLibrary(PChar('libtest.dylib'));

   // check whether loading was successful
   if LibHandle <> 0 then
       // assign address of the subroutine call to the variable cvtString
       Pointer(cvtString) := GetProcAddress(LibHandle, 'cvtString');

       // check whether a valid address has been returned
       if @cvtString <> nil then
         WriteLn(cvtString('hello world'))
       // error message on no valid address
         WriteLn('GetLastOSError1 = ', SysErrorMessage(GetLastOSError));
     // error message on load failure
     WriteLn('GetLastOSError2 = ', SysErrorMessage(GetLastOSError));

   // release memory
   cvtString := nil;


 fpc dynlibdemo.pas


$ ./dynlibdemo

Additional steps using a Lazarus project

If you turn test.pas above into a Lazarus project named project1 and create an application bundle then you need to:

  • Delete the symbolic link to the executable file
  • Copy the project1 executable file into the
  • Copy libTestLibrary.dylib into the directory
  • Change into the directory
  • Enter: install_name_tool -add_rpath @executable_path/. project1

This ensures that the project1 executable in your application bundle will look in the directory in which it is located to find your dynamic library.

For more information on the install_name_tool utility, open a Terminal and enter:

 man install_name_tool

See also