Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Les bases de la compilation

Principes, méthodes et outils

Anne Cadiou

Laboratoire de Mécanique des Fluides et d’Acoustique

Séminaires et ateliers pour le calcul scientifique

PMCS2I - LMFA
Vendredi 2 mars 2018
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Pourquoi utiliser un compilateur ?

Un compilateur est un programme permettant de traduire un code écrit dans

un langage de programmation en autre programme en langage machine.

Le langage machine est composé d’instructions et de données codées en binaire

(composé de 0 et de 1). Chaque type de processeur possède son propre jeu
d’instruction, donc est spécifique au processeur sur lequel on travaille.

Le compilateur doit donc

• analyser les sources du programme
• générer l’objet binaire correspondant
• assembler éventuellement différents objets en un exécutable binaire
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Un peu d’histoire

• 1950-1970 Premiers compilateurs

• 1957 Langage FORTRAN FORmula TRANslator
• 1970-1990 Processeurs électroniques
• 1971 Intel 4004 pour PC
• 1972 Langage C
• 1983 Langage C++
• 1983 premier compilateur open source GCC 1.0 (génère un binaire
sémantiquement proche du programme source, peu d’optimisaion)
• 1984 MIPS, architecture RISC
• 1990-2000 Développement de nouveaux concepts architecturaux (pipelines,
processeurs superscalaires, mémoire caches, machine parallèles...)
• Compilation à la volée (just-in-time, JIT) par opposition à sa réalisation
classique, en avance de phase (ahead-of-time, AOT), utilisée dans LLVM
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

1 . f i l e ” p r o g . cpp ”
. text
3 . globl main
. t y p e main , @ f u n c t i o n
5 main :
. LFB0 :
7 . cfi startproc
pushq %r b p
9 . c f i d e f c f a o f f s e t 16
1 i n t main ( ) . c f i o f f s e t 6 , −16
{ 11 movq %r s p , %r b p
3 i n t a =97;
. cfi def cfa register 6
5 return 0; 13 movl $97 , −4(%r b p )
} movl $0 , %e a x
15 popq %r b p
. cfi def cfa 7, 8
Programme C++ [Link] 17 ret
. cfi endproc
19 . LFE0 :
. s i z e main , .−main
21 . i d e n t ”GCC : ( Ubuntu 5.4.0 −6 ub u nt u1
˜ 1 6 . 0 4 . 4 ) 5 . 4 . 0 20160609 ”
. section . n o t e . GNU−s t a c k , ” ” , @ p r o g b i t s

Programme correspondant en assembleur

Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Code compilé affiché en ASCII Code compilé affiché en hexadécimal

Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Qu’attend-on d’un compilateur ?

Détection de erreurs :
• erreur typographique, parenthèses non fermées, etc.
• constructions syntaxiques incorrectes
• identificateur non déclaré
• expressions mal typées
• références non instanciées
• etc.
Les erreurs détectées à la compilation sont des erreurs statiques.
Les erreurs détectées à l’exécution sont des erreurs dynamiques (division par
zéro, dépassement mémoire etc.)
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Qu’attend-on d’un compilateur ?

Efficacité :
• il doit être le plus rapide possible
• il doit produire un code qui utilisera efficacement les ressources disponibles
(et sera aussi rapide que possible)
Généralement, le compilateur produit en premier lieu un code intermédiaire,
constitué d’une sére d’instructions bas niveau, sans optimisation. Il doit être
optimisé pour produire un code exécutable.
La traduction binaire dépend
• du processeur utilisé
• des conventions utilisées par le système d’exploitation utilisé
L’optimisation du code intermédiaire se fait
• en diminuant la taille du code (réduction du nombre de variables,
d’opérations, etc.)
• en ordonnançant les instructions en fonction des dépendances,
• en utilisant au mieux les registres du processeur,
• en déroulant les boucles pour profiter des unités vectorielles des
processeurs
La quantité de travail d’un compilateur dépend du jeu d’instructions du
processeur.
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Opérations réalisées par un compilateur

