Linking with x86 shared library on Linux x64

Dynamic Link Libraries, also known as Shared Libraries, are collections of compiled code, data, and resources that can be loaded and executed by an application at runtime. Shared libraries are commonly used in development of Linux applications and are an integral part of x86 architecture. In this article, we will explore the process of linking with x86 shared libraries on Linux x64 systems.

Understanding x86 Shared Libraries

An x86 shared library is a file that contains compiled code, data, and resources that can be shared among multiple applications at runtime. Shared libraries are loaded into memory only when required by an application, reducing the memory footprint of the application. They are commonly used to share code among multiple applications or to provide additional functionality to an application.

The x86 shared library format is designed to be platform independent, which means that a shared library compiled on one system can be used on another system, as long as both systems have the same architecture. This makes x86 shared libraries an ideal solution for creating portable software.

Linking with x86 Shared Libraries

To link an application with an x86 shared library on Linux x64, we need to follow these steps

Step 1: Create a Shared Library

The first step is to create a shared library that we want to link with our application. We can use any programming language to create a shared library, as long as it is compiled for x86 architecture.

For this example, we will use C programming language to create a shared library called libexample.so. We will create a simple function in the shared library that adds two integers and returns the result.

Here is the code for our shared library

// example.c
int add(int a, int b) {
    return a + b;
}

To create the shared library, we need to compile the code using the following command

gcc -shared -fPIC -o libexample.so example.c

This command will create a shared library called libexample.so in the current directory. The -fPIC flag generates position-independent code, which is required for shared libraries.

Step 2: Link Application with Shared Library

The next step is to link our application with the shared library. To do this, we need to use the -l option with the linker command.

Here is the code for our application

// app.c
#include <stdio.h>
#include <stdlib.h>

// Function declaration
extern int add(int a, int b);

int main(int argc, char **argv) {
    int a = 10;
    int b = 20;
    int c = add(a, b);
    
    printf("The result is: %d
", c);
    
    return 0;
}

To link the application with the shared library, we need to compile the code using the following command

gcc -o app app.c -L. -lexample

This command will link our application with the shared library libexample.so.

Step 3: Run the Application

The final step is to run our application. Since the shared library is in the current directory, we need to set the library path

export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
./app

This will execute our application and print the result of the function call to the console

The result is: 30

Additional Considerations

When linking with shared libraries, there are some additional considerations that we need to keep in mind

Library Search Path

When linking with a shared library, the linker needs to know where to find the library. By default, the linker looks for libraries in standard directories such as /usr/lib and /usr/local/lib. However, if our library is located in a different directory, we need to tell the linker where to find it.

We can do this by using the -L option, followed by the directory path. For example, if our library is located in the directory /home/user/lib, we can use the following command

gcc -o app app.c -L/home/user/lib -lexample

Symbol Visibility

When creating a shared library, we can specify the visibility of symbols that are exported by the library. By default, all symbols in a shared library are visible to other applications that link with the library. However, this can lead to naming conflicts if multiple libraries export symbols with the same name.

To avoid this, we can use the visibility attribute to specify the visibility of each symbol. There are three levels of visibility: default, hidden, and protected. To make a function hidden, we can use the following code

int __attribute__ ((visibility("hidden"))) add(int a, int b) {
    return a + b;
}

Common Linker Flags

When working with shared libraries, several important linker flags are commonly used

Conclusion

Linking with x86 shared libraries on Linux x64 systems enables code reusability and reduces memory footprint through dynamic loading. By following the proper compilation steps with appropriate flags like -fPIC and -shared, and managing library search paths correctly, developers can effectively utilize shared libraries for modular application development.