Quand on développe sur une machine des programmes devant s'exécuter sur une autre machine, on dit que l'on fait du développement croisé. Les outils utilisés dans ce cas s'appelle outils de développement croisés, les outils habituels, ceux qui génèrent des programmes qui devront s'exécuter sur la même machine s'appellent outils de développement natifs.
La machine sur laquelle on fait le développement s'appelle machine
hôte (la station de travail HP). La machine sur laquelle
s'exécutent les programmes s'appelle machine cible (le kit 68040).
- édition du programme source.
- assemblage/compilation et édition de liens
.
- exécution du programme sur la machine.
En développement croisé c'est un peu plus compliqué:
Sur la machine hôte (la station HP):
- édition du programme.
- assemblage/compilation croisé
(génération de code pour processeur 68k de notre kit)
- édition de liens adaptée
a la machine cible (le kit 68040) et non pour la machine hôte (la
station) !.
Sur la machine cible (le kit 68040):
- récupérer le code exécutable de la machine
hôte (la station).
- lancer l'exécution de ce code.
La machine hôte et la machine cible doivent être reliés
d'une manière ou d'une autre pour permettre le transférer du code
exécutable :
- HP (celui que nous utilisons depuis le début);
- MicroTec (le nouveau, celui que l'on devrait utiliser
mais qui demande un effort: refaire la doc, les scripts, ect...)
- GNU (vachement bien, gratuit, c'est celui
que tout le monde utilise sauf à l'ESIEE car partiellement porte
sur
HPUX 10.2 et pas vraiment maintenu par le SMIG dommage).
Ces outils existent sur votre station de travail sous deux formes: la forme native et la forme croisé pour la famille des processeurs Motorola 68000. Les commandes essentiels sont:
- cc68000 : le compilateur
- as68k : l'assembleur
- ld68k : l'éditeur
de liens
- ar68k : gestionnaire
de librairie
Pour simplifier à l'extrême l'utilisation de ces commandes vous disposez des scripts suivants:
- cckit
: pour compiler
- assemblage
: pour assembler
- c68, a68 et l68
Il suffit simplement d'utiliser la commande:
assemblage Fichier (sans extension .s)
Cette commande génère 3 fichiers:
Le Fichier.lst qui contient le code machine + le source + la table des symboles + les éventuelles erreurs. Le Fichier.o qui est le fichier objet. Le Fichier.s29 qui est le fichier a télécharger dans le kit.
Compiler un ficher source en langage C
Il faut utiliser la commande de compilation:
cckit [68000 | 68010 | 68030 | 68040] Fichier (sans extension .c, l'option par défaut est 68040)
Ne vous trompez pas d'option car elle détermine l'adresse d'implantation de votre programme dans la RAM du kit cible. Pour un kit 68000 cette adresse est 800h, un kit 68010 cette adresse est FF9000h et un kit 68040 cette adresse est 0h.
Cette commande génère alors 4 fichiers:
Le Fichier.lst qui contient le mnémonique assembleur (en correspondance avec le source C ) + le code machine + la table des symboles + les eventuelles erreurs. Le Fichier.map qui est le rapport de l'édition des liens, il contient le mapping d'implantation de votre code dans la mémoire du kit cible. Le Fichier.o est le fichier objet. Le Fichier.s29 est le fichier a télécharger dans la mémoire du kit.
Pour implémenter les conventions du langage ANSI C, cckit ajoute au début de votre programme du code nommé startup, qui implémente l'algorithme suivant:
- initialisation de l'environnement
d'exécution (est fonction du kit)
- jsr main (appel de la fonction main)
- terminaison du programme: retour
au moniteur du kit.
Votre code est donc placé juste derrière celui du
startup.
Vous pouvez le constater en regardent le fichier .map.
Pour une application comportant des modules en langages C et assembleur 680X0
Soit une application comportant:
1 module main.c (programme
principal en langage C).
1 module ext.s (sous-programme
en langage assembleur 68000).
TRADUCTIONS SÉPARÉES :
a) Compilation des sources C avec la commande c68
+ nomfichier :
info18
4: ls
main.c
info18 5: c68 main
info18 6: ls
main.c main.lst main.o
La commande c68 [68000
| 68010 | 68030 | 68040] + liste de fichiers
ne génère que les fichiers .o (pour
une édition des liens séparées)
de la liste des fichiers. L'option par défaut est le processeur cible 68000.
main.c source
C du programme.
main.o contient
le code objet translatable de main.c ( existe si main.c est sans erreur).
main.lst contient
la traduction du fichier source C main.c en mnémonique assembleur + le
code machine 680X0.
b) Assemblage des sources assembleur avec la commande a68 + nomfichier
info18 6: ls
ext.s
info18 7: a68 ext
info18 8: ls
ext.s ext.lst
ext.o
La commande a68 [68000 | 68010 | 68030 | 68040] + liste de fichiers. L'option par défaut est le processeur cible 68000.
ext.s source
68000, extension en .s obligatoire !
ext.o contient
le code objet translatable de ext.s
ext.lst contient
le code machine 68000 + la table des symboles + les éventuelles erreurs...
c) ÉDITION DES LIENS
La commande l68 [
kit68000 | kit68010 | kit68040 ] NomFichier permet l'édition des liens avec tous les fichiers objets (extension .o)
présents dans le répertoire courant.
L'option permet de préciser le kit cible pour implanter votre code à des adresses compatibles avec
la RAM du kit cible et de lui ajouter le bon code de startup.
Cette option fait en faite référence a un fichier de commande qui contient
les ordres pris en compte par l'éditeur de liens. Ces fichiers de
commandes sont Kit68000.k,
Kit68010.k, Kit68030.k
et Kit68040.k.
Ils indiquent a l'éditeur de liens ou placer les différentes sections
des code de la mémoire de la machine cible.
Si vous voulez changer l'adresse d'implantation de votre programme ou ajouter une autre librairie (par exemple iofischer10 qui contient les routines pour piloter une maquette Fischer) vous devrez écrire vous même ce fichier de commande. Vous trouverez dans le répertoire user/info_lib/Kits68k/exemple/LinkCom un exemple (commencer par lire ALIRE).
info18 8: ls
ext.s ext.lst ext.o main.c
main.lst main.o
info18 9: l68 appli
info18 10: ls
ext.s ext.lst ext.o
main.c main.lst main.o
appli.map appli.s29
appli.s29 executable au format S de Montorola a télécharger sur le kit
appli.map rapport de édition des liens et éventuellement les erreurs.