• Prétraitement (preprocessing) : inclue des directives, insère des macros et
permet la compilation conditionnelle
• Analyse lexicale (lexer) : identifie les lexèmes (unités lexicales) du langage
(mot-clé, identifiant etc.)
f l o a t x = #; e r r o r : s t r a y ’# ’ i n program

• Analyse syntaxique (parsing) : trouve la structure syntaxique (arbre) et

teste l’appartenance au langage
1 ( x > 0 . ) x=+1; e l s e x=−1; error : ’ else ’ without a previous ’ if ’

• Analyse sémantique : vérifie la cohérence des instructions reconnues

1 float y ; y = x + 1.0; error : ’ x ’ was n o t d e c l a r e d i n t h i s s c o p e

• Génération du code : encodage en assembleur, optimisations et allocation

des registres, traduction en code objet.
Lorsque qu’un code compilé sur une machine peu s’exécuter sur une autre, on
parle de compilation croisée (cross compiler)
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Après la compilation

• La compilation d’un programme se fait souvent de manière modulaire. Les

dépendances par rapport aux autres parties du programme ou aux
bibliothèques sont faites par l’édition de liens.
• La compilation peut être intégrée à un runtime (environnement
d’éxecution), qui fournit des services indépendants du programme (accès
systèmes, I/O, gestionnaires de mémoire, etc.). Le code natif est éxecuté
par le compilateur, alors que le code objet l’est par le runtime. Pour les
langages interprétés, le runtime est l’interpréteur.
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Phase de pré-processing

Le pré-processeur procède à des transformations du code source. Il enlève les

commentaires et exécute les instructions commençant par un dièse.
Le plus utilisé est celui de C et C++. Actions possibles :
• inclusion d’autres fichiers
• définition de constantes symboliques et de macros
• compilation conditionnelle de morceaux de programme
• exécution conditionnelle des directive du précompilateur
En fortran les inclusions sont dépréciées au profit de l’usage des modules. Le
préprocesseur est automatiquement appelé sur les fichiers d’extension .F90,
.F95, etc. (doit être spécifié par une option de compilation sinon)
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Directives de pré-compilation
#include : entraı̂ne l’insertion d’une copie d’un fichier spécifié à la place de la
directive
1 #i n c l u d e <i o s t r e a m >

#define const : permet de définir des constantes

1 #d e f i n e PI 3 . 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6

#define macro : permet de définir des macros avec ou sans arguments

1 #d e f i n e PRINTA ( a ) { i f ( myid==0) s t d : : c o u t << a ; }

En C++, les macros sont remplacées par les modèles et fonctions inline
1 i n l i n e i n t min ( i n t a , i n t b )
{
3 r e t u r n ( a<b ) ? a : b ;
}

Elles sont définies jusqu’à la fin du fichier où elles sont déclarées ou jusqu’à ce
qu’elles soient supprimée par la directive #undef
#u n d e f P I
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Macros pré-définies

LINE numéro de ligne en cours dans le code source

FILE nom du fichier source
DATE date de compilation
TIME heure de compilation
STDC index de compatibilité avec la norme ANSI

Exemple d’usage :
1 #d e f i n e XYC Only ( v e c ) \
{\
3 i f ( ! ( v e c ) . XYC ( ) ) \
{\
5 s t d : : c o u t << FILE << ” , l i n e ”\
<< LINE << ” , c o m p i l e d ”\
7 << DATE << ” a t ” << TIME <<” ∗∗∗” << s t d : : e n d l ; \
ERREUR( ” V e c t e u r 3 D i s n o t XYC ( ) ” ) ; \
9 }\
}

On note que le symbole \ permet d’écrire sur plusieurs lignes.

[Link]
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Autres directives

permet de faire du diagnostic en affichant un message

#error :
d’erreur
#i f ! d e f i n e d (FOO) && d e f i n e d (BAR)
2 #e r r o r ”BAR r e q u i r e s FOO . ”
#e n d i f

#pragma : provoque une action définie au niveau du compilateur

