Creating a shared library always involves two separate commands: first, compiling source files into position-independent object files; second, linking those object files into the .so file.

gcc -g -c -fPIC -Wall mod1.c mod2.c mod3.c

gcc -g -shared -o libfoo.so mod1.o mod2.o mod3.o

It is possible to combine both steps into one GCC command. GCC is smart enough to handle compilation and shared library creation together:

gcc -g -fPIC -Wall mod1.c mod2.c mod3.c -shared -o libfoo.so

However, the book and most professional workflows keep the two steps separate because:

• It is clearer which step is compilation vs. library building
• The compiled .o files can be reused without recompiling
• Build systems like make handle incremental builds better with separate steps

With a static library (.a file), the individual object files (.o) retain their identities inside the archive. You can add or remove individual .o files from a .a archive using the ar command.

With a shared library (.so file), the object files are merged together during linking and lose their individual identities. You cannot extract or replace individual .o files from a .so. If you need to change one source file, you must rebuild all the object files and relink the entire .so.

After building libfoo.so, you link a program against it and run it:

# Link prog against libfoo.so in the current directory
gcc -Wall -o prog main.c -L. -lfoo

# Tell the dynamic linker to also search the current directory
export LD_LIBRARY_PATH=.

# Run the program
./prog

The LD_LIBRARY_PATH environment variable tells the dynamic linker (ld.so) where to find shared libraries at run time. This is fine for development, but not recommended for production. The proper solution is to install the library in a standard location like /usr/local/lib and run ldconfig.

A complete walkthrough: three source files, build as shared library, write a program that uses it, compile the program, and run it.

mod1.c — string utilities

/* mod1.c */
#include <stdio.h>
#include <string.h>

void print_upper(const char *str) {
    char buf[256];
    int i;
    for (i = 0; str[i] && i < 255; i++)
        buf[i] = (str[i] >= 'a' && str[i] <= 'z') ? str[i] - 32 : str[i];
    buf[i] = '\0';
    printf("%s\n", buf);
}

int string_len(const char *s) {
    return (int)strlen(s);
}

mod2.c — math utilities

/* mod2.c */
#include <stdio.h>

int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

double power(double base, int exp) {
    double result = 1.0;
    int i;
    for (i = 0; i < exp; i++)
        result *= base;
    return result;
}

mod3.c — info function

/* mod3.c */
#include <stdio.h>

void library_info(void) {
    printf("libutils.so version 1.0 — loaded successfully\n");
}

main.c — program using all three modules

/* main.c */
#include <stdio.h>

/* Declare functions from the shared library */
void print_upper(const char *str);
int string_len(const char *s);
int factorial(int n);
double power(double base, int exp);
void library_info(void);

int main(void) {
    library_info();

    print_upper("hello from shared library");
    printf("Length of 'hello': %d\n", string_len("hello"));

    printf("5! = %d\n", factorial(5));
    printf("2^10 = %.0f\n", power(2.0, 10));

    return 0;
}

Makefile to build everything

# Makefile for shared library demo
CC = gcc
CFLAGS = -g -Wall -fPIC

# Step 1: Compile each source to a PIC object file
mod1.o: mod1.c
	$(CC) $(CFLAGS) -c mod1.c

mod2.o: mod2.c
	$(CC) $(CFLAGS) -c mod2.c

mod3.o: mod3.c
	$(CC) $(CFLAGS) -c mod3.c

# Step 2: Link object files into shared library
libutils.so: mod1.o mod2.o mod3.o
	$(CC) -g -shared -o libutils.so mod1.o mod2.o mod3.o

# Step 3: Compile and link the main program
prog: main.c libutils.so
	$(CC) -g -Wall -o prog main.c -L. -lutils

# Run target: sets LD_LIBRARY_PATH and executes
run: prog
	LD_LIBRARY_PATH=. ./prog

clean:
	rm -f *.o *.so prog

# Build and run manually
gcc -g -Wall -fPIC -c mod1.c mod2.c mod3.c
gcc -g -shared -o libutils.so mod1.o mod2.o mod3.o
gcc -g -Wall -o prog main.c -L. -lutils
LD_LIBRARY_PATH=. ./prog

# Expected output:
# libutils.so version 1.0 — loaded successfully
# HELLO FROM SHARED LIBRARY
# Length of 'hello': 5
# 5! = 120
# 2^10 = 1024

These tools reveal what is inside your shared library: the symbol table, section headers, and relocation entries. Understanding this output is essential for debugging linking problems.

# After building libutils.so from the previous example:

# 1. nm — list all symbols in the shared library
nm -D libutils.so
# -D shows dynamic symbol table (what's exported)
# T prefix = function in text segment (defined, exported)
# U prefix = undefined (must come from another library)
# Output includes: factorial, power, print_upper, etc.

# 2. nm with better output (demangle, sort by address)
nm -D --defined-only libutils.so

# 3. readelf — show ELF headers and sections
readelf -h libutils.so        # ELF header (type, arch, entry point)
readelf -S libutils.so        # Section headers (.text, .data, .bss, etc.)
readelf -d libutils.so        # Dynamic section (soname, needed libs)
readelf --syms libutils.so    # Full symbol table

# 4. objdump — disassemble and show headers
objdump -d libutils.so        # Disassemble code sections
objdump --all-headers libutils.so   # All headers including dynamic
objdump -p libutils.so        # Program/segment headers

# 5. Check for TEXTREL — means some .o was compiled WITHOUT -fPIC
objdump --all-headers libutils.so | grep TEXTREL
readelf -d libutils.so | grep TEXTREL
# No output = good (all modules compiled with -fPIC)
# If TEXTREL appears = some module was missing -fPIC

# 6. Check if an object file was compiled with -fPIC
# Look for _GLOBAL_OFFSET_TABLE_ in its symbol table:
nm mod1.o | grep _GLOBAL_OFFSET_TABLE_
readelf -s mod1.o | grep _GLOBAL_OFFSET_TABLE_

# If this symbol is PRESENT = compiled WITH -fPIC (good)
# If ABSENT = compiled WITHOUT -fPIC (bad for shared libs)

# 7. ldd — show run-time library dependencies of a program
ldd prog
# Example output:
#   libutils.so => ./libutils.so (0x00007f8a12345000)
#   libc.so.6   => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f8a12100000)
#   /lib64/ld-linux-x86-64.so.2 => /lib64/ld-linux-x86-64.so.2

# 8. file command — confirms the library is an ELF shared object
file libutils.so
# Output: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV),
#         dynamically linked, with debug_info, not stripped