On peut donc contrôler un kit 68040 ou lui envoyer un programme depuis une station de travail par 2 types de connexions:
- une connexion série à faible débit sous le moniteur monotâche 162bug de Motorola.
- une connexion réseau à haut débit sous le moniteur multitâche XRAY debugeur de Microtec.
A la base l'unique programme
de gestion de la carte
MVME162LX
fournit par le constructeur est le moniteur 162bug. Ce moniteur 162bug joue vis
à vis d'un
Kit 68040 le même rôle que
joue un shell vis à vis d'une machine UNIX. Le 162bug
attend, interprète et retourne le résultat des commandes de l'utilisateur via sa première ligne
série. Ces
commandes
permettent de contrôler totalement la carte: vous pouvez par exemple visualiser/modifier le contenu des registres du processeur ou de
sa mémoire, mais surtout vous pouvez récupérer le code exécutable
provenant
de la station hôte pour l'exécuter et le débuguer.
Dans le but de gérer des applications temps réels sous VRTX nous avons ajouté en UVPROM le moniteur multitâches XRAY de Microtec. Il fait la même chose que le 162bug mais utilise le réseau pour communiquer avec une station hôte. Sur la station vous disposez d'outils puissants pour la mise au point de vos programmes (assembleur ou langage C) comme: le shell xsh qui vous met en communication direct avec le kit ou le débuggeur graphique xmo68ks.
Vous avez aussi la possibilité de démarrer le kit comme une machine diskless: dans ce cas le kit va chercher sur le réseau un programme (le système d'exploitation Linux par exemple ou une application) qu'il exécute ensuite. On utilise se fonctionnement pour booter le kit sur le système d'exploitation Linux.
Pour choisir ces différents mode de fonctionnement nous avons ajoute un ronboot de démarrage. Ce programme se trouve en UVPROM et s'exécute des la mise sous-tension du kit; sont comportement dépend de la position des cavaliers 13-14 et 15-16 en J11 sur la carte MVME162LX:


Pour démarrer sous le 162bug taper 1.

Tapez un Retour Chariot dans la fenêtre pour vérifier que vous obtenez bien le prompt 162bug>.
C'est tout bon le 162bug attend vos commandes ! Si ça ne marche pas vérifiez la présence du câble série !

Dans ce mode particulier vous devez consulter les pages sur l'utilisation du kit sous XRAY debugger.
Mais si vous avez besoin d'utiliser le moniteur 162bug demandez au responsable du Labo, d'effectuer pour vous les manipulations suivantes:
- mettre hors tension le kit 68040,
- dégager de son logement la carte MVME162,
- replacer le cavalier en 13-14 sur J11 (a coté du processeur),
- et enfin reloger la carte dans son emplacement.
Il faut respecter les champs séparés par des tabulations:
Étiquette Tabulation Mnémonique
Assembleur Tabulation Opérande Tabulation
;
Commentaire
Ou Directive d'assemblage
Un commentaire situé en début de ligne doit être précédé d'une étoile *, s'il est situé après l'opérande il doit être précédé d'un point-virgule ;. exemple:
| BASE | PRÉFIXE | SUFFIXE |
| binaire | % | B |
| octal | @ | O ou Q |
| décimal | aucun | D |
| hexadécimal | $ | H (un 0 doit être ajouter
devant un nombre
hexa d'on le premier caractère ne commence pas par un nombre décimal). |
exemples de constantes numériques:
L'adressage immédiat est indiqué par une dièse #:%1001 = 1001B
@56 = 56O
678290 (base 10 par défaut)
$A2CF9 = 0A2CFH
$4C1D0 = 4C1D0H
L'adressage indirect est symbolisé par des parenthèses ( ):MOVE.B #0C3H,D1
ADD.L (A5),D4 ; Le contenu pointé par A5 est ajouté au
; registre D4
Seul un fichier (extension en .29) au format
S-record de Motorola peut être téléchargé dans la mémoire d'un kit. Ce type de fichier est
géné automatiquement pars les commandes de développement
croisés
(cckit, assemblage,...).
La commande de transfère de fichier vers un kit est send + nom de
fichier sans extension:
162bug>
162bug>send test40
Chargement du fichier test40.s29
0
1
2
.....
22
fin de chargement
162bug>
162bug>
Le chargement initialise également certain des registres du processeur, en particulier le PC. Donc après un chargement vous pouvez lancer l'exécution directement par un simple go. sinon un go + l'adresse de début du code.