Processeurs de langages – quelques liens pertinents

Quelques raccourcis :

Ce qui suit est un survol informel. Pour aller plus loin, il se donne d'excellents cours et il existe d'excellents livres (dont certains en ligne, comme celui-ci et celui-ci). La plupart des sections sont incomplètes pour des raisons de manque de temps...

J'ai gardé une section spécifiquement sur les compilateurs C++ dans ../Sujets/Divers--cplusplus/outils-compilateurs.html

Assembleurs

à venir...

Assembleur pour débutants : http://forum.dev-hq.net/showthread.php?318-ASM-From-Scratch!-%28An-ASM-tutorial-for-Beginners%29

En 2015, Wilson Minesco exprime l'opinion que comprendre un langage d'assemblage sera toujours quelque chose de pertinent : http://wilsonminesco.com/AssyDefense/

Exemples :

Assembleur pour programmeurs C, texte de 2009 : http://myw3b.net/blog/index.php/2009/10/assembly-for-c-programmers-1/

Livres de programmation en langage d'assemblage :

Il faut que la « guerre des langages » (des Instruction Sets) se termine : http://www.agner.org/optimize/blog/read.php?i=25

Ressource d'ordre général pour les langages d'assemblage : http://homepage.mac.com/randyhyde/webster.cs.ucr.edu/index.html

Langage d'assemblage, famille PowerPC :

Langage d'assemblage, famille x86 :

Langage d'assemblage, famille ARM :

Optimisation pour le Pentium 4 : http://software.intel.com/en-us/articles/intel-pentiumr-4-processor-optimization-reference-manual/

Un langage d'assemblage avec collecte automatique d'ordures : ftp://ftp.research.microsoft.com/pub/tr/TR-2006-169.pdf

De l'assembleur en ligne avec gcc :

Comment le code C est traduit en langage d'assemblage : http://www.avabodh.com/cin/introduction.html

De l'assemblage intégré (Inline Assembly) pour le langage D, un texte de Walter Bright : http://drdobbs.com/blogs/tools/231002363

Guide pas à pas pour de l'assembleur sous Linux : http://www.cin.ufpe.br/~if817/arquivos/asmtut/index.html#intro

L'évolution d'un langage d'assemblage, à travers les années et les processeurs : http://blog.julien-oster.de/2011/10/assembly-evolution-part-1-accessing.html

Langage d'assemblage pour ceux qui écrivent des compilateurs : http://www.cse.nd.edu/~dthain/courses/cse40243/fall2008/ia32-intro.html

Exemple concret de fusion de deux vecteurs, par Anita Cosmin en 2012 : http://en.nerdaholyc.com/memory-snipping-a-simple-example-in-assembly-codemerging-two-vectors/

Les instructions « machines » de certains langages intermédiaires :

Déposer 0 dans un registre de manière efficace, texte de Bruce Dawson en 2012 : http://randomascii.wordpress.com/2012/12/29/the-surprising-subtleties-of-zeroing-a-register/

Langage d'assemblage et cas d'utilisation sous Linux, texte de 2013 : https://wiki.linaro.org/LEG/Engineering/OPTIM/Assembly

La prochaine génération d'instructions pour puces Intel, le AVX-512, selon Agner Fog en 2013 : http://agner.org/optimize/blog/read.php?i=288

Simulateur en-ligne d'assembleur 8 bits : http://schweigi.github.io/assembler-simulator/

Programmer avec des 1 et des 0, ou comment faire le lien entre un langage d'assemblage et du code machine, texte de 2015 : http://www.hanshq.net/ones-and-zeros.html

Assembleur 64 bits :

Quelques assembleurs connus

Le Netwide Assembler, ou NASM : http://www.nasm.us/

JWASM, un dérivé du Watcom Assembler, ou WASM :

Introduction à l'assembleur MIPS, par Bradley Kjell en 2007 : http://chortle.ccsu.edu/AssemblyTutorial/index.html

