Diagramme en T du compilateur croisé

J'étudie Bootstrapping de Red Dragon Book Compilers et j'ai trouvé le diagramme en T pour le compilateur croisé assez déroutant. Je ne peux pas comprendre ce que l'on entend par «exécuter compilateur1 à compilateur2». Quelqu'un peut-il fournir une meilleure explication, une analogie ou un exemple pour se rapporter à un compilateur réel?

Quelques notations d'abord. Par Je veux dire un compilateur pour le langage écrit en langage qui produit des codes de langue de sortie / machine à N . Ceci est une pierre tombale ou T-diagrammes .$LSN=$ $L$$S$$N$

Compiler un compilateur

1. Supposons que nous ayons un compilateur croisé pour un nouveau langage L dans le langage d'implémentation S générant du code pour la machine N.

   $LSN=$
   

2. Supposons que nous ayons également un compilateur S existant fonctionnant sur la machine M implémentant le code de la machine M:

   $SMM=$
   

3. Exécutez LSN via SMM pour produire LMN

Construction du compilateur

$LMN = LSN + SMM$

Les diagrammes en T (que vous aviez omis de la version originale de votre question) sont cruciaux pour comprendre ce type de question. Regardons le dernier diagramme en T.

Le premier T décrit un compilateur de L à N écrit en S.

Le second T décrit un compilateur de S à M écrit en M (ou fonctionnant sur M). Ce sera votre compilateur compilateur .

L'application du second T au premier T compile le premier T pour qu'il s'exécute sur la machine M. Le résultat est donc un compilateur de L à N fonctionnant sur la machine M.

Le fait que le second T s'exécute également sur la machine M signifie que vous exécutez le compilateur du compilateur sur la machine sur laquelle vous exécuterez le compilateur, plutôt que d'avoir à utiliser un compilateur croisé (ce qui serait le cas si le M inférieur était différent). ).

Cela signifie que nous compilons LSN avec SMM, c'est-à-dire, exécutons le code source de LSN via SMM.

Lorsque SMM compile du code source, il produit un exécutable pour la machine M, donc lorsque nous compilons LSN avec SMM, nous obtenons LMN - un exécutable, qui compile L fichiers source sur la machine M afin de produire des exécutables pour la machine N.

Il serait peut-être plus facile de comprendre cela avec une analogie. Supposons que nous ayons un compilateur C ccqui est écrit en Fortran, qui génère du code ARM. Supposons que nous ayons également un compilateur Fortran fcsur notre ordinateur x64. Si nous compilons ccle code source avec fcnous obtenons un programme qui fonctionne sur x64, compile les programmes C, mais produit des exécutables pour ARM.

Pour faire simple ....

Remarque: N'oubliez pas que le compilateur ne peut s'exécuter que sur un langage de bas niveau.

Dans le 1er diagramme, le compilateur est écrit en HLL (High Level Langg) afin de ne pas exécuter que sur une machine le langage d'implémentation du compilateur doit être en LLL.

Ainsi, dans le deuxième diagramme, le langage d'implémentation du compilateur est exécuté sur un compilateur auto-résident de telle sorte que le code cible puisse s'exécuter sur sa propre machine.

Enfin, en combinant les deux, le compilateur s'exécute sur une machine avec langg - M

langg d'entrée - L

sortie Langg - N