Linux ranlib Command with Practical Examples

Introduction

In this lab, we will explore the Linux ranlib command and its practical applications. The ranlib command is used to generate an index to the contents of an archive file, which is typically a static library file. We will create a simple C program that uses a static library, and then demonstrate how to use the ranlib command to update the symbol table in the library, making it easier for the linker to access the symbols defined in the library. Additionally, we will cover the process of creating a static library and using the ranlib command to ensure its proper functionality.

Linux Commands Cheat Sheet

Skills Graph

Understand the Purpose of ranlib Command

In this step, we will explore the purpose of the ranlib command in Linux. The ranlib command is used to generate an index to the contents of an archive file, which is typically a static library file.

Static libraries are collections of object files that can be linked into programs. The ranlib command is used to create or update the symbol table in the archive file, which is used by the linker to quickly access the symbols defined in the library.

Let's start by creating a simple C program that uses a static library:

// main.c
#include <stdio.h>
#include "mylib.h"

int main() {
    printf("The answer is: %d\n", myfunction());
    return 0;
}

// mylib.c
int myfunction() {
    return 42;
}

// mylib.h
int myfunction();

Now, let's compile the mylib.c file into an object file and then create a static library from it:

gcc -c mylib.c
ar rcs libmylib.a mylib.o

Example output:

The ar command is used to create the static library file libmylib.a from the mylib.o object file.

Next, we need to use the ranlib command to generate an index to the contents of the static library:

ranlib libmylib.a

Example output:

The ranlib command updates the symbol table in the static library, which makes it easier for the linker to access the symbols defined in the library.

Now, we can compile the main.c file and link it against the static library:

gcc -c main.c
gcc -o main main.o -L. -lmylib

Example output:

The -L. option tells the linker to search for the library in the current directory, and the -lmylib option tells the linker to link against the libmylib.a library.

When you run the main program, you should see the following output:

The answer is: 42

Create a Static Library and Use ranlib

In this step, we will create a simple static library and use the ranlib command to update its symbol table.

First, let's create a new directory for our project and navigate to it:

mkdir ~/project/static-library
cd ~/project/static-library

Now, let's create a new C file called mylib.c with a simple function:

// mylib.c
int myfunction() {
    return 42;
}

Next, we'll compile the mylib.c file into an object file:

gcc -c mylib.c

Example output:

Now, we can create a static library from the mylib.o object file using the ar command:

ar rcs libmylib.a mylib.o

Example output:

The ar command creates the static library file libmylib.a from the mylib.o object file.

To update the symbol table in the static library, we need to use the ranlib command:

ranlib libmylib.a

Example output:

The ranlib command generates an index to the contents of the static library, which makes it easier for the linker to access the symbols defined in the library.

Now, let's create a simple program that uses the myfunction() from the static library:

// main.c
#include <stdio.h>
#include "mylib.h"

int main() {
    printf("The answer is: %d\n", myfunction());
    return 0;
}

// mylib.h
int myfunction();

We can compile the main.c file and link it against the static library:

gcc -c main.c
gcc -o main main.o -L. -lmylib

Example output:

The -L. option tells the linker to search for the library in the current directory, and the -lmylib option tells the linker to link against the libmylib.a library.

When you run the main program, you should see the following output:

The answer is: 42

Verify the Updated Library Information

In this final step, we will verify the updated information in the static library we created in the previous step.

First, let's use the nm command to list the symbols defined in the static library:

nm libmylib.a

Example output:

0000000000000000 T myfunction
                 U __libc_start_main
                 U printf

The output shows that the static library contains a single symbol, myfunction, which is defined as a text (code) symbol.

Next, let's use the ar command to list the contents of the static library:

ar -t libmylib.a

Example output:

mylib.o

The output shows that the static library contains a single object file, mylib.o.

Finally, let's use the ranlib command to display the symbol table information for the static library:

ranlib -t libmylib.a

Example output:

mylib.o

The output shows that the ranlib command has updated the symbol table information for the static library.

Now, let's verify that the program we created in the previous step is still able to link against the static library and run correctly:

gcc -o main main.o -L. -lmylib
./main

Example output:

The answer is: 42

The program runs as expected, demonstrating that the static library and its symbol table information are correctly updated.

Summary

In this lab, we learned the purpose of the ranlib command in Linux, which is used to generate an index to the contents of an archive file, typically a static library file. We created a simple C program that uses a static library, compiled the source code into an object file, and then created a static library from it. We then used the ranlib command to update the symbol table in the static library, which makes it easier for the linker to access the symbols defined in the library. Finally, we compiled the main program and linked it against the static library to demonstrate the usage of the ranlib command.

Linux Commands Cheat Sheet