Désassembleurs

Texte à venir...

Un wiki sur le sujet : http://en.wikipedia.org/wiki/Disassembler

Compilateurs

Pour en savoir plus sur le processus de compilation en C ou en C++, je vous invite à lire ceci, qui est un peu vieux mais va quand même dans le détail. Vous trouverez aussi ici un livre en ligne sur les bases de l'écriture de compilateurs, puis un autre, tiens. Et un autre, et encore un autre. Pour un texte sur l'écriture de compilateurs avec C# 4.0, voir ceci par Christopher Diggins.

Un compilateur est en quelque sorte un traducteur, qui :

En prenant l'exemple d'un programme simple, dans le cycle de développement associé aux langages compilés, lorsqu'une programmeuse ou un programmeur rédigera un programme, elle ou il :

Le fruit de la compilation n'est pas nécessairement un programme. Il peut s'agir d'une bibliothèque, qui sera intégrée ultérieurement (de manière statique, dès l'édition des liens, ou de manière dynamique, lors de l'exécution du programme) aux programmes qui en auront besoin.

Quelques liens pertinents :

Métacompilateurs :

Compilateurs vers une machine virtuelle :

Comparatifs :

Pour ce qui est des étapes d'analyse lexicale et d'analyse sémantique, plus particulièrement :

Compilateurs et parallélisme :

Compilateurs juste à temps (JIT)

à venir...

Une discussion : les compilateurs juste à temps capables de traçage ont-ils gagné? http://lambda-the-ultimate.org/node/3851#comment

Le compilateur juste à temps HotpathVM, visant la compilation de code Java pour plateformes à faibles ressources, par Andreas Gal, Christian W. Probst et Michael Franz en 2006 : http://static.usenix.org/events/vee06/full_papers/p144-gal.pdf

Les compilateurs juste à temps peuvent-ils mener à du code qui serait à la hauteur des compilateurs Ahead of Time?

Texte de Kannan Vijayan en 2012 sur la difficulté de réaliser certaines optimisations sur la base d'a priori dans un compilateur juste à temps destiné au code JavaScript : https://blog.mozilla.org/javascript/2012/10/15/the-ins-and-outs-of-invalidation/

À propos du Baseline Compiler de Mozilla pour JavaScript, texte de Kannan Vijayan en 2013 : https://blog.mozilla.org/javascript/2013/04/05/the-baseline-compiler-has-landed/

Introduction à la rédaction de compilateurs JIT :

Un petit compilateur JIT, et pourquoi il est sage de garder ces programmes « petits », par Josh Haberman en 2012 : http://blog.reverberate.org/2012/12/hello-jit-world-joy-of-simple-jits.html

Optimiser le code pour profiter au maximum d'un compilateur JIT pour JavaScript, le point de vue d'Alon Zakai en 2013 : http://mozakai.blogspot.ca/2013/08/outlining-workaround-for-jits-and-big.html

Écrire un compilateur JIT :

En 2014, Nelson Elhage relate ce qu'il a appris en écrivant un JIT à l'aide de Go : http://nelhagedebugsshit.tumblr.com/post/84342207533/things-i-learned-writing-a-jit-in-go

Comment les compilateurs JIT influencent nos pratiques de débogage, réflexion de Shu-yu Guo en 2014 : http://rfrn.org/~shu/2014/05/14/debugging-in-the-time-of-jits.html

Le projet Roslyn, un compilateur C# juste à temps qui se présente comme un service :

En 2012, Josh Haberman parle des joies des compilateurs JIT simples, avec exemples qui fonctionnent : http://blog.reverberate.org/2012/12/hello-jit-world-joy-of-simple-jits.html

FTL, un compilateur JIT pour WebKit, basé sur LLVM : http://blog.llvm.org/2014/07/ftl-webkits-llvm-based-jit.html

Utiliser g++ comme compilateur JIT, texte de 2015 : http://developerblog.redhat.com/2015/04/07/jit-compilation-using-gcc-5-2/

