Compilation du compilateur

L'équipe Free Pascal publie à intervalles réguliers un paquet entièrement préparé, avec un compilateur et des unités tous prêts à l'emploi, ce qu'on appelle les réalisations. Après une version, le travail sur le compilateur se poursuit, les bogues sont corrigés et des fonctionnalités sont ajoutées. L'équipe Free Pascal ne crée pas de nouvelle version chaque fois qu'elle modifie quelque chose dans le compilateur, mais les sources sont disponibles pour que quiconque puisse les utiliser et les compiler. Il existe un processus automatisé créant des versions compilées de RTL et du compilateur étant également créées quotidiennement et mises sur le Web (si la construction réussit). Des fichiers Zip avec les sources sont également créés quotidiennement.

Il existe néanmoins des circonstances dans lesquelles le compilateur doit être recompilé manuellement. Lorsque des modifications sont apportées au code du compilateur ou lorsque le compilateur est téléchargé via Subversion. Il existe essentiellement 2 manières de recompiler le compilateur : à la main ou en utilisant les makefile. Chacune de ces méthodes sera discutée.

Avant de commencer

Pour compiler facilement le compilateur, il est préférable de conserver la structure de répertoires suivante (un répertoire de base de /pp/src est supposé, mais cela peut être différent) :

Lorsque les makefile doivent être utilisés, l'arborescence de répertoires ci-dessus doit être utilisée.

Le compilateur et la source RTL sont compressés de telle manière que lorsque les deux sont décompressés dans le même répertoire (/pp/src dans ce qui précède), l'arborescence de répertoires ci-dessus résulte.

Il existe 2 façons de commencer à compiler le compilateur et RTL. Les deux méthodes doivent être utilisées, selon la situation. Habituellement, le RTL doit être compilé en premier, avant de compiler le compilateur, après quoi le compilateur est compilé à l'aide du compilateur actuel. Dans certains cas particuliers, le compilateur doit être compilé en premier, avec un RTL préalablement compilé.

Comment décider lequel doit être compilé en premier ? En général, la réponse est que le RTL doit être compilé en premier. Il existe 2 exceptions à cette règle :

• Le premier cas est celui où certaines routines internes du RTL ont changé, ou si de nouvelles routines internes sont apparues. Étant donné que l'ancien compilateur ne connaît pas ces routines internes modifiées, il émettra des appels de fonction basés sur l'ancien RTL compilé et ne seront donc pas corrects. Soit le résultat ne sera pas lié, soit le binaire donnera des erreurs.
• Le deuxième cas est celui où quelque chose est ajouté au RTL que le compilateur doit connaître : un nouveau mécanisme assembleur par défaut, par exemple.

Comment savoir si l'une de ces choses s'est produite ? Il n'y a aucun moyen de le savoir, sauf en envoyant un mail à l'équipe Free Pascal. Lorsque le compilateur ne peut pas être recompilé lors de la première compilation du RTL, essayez l'autre méthode.

Compiler avec make

Compilation de base

Lors de la compilation avec make, il est nécessaire d'avoir la structure de répertoires ci-dessus. La compilation du compilateur est réalisée avec le cycle cible.

Dans des circonstances normales, la recompilation du compilateur se limite aux instructions suivantes (en supposant que vous démarrez dans le répertoire /pp/src) :

Cela ne fonctionnera que si le makefile est correctement installé et si les outils nécessaires sont présents dans la variable d'environnement PATH.

Les instructions ci-dessus feront ce qui suit :

1. À l'aide du compilateur actuel, le RTL est compilé dans le répertoire correct, déterminé par le système d'exploitation. Par exemple, sous Linux, le RTL est compilé dans le répertoire rtl/linux.
2. Le compilateur est compilé à l'aide du RTL nouvellement compilé. En cas de succès, l'exécutable du compilateur nouvellement compilé est copié dans un exécutable temporaire.
3. À l'aide de l'exécutable temporaire de l'étape précédente, le RTL est recompilé.
4. En utilisant l'exécutable temporaire et le RTL nouvellement compilé de la dernière étape, le compilateur est à nouveau compilé.

Les deux dernières étapes sont répétées 3 fois, jusqu'à ce que trois passes aient été effectuées ou jusqu'à ce que le binaire du compilateur généré soit égal au binaire avec lequel il a été compilé. Ce processus garantit que le binaire du compilateur est correct.

Compilation pour une autre cible

Lors de la compilation du compilateur pour une autre cible, il est nécessaire de spécifier la variable makefile OS_TARGET. Il peut être défini sur les valeurs suivantes : win32, go32v2, os2 et linux. A titre d'exemple, la compilation croisée pour la cible go32v2 à partir de la cible win32 est choisie :

Cela compilera le RTL go32v2 et compilera un compilateur go32v2.

