présentation de CGEN
Présentation des outils de binutils

Par Wilfrid et Michel

Présentation de CGEN, le générateur d'architecture pour Binutils

CGEN est un framework ou « cadriciel » développant des générateurs d'outils tels que des assembleurs, des désassembleurs et des simulateurs pour différents processeurs. Il implémente un langage de description pour décrire l'architecture et l'organisation d'une CPU sans référencer n'importe quelle particularité. CGEN est écrit en Scheme et peut être exécuté sous l'interpréteur GNU Guile.  Il est placé sous licence de logiciel libre.

Donc CGEN nous génère les fichiers opcodes vus précédemment. Pour cela, nous devons lui fournir des fichiers contenant toutes les caractéristiques de SIMPLE-CPU. Ces fichiers sont nommés '<arch>.cpu' et '<arch>.opc'

Le fichier '<arch>.cpu' contient toutes les descriptions du processeur cible. Il est écrit en Scheme (comme les fichiers de configuration de GCC).

Comme le représente le schéma suivant, un fichier '<arch>.cpu' implémente une architecture bien précise. Puis pour cette architecture, on peut définir plusieurs familles de CPU, et de modèle de CPU. Voici la représentation arborescente que l'on peut en faire.

Arborescence générale Arborescence du FR30 Arborescence du FR30
                     architecture
                        /            \
            cpu-family1   cpu-family2 ..
              /           \
      machine1   machine2  ...
        /         \
model1   model2  ...                         
                   Fujitsu FR30
                      /            \
              fr30bf          ...
             /          \
       fr30bf        ...
        /         \
   fr30-1        ...             
               SimpleCPU
               /            \
     SC91_32      SC91_64
             |   
           SC91        
        /              \
SC91_32_A  SC91_32_B     

Dans ce fichier, nous trouvons d'autres informations tels que les décompositions de la ligne d'instructions. Grâce à ceci, les programmes assembleur et désassembleur peuvent convertir une instruction de mnémoniques en code machine et vice versa.

Voici un exemple explicatif sur les instructions d'additions de SIMPLE-CPU.

(dnf Code "Code Instruction" () 31 24)
(dnf Rd "Registre Rdd" () 19 23)
(dnf Rn "Registre Rnn" () 18 14)
(dnf Rm "Registre Rmm" () 13 9)
(dnf Mode "Mode de l'addition" () 8 6)
(dnf C_Value "Code Value" () 25 24)
(dnf Value "Value" () 13 0)

Nous devons effectuer ce travail pour toutes les instructions du coeur. Ainsi l'instruction ADDd peut être construite comme suit : Code+Rd+Rn+Rm+Mode (le signe '+' est à comprendre au sens concaténation et non pas au sens arithmétique ou logique). S'il y a des interruptions dans la séquence, le programme complétera avec des 0. 

Un autre fichier peut être présent. Il s'agit de '<arch>.opc'. Il contient du code C spécifique à la cible. Il sert à construire de façon plus aisée les instructions complexes que supporte les coeurs.

Une fois ces fichiers créés, nous pouvons lancer CGEN.  L'exécution se fait à partir de l'interpréteur Guile. Pour le fonctionnement de l'interpréteur, une documentation est disponible sur le site officiel du projet GNU.

Les fichiers générés par CGEN sont appelés fichiers opcode. Voici une brève présentation :

Étant donné que ces fichiers sont générés automatiquement par CGEN, nous ne les avons pas étudié dans le détail. 

Maintenant que nous avons modifié une instruction, nous pouvons estimer la charge horaire afin de réaliser le portage de GCC et des binutils pour SIMPLE-CPU. Nous avons fixé un maximum de 10 min par ligne de code. Dans ces 10 minutes, nous comptons, bien évidemment, la réflexion, la réalisation et la vérification. Sachant également que les lignes de codes sont répétitives, surtout lors des descriptions des fonctions, donc dans ce cas, le temps de réflexion diminue considérablement. La vérification peut se faire de façon groupée.

Pour les fichiers '<arch>.cpu' et '<arch>.opc', nous estimons le temps maximum à 350H, mais après avoir diminué le temps dû aux tâches répétitive, nous fixons ce délai à 250H.

Pour les fichiers back-end de GCC, nous avons calculé un temps d'environ 650H. Ce temps peut paraître excessif, mais il faut savoir que les fichiers de descriptions GCC sont plus nombreux, et également qu'il n'existe à l'heure actuelle aucun outil qui permette la génération automatique. Cependant, sur le site officiel de l'outil CGEN, nous avons lu que les développeurs ont l'ambition de créer une nouvelle version qui générera automatiquement les fichiers de descriptions binutils et de GCC. Ainsi, le portage de GCC vers une cible sera plus aisé. Pour le moment, nous devons coder ces fichiers "à la main", mais il faut savoir qu'ils sont extrêmement répétitifs. Donc une fois que l'on a compris comment les coder, le temps prévu pour les suivantes diminue, c'est pourquoi nous avons revu ce temps à la baisse. Nous évaluons donc ce temps à 400H.

Donc nous pensons que le portage de GCC vers SIMPLE-CPU peut s'effectuer en un temps d'environ 650H. Ce temps tient également compte de la connaissance que nous avons acquise tout au long de cette présentation.

Portage GCC, modification d'une instruction
Simple-Cpu The Simple CPU project The Simple CPU project
Un projet de disk91
Small CPU project