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 residant en EPROM. Ce moniteur permet
tout 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 program-
me. 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 les registres de piles, appeler le sous-
programme main et redonner la main au moniteur du kit. Mais vous pouvez aussi initialiser
de la memoire (un vecteur d'interruption par exemple) ou configurer des circuits peri-
pheriques (pia, ptm,...):
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 proprement l'editions
des liens
Etude d'un exemple simple sur kit68000
Les sources des fichiers qui suivent sont dans le repertoire $kits68k/exemple/LinkCom.
Algorithme du startup minimum:
debut
Initialisation du registre de pile
Appel de la fonction main
Retour au moniteur
end
Ce 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
END
Explication:
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 public (accessible au un autre module) un symbole local.
Ainsi un autre module pourra faire reference a ce symbole.
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
=================================================================
000800h debut de la section 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 prog (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 prog du code utilisateur
---------------------------------------------
. Puis suivent les sections const et data qui contiennent
. les constantes et les donnees de la section code utilisateur.
-----------------------------------------------------------------
. Et enfin les autres sections: lib, libc, libm ,...
.
. Code des fonctions des librairies standards appelees
. par le code utilisateur.
-----------------------------------------------------------------
.
.
01FFFFh
=================================================================
fin de la memoire utilisateur sur kit 68000
Pour obtenir un mapping memoire identique a celui montre ci-dessus on doit donner des
directives a l'editeur des liens (commande l68) par l'intermediaire d'un fichier de commande
souvent appele LinkCom.k.
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 /usr/hp64000/lib/68000/libm.a
LOAD /usr/hp64000/lib/68000/libc.a
LOAD /usr/hp64000/lib/68000/lib.a
END
Description du fichier test.k :
La directive CHIP precise le type du processeur.
La diretive ORDER permet de specifier l'odre de placement 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 permet de preciser l'adresse de debut d'une section. SECT startup00 = $800 fait commencer
la section startup00 a partir de l'adresse 800 hexa. Les autres sections (prog, const, lib,...) serront placees
apres la section startup comme le precise la directive ORDER.
La directive LOAD precise un module objet (en .o) ou une librairie (en .a) qui doit etre charge. Le
module objet contient des sections de code operatoire translatable d'un ensemble de routines et de donnees.
Une libairie n'est qu'un fichier archive qui contient un ensemble de fichiers objets.
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.