1 #i f d e f BORLANDC
#pragma m e s s a g e You a r e c o m p i l i n g u s i n g B o r l a n d C++ v e r s i o n BORLANDC .
3 #e l s e
#pragma m e s s a g e ( ” T h i s c o m p i l e r i s n o t B o r l a n d C++” )
5 #e n d i f

#pragma omp f o r
f o r ( i n t i =0; i<N ; i ++) b u f f 1 [ i ] ∗= b u f f 2 [ i ] ;

#line : provoque la numérotation des lignes de code source

#l i n e 10 myfunc . C
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Autres directives

conversion d’une série de caractères en une chaı̂ne de

# :
caractères entourée de guillements
1 #d e f i n e BONJOUR( x ) s t d : : c o u t << ” B o n j o u r , ” #x << s d t : : e n d l

L’appel à BONJOUR(Jean) sera développé en

s d t : : c o u t << ” B o n j o u r , ” ” J e a n ” << s t d : : e n d l

provoque la conversion d’une série de caractères du texte

## : de remplacement par une série de caractères passée en
paramètre
1 #d e f i n e AFFICHE ( n ) ( c o u t << e n d l << s##n << e n d l )
u s i n g namespace s t d ;
3 v o i d main ( )
{
5 s t r i n g s1 , s 2 ( ”OUF” ) , s 3 ( ”STOP” ) ;
AFFICHE ( 1 ) ;
7 AFFICHE ( 2 ) ;
AFFICHE ( 3 ) ;
9 }
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Compilation conditionnelle

évalue une expression régulière constante qui détermine

#if ... #endif :
si le code doit être compilé
1 #i f ! d e f i n e d (KEY)
#d e f i n e KEY 0
3 #e n d i f

#ifdef #ifndef : raccourcis pour #if define(KEY) et #if !define(KEY)

• évite d’include le même fichier plusieurs fois
• aide par exemple au débogage en permettant d’insérer des portions de
codes à ne compiler qu’en mode debug
Exemple classique d’utilisation en Exemple d’utilisation en mode debug
en-tête des fichiers à inclure Compilation avec l’option -DDEBUG
#i f n d e f p a r a l l e l H #i f d e f DEBUG
#d e f i n e p a r a l l e l H M P I C o m m s e t e r r h a n d l e r (MPI COMM WORLD,
... MPI ERRORS RETURN ) ;
#e n d i f #e n d i f
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Principales options de compilation

