Introduction au Motorola ColdFire

Avant d'aller plus loin, il est nécessaire de présenter rapidement la syntaxe Motorola. Ceux qui ont déjà pratiqué l'assembleur savent que chaque constructeur a sa syntaxe propre qui est de plus susceptible de varier suivant le compilateur utilisé. Pour plus de détails, il faudra se référer à la documentation du programme d'assemblage choisi.

• Les mnémoniques sont suffixées par la taille de l'opérande
• La source précède la destination.

MOVE.L D0, D1 ; Place le mot  long (32 bits) contenu dans D0 dans D1  
MOVE.W D0, D1 ; Place le mot (16 bits de poids faible) contenu dans D0 dans D1  
MOVE.B D0, D1 ; Place l'octet (8 bits de poids faible) contenu dans D0 dans D1

• # est l'opérateur d'immédiateté
• $ désigne un nombre hexadécimal
• % désigne un nombre binaire

MOVE.B #10,D0 ; place 10 (décimale) dans D0 
MOVE.B #$10,D0 ; place 0x10 (hexadécimale) dans D0 
MOVE.B #,D0 ; place 0b10 (binaire) dans D0 
MOVE.B 10,D0 ; place ce qui est à l'adresse 10 dans D0

Les labels commencent en colonne 0 par une lettre. Ils terminent par " : " et contiennent uniquement des caractères alphanumériques ainsi que l'underscore " _ ". Ils sont sensibles à la casse.

label:  nop             
 bra label

Certains assembleurs (pas très malins) exigent de suffixer la source pour lever l'ambiguïté entre différents opcodes. Cela n'a rien à voir avec la taille de l'opérande.

MULU.W D0.L,D1

Avant d'attaquer les instructions attardons-nous sur les modes d'adressages. Ils sont au nombre de onze. Leur choix détermine souvent le succès d'un développement.

Absolu

MOVE.L $10,D0

Place ce qui est à l'adresse 10 dans D0

Immédiat

MOVE.L #$10,D0

Place la valeur 10 dans D0

Direct registre d'adresse

MOVEA.L A0,A1

Place ce qui est dans le registre A0 dans le registre A1

Direct registre de donnée

MOVE.L D0,D1

Place ce qui est dans D0 dans D1

Indirect registre d'adresse

MOVE.L (A0),D0

Place ce qui est désigné par l'adresse contenue dans A0 dans D0

Indirect registre d'adresse pré-décrémenté

MOVE.L -(A0),D0

Décrémente A0 de la taille de l'opérande puis comme indirect registre d'adresse

Indirect registre d'adresse post-incrémenté

MOVE.L (A0)+,D0

Comme indirect registre d'adresse puis A0 est incrémenté de la taille de l'opérande

Indirect registre d'adresse avec déplacement

MOVE.L (12,A0),D0

Place dans D0 ce qui est désigné par l'adresse contenue dans A0 +12. Le déplacement est sur 16 bits. L'addition est signée. A0 n'est pas modifié.

Indirect registre d'adresse avec déplacement, index et facteur d'échelle

MOVE.L (12,A0,D0,S)

L'adresse effective est obtenue en additionnant en signé les 32 bits de A0 au déplacement (ici 12) puis à l'index (D0) multiplié par le facteur d'échelle (S). S peut être égal à 1, 2 ou 4. A0 n'est pas modifié

Relatif

BRA $2A

On ajoutera 0x2A en signé au Program Counter. Le déplacement est sur 16 bits signé. Généralement on utilise un label.

Relatif compteur programme avec déplacement et relatif compteur programme avec déplacement, index et facteur d'échelle.

MOVE.W ($14,PC) MOVE.W ($14,PC,D3,S)

Voir indirect registre d'adresse avec déplacement et suivant. Interdit en destination

Pour écrire des modules translatables, il est important de définir une stratégie d'adressage souple. L'utilisation de pointeurs plutôt que d'adresses "dures" est vivement recommandé. On trouvera en annexe toutes les combinaisons possibles entre modes d'adressage et instructions. Le MCF est bien plus contraignant que le 68000 en ce domaine. Il est par exemple impossible d'écrire :

DIVU.W #1000,D3

Il faut passer la constante par un registre

MOVE.L #1000,D2 
DIVU.W D2,D3

Une instruction est composée d'une mnémonique suffixée et de deux opérandes (une seule dans certains cas). Chaque opérande est elle-même composée d'un couple valeur / mode d'adressage. Lorsque l'instruction modifie une valeur le résultat est toujours placé dans la destination.

Certaines instructions ont une incidence sur le CCR et ne supportent pas toutes les tailles d'opérandes. Le détail est fourni en annexe.

L'un des opérateurs est toujours un registre.

On a toujours envie de trouver une façon ludique de présenter les instructions. Malheureusement, je ne vois pas de meilleur moyen pour être relativement concis et exhaustif que d'utiliser des tableaux énumératifs.

Chaque mnémonique présentée correspond à un opcode particulier. Autrement dit, ADD ou ADDQ font tout les deux des additions, mais il s'agit d'instructions totalement différentes d'un point de vue physique. Les câbles utilisés ne sont pas les mêmes. Cela implique qu'il ne faut pas se tromper dans le choix des instructions, si l'on veut des performances optimales. Certains assembleurs sauront choisir entre, par exemple, ADDI, ADDQ ou ADD. Mais ce n'est pas toujours le cas.

