pasSteve pasJobs a écrit 10 commentaires

steve@myhost ~ $ cat test.c
#include <stdio.h>

int main() {
double a = 800.0 ;
double b = 0.75 ;
double c = 0.6 ;
double d = a*b*c ;
printf("Prend %f * %f * %f = %f ( %i ) = %f ( %i ) %\n",
a, b, c, a*b*c, (int)(a*b*c), d, (int)d) ;
return 0;
}
steve@myhost ~ $ gcc test.c -o test
steve@myhost ~ $ ./test
Prend 800.000000 * 0.750000 * 0.600000 = 360.000000 ( 359 ) = 360.000000 ( 360 ) %
steve@myhost ~ $ llvm-gcc test.c -o test
steve@myhost ~ $ ./test
Prend 800.000000 * 0.750000 * 0.600000 = 360.000000 ( 360 ) = 360.000000 ( 360 ) %
steve@myhost ~ $ icc test.c -o test
steve@myhost ~ $ ./test
Prend 800.000000 * 0.750000 * 0.600000 = 360.000000 ( 360 ) = 360.000000 ( 360 ) %
steve@myhost ~ $ gcc --version
gcc (GCC) 4.2.1
Copyright © 2007 Free Software Foundation, Inc.
Ce logiciel est libre; voir les sources pour les conditions de copie. Il n'y a PAS
GARANTIE; ni implicite pour le MARCHANDAGE ou pour un BUT PARTICULIER.

steve@myhost ~ $ llvm-gcc --version # LLVM 2.0
llvm-gcc (GCC) 4.0.1 (Apple Computer, Inc. build 5449)
Copyright © 2005 Free Software Foundation, Inc.
Ce logiciel est libre; voir les sources pour les conditions de copie. Il n'y a PAS
GARANTIE; ni implicite pour le MARCHANDAGE ou pour un BUT PARTICULIER.

steve@myhost ~ $ icc --version
icc (ICC) 10.0 20070426
Copyright (C) 1985-2007 Intel Corporation. All rights reserved.

Non, en réalité il dit qu'il utilise Vista et affirme vouloir débuter un projet de micro-noyau en VB.NET.

Je me réponds : GLS³ a l'air d'être un gros vaporware, le seul code disponible sur le site contient un README affirmant

Makefiles were temporarily removed from this module due to some issues.

Will be restored in the next commit.

Et les dernières nouvelles fraîches indiquant un poli « ralentissement de l'activité » datent d'Octobre 2006. Dommage :-(

Prochaine étape : un journal vide où l'on doit faire le contenu soi-même ? :)

Bonne idée, on a qu'à appeler ça Journal 2.0.

Le premier lien c'est http://lists.cs.uiuc.edu/pipermail/llvmdev/2007-July/009817.(...) je suppose que tu parles plutôt de http://lucille.atso-net.jp/blog/?p=294 ?
De plus, il y a un s à Benchs, tu juges la qualité d'un compilateur à un seul bench ? Si on va par là, j'ai essayé avec nbench[0] et le dernier LLVM-GCC stable + LLVM 2.0 sont battus à plate couture par GCC 4.2.

[0] : http://www.tux.org/~mayer/linux/bmark.html

C'est faux : le code compilé par LLVM est bien plus rapide qu'avec GCC, simplement parce que LLVM fait des optimisatons plus poussées, en particulier à l'édition de liens.

Preuves ? Benchs ?

Le format intermédiaire de LLVM, de type SSA, a justement été choisi car il permettait la mise en place des tous derniers algorithmes d'optimisations issus de la recherche.

L'IR du « middle-end » de GCC, Gimple, est aussi en forme SSA depuis la branche 4.x. Il a remplacé RTL pour la plupart des optimisations de haut niveau.

Cela implique que les filtrages effectués dans le code sont vérifiés à la compilation, car le formalisme permet de s'assurer que les élements filtrés sont tous disjoint mais aussi que leur union soit égal à l'ensemble filtrés.

En OCaml, le filtrage est aussi vérifié à la compilation : le compilateur affiche un warning si un cas n'est pas traité (ie. si leur union est différente de l'ensemble filtré). En Haskell ce n'est pas le cas par défaut à ma connaissance (pas avec GHC en tout cas), mais le travail de Neil Mitchell sur Catch[0] permet de vérifier qu'il n'y a pas d'erreur de filtrage à l'exécution, c'est à dire qu'un chemin du code ne mène pas à un cas non traité dans un filtrage non exhaustif.

[0] : http://www-users.cs.york.ac.uk/~ndm/catch/

Je suspecte fortement que la traduction correcte d'AST soit « arbre de syntaxe abstraitE », en opposant la syntaxe abstraite à celle, concrète, du fichier source.

Non, LLVM est moins porté que GCC (normal, il est plus récent).

Ce qu'il veut dire, je pense, c'est que LLVM peut compiler directement son IR en assembleur natif (ou même en C bas niveau ou CIL/MSIL), quelle que soit la machine sur laquelle tu es, juste en spécifiant une option sur la ligne de commande.

À l'inverse, GCC est beaucoup moins modulaire, à ma connaissance il faut tout compiler à part pour construire un cross-compilateur.

Toutefois, attention : ce n'est pas très clair dans la dépèche, mais l'IR LLVM n'est portable que dans la mesure ou le front-end qui le génère s'en assure. À l'heure actuelle, l'IR produit par llvm-gcc n'est pas du tout portable[0] vu que le C/C++ ne l'est pas (taille des données dépendant de l'architecture, etc), donc il ne faut pas espérer distribuer un programme compilé via llvm-gcc vers le « bitcode » LLVM sur d'autres architectures.

[0] : http://lists.cs.uiuc.edu/pipermail/llvmdev/2005-June/004450.(...) par exemple.

Je suis là.