Compilation de bibliothèque statique

Ce laboratoire vous guide dans la création et la compilation de bibliothèques statiques et dynamiques en langage C sous Linux. Vous apprendrez à écrire une fonction factorielle, à compiler cette fonction en bibliothèque, puis à l’utiliser dans un programme principal. Vous aurez besoin d’un compilateur gcc et d’un environnement Linux pour réaliser les différentes étapes.

Objectifs

• Écrire une fonction factorielle en C et son prototype.
• Compiler une bibliothèque statique à partir d’un fichier objet.
• Compiler un programme utilisant la bibliothèque statique.
• Compiler une bibliothèque dynamique avec position-independent code (PIC).
• Créer un lien symbolique pour la bibliothèque dynamique.
• Configurer l’environnement pour exécuter un programme lié à une bibliothèque dynamique.

Prérequis et configuration

• Un compilateur gcc installé sur un système Linux.
• Connaissances de base en programmation C (fonctions, prototypes, compilation).
• Accès à un terminal pour lancer les commandes gcc, ar, ln, et exporter des variables d’environnement.
• Les fichiers sources fact.c, fact.h, et calcule_factorielle.c (ou leurs équivalents factsol.c, factsol.h, calcule_factorielle_sol.c).

Compilation de la bibliothèque statique

Dans cette étape, vous allez créer une bibliothèque statique contenant la fonction factorielle. Cette bibliothèque sera ensuite utilisée par un programme principal qui calcule la factorielle de nombres passés en argument.

Étapes à suivre :

1. Créez un fichier fact.c contenant l’implémentation de la fonction factorielle() :

long int factorielle(long int n)
{
    long int f = 1;
    while(n > 1) {
        f = f * n;
        n = n - 1;
    }
    return f;
}

2. Créez un fichier fact.h contenant le prototype de la fonction :

long int factorielle(long int n);

3. Créez un programme calcule_factorielle.c qui utilise la fonction factorielle() pour chaque argument passé en ligne de commande et affiche le résultat :

#include <stdio.h>
#include <stdlib.h>
#include <fact.h>

int main(int argc, char *argv[])
{
    long int n;
    int i;
    if (argc < 2) {
        fprintf(stderr, "usage: %s valeurs...\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    for (i = 1; i < argc; i++)
        if (sscanf(argv[i], "%ld", &n) == 1)
            fprintf(stdout, "%ld! = %ld\n", n, factorielle(n));
    return EXIT_SUCCESS;
}

4. Compilez le fichier fact.c en fichier objet fact.o avec l’option -I. pour inclure le répertoire courant :

gcc -I. -c fact.c

5. Créez la bibliothèque statique libfact.a à partir de fact.o en utilisant l’archiveur ar avec les options rcs :

ar -rcs libfact.a fact.o

6. Compilez le programme principal calcule_factorielle.c en indiquant la bibliothèque statique à lier avec -lfact, le chemin de la bibliothèque avec -L. et en forçant la liaison statique avec -static :

gcc -static -I. -L. calcule_factorielle.c -lfact -o calcule_factorielle

Pourquoi cette étape ? Ces commandes permettent de créer une bibliothèque statique, puis de compiler un programme qui utilise cette bibliothèque. L’option -static force la liaison statique, ce qui signifie que tout le code nécessaire est inclus dans l’exécutable final.

Résultat attendu : Un exécutable nommé calcule_factorielle qui, lorsqu’il est lancé avec des arguments numériques, affiche leur factorielle.

Compilation de la bibliothèque dynamique

Dans cette deuxième partie, vous allez créer une bibliothèque dynamique (partagée) à partir des mêmes fichiers sources. Cette méthode permet de partager le code entre plusieurs programmes et de réduire la taille des exécutables.

Étapes à suivre :

1. Compilez le fichier fact.c en fichier objet fact.o en ajoutant l’option -fPIC (Position Independent Code) pour que le code soit indépendant de son adresse mémoire :

gcc -I. -fPIC -c fact.c

2. Créez la bibliothèque dynamique libfact.so.1 avec les options suivantes :

• -shared pour créer une bibliothèque partagée.
• -Wl,-soname,libfact.so pour indiquer au linker le nom de la bibliothèque.
• -o libfact.so.1 pour nommer le fichier de sortie.

gcc -shared -Wl,-soname,libfact.so -o libfact.so.1 fact.o

3. Créez un lien symbolique libfact.so pointant vers libfact.so.1 :

ln -sf libfact.so.1 libfact.so

4. Compilez le programme principal calcule_factorielle.c en indiquant la bibliothèque dynamique à lier :

gcc -I. -L. -lfact calcule_factorielle.c -o calcule_factorielle

5. Avant d’exécuter le programme, configurez la variable d’environnement LD_LIBRARY_PATH pour indiquer au chargeur où trouver la bibliothèque dynamique :

export LD_LIBRARY_PATH=.

6. Exécutez le programme avec des arguments pour vérifier le bon fonctionnement :

./calcule_factorielle 5 6 7

Pourquoi cette étape ? Le code compilé avec -fPIC peut être chargé à n’importe quelle adresse mémoire, ce qui est nécessaire pour les bibliothèques partagées. Le lien symbolique facilite la gestion des versions de la bibliothèque. La variable LD_LIBRARY_PATH permet au système de trouver la bibliothèque lors de l’exécution.

Résultat attendu : Le programme affiche :

5! = 120
6! = 720
7! = 5040

Résultats attendus

• Un exécutable statique calcule_factorielle qui affiche la factorielle des nombres passés en argument.
• Une bibliothèque statique libfact.a contenant le code compilé de la fonction factorielle.
• Une bibliothèque dynamique libfact.so.1 avec un lien symbolique libfact.so.
• Un exécutable dynamique calcule_factorielle qui fonctionne correctement après configuration de LD_LIBRARY_PATH.
• Affichage correct des factorielles, par exemple :

5! = 120
6! = 720
7! = 5040

Pièges courants

• Oublier l’option -fPIC lors de la compilation pour la bibliothèque dynamique, ce qui provoque des erreurs de linkage.
• Ne pas créer le lien symbolique libfact.so, ce qui peut empêcher le linker de trouver la bibliothèque.
• Ne pas configurer LD_LIBRARY_PATH avant d’exécuter le programme dynamique, entraînant une erreur de chargement de la bibliothèque.
• Mettre l’option -lfact avant le fichier source
• Ne pas inclure le répertoire courant avec -I. ou -L.
• Passer des arguments non numériques