Si certaines instructions apparaissent deux fois c'est qu'elles ont un comportement différent suivent les modes d'adressages utilisés.

On peut découper le jeu d'instruction en plusieurs sous catégories : arithmétique, logique, branchement, contrôle, déplacement ... Commençons par les plus populaires :

III-C-1. Les instructions de déplacement▲

III-C-2. Les instructions logiques▲

III-C-3. Les instructions arithmétiques▲

III-C-4. Décalages et permutations▲

III-C-5. Opérations sur les bits▲

III-C-6. Tests, comparaisons, branchements▲

III-C-7. Instructions de contrôle et divers▲

Pour se familiariser avec le jeu d'instruction des MCF, il serait bon de regarder ces quelques exemples/exercices classiques :

III-D-1. Le codage BCD▲

     Entier N //valeur initiale sur 16 bits                              
	Entier r <br/>                                                            
	    <br/>                                                                
	On divise N par 10000 -> premier chiffre du résultat <br/>                
	r <- reste de la division         <br/>                                   
	On divise r par 1000 -> second chiffre du résultat   <br/>                 
	r <- reste de la division      <br/>                                       
	On recommence avec 100 puis 10 -> troisième et quatrième chiffres <br/>   
	Le reste donne le cinquième chiffre     <br/>                             
                       <br/>

	org $10000
debut:		nop 			;ne rien faire
		andi.L #$FFFF,D0	;on efface les 16 bits de poids fort de D0
		move.L D0,D2		;copions D0 dans D2
		clr.L D1		;effaçons D1
		move.L #10000,D3	;plaçons 10000 dans D3. La division ne supporte pas l'adressage immédiat
		divu.w D3,D2		;divisons de D2 (sur 32 bits) par D3 (sur 16 bit).
					;Le résultat sera dans les 16 bits de poids faible de D2
					;Le reste dans les 16 bits de poids fort de D2
		move.w D2,D1		;on place le resultat dans D1
		lsl.L #4,D1		;on décale D1 de 4 bits vers la gauche
		swap.w D2		;on permute les 16 bits de pods faible et les 16 bits de poids fort de D2
 
fin_1:		nop

debut_2:	nop
		andi.L #FFFF,D2
		move.L #1000,D3		;Une division par 10 de D3 serait bien plus couteuse
		divu.w D3,D2
		move.b D2,D3		;ce qui nous interesse est dans l'octet de poids faible de D2
		andi.L #F,D3		;plus précisement dans les 4 premier bits
		or.L D3,D1
		lsl.l #4,D1
		swap.w D2
 
fin_2:		nop

III-D-2. Addition de deux mots de 64 bits▲

*Directives d'assemblages et définition de constantes *
 
mem_op equ  $20010	;définition de deux constantes
mem_res equ  $2001C
 
		org $10000	; adresse à laquelle le programme sera chargé
		cpu 5206e	; cela permet de gérer les versions des MCF
		opt optimise=all; On demande au compilateur d'être intelligeant.
 
*dans cet entête, dans ce cas précis seul org est obligatoire. Le reste est donné à titre d'exemple*
debut:	nop
 
	movea.L #mem_op,A0	;mise en place des pointeurs
	movea.L #mem_res,A1
 
	addi.L #0,D0		;mise à zéro du bit x
 
	move.L -(A0),D0		;récupération des poids faibles de l'operande 2
	move.L (-8,A0),D1	;récuperation des poids faibles de l'operande 1
	addx.L D0,D1		;L'utilisation d'addx plustôt que d'add ne se justifiera que plus tard. 
				;En M68K on aurait pu aller chercher la source directement en mémoire 
	move.L D1,-(A1)		;On range les poids faibles du résultat
 
 
 
	move.L -(A0),D0		;Cette sequence est exactement identique à la précedente (d'où l'addx).
	move.L (-8,A0),D1	;Ne pourrait-on pas boucler ? Essayez (attention à la retenue)! est-ce interessant ? 
	addx.L D0,D1		
	move.L D1,-(A1)		
 
 
 
	clr.L D0		;On efface D0
	addx.L D0,D0		;On récupère la retenue
	move.L D0,-(A1)		;On la range
 
fin:	nop

III-D-3. Parcours itératif d'un tableau d'octet▲

	org $10000
 
debut :		nop
 
		move.L D0,D2		; sauvegardons l'offset de réference
 
bou:		cmp.B (A0,D2),D1	;La valeur pointé par A0 + offest est-elle la valeur cherchée ?
		beq trouve		;Si oui on va à trouve
		subi.L #1,D2		;Sinon on décrémente l'offset
		bne no_value		;Si l'offset est négatif on a pas trouvé
		bra bou			;Sinon on recommence
 
no_value:	clr.L A1		;Si on n'a rien trouvé, on renvera un pointeur = 0
		bra fin			;et on termine
 
trouve:		movea.L A0,A1		;Si on a trouvé, on calcule l'adresse du pointeur
		adda.L D2,A1
 
fin: 		nop