Pour gcc
-c : compilation et assemblage sans édition de liens ; génère un
fichier objet d’extension *.o.
-S : génère un fichier en assembleur d’extension *.s, sans faire
l’assemblage.
-E : stoppe après l’étape de pré-processing. le code généré est
envoyé sur la sortie standard.
-o file : renvoie le fichier compilé dans file ; par défaut, l’exécutable
s’appelle [Link].
-v : sort les différentes commandes exécutées pendant les étapes
de compilation (mode verbose.
-ansi : impose une compatibilité avec les standards iso.
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Contôle des warnings, options de débogage

-Werror : transforme les warnings en erreur.

-pedantic : émet des warnings prévus par les normes ISO appliquées
de façon très strictes.
-Wall : active tous les avertissements indispensables.
-Wextra : active quelques avertissements supplémentaires par
rapport à Wall.
-Wstrict-aliasing : vérifie le strict aliasing (deux types indépendants ne
peuvent pas pointer vers la même mémoire) ; s’utilise avec
-fstrict-aliasing.
-g : activation de la génération des informations pour le
déboggage. En particulier, -ggdb pour l’utilisation de gdb.
-pg : instrumentation et production des informations pour l’outil
de profiling gprof.
-coverage : options utilisées pour l’analyse de couverture d’un code
avec gcov (-coverage équivalent à -fprofile-arcs
-ftest-coverage).
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Optimisation d’optimisation

-O0 : aucune optimisation

-O1 : optimisation visant à accélérer le code, en particulier
quand il ne contient pas beaucoup de boucles
-O2 : O1 et déroulage de boucles ; augmente le temps de
compilation
-O3 : O2 et transformation des boucles, des accès mémoire
-march=cpu type : génère les instructions adaptées au jeu d’instructions du
processeur spécifié

Certaines optimisations peuvent modifier l’ordre des opérations et donc affecter

les résultats
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Options du pré-processeur, option du link

-DKEY ou -DKEY=valeur : affectation d’une valeur à une macro
-UKEY : annule toute affectation à la clef KEY
-ldirectory : indique le chemin de recherche pour trouver les fichiers
inclus dans les macros #include. un certain nombre
de répertoires sont prédéfinis et n’ont pas besoin d’être
spécfiés
-M : définit les règles de dépendances pour le fichier donné,
adapté à l’utilitaire make. l’option -MM fait le même
travail sans référencer les headers système
-llibrary : cherche la bibliothèque library au moment de la
génération de liens. Le linker cherche et lie les fichiers
objet et bibliothèques dans l’ordre spécifié. La
bibliothèque est cherché sous la forme liblibrary.a.
-Ldirectory : chemin de recherche pour les bibliothèques
-static-libstdc++ : force le linkage statique avec la librairie standard C++
-static : force le linkage statique avec les autres librairies

Certaines optimisations peuvent modifier l’ordre des opérations et donc affecter

les résultats
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Outils de construction de programmes

• encapsulés dans les IDE,

• autotools, automake,
• Makefile,
• CMake,
• scons, etc.
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Compilation séparée, édition de lien

• séparer le source en plusieurs fichiers

• création de plusieurs fichiers objets
• édition de liens : assemblage de ces fichiers en un exécutable

bibliothèque statique : include dans l’exécutable. nécessite la recompilation du

code à chaque changement de la bibliothèque. copie
multiple de la bibliothèque si plusieurs codes l’utilisent.
bibliothèque dynamique : l’appel de la bibliothèque est géré à l’exécution du
code par le chargeur dynamique ([Link])

Nécessite un environnement utilisateur bien configuré :

• chemin de recherche standard défini dans
/etc/[Link]
• variable d’environnement LD LIBRARY PATH
• visualisation des dépendances d’un exécutable ldd
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Création et utilisation de bibliothèques

• par défaut, utilisation de bibliothèques dynamiques. Options -Wl -Bstatic

pour préciser un lien statique : g++ object1.o object2.o -Wl,-Bstatic
-lapplejuice -Wl,-Bdynamic -lorangejuice -o binary
• bibliothèque statique : ar rcs libfile.a file1.o file2.o file3.o créé une
bibliothèque avec un index (option s).
• bibliothèque dynamique : création à l’aide de l’option -shared du
compilateur : g++ -o [Link] -shared file1.o file1.o file3.o
• L’ordre dans l’édition des liens est important : les symboles d’une
bibliothèque ne sont pris en compte que s’ils sont utilisés par un objet
présent avant dans la ligne de commande : si b dépend de a, a devra
figurer après b. Possibilité de dépendances circulaires : certaines
bibliothèques peuvent figurer plusieurs fois.

nm : liste l’ensemble des symboles contenus dans un fichier

objet ou un exécutable (fonctions, constantes ...).
objdump, readelf : donne différentes informations sur des fichiers objets.
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Makefile

• automatise le compilation des fichiers

• basé sur un fichier Makefile et sur l’appel de la commande make
• le fichier Makefile contient une liste de règles et de dépendances utilisées
pour construire des cibles
• chaque commande est précédée d’une tabulation

cible : dependances
commandes

exe : v e c t o r . h main . cpp

g++ main . cpp −o e x e
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Fonctionnement de make

• La cible de la première règle est la principale.

• Make ne recompile que ce qui a été modifié.
• Make regarde si les dépendances sont satisfaites :
• Si elles ne le sont pas, prend la première dépendance pour cible.
• Si elles le sont, exécute les commandes associées à la règle.
• En terme d’exécution, on peut voir make comme un programme récursif.

Exemple :
# Regle p r i n c i p a l e
e x e : main . o
g++ main . cpp −o e x e

# Regle 1
main . o : v e c t o r . h main . cpp
g++ −c main . cpp

# Regle 2 :
clean :
rm main . o
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Cibles classiques

all : génération de tous les exécutables.

.PHONY : les dépendances sont toujours reconstruites.
clean : suppression des fichiers intermédiaires.
mrproper : suppression des fichiers intermédiaires et des
exécutables.
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Variables

• déclaration : NOM = VALEUR

• utilisation : $NOM
variables prédéfinies :
CFLAGS : options de compilation pour le C
CPPFLAGS : options de précompilation
LDFLAGS : options d’édition de liens
CXXFLAGS : options de compilation pour le C++
CC ou CXX : désignent les compilateurs
Exemple :
CC = g c c
CFLAGS = −O4 −W a l l
LD = g c c
LDFLAGS = −s
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Variables internes

• $ @ représente la cible.
• $ ^ représente la liste des dépendances.
• $ < représente la première dépendance.
• $ ? représente la liste des dépendances plus récentes que la cible.
• $ * représente le nom de la cible sans suffixe.

Exemple :
# $@ == r k 4 e t $ ˆ == main . o r k 4 . o
r k 4 : main . o r k 4 . o
$ (CC) −o $@ $ ˆ
main . o : main . cpp r k 4 . hpp
$ (CC) −o $@ −c $<
r k 4 . o : r k 4 . cpp r k 4 . hpp
$ (CC) −o $@ −c $<
$
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Règles d’inférence

Ce sont de règles génériques qui sont appelées par défaut.

Exemple :
r k 4 : main . o r k 4 . o
$ (CXX) −o $@ $ ˆ $ ( LDFLAGS )

%.o : % . cpp
$ (CXX) −o $@ −c $< $ (CXXFLAGS)

main . o : r k 4 . hpp
r k 4 . o : r k 4 . hpp
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Manipulation des noms des fichiers source

wildcard : récupération des noms de fichiers

SRC=$ ( w i l d c a r d ∗ . cpp )

patsubst : remplacement d’une expression par une autre

OBJ=$ ( SRC : . cpp =. o )
OBJ=$ ( p a t s u b s t %. cpp , % . o , $ ( SRC ) )

notdir : extraction du nom dufichier

OBJ=$ ( n o t d i r \$ ( p a t s u b s t %.cpp ,%o , $ ( SRC ) ) )
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Utilisation de conditions

Utilisation :
make MODE DEBUG=y e s

Exemple :
MODE DEBUG=no
i f e q ( $ (MODE DEBUG) , y e s )
CXXFLAGS= −W a l l −a n s i −g
LDFLAGS=−W a l l −a n s i −g
else
CXXFLAGS=−W a l l −a n s i
LDFLAGS=−W a l l −a n s i
endif
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Projet simple

Programme seul, sans dépendances.

#i n c l u d e <i o s t r e a m >
2
i n t main ( )
4 {
s t d : : c o u t << ” ’ H e l l o , w o r l d ! ’ \ n” ;
6 }

Structure du projet

project/
src/
[Link]

Objectif : compiler le code, l’installer, le tester.

Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Compilation manuelle

en utilisant les compilateurs de GNU

cadiou@moon : ˜ / p r o j e c t / s r c $ g++ p r o g . cpp

Génération de l’exécutable
cadiou@moon : ˜ / project / src$ l s
cadiou@moon : ˜ / p r o j e c t / s r c $ a . out p r o g . cpp
cadiou@moon : ˜ / p r o j e c t / s r c $ . / a . out
’ Hello , world ! ’
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Création manuelle d’un Makefile

project/
src/
[Link]
Makefile
bin/

cadiou@moon : ˜ / p r o j e c t / s r c $ make −n
g++ −c p r o g . cpp
g++ −o a . o u t p r o g . o
cadiou@moon : ˜ / p r o j e c t / s r c $ make
cadiou@moon : ˜ / p r o j e c t / s r c $ make i n s t a l l
mv a . o u t . . / b i n / .
cadiou@moon : ˜ / p r o j e c t / s r c $ cd . . / b i n
cadiou@moon : ˜ / p r o j e c t / b i n $ . / a . out
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Exemple de Makefile

CC = g++
CLINKER = g++

OBJS = prog . o

. SUFFIXES : . o . cpp
. cpp . o :
$ (CC) −c $ (CCLAGS) $<

EXE = a . o u t

all : $ (EXE)

$ (EXE) : $ ( OBJS )
$ ( CLINKER ) $ ( LDFLAGS ) −o $@ $ ( OBJS )

clean :
rm −f $ ( OBJS ) $ (EXE)

install :
mv $ (EXE) . . / b i n / .
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Pourquoi ne pas se contenter d’appeler le compilateur ?

Dans les codes de calculs, la construction de l’éxecutable est une tâche parfois
délicate. Elle dépend
• d’un grand nombre de fichiers
• avec de nombreuses dépendances
• du cas à traiter (compilation conditionnelle, ...)
• de nombreux éléments externes (bibliothèques, ...)
• et de la manière dont ils sont installés
• de la plateforme
• de l’environnement sur le plateforme
La plupart du temps, on ne contrôle pas ces dépendances.
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Résultats
Résolution d’un système linéaire par le méthode S.O.R. 64 × 64 × 64 (2002)
Système Cpu Compilateur Options Time
Linux Pentium IV Xeon 1.7Ghz Intel(R) Fortran Compi- -O3 -tpp7 -axW -ipo 61s
2.4.7-10smp (Redhat Memory : 1024Mb RDRAM ECC PC860 ler for 32-bit applications
7.2) Cache : 8K L1, 256K L2 Linux Version 5.0.1 Build
Linux Pentium IV Xeon 1.7Ghz Absoft f90 -O -B100 84s
2.4.7-10smp (Redhat Memory : 1024Mb RDRAM ECC PC860
7.2) Cache : 8K L1, 256K L2
Linux Pentium IV Xeon 1.7Ghz GNU g77 -s -mcpu=pentiumpro 85s
2.4.7-10smp (Redhat Memory : 1024Mb RDRAM ECC PC860 -march=pentiumpro
7.2) Cache : 8K L1, 256K L2 -mpentiumpro -O6
-frerun-cse-after-loop -
fno-defer-pop -fschedule-
insns -fomit-frame-
pointer -fstrength-reduce
-fforce-mem -fforce-addr
-funroll-loops -freduce-
all-givs -Wall
Linux Pentium IV Xeon 1.7Ghz Portland Group -fast 88s
2.4.7-10smp (Redhat Memory : 1024Mb RDRAM ECC PC860 pgf90
7.2) Cache : 8K L1, 256K L2
Alpha Server Compaq Mémoire : 1.2 Gb DIGITAL f90 -O4 -tune ev6 -arch ev6 99s
DS20 OSF 4.0F Cache Prim. : ? -fast
Cache Second. : 4 Mb
Alpha Server Compaq Mémoire : 2 Gb DIGITAL f90 -O4 -tune ev6 -arch ev6 150s
8200 Cache Prim. : ? -fast
OSF 4.0F Cache Second. : 4 Mb
Linux Pentium IV Xeon 1.7Ghz GNU g77 . 173s
2.4.7-10smp (Redhat Memory : 1024Mb RDRAM ECC PC860
7.2) Cache : 8K L1, 256K L2
Linux Pentium III Coppermine 993.33Mhz Me- Portland Group -fast 366s
2.4.2-2 (Redhat 7.2) mory : 512Mb Cache : 8K L1, 256K L2 pgf90
Linux Pentium III Coppermine 993.33Mhz GNU g77 . 466s
2.4.2-2 (Redhat 7.2) Memory : 512Mb
Cache : 8K L1, 256K L2
Introduction Tâches du compilateur Pré-compilation Principales options de compilation Outils de construction Références

Références

Certaines planches de cette présentation sont directement reprise des cours

suivants (dont la lecture vous est recommandée !) :
1 Compilation, debogage, Violaine Louvet, École doctorale MathIf, 2009
2 Introduction à la compilation, Christine Paulin-Mohring, Université
Paris-Sud, 2011
Merci à leurs auteur(e)s respectives.