LABORATOIRE ARCHITECTURES ET SYSTEMES (5201)
Utilisation des fichiers de commandes pour maitriser l'edition des liens
Il est important de remarquer qu'un kit 68000 ou 68010 ne possede pas de systeme d'exploitation mais un "simple" moniteur. Ce moniteur permet juste de charger un programme en memoire et de lancer sont execution. Lancer l'execution d'un programme n'est pas aussi simple qu'il n'y parait. Sur une station de travail la complexite du chargement et du lancement du programme en memoire est masquee par le systeme d'exploitation. Sur un kit 68000 ou 68010 c'est le programmeur qui a la charge de charger et de lancer en memoire le programme. Un simple go a l'adresse d'implantation en memoire de la fonction main ne suffit pas. L'execution du sous/programme main doit etre faite sous le controle d'un programme appele' startup. Le startup doit effectuer l'interface logiciel entre le syteme cible et le programme utilisateur. Pour un kit 68000 ou 68010 le startup ecrit en assembleur reste simple: il doit au minimun initialiser le registre de pile, appeler le sous- programme main et redonner la main au moniteur du kit. Mais vous pouvez initialiser de la memoire (un vecteur d'interruption par exemple) ou configurer des circuits peripheriques: debut Initialisation logiciel (memoire, registres,...) Initialisation materiel (circuit d'entrees/sorties,...) Appel du programme utilisateur (fonction main) Retour au moniteur fin L'utilisation d'un startup est donc obligatoire. Elle necessite d'assembler et de compiler separement les modules en assembleur et en langage C pour effectuer une l'editions des liens.Etude d'un exemple simple sur kit68000
Les sources des fichiers qui suivent sont dans le repertoire $kits68k/exemple/LinkComAlgorithme du startup minimum:
debut Initialisation du registre de pile Appel de la fonction main Retour au moniteur endCe qui donne en assembleur (fichier startup00.s):
* Declaration de la section SECT startup00 * Declarations des symboles externes: XREF _main ; nom de la fonction principale * Declarations des symboles publics: XDEF _exitkit ; S/P d'appel du moniteur * Debut du startup entry MOVE.L #20000H,A7 ; init pile utilisateur JSR _main ; appel du sous/programme principal utilisateur _exitkit TRAP #14 ; retour au moniteur du kit ENDExplication:
La directive SECT permet de nommer une section de code ou de donnees. La directive XREF permet de faire reference a un symbole public (declare' dans un autre module). Ici le symbole externe est _main qui est le nom objet donne' apres compilation du fichier .c contenant la fonction main(). La directive XDEF permet de rendre accessible un symbole local de ce module a un autre module.Assemblage du fichier startup00.s:
Il suffit de lancer la commande a68: a68 startup00 Ce qui a pour effet de generer un module objet startup00.o en code operatoire 68000 translatable.Compilation du fichier C d'exemple test.c:
Il suffit de lancer la commande c68: c68 test Ce qui a pour effet de generer un module objet test.o en code operatoire 68000 translatable.Edition des liens :
Avant d'effectuer l'editions des liens il faut imaginer l'emplacement des differentes sections de code, de donnees et de constantes dans la memoire du kit cible: debut de la memoire utilisateur sur kit 68000 ================================================================= 000800 (debut de la section de startup) . . / Initialisation du registre de pile . Code du Startup - Appel de la fonction main . \ Retour au moniteur . . (fin de la section de startup) ----------------------------------------------------------------- . (debut de la section du code utilisateur) . . Elle contient le code du fichier test.c et en . particulier le code de la fonction main ainsi que . les eventuels appels aux routines des librairies . standards. . . (fin de la section du code utilisateur) --------------------------------------------- . Section des constantes et des donnees du . code utilisateur. ----------------------------------------------------------------- . Sections des librairies standards. . . Code des fonctions des librairies standards appelees . par le code utilisateur. ----------------------------------------------------------------- . . 01FFFF ================================================================= fin de la memoire utilisateur sur kit 68000 Pour obtenir un mapping memoire identique a celui montre ci-dessus il faut donner des directives a l'editeur des liens (commande l68). La commande l68 va chercher les directives d'edition des liens dans un fichier qui porte une extension en .k et qui doit etre dans le repertoire local de travail. Si ce fichier est absent, la commande l68 va chercher un fichier de commande par defaut. Dans notre exemple le fichier de commande des liens est test.k: CHIP 68000 ORDER startup00,prog,const,lib,libc,data,libdata,libcdata SECT startup00 = $800 LOAD startup00.o LOAD /nfs/srv3_d1/usr/hp64000/lib/68000/libm.a LOAD /nfs/srv3_d1/usr/hp64000/lib/68000/libc.a LOAD /nfs/srv3_d1/usr/hp64000/lib/68000/lib.a ENDDescription du fichier test.k :
La directive CHIP precise le type du processeur a titre indicatif. La directive LOAD impose les modules a linker. Par exemple le LOAD startup00.o permet a l'editeur de liens de trouver la section startup00. Attention il n'y a pas de message d'erreur si une section presente dans la directive ORDER n'est pas trouvee. Chaque directive LOAD + nom de fichier precise un fichier qui peut etre soit un module objet extension en .o soit une librairie extension en .o (une librairie est un fichier archive qui contient le code operatoire translatable d'un ensemble de routines). La diretive ORDER impose l'odre d'apparition en memoire des differentes sections de code, de constantes et de donnees. Donc ici toutes les section de code nommees startup00 des modules objets seront placees en memoire avant toutes les autres sections. La section suivante sera prog, ect... La directive SECT startup00 = $800 fait commencer la section startup00 a partir de l'adresse 800 hexa. Evidemment les autres sections suivront derriere la section startup00 commen indique par la directive ORDER.Execution de l'edition des liens :
Il suffit de lancer la commande l68: l68 test Ce qui a pour effet de generer un fichier telechargable test.s29. Avant de tester le programme regardez le fichier test.map pour verifier que les adresses d'implantation des sections sont dans la memoire utilisateur.Les entrees/sorties sur kit68000 :
Il existe un module qui contient le code des fonctions standard C suivantes: void exitkit (void); /* retour au moniteur */ char getchar (void); /* retourne le caractere saisie apres un return au clavier */ char getkey (void); /* retourne un caratere saisie au clavier */ char *gets (char*); /* retourne une chaine de carateres saisie au clavier */ void puts (char*); /* affiche la chaine de cararteres en parametre */ void putchar (char); /* affiche le caracter en parametre */ Le code source de ces fonctions est disponibles dans le fichier $kit68k/src/iokit00.s Pour pouvoir utiliser ces fonctions il faut: -inserer le fichier include suivant: #include <iokit00.h> (dans votre fichier .c) -ajouter dans votre fichier .k a la ligne ORDER la section iokit00: ORDER startup00, iokit00, ... LOAD /user/info_lib/Kits68k.new/lib/iokit00.o