LLVM

Le projet LLVM est un ensemble d'outils à code ouvert permettant de générer des compilateurs de qualité. Très contemporain, gagnant de plusieurs prix, ce projet dont l'architecte principal est Chris Lattner est entre autres soutenu par Google et Apple. Sa partie la plus visible est Clang, un compilateur C++ ayant la réputation de produire d'excellents diagnostics.

Quelques liens :

L'architecture de LLVM :

La plateforme LLVM a eu des répercussions dans plusieurs domaines d'applications :

Comparatifs :

DSL (Domain Specific Language)

Langages conçus pour mieux régler une catégorie particulière de problème, plutôt que pour faciliter la programmation de manière générale. Quand le langage est intégré à un autre langage, comme un peut le faire parfois avec un métalangage riche comme celui des templates avec C++, on parlera d'un EDSL, le « E » signifiant Embedded.

Idées et opinions :

Quelques exemples :

Critiques :

Éditeur de liens (Linker)

../Sujets/Developpement/Programmation-Systeme--Mecanique-Compilation.html

à venir...

Un guide sur les éditeurs de liens, destiné aux débutants (avec connaissances en C ou en C++), par David Drysdale : http://www.lurklurk.org/linkers/linkers.html

Comprendre le fonctionnement de l'éditeur de liens de gcc sous Linux, texte d'Eli Bendersky en 2013 : http://eli.thegreenplace.net/2013/07/09/library-order-in-static-linking/

Livre en ligne, par John Levine en 2001 : http://www.iecc.com/linker/

Douze faits sur les éditeurs de liens, relatés par Julia Evans en 2013 : http://jvns.ca/blog/2013/12/10/day-40-12-things-i-learned-today-about-linkers/

Le Link-Time Optimization avec gcc, expliqué par Jan Hubička en 2014 :

Le Link-Time Code Generation, ou Whole Program Optimization, relaté par Raymond Chen en 2014 : http://blogs.msdn.com/b/oldnewthing/archive/2014/06/06/10531604.aspx

Pourquoi le système d'exploitation Plan 9 privilégie l'édition des liens statique à sa contrepartie dynamique, un texte de 2004 par Ron Minnich : http://www.plan9.bell-labs.com/wiki/plan9/why_static/

Introduction détaillée à l'édition des liens, par Ian Lance Taylor en 2007 :

Livre en ligne sur les Linkers et les Loaders, en version « brute » (avant l'action de l'éditeur), par John Levine en 2014 : http://iecc.com/linker/

Comme le rappelle Raymond Chen en 2015, on ne peut pas impunément entremêler diverses technologies de Runtime C, même si elles proviennent d'un même fournisseur : http://blogs.msdn.com/b/oldnewthing/archive/2015/09/11/10640979.aspx

En 2016, Nick Desaulniers propose une série d'articles sur l'édition des liens :

Générateurs de processeurs

Quelques outils assistant les concepteurs de langages et de compilateurs dans leurs tâches.

Interpréteurs

à venir...

Langages intermédiaires

Plusieurs générateurs de code produisent des instruction non pas dans un langage machine pour une machine physique mais bien dans un intermédiaire. Il existe plusieurs langages intermédiaires, destinés à des interpréteurs, des compilateurs ou des machines virtuelles. Sans surprises, chacun a ses qualités, défauts et caractéristiques propres.

Il existe un Wiki sur le bytecode, mais il s'agit en fait d'un article général sur les langages intermédiaires. Puisque le langage destiné à la JVM utilise le même nom pour se décrire, ce nom entraîne un peu de confusion. Tout de même, l'article existe : http://en.wikipedia.org/wiki/Bytecode

Textes généraux :

Quelques-uns des langages intermédiaires les plus connus suivent :

Vous trouverez ici les listes d'instructions « machines » de quelques-uns de ces langages intermédiaires.

Valid XHTML 1.0 Transitional

CSS Valide !