Architecture Interne - L'Assembleur

Page réalisée par:
Philippe Moreau
UPJV

En utilisant un éditeur de texte ASCII, on tape un fichier source et on le sauvegarde avec l'extension .X68 (sauver le fichier Nom_fich.X68). Ici on utilisera, à priori l'éditeur de EASy68K, mais on peut taper le programme dans n'importe quel autre éditeur de texte ASCII (ex: Bloc-notes, WordPad, etc...).

Ce fichier source contiendra toujours une première ligne indiquant l'adresse où s'assemblera le programme (avec la directive d'assemblage ORG (par exemple: ORG $400)) et une dernière ligne indiquant la fin d'écriture physique du programme (arrêt de l'assemblage) et l'adresse où se trouve la première instruction à exécuter au lancement du programme (débute de programme donné par la directive d'assemblage END (par exemple: END $400)).

Un fichier "Nom_fich.X68" se présentera donc sous la forme:

ORG	$400	adresse d'assemblage de la suite
┃
┃
┃
END	$400	fin de l'assemblage, et début de l'exécution en $400

Remarques:

- La directive d'assemblage ORG permet de donner l'adresse à laquelle on souhaite poursuivre la suite de l'assemblage du programme. Ainsi, on pourra éventuellement trouver plusieurs lignes avec la directive d'assemblage ORG dans un même programme (cela permet entre autre de positionner de façon précise des variables en mémoire et pouvoir ainsi vérifier leurs contenus directement en mémoire).

- La directive d'assemblage END signifie que l'on est en présence de la dernière ligne qui sera assemblée. De ce fait, même si certaines lignes figurent (sont écrites) après le END, celles-ci ne seront pas assemblées.

- Le fait de trouver généralement l'adresse $400 pour débuter l'assemblage d'un programme, vient de la gestion mémoire des machines à base de 68000. En effet, sur ces machines le premier Ko de la mémoire est réservé pour stocker des informations sur l'état de la machine et d'ailleurs, ce Ko n'est accessible qu'en mode superviseur (l'utilisateur n'a pas l'autorisation d'y accéder).

- Il a plusieurs "écoles"pour structurer l'écriture d'un programme en assembleur. Ici on partira du principe que la première ligne physique du programme est également la première ligne logique (première instruction à exécuter). De ce fait on trouvera toujours derrière le END, la même adresse que celle précisée lors du ORG de début d'écriture de programme.

Le programme pourra donc s'écrire:

DEBUT:	ORG	$400	adresse d'assemblage de la suite
	┃
	┃
	┃
	END	DEBUT	fin de l'assemblage, et exécution à partir de DEBUT(=$400)

C'est d'ailleurs sous cette forme qu'EASy68K nous proposera les ébauches de programmes.

Outre le fait que l'on supposera que l'écriture d'un programme commence par le "programme principal", on a vu également que les "déclarations" de "variables" ne pouvaient pas se faire de façon quelconque (au risque d'insérer des parties illisibles par le micro-processeur au milieu du programme, mais aussi au risque d'avoir des "variables" "déclarées" en .w ou .l à des adresses impaires).

On va donc pouvoir décrire un schéma "idéal" pour l'écriture d'un programme.

Schéma général d'écriture d'un programme

EXEMPLE DE PROGRAMME:

Dans le programme qui suit, on suppose que les morceaux de programme vus précédemment (AFFCAR,SAISCAR,FINPRG) ont été stockés dans le fichier BIBLIO.X68. Ce programme va chercher le dixième caractère d'une chaîne déclarée dans le programme sous le nom "CHAINE", stocke ce dixième caractère dans une variable nommée CAR10, affiche le caractère à l'écran et attend que l'utilisateur frappe sur la barre d'espace avant de rendre la main au moniteur.

DEBUT:	ORG	$400	le programme s'assemblera en $400
	MOVE.L	#CHAINE,A0
	ADD.L	#9,A0	A0 contient l'adresse du 10ème caractère
	MOVE.B	(A0),D1	on récupère le code ASCII du caractère (ici $65(=code ASCII de 'e')) dans D1
	MOVE.B	D1,CAR10	le code ASCII du caractère est stocké dans CAR10
	JSR	AFFCAR	le caractère est affiché
ATTENTE:
	JSR	SAISCAR	on attend que l'utilisateur frappe au clavier
	CMP.B	#$20,D1	on teste si le code ASCII saisie est $20 (code ASCII de l'espace)
	BNE	ATTENTE	si ce n'est pas le cas on recommence l'attente
	BRA	FINPRG
	INCLUDE	'BIBLIO.X68'	les lignes du fichier 'BIBLIO.X68' sont insérées ici
	ORG	$600	la suite sera assemblée à partir de $600, on
CAR10:	DS.B	1	pourra donc vérifier le contenu de CAR10 en affichant le contenu de la mémoire
CHAINE:	DC.B	'Il fait beau ce matin'
	END	DEBUT	fin de l'assemblage, et exécution à partir de DEBUT(=$400)

Remarque: Lors de l'utilisation d'un deuxième "ORG", il faut bien évidemment avoir une idée sur l'assemblage du début de programme, ce qui n'est pas toujours facile (surtout s'il y a des directives "INCLUDE" qui précèdent, car on ne voit pas le nombre de lignes insérées).

Quelques mots sur la "Plate-forme" de développement utilisée:

Une fois le programme source enregistré, on faut demander l'assemblage de ce programme.

Menu PROJECT → ASSEMBLE SOURCE

L'assembleur de EASy68K génère alors un fichier Nom_fich.S68 dont se servira la partie "exécuteur", et lance l'émulateur Sim68K ("exécuteur") en ouvrant une nouvelle fenêtre dans laquelle on retrouve l'affichage du contenu des registres du micro-processeur ainsi que la portion de mémoire qui contient le code source et le code assemblé du programme.

Dans l'émulateur on a la possibilité d'ouvrir plusieurs fenêtres qui peuvent avoir un intérêt au moment de l'exécution pour la visualisation.

On peut ainsi ouvrir : Menu VIEW

- une fenêtre correspondant au terminal de sortie (texte et graphisme)

- une fenêtre affichant le contenu de la mémoire (avec une interprétation "ASCII" de celle-ci). Ceci permet d'aller vérifier le contenu de celle-ci (ex: zone de data)

- une fenêtre affichant le contenu de la pile; on peut vérifier son évolution lors de l'appel de sous-programmes

- une fenêtre "Hardware" montrant un afficheur à 8 chiffres 7 segments , 8 LEDs, 8 Interrupteurs, 8 poussoirs...

- une fenêtre similaire à celle de l'émulateur, mais qui permet de placer des "BreakPoints" dans le programme.

les différentes fonctionnalités seront, bien sûr, reprises lors des TPs.