Lors de la compilation d'un nouveau compilateur et que le compilateur doit être compilé à l'aide d'un RTL compilé existant, la cible all doit être utilisée et un autre répertoire RTL que celui par défaut (qui est le répertoire ../rtl/$(OS_TARGET)) doit être indiqué. Par exemple, en supposant que les unités RTL compilées se trouvent dans /pp/rtl/units/i386-linux, en tapant :

doit utiliser le RTL du répertoire /pp/rtl/units/i386-linux.

Cela compilera ensuite le compilateur en utilisant les unités RTL dans /pp/rtl/units/i386-linux. Une fois cela fait, le «make cycle» peut être utilisé, en commençant par ce compilateur :

Cela effectuera le cycle make par le haut, mais démarrera avec le compilateur généré par l'instruction make all.

Dans tous les cas, de nombreuses options peuvent être passées à make pour influencer le processus de compilation. En général, les makefile ajoutent toutes les options de compilateur nécessaires à la ligne de commande, afin que le RTL et le compilateur puissent être compilés. Des options supplémentaires (par exemple des options d'optimisation) peuvent être spécifiées en les transmettant dans OPT.

Installation du nouveau compilateur

Pour installer le compilateur nouvellement compilé, la cible d'installation peut être utilisée :

Cela installera le compilateur à l'emplacement par défaut (ce qui dépend de votre plate-forme). Si vous souhaitez spécifier l'emplacement, vous pouvez utiliser la variable INSTALL_PREFIX :

Accélération de la compilation

Le makefile prend en charge la compilation en parallèle. Pour cela, vous pouvez utiliser l'option -j N make, pour démarrer N processus.

Pour les paquets et utilitaires, la compilation est régie par fpmake, et make démarre simplement fpmake.

Le processus fpmake peut également compiler en parallèle, mais cela nécessite une option distincte -T N. Vous devez spécifier cette option dans la variable FPMAKEOPT :

La dernière étape d'un cycle de compilation normal consiste à recompiler le compilateur avec une optimisation complète du programme. Cela peut être désactivé :

Ajout d'informations de débogage

Par défaut, le compilateur, RTL et les paquets sont compilés sans informations de débogage. Vous pouvez forcer les informations de débogage à l'aide de la variable OPT :

Si vous souhaitez que heaptrc vérifie les fuites de mémoire, ajoutez l'option -glh :

Diverses autres options

Il existe d'autres options pouvant être définies avec des variables spéciales. En général, ce sont simplement des raccourcis et peuvent être remplacés par l'ajout d'options de ligne de commande du compilateur à OPT :

Compilation à la main

La compilation à la main est difficile et fastidieuse, mais cela peut être fait. La compilation de RTL et du compilateur seront traités séparément.

Compilation du RTL

Pour recompiler le RTL, afin qu'un nouveau compilateur puisse être construit, au moins les unités suivantes doivent être construites, dans l'ordre spécifié :

Pour compiler ces unités sur un i386, les instructions suivantes suffiront :

Ce sont les options minimales de ligne de commande nécessaires pour compiler le RTL.

Pour un autre microprocesseur, le i386 doit être remplacé par le processeur approprié. Pour un autre système d'exploitation cible, le paramètre du système d'exploitation cible (-T) doit être défini en conséquence.

Selon le système d'exploitation cible, d'autres unités peuvent être compilées, mais qui ne sont pas strictement nécessaires pour recompiler le compilateur. Les unités suivantes sont disponibles pour toutes les plateformes :

Compilation du compilateur

La compilation du compilateur peut être effectuée avec une seule instruction. Il est toujours préférable de supprimer d'abord toutes les unités du répertoire du compilateur, donc quelque chose comme :

sous Linux et sous DOS :

Après cela, le compilateur peut être compilé avec la ligne de commande suivante :

Toutes les options doivent être données sur une seule ligne, la barre oblique inverse est nécessaire si vous souhaitez spécifier les options sur plusieurs lignes.

Ainsi, les options minimales sont :

• Le système d'exploitation cible. Peut être ignoré lors de la compilation pour la même cible que le compilateur utilisé.
• Un chemin vers un RTL. Peut être ignoré si une configuration fpc.cfg correcte est sur le système. Si le compilateur doit être compilé avec le RTL ayant été compilé en premier, celui-ci doit être ../rtl/OS (remplacez le système d'exploitation par le sous-répertoire approprié du système d'exploitation du RTL).
• Une définition avec le processeur pour lequel le compilateur est compilé. Requis.
• -dGDB requis.
• -Sg est nécessaire, certaines parties du compilateur utilisent des instructions goto (pour être précis : le balayage).
• Un répertoire avec quelques unités et inclure des fichiers pour le processeur pour lequel vous compilez.
• Un répertoire avec les définitions du système.

La ligne de commande minimale absolue est donc :

Certaines autres options de ligne de commande peuvent être utilisées, mais celles ci-dessus constituent le minimum. Une liste des options reconnues peut être trouvée dans le tableau :

Cette liste est susceptible d'évoluer, le fichier source pp.pas contient toujours une liste à jour.