Une approche très préliminaire de µCsim

Le désir le plus évident n’est pas celui que l’on ne remet jamais en cause, mais celui auquel on revient le plus souvent.
Blanche de Richemont, Eloge du Désir

Je recommence à penser à cette idée de faire un compilateur C pour le TLCS-900H. C’est un peu un serpent de mer cette idée, je laisse tomber pendant des mois, puis à moment donné ça me revient en tête, et je me dis "je devrais essayer." Je n’ai jamais écrit de compilateur, je n’ai jamais écrit d’émulateur, ni de simulateur. J’ai fait un vague cours d’architecture des ordinateurs il y a un peu plus de 20 ans maintenant. J’ai un bébé qui prend tout mon temps.

Mais, j’ai le désir. Et il y a un vrai manque dans le monde du développement amateur pour la Neo Geo Pocket, d’un compilateur C libre. En libre il existe un assembleur, mais aujourd’hui tout le monde développe en C (ce qui est normal !) et tous les outils qui existent autour de cette console, dépendent du compilateur commercial proposé par Toshiba, qui est donc joyeusement piraté. En soi je ne vois pas nécessairement de problème à utiliser gratuitement un logiciel payant pour faire des projets amateurs, mais je trouve que cela laisse un risque juridique qui me semble exagéré.

Le serpent de mer revient donc, et cette fois je me décide à creuser. Utilisant ChatGPT comme un partenaire de discussion sur ce projet, je réalise que...

(un réveil de bébé plus tard)

... le point de départ doit être de fabriquer une machine qui interprète le code binaire du TLCS-900H, afin que ensuite, quand on passe à l’étape de réfléchir à comment transformer du C en assembleur, on ait déjà un outil pour tester que le code généré fasse bien ce qu’on attende qu’il fasse. Et ça, on appelle ça un simulateur.

ChatGPT m’indique que µCsim est justement ce simulateur utilisé par SDCC (je reste sur mon idée d’implémenter un nouveau processeur sur ce compilateur multiarchitecture qui contient déjà le TLCS-90, de la même famille bien que plus simple), et qu’il semble avoir déjà une architecture permettant d’ajouter "facilement" (guillemets nécessaires) un nouveau processeur.

Seul problème : il n’y a aucune documentation, comme souvent sur les anciens logiciels libres. Alors, que faire ? Je regarde un peu la masse de fichiers sources, la plupart sans commentaires, en C++ - langage que je n’ai jamais vraiment pratiqué, ayant plutôt fait du C. Et je soupire. Par où commencer ? Il y a un dossier core qui semble contenir des fichiers source, et un dossier sims qui contient des sous-dossiers portant chacun le nom d’une architecture. J’ouvre quelques fichiers au hasard, je vois qu’il y a plein de macros qui définissent du code, bref l’horreur. Comment mettre le pied dans ce code ?

J’interroge ChatGPT qui me suggère 3 choses :

• d’utiliser un éditeur de code qui permet de naviguer dans le code. En l’occurence après discussion, je choisis Geany, un éditeur libre et léger.
• d’utiliser la ligne de commande ctags -R * dans le dossier racine du projet afin de générer une base de données de symboles qui me permettront de faciliter la navigation
• de chercher le point de départ sur programme, à savoir la fonction main().

Et là surprise : il y a des dizaines de main(). Ce programme µCsim est en fait un assemblage de petits programmes autonomes. Alors, quel est le bon point de départ ?

Eh bien il se trouve que chaque architecture simulée a son propre main() que l’on trouve dans (par exemple) src/sims/tlcs/sltcs.cc et qui contient toujours plus ou moins la même chose :

int
main(int argc, char *argv[])
{
  int retval;
  class cl_sim *sim;

  app_start_at= dnow();
  cpus= cpus_tlcs;
  application= new cl_app();
  application->set_name("stlcs");
  application->init(argc, argv);
  sim= new cl_simtlcs(application);
  if (sim->init())
    sim->state|= SIM_QUIT;
  application->set_simulator(sim);
  retval= application->run();
  application->done();
  delete application;  
  return retval;
}

Et ca fait quoi ? Ben, ça crée une instance d’une application (classe cl_app) et ensuite ça appelle une classe de simulateur (cl_simtlcs) avec pour paramètre cette application. Le simulateur est initialisé et on indique à l’application qu’elle est appelée avec ce simulateur là. Enfin, on lance l’application.

De ce tout début d’analyse on comprend que la partie "application" est plus ou moins générique (une interface que je vais devoir comprendre mais que j’aurai pas à toucher) et que la partie simulateur doit être une classe dérivée d’une classe de base ou abstraite, dont je peux éventuellement m’inspirer pour construire mon propre simulateur ! Encore faudra-t-il la trouver...

ChatGPT me donne également un autre conseil, celui de créer mon propre simulateur plutôt que de rajouter une variante de processeur au simulateur TLCS existant. Le TLCS-900H étant très différent du TLCS-90 et du TLCS-870 qui sont implémenter, cela me semble une bonne idée. Je vais partir comme ça....