Chapitre 4-8 - Set D'instructions, Directives Assembleur, Architecture Mémoire

DSP et temps réel
DSP ORIENTÉ APPLICATIONS INDUSTRIELLES

____________
Chapitre 4_8 4. Set d’instructions
5. Directives assembleur
6. Architecture mémoire
7. Editeur de lien
8. Création d’un fichier de commande
CD\DSP\Cours\Chap4_8 M. Correvon
T A B L E D E S M A T I E R E S
PAGE
4. SET D’INSTRUCTIONS................................................................................................................................................1
4.1 INTRODUCTION ...........................................................................................................................................................1
4.2 NOTATIONS ET CONVENTIONS ...................................................................................................................................1
4.3 LES OPÉRATIONS DE TYPE MULTIFONCTION ..............................................................................................................2
4.3.1 Opération ALU / MAC avec lecture de la mémoire PM et DM............................................................ 2
4.3.2 Lectures simultanées en mémoire de données (DM et de programme (PM)......................................... 3
4.3.3 Opération avec l’ALU, le MAC ou le décaleur à barillet et lecture en mémoire .................................. 3
4.3.4 Opération avec l’ALU, le MAC ou le décaleur à barillet et écriture en mémoire ................................. 4
4.3.5 Opération avec l’ALU, le MAC ou le décaleur à barillet et un transfert de registre à registre ............. 4
4.4 L’UNITÉ ARITHMÉTIQUE ET LOGIQUE (ARITHMETIC/LOGIC UNIT)............................................................................5
4.4.1 Définition des registres xop et yop autorisés pour les instructions ALU .............................................. 5
4.4.2 Conditions autorisées ............................................................................................................................ 6
4.4.3 Notation sur les registres ASTAT, SSTAT, MSTAT............................................................................ 6
4.4.4 Addition X+Y simple et addition avec report ....................................................................................... 7
4.4.5 Soustraction X-Y simple et soustraction avec report ............................................................................ 8
4.4.6 Soustraction Y-X simple et soustraction avec report ............................................................................ 9
4.4.7 Fonction logique AND, OR, XOR ...................................................................................................... 10
4.4.8 Instruction sur un bit ........................................................................................................................... 11
4.4.9 Test de l’état d’une variable sans la modifier...................................................................................... 12
4.4.10 Complément à deux............................................................................................................................. 13
4.4.11 Complément à un ................................................................................................................................ 14
4.4.12 Valeur absolue..................................................................................................................................... 15
4.4.13 Incrémentation..................................................................................................................................... 16
4.4.14 Décrémentation ................................................................................................................................... 17
4.4.15 Division............................................................................................................................................... 18
4.4.16 Génération d’un état de l’ALU............................................................................................................ 20
4.5 LE MULTIPLIEUR ET ACCUMULATEUR (MULTIPLIER/ACCUMULATOR) ...................................................................21
4.5.1 Définition des registres xop et yop autorisés pour les instructions MAC ........................................... 21
4.5.2 Conditions autorisées .......................................................................................................................... 22
4.5.3 Notation sur le registre d’état ASTAT ................................................................................................ 22
4.5.4 Multiplication...................................................................................................................................... 23
4.5.5 Multiplication /addition....................................................................................................................... 24
4.5.6 Multiplication/soustraction.................................................................................................................. 25
4.5.7 Multiplication par 0 (mise à zéro des registres résultat MR ou MF)................................................... 26
4.5.8 Transfert .............................................................................................................................................. 27
4.5.9 Limitation conditionnelle du résultat dans MR (saturation)................................................................ 28
4.6 LE DÉCALEUR À BARILLET (BARREL SHIFTER) ........................................................................................................29
4.6.1 Définition des registres xop autorisés pour les instructions du barrel shifter ...................................... 29
4.6.2 Conditions autorisées .......................................................................................................................... 30
4.6.3 Notation sur le registre d’état ASTAT ................................................................................................ 30
4.6.4 Décalage arithmétique......................................................................................................................... 31
4.6.5 Décalage logique................................................................................................................................. 32
4.6.6 Normalisation...................................................................................................................................... 33
4.6.7 Définition de l’exposant ...................................................................................................................... 34
4.6.8 Ajustement de l’exposant .................................................................................................................... 35
4.6.9 Décalage arithmétique immédiat......................................................................................................... 36
4.6.10 Décalage logique immédiat ................................................................................................................. 37
4.7 TRANSFERT DE DONNÉES .........................................................................................................................................38
4.7.1 Transfert de données de registre à registre .......................................................................................... 38
4.7.2 Chargement immédiat d’un registre .................................................................................................... 39
4.7.3 Lecture de la mémoire de données (adressage direct) ......................................................................... 40
4.7.4 Lecture de la mémoire de données (adressage indirect)...................................................................... 41
4.7.5 Lecture de la mémoire de programme (adressage indirect)................................................................. 42
4.7.6 Ecriture de la mémoire de données (adressage direct) ........................................................................ 43
4.7.7 Ecriture de la mémoire de données (adressage indirect) ..................................................................... 44
4.7.8 Ecriture de la mémoire de programme (adressage indirect)................................................................ 45
4.8 DÉROULEMENT SÉQUENTIEL D’UN PROGRAMME ....................................................................................................46
4.8.1 Saut...................................................................................................................................................... 46
4.8.2 Appel à un sous-programme ............................................................................................................... 47
4.8.3 Saut ou appel à un sous-programme sous condition externe............................................................... 48
4.8.4 Retour d’un sous programme .............................................................................................................. 49
4.8.5 Retour d’une routine d’interruption .................................................................................................... 50
4.8.6 Boucle ................................................................................................................................................. 51
4.8.7 Mise en veille ...................................................................................................................................... 53
4.9 INSTRUCTIONS ADDITIONNELLES .............................................................................................................................54
4.9.1 Contrôle des piles (stack) .................................................................................................................... 54
4.9.2 Lecture et écriture dans la pile du compteur de programme (PC stack).............................................. 56
4.9.3 Activation/désactivation des bits du registre de mode de contrôle MSTAT ....................................... 57
4.9.4 Modification des pointeurs des générateurs d’adresses DAG ............................................................. 58
4.9.5 Cycle sans instruction.......................................................................................................................... 59
4.9.6 Activation / désactivation des interruptions ........................................................................................ 60
4.10 EXÉCUTION DE PLUSIEURS INSTRUCTION EN UN CYCLE (MULTIFUNCTION) ...............................................61
4.10.1 Exécution d’une instruction ALU / MAC / SHIFTER et lecture simultanée en mémoire .................. 61
4.10.2 Exécution d’une instruction ALU / MAC / SHIFTER et modification simultanée de registre ........... 64
4.10.3 Exécution d’une instruction ALU / MAC / SHIFTER et écriture simultanée en DM / PM................ 66
4.10.4 Lecture simultanée en DM et PM........................................................................................................ 68
4.10.5 Exécution d’une instruction ALU / MAC et lecture simultanée en DM et PM................................... 69
5. DIRECTIVES ASSEMBLEUR...................................................................................................................................71
5.1 INTRODUCTION .........................................................................................................................................................71
5.2 DIRECTIVES DU PRÉPROCESSEUR C.........................................................................................................................73
5.2.1 Exemples de directive pour le préprocesseur C................................................................................... 73
5.2.2 Commentaires pour le préprocesseur C............................................................................................... 75
5.3 DIRECTIVES DU PRÉPROCESSEUR DE L’ASSEMBLEUR .............................................................................................75
5.3.1 Directives de module de programme .MODULE................................................................................ 76
5.3.2 Module chargé à partir de la mémoire de boot (ROM) ....................................................................... 76
5.3.3 Module défini avec l’attribut STATIC................................................................................................ 77
5.3.4 Directives des variables et des buffers .VAR...................................................................................... 79
5.3.5 Directives d’initialisation des variables et des buffers .INIT .............................................................. 82
5.3.6 Directive d’insertion d’autres fichier source .INCLUDE.................................................................... 82
5.3.7 Directives concernant la définition de macro .MACRO ..................................................................... 83
5.3.8 Directive concernant les étiquettes dans les macro .LOCAL .............................................................. 83
5.3.9 Directive de déclaration globale de variables et buffers .GLOBAL.................................................... 84
5.3.10 Directive de déclaration globale d’étiquettes de programme .ENTRY ............................................... 84
5.3.11 Directive de déclaration externe de variables, de buffers et d’étiquettes .EXTERNAL ..................... 84
5.3.12 Directive de déclaration de constante .CONST................................................................................... 84
6. CONSTRUCTION DE L’ARCHITECTURE MÉMOIRE (SYSTEM BUILDER) ...........................................85
6.1 INTRODUCTION .........................................................................................................................................................85
6.2 DIRECTIVE DU « SYSTEM BUILDER » ......................................................................................................................85
6.2.1 Directive principale du ficher de description :SYSTEM..................................................................... 86
6.2.2 Directive d’identification .ADSP21xx ................................................................................................ 86
6.2.3 Directive du plan mémoire .MMAP.................................................................................................... 86
6.2.4 Directive de déclaration des segments de mémoire .SEG ................................................................... 86
6.3 FICHIER DE DESCRIPTION D’ARCHITECTURE DU KIT D’ÉVALUATION DE L’ADMC401........................................87
6.4 FICHIER DE DESCRIPTION D’ARCHITECTURE DE LA CARTE CHPSE........................................................................88
7. EDITEUR DE LIEN (LINKER) ..................................................................................................................................90
7.1 INTRODUCTION .........................................................................................................................................................90
7.2 FONCTIONNEMENT DE L’ÉDITEUR DE LIEN ..............................................................................................................91
7.2.1 Allocation mémoire d’exécution ......................................................................................................... 91
7.2.2 Allocation de la mémoire de stockage................................................................................................. 92
7.2.3 Traduction des symboles..................................................................................................................... 92
7.3 UTILISATION DE LIBRAIRIES AVEC DES APPLICATIONS SPÉCIFIQUES ......................................................................92
7.3.1 Construction d’une librairie unique pour un accès rapide ................................................................... 93
8. CRÉATION DE FICHIERS DE COMMANDE ......................................................................................................94
Bibliographie
ADMC401 : 4. SET D’INSTRUCTIONS Page 1
4. SET D’INSTRUCTIONS
4.1 INTRODUCTION
Cette première partie décrit l’ensemble des instructions pouvant être réalisées par
l’ADMC401, Ces instructions codées sur 24 bits sont exécutées en un cycle d’horloge
(CLKOUT) pour autant que l’accès à la mémoire externe se fasse sous certaines conditions.
Les opérations principales sont :
− opérations avec l’ALU, le MAC ou le décaleur à barillet avec ou sans condition ;
− transfert de registre à registre ;
− lecture et écriture en mémoire ;
− opération avec l’ALU, le MAC ou le décaleur à barillet liée avec
un transfert de registre à registre ;
une lecture / écriture de la mémoire ;
une lecture de deux positions mémoire.
Pour le dernier point on parle de multifonctions. Les multifonctions sont également codées
sur 24 bits.
4.2 NOTATIONS ET CONVENTIONS

Les instructions détaillées de cette première partie sont réparties en cinq catégories :
− opération de calcul (ALU, MAC et décaleur à barillet) ;
− transfert (move) ;
− déroulement du programme (program flow) ;
− multifonction (multifunction) ;
− divers (miscellaneous).
Les conventions de notations suivantes sont utilisées.
[ ] : partie optionnelle d’une instruction
⏐ ⏐ : liste d’opérandes dont un doit être choisi pour la réalisation de
l’instruction.
MAJUSCULE : mot réservé représentant le nom d’une instruction, d’un registre,
d’une directive, …
opérande : certaines opérandes liées à une instruction sont notées en
minuscule. Ces opérandes peuvent prendre différentes valeurs.
Par exemple xop ou yop représentent le nom d’un registre.
<exp> : représente un exposant (valeur de décalage immédiat. Doit être
une grandeur signée de 8 bits.
<data> : représente une valeur immédiate. Peut aussi être un symbole
(étiquette, variables) ou un nom de buffer précédé par les
caractères % ou ^.
<addr> : représente une adresse immédiate ou une étiquette de programme.
<reg> : représente un registre (voir Tableau 4-1).
<dreg> : représente un registre de données (voir Tableau 4-1).
Les valeurs immédiates <exp>, <data> ou <addr>, sont des constantes définies en format
décimal (par défaut), hexadécimal, octal ou binaire.
CD\DSP\Cours\Chap4_8
Registres reg
SB Registres dreg
PX
I0 – I7, M0 – M7, L0 – L7 AX0, AX1, AY0, AY1, AR
CNTR MX0, MX1, MY9, MY1, MR0, MR1, MR2
ASTAT, MSTAT, SSTAT, SI, SE, SR0, SR1
IMASK, ICNTL, IFC
TX0, TX1, RX0, RX1
Tableau 4-1 : Définition des registres et des registres de données
4.3 LES OPÉRATIONS DE TYPE MULTIFONCTION

Grâce à la structure Harvard du DSP, il est possible de réaliser plusieurs instructions en un
seul cycle d’horloge. Ce groupe d’instruction doit obéir à un certain nombre de règles pour
pouvoir réaliser le codage de l’ensemble sur 24 bits. On donne ici un exemple de codage pour
la multifonction
AR = AX0 + AY0 , AX0 = DM(I0, M1);
Le codage de la multifonction correspond à un format d’instruction de type 4

ALU/MAC avec lecture de la mémoire de données DM, instruction de type 4
23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
0 1 1 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1
G Z AMF yop : AY0 xop : AX0 dreg : AX0 I0 M1
G Générateur d’adresse dreg Registres de données

0 DAG1 0 0 0 0 AX0
1 DAG2 0 0 0 1 AX1
… … … …
Z Registre de destination de l’ALU
0 AR I Registre d’index
1 AF G=0 G=1
0 0 I0 I4
AMF Codage de l’instruction d’addition de 0 1 I1 I5
l’ALU 1 0 I2 I6
1 0 0 1 1 X+Y 1 1 I3 I7
xop Registre d’entrée X de l’ALU M Registre de modification
0 0 0 AX0 G=0 G=1
0 0 1 AX1 0 0 M0 M4
… … … … 0 1 M1 M5
1 0 M2 M6
yop Registre d’entrée Y de l’ALU 1 1 M3 M7
0 0 AY0
0 1 AY1
… … …
4.3.1 Opération ALU / MAC avec lecture de la mémoire PM et DM

Cette multifonction est sans aucun doute la plus performante. En un cycle d’horloge, les
opérations suivantes peuvent être réalisées :
− Multiplication de deux opérandes et sommation avec le résultat de la multiplication
précédente.
− Lecture de deux opérandes pour la multiplication suivante.

Par exemple
MR = MR + MX0 * MY0 (SS) , MX0 = DM(I0, M0) , MY0 = DM(I4, M4)
La première instruction de cette ligne de programmation (jusqu’à la première virgule)

indique que le registre de résultat du MAC (MR) contient la somme du résultat de la
multiplication précédente avec le produit des contenus signés actuels des registres MX0 et
MY0 du MAC.
La seconde instruction de cette ligne de programmation exécute le transfert du contenu d’une
position de la mémoire de données (DM) dans le registre MX0. Il s’agit là d’une adresse
indirecte utilisant le générateur d’adresse DAG1.
La troisième instruction de cette ligne de programmation exécute le transfert du contenu
d’une position de la mémoire de programme (PM) dans le registre MY0. Il s’agit là d’une
adresse indirecte utilisant le générateur d’adresse DAG2.
Pour bien comprendre le déroulement séquentiel des événements, il faut se souvenir que les
registres / positions mémoire sont
− lus au début d’un cycle ;
− écrits à la fin d’un cycle.
A la fin du cycle, le registre MR contient le résultat de la multiplication / addition et les
registres MX0, MY0 les valeurs contenues dans les positions mémoire DM(I0.M0) et
PM(I4,M4).
Il existe toutefois une restriction si plus d’une instruction de transfert se trouvent en mémoire
externe. Dans ce cas, les accès aux mémoires de données et de programme ne peuvent se
faire simultanément.
4.3.2 Lectures simultanées en mémoire de données (DM et de programme (PM)

Cette multifonction est comparable à la précédente si on omet l’opération de multiplication.
AX0 = DM(I0, M0) , AY0 = DM(I4, M4)
La structure de l’ALU impose que la donnée transférée au registre AX0 soit issue de la
mémoire de données et que la donnée transférée au registre AY0 soit issue de la mémoire de
programme.
Il existe toutefois une restriction si plus d’une instruction de transfert se trouvent en mémoire
externe. Dans ce cas, les accès aux mémoires de données et de programme ne peuvent se
faire simultanément
4.3.3 Opération avec l’ALU, le MAC ou le décaleur à barillet et lecture en mémoire

Si un seul transfert (lecture) de mémoire à registre est exécuté, il est possible de réaliser dans
le même cycle d’horloge une opération non conditionnelle avec l’ALU (excepté la division
DIVS et DIVQ), le MAC, ou le décaleur à barillet (excepté les décalages immédiats)
AR = AX0 + AY0 , AX0 = DM(I0, M3);
Une opération d’addition et une lecture en mémoire de données (DM) en adressage indirect
sont exécutées dans un même cycle. Il est clair que le registre AR ne peut être utilisé comme
registre de destination de la lecture en mémoire.
4.3.4 Opération avec l’ALU, le MAC ou le décaleur à barillet et écriture en mémoire

Cette multifonction est comparable à la précédente. Il s’agit de transférer le contenu d’un
registre dans la mémoire puis d’exécuter une opération avec l’ALU (excepté la division
DIVS et DIVQ), le MAC, ou le décaleur à barillet (excepté les décalages immédiats).
DM(I0, M3) = AR , AR = AX0 + AY0;
Dans ce cas les registres AR, AX0 et AY0 sont lus au début d’un cycle, le résultat de
l’addition et l’écriture en mémoire étant exécutés à la fin du cycle. La position mémoire
DM(I0,M3) va donc contenir la valeur de AR avant l’addition.
4.3.5 Opération avec l’ALU, le MAC ou le décaleur à barillet et un transfert de

registre à registre
Cette multifonction permet un transfert de registre à registre et l’exécution d’une opération
non conditionnelle avec l’ALU (excepté la division DIVS et DIVQ), le MAC, ou le décaleur
à barillet (excepté les décalages immédiats)
MR = AX0 + AY0 , AX0 = MR2 ;
Dans cet exemple, la lecture des registres AX0, AY0 et MR2 sont exécuté au début de
chaque cycle, le résultat de l’opération de l’ALU, du MAC ou du décaleur à barillet et le
transfert du contenu du registre MR2 étant stocker et dans MR respectivement AX0 à la fin
du cycle. Le transfert de registre à registre peut se faire entre n’importe quels registres
exceptés les registres de boucle (feedback) AF et MF et le registre SB du décaleur à barillet.
4.4 L’UNITÉ ARITHMÉTIQUE ET LOGIQUE (ARITHMETIC/LOGIC UNIT)
24 bits PMD BUS
16 bits DMD BUS 16 bits

MSB
16 bits MUX
16 bits
Bank 2 Bank 2
Bank 1 Bank 1
AX REGISTERS AY REGISTERS
16 bits 2 x 16 2 x 16 16 bits
16 bits 16 bits
MUX MUX 16 bits
16 bits 16 bits
Bank 2
Bank 1
AF REGISTER
1 x 16
AZ
X Y
AN
AC
AV ALU CI
AS
AQ 16 bits
R
16 bits
MUX
16 bits
Bank 2
Bank 1
AR REGISTER
1 x 16
16 bits
16 bits
16 bits 16 bits
R BUS
Figure 4-1 : Unité Arithmétique et logique
4.4.1 Définition des registres xop et yop autorisés pour les instructions ALU
X opérande : xop AX0, AX1, AR
MR0, MR1, MR2
SR0, SR1
Y opérande : yop AY0, AY1, AF
4.4.2 Conditions autorisées

Syntaxe Condition Si vraie
EQ Egale zéro AZ=1
NE Différent de zéro AZ=0
LT Plus petit que zéro AN .XOR. AV=1
GE Plus grand ou égal à zéro AN .XOR. AV=0
LE Plus petit ou égal à zéro (AN .XOR. AV) .OR. AZ=1
GT Plus grand que zéro (AN .XOR. AV) .OR. AZ=0
AC Report (ALU carry) AC=1
NOT AC Pas de report (not ALU carry) AC=0
AV Dépassement (ALU overflow) AV=1
NOT AV Pas de dépassement (not ALU overflow) AV=0
MV Dépassement (MAC overflow) MV=1
NOT MV Pas de dépassement (not MAC overflow) MV=0
NEG Signe négatif sur entrée x (ALU) AS=1
POS Signe positif sur entrée x (ALU) AS=0
NOT CE Compteur différent de zéro (not counter expired)
4.4.3 Notation sur les registres ASTAT, SSTAT, MSTAT

Dans le but de définir l’effet de chaque instruction sur les bits du registre d’état ASTAT, les
notations suivantes sont utilisées :
* Le bit en question est modifié en fonction du résultat de l’instruction.

- Le bit en question n’est pas affecté par le résultat de l’instruction.
0 Le bit en question est forcé à « 0 ».
4.4.4 Addition X+Y simple et addition avec report
4.4.4.1 Syntaxe
+ yop
+C
AR
[IFcond] = xop + yop + C ;
AF
+ constant
+ constant + C
4.4.4.2 Définitions des opérandes et des conditions

xop yop Condition
AX0 MR2 AY0 EQ LE AC
AX1 MR1 AY1 NE NEG NOT AC
AR MR0 AF GT POS MV
SR1 GE AV NOT MV
SR0 LT NOT AV NOT CE
4.4.4.3 Exemple
IF EQ AR = AX0 + AY0 + C ;
AR = AX0 + 512 ;
4.4.4.4 Description
Test la condition optionnelle :
Vrai : exécution de l’instruction d’addition.
Faux : l’instruction d’addition n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction d’addition.
L’opération consiste à additionner la première opérande xop à la seconde opérande yop et, si
demandé à ajouter le bit de report (AC : ALU Carry).
4.4.4.5 Etats générés par l’instruction

ASTAT : 7 6 5 4 3 2 1 0
SS MV AQ AS AC AV AN AZ
- - - - * * * *
AZ Mise à 1 si le résultat est nul, sinon mise à 0.
AN Mise à 1 si le résultat est négatif, sinon mise à 0.
AV Mise à 1 si le résultat arithmétique est en dépassement de capacité, sinon mise à 0.
AC Mise à 1 si il y a une retenue, sinon mise à 0.
4.4.5 Soustraction X-Y simple et soustraction avec report
4.4.5.1 Syntaxe
− yop
+ C −1
AR
[IFcond] = xop − yop + C − 1 ;
AF
+ constant
+ constant + C

xop yop Condition
AR MR0 AF GT POS MV
SR1 GE AV NOT MV
4.4.5.3 Exemple
IF GE AR = AX0 − AY0 ;
4.4.5.4 Description
Vrai : exécution de l’instruction de soustraction.
Faux : l’instruction de soustraction n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction de soustraction.
L’opération consiste à soustraire la première opérande xop à la seconde opérande yop et, si
demandé à ajouter le bit de report (AC : ALU Carry) auquel on retranche 1.
L’addition de « +C-1 » pour les calculs en multiprécision correspond à un report d’addition
« C » auquel il faut soustraire 1 pour passer du complément à 2 au complément à 1 (voir
technique de soustraction en multiprécision).

ASTAT : 7 6 5 4 3 2 1 0
- - - - * * * *
4.4.6 Soustraction Y-X simple et soustraction avec report
4.4.6.1 Syntaxe
xop
yop −
xop + C − 1
AR
[IFcond] = − xop + C − 1 ;
AF
− xop + constant
− xop + constant + C − 1

xop yop Condition
AR MR0 AF GT POS MV
SR1 GE AV NOT MV
4.4.6.3 Exemple
IF GT AR = AY0 − AX0 + C − 1 ;
4.4.6.4 Description
Vrai : exécution de l’instruction de soustraction.
Faux : l’instruction de soustraction n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction de soustraction.
L’opération consiste à soustraire la première opérande xop à la seconde opérande yop et, si
demandé à ajouter le bit de report (AC : ALU Carry) auquel on retranche 1.
L’addition de « +C-1 » pour les calculs en multiprécision correspond à un report d’addition
« C » auquel il faut soustraire 1 pour passer du complément à 2 au complément à 1 (voir
technique de soustraction en multiprécision).

ASTAT : 7 6 5 4 3 2 1 0
- - - - * * * *
4.4.7 Fonction logique AND, OR, XOR
4.4.7.1 Syntaxe
AND
AR yop
[IFcond] = xop OR ;
AF constant
XOR

xop yop Condition
AR MR0 AF GT POS MV
SR1 GE AV NOT MV
4.4.7.3 Exemple
IF FLAG _ IN AR = MR0 AND 8192 ;
AR = AX0 XOR AY0 ;
4.4.7.4 Description
Vrai : exécution de l’instruction logique bit à bit.
Faux : l’instruction logique bit à bit n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction logique bit à bit.
L’opération consiste réaliser une fonction logique ET, OU, OU exclusif bit à bit.

ASTAT : 7 6 5 4 3 2 1 0
- - - - 0 0 * *
AV Mise à 0.
AC Mise à 0.
4.4.8 Instruction sur un bit
4.4.8.1 Syntaxe
TSTBIT n OF xop
AR SETBIT n OF xop
[IFcond] = ;
AF CLRBIT n OF xop
TGLBIT n OF xop

xop yop Condition n
AX0 MR2 AY0 EQ LE AC 0, … 15
AR MR0 AF GT POS MV
SR1 GE AV NOT MV
4.4.8.3 Exemple
AF = TSTBIT 5 OF AR ;
AF = TGLBIT 13 OF AX0 ;
4.4.8.4 Description
Vrai : exécution de l’instruction sur un bit.
Faux : l’instruction sur un bit n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction sur un bit.
Ces instructions sont définies de la manière suivante
TSTBIT : Fonction AND bit à bit avec un 1 sur le bit N°n sélectionné.
SETBIT : Fonction OR bit à bit avec un 1 sur le bit N°n sélectionné.
CLRBIT : Fonction AND bit à bit avec un 0 sur le bit N°n sélectionné.
TGLBIT : Fonction XOR bit à bit avec un 1 sur le bit N°n sélectionné.

ASTAT : 7 6 5 4 3 2 1 0
- - - - 0 0 * *
AV Mise à 0.
AC Mise à 0.
4.4.9 Test de l’état d’une variable sans la modifier
4.4.9.1 Syntaxe
xop
AR
[IFcond] = PASS yop ;
AF
constant

xop yop Condition constant
MR2 AY0 EQ LE AC État des flags de ASTAT
MR1 AY1 NE NEG NOT AC
MR0 AF GT POS MV -1,0,1 : affectés
SR1 GE AV NOT MV 2…32767 : indéfinis
SR0 LT NOT AV NOT CE -32768 ..-2 : indéfinis
4.4.9.3 Exemple
IF GE AR = PASS AY0 ;
AR = PASS 0 ;
AR = PASS 8191 ;
4.4.9.4 Description
Vrai : exécution de l’instruction de passage au travers de l’ALU.
Faux : l’instruction de passage au travers de l’ALU n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction de passage au
travers de l’ALU.
PASS 0 est une méthode pour la mise à « 0 » (Clear) les registres AR ou AF.
Par rapport à une instruction de transfert (voir §4.7), l’instruction PASS permet de modifier
les flag du registre ASTAT.

ASTAT : 7 6 5 4 3 2 1 0
- - - - 0 0 * *
AV Mise à 0.
AC Mise à 0.
4.4.10 Complément à deux
4.4.10.1 Syntaxe
AR xop
[IF cond] = − ;
AF yop

xop yop Condition
AR MR0 AF GT POS MV
SR1 GE AV NOT MV
4.4.10.3 Exemple
IF LT AR = − AY0 ;
4.4.10.4 Description
Vrai : exécution de l’instruction du complément à deux.
Faux : l’instruction du complément à deux n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction du complément à deux.

ASTAT : 7 6 5 4 3 2 1 0
- - - - * * * *
AV Mise à 0.
AC Mise à 0.
4.4.11 Complément à un
4.4.11.1 Syntaxe
AR xop
[IF cond] = NOT ;
AF yop

xop yop Condition
AR MR0 AF GT POS MV
SR1 0 GE AV NOT MV
4.4.11.3 Exemple
IF NE AF = NOT AX0 ;
Vrai : exécution de l’instruction du complément à un.
Faux : l’instruction du complément à un n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction du complément à un.

ASTAT : 7 6 5 4 3 2 1 0
- - - - 0 0 * *
AV Mise à 0.
AC Mise à 0.
4.4.12 Valeur absolue
4.4.12.1 Syntaxe
AR
[IF cond] = ABS xop ;
AF

xop Condition
AX0 MR2 EQ LE AC
AX1 MR1 NE NEG NOT AC
AR MR0 GT POS MV
SR1 GE AV NOT MV
4.4.12.3 Exemple
IF NEG AF = ABS AX0 ;
Vrai : exécution de l’instruction de la valeur absolue.
Faux : l’instruction de la valeur absolue n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction de la valeur absolue.

ASTAT : 7 6 5 4 3 2 1 0
- - - * 0 * * *
AN Mise à 1 si xop=0x8000, sinon mise à 0.
AV Mise à 1 si xop=0x8000, sinon mise à 0.
AC Mise à 0.
AS Mise à 1 si xop est négatif, sinon mise à 0.
4.4.13 Incrémentation
4.4.13.1 Syntaxe
AR
[IF cond] = yop + 1 ;
AF

xop yop Condition
AR MR0 AF GT POS MV
SR1 GE AV NOT MV
4.4.13.3 Exemple
IF GT AF = AF + 1 ;
Vrai : exécution de l’instruction d’incrémentation.
Faux : l’instruction d’incrémentation n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction d’incrémentation.

ASTAT : 7 6 5 4 3 2 1 0
- - - - * * * *

4.4.14 Décrémentation
4.4.14.1 Syntaxe
AR
[IF cond] = yop − 1 ;
AF

xop yop Condition
AR MR0 AF GT POS MV
SR1 GE AV NOT MV
4.4.14.3 Exemple
IF EQ AR = AY1 − 1 :
Vrai : exécution de l’instruction de décrémentation.
Faux : l’instruction de décrémentation n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction de décrémentation.

ASTAT : 7 6 5 4 3 2 1 0
- - - - * * * *

4.4.15 Division
4.4.15.1 Syntaxe
DIVS yop, xop;
DIVQ xop;
4.4.15.2 Exemple
DIVS = AY1, AX0 ;
DIVQ AX0 ; DIVQ AX0 ; DIVQ AX0 ; DIVQ AX0 ; DIVQ AX0 ;
ou
do _ div : DIVS = AY1, AX0 ;
CNTR = 15;
DO div _ loop UNTIL CE;
div _ loop : DIVQ AX0

xop yop
AX0 MR2 AY1
AX1 MR1 AF
AR MR0
SR1
SR0
Cette instruction permet la division yop par xop à l’aide de ceux primitives , DIVS et DIVQ.
Une division simple précision est constituée d’un numérateur de 32 bits et d’un dénominateur
de 16 bits conduisant à un résultat sur 16 bits. Dans ce cas, l’exécution de la division prend
16 cycles.
La division peut être signée ou non-signée. Le numérateur et le dénominateur doivent être
soit les deux signés, soit les deux non-signés. Les 16 bits de poids forts du numérateur sont
dans le registre AF ou AY1, les 16 bits de poids faibles doivent être dans AY0. Les 16 bits du
dénominateur peuvent se trouver dans un des registres définis en 4.4.15.3. Le résultat de la
division se trouve dans le registre AY0.
Pour une division signée, la primitive DIVS est utilisée une fois afin de définir le signe du
quotient. Ensuite c’est la primitive DIVQ qui doit être utilisée autant de fois qu’il reste de bit
dans le quotient (pour une division simple précision, DIVQ est utilisé 15 fois).
Pour une division non-signée, il faut placer les 16 bits de poids fort du numérateur dans le
registre AF et les 16 bits de poids faibles dans le registre AY0. Ensuite il faut forcer le
ASTAT[5] (AQ) à « 0 » afin d’indiquer que le quotient est positif. La primitive DIVQ doit
ensuite être utilisée autant de fois qu’il reste de bit dans le quotient (pour une division simple
précision, DIVQ est utilisé 16 fois).
Le bit du quotient généré à chaque instruction DIVS ou DIVQ est le bit ASTAT[5] (AQ). Le
reste de la division n’est pas utilisable sans correction. Pour plus de détails se référer à [4],
Appendix :Division Exception.

ASTAT : 7 6 5 4 3 2 1 0
- - * - - - - -
AQ Chargé avec la valeur du bit AQ calculé à chaque exécution de DIVs ou DIVQ
4.4.16 Génération d’un état de l’ALU
4.4.16.1 Syntaxe
NONE = < ALU > ;
4.4.16.2 Exemple
NONE = AX0 − AY0 ;
NONE = PASS SR0 ;
Exécute l’opération programmée et met à jour les bits du registre ASTAT. Le résultat n’est
pas sauvé. Cette instruction permet de réaliser un test sur l’état d’une opération sans altérer le
contenu des registres de résultats AR et AF. Les instructions suivantes ne sont pas
autorisées :
xop + constant
xop − constant
− xop + constant
AND
xop OR constant
NONE = XOR ;
PASS (excepté − 1,0,+1)
TSTBIT
SETBIT
xop
CLRBIT
TGLBIT

ASTAT : 7 6 5 4 3 2 1 0
- - - - * * * *
4.5 LE MULTIPLIEUR ET ACCUMULATEUR (MULTIPLIER/ACCUMULATOR)

24 bits PMD BUS
16 bits DMD BUS 16 bits

MSB
16 bits MUX
16 bits
Bank 2 Bank 2
Bank 1 Bank 1
MX REGISTERS MY REGISTERS
16 bits 2 x 16 2 x 16 16 bits
16 bits 16 bits
MUX MUX 16 bits
16 bits 16 bits
Bank 2
Bank 1
MF REGISTER
1 x 16
X Y
MULTIPLIER
40 bits
P 16 bits
32 bits
16 bits
ADD / SUBTRACT MV
MUX MUX MUX
8 bits 16 bits 16 bits 16 bits
Bank 2 Bank 2 Bank 2

Bank 1 Bank 1 Bank 1
MR2 REGISTER MR1 REGISTER MR0 REGISTER
1x8 1 x 16 1 x 16
8 bits 16 bits 16 bits

M
U
X
16 bits
8 bits 16 bits 16 bits

R BUS 16 bits
Figure 4-2 : Multiplicateur et accumulateur
4.5.1 Définition des registres xop et yop autorisés pour les instructions MAC
X opérande : xop AR
MX0, MX1, MX2, MR0, MR1
SR0, SR1
Y opérande : yop MY0, MY1, MF

EQ Egale zéro AZ=1
4.5.3 Notation sur le registre d’état ASTAT


4.5.4 Multiplication
4.5.4.1 Syntaxe
(SS)
(SU)
MR yop
[IF cond] = xop ∗ (US) ;
MF xop
(UU)
(RND)

xop yop Condition
MX0 AR MY0 EQ LE AC
MX1 SR1 MY1 NE NEG NOT AC
MR2 SR0 MF GT POS MV
MR1 GE AV NOT MV
MR0 LT NOT AV NOT CE
4.5.4.3 Exemple
IF EQ MR = MX0 + MF (UU) ; { xop ∗ yop }
MF = SR0 ∗ SR0 (SS) ; { xop ∗ xop }
4.5.4.4 Description
Les opérandes sont contenus dans les registres spécifiés dans la syntaxe de l’instruction. Lors
que le registre MF est la destination du résultat, seul les bits N°31 à 16 sont sauvés.
L’opération xop ∗ xop (élévation au carré), les deux opérandes xop doivent être stockés dans
le même registre.
Le format de chaque opérande est définit comme S : signé ou U : non-signé. La première et la
deuxième lettres en parenthèse se rapportent respectivement au premier et au deuxième
opérandes. Pour une élévation au carré ( xop ∗ xop ) les formats valides sont (UU) ou (SS).
Si (RND) est spécifié, le MAC multiplie les deux opérandes et arrondi le résultat pour ne
prendre en compte que les 16 bits de poids fort qui sont sauvés dans le registre de destination.
Les deux opérandes sont considérés comme des nombres en complément à deux. La fonction
d’arrondi est décalée. Pour plus de détails sur l’algorithme utilisé pour l’arrondi, voir [4]
Chapitre 2 § 2.3.2.6.

ASTAT : 7 6 5 4 3 2 1 0
- * - - - - - -
MV Mise à 1 si le résultat arithmétique est en dépassement de capacité, sinon mise à 0.
Il y a dépassement de capacité si les 9 bits de poids fort de MR ne sont pas tous de 0 ou tous
des 1.
4.5.5 Multiplication /addition
4.5.5.1 Syntaxe
(SS)
(SU)
MR yop
[IF cond] = MR + xop ∗ (US) ;
MF xop
(UU)
(RND)

xop yop Condition
MX0 AR MY0 EQ LE AC
MR1 GE AV NOT MV
4.5.5.3 Exemple
IF EQ MR = MR + MX0 + MY1 (SS) ;
MF = MR + MX0 ∗ MX0 (SS) ;
4.5.5.4 Description
que le registre MF est la destination du résultat, seul les bits N°31 à 16 sur les 40 du résultat
sont sauvés.
le même registre.
Si (RND) est spécifié, le MAC multiplie les deux opérandes, additionne le contenu courant
du registre MR et arrondi le résultat pour ne prendre en compte que les 16 bits de poids fort
qui sont sauvés dans le registre de destination. Les deux opérandes sont considérés comme
des nombres en complément à deux. La fonction d’arrondi est décalée. Pour plus de détails
sur l’algorithme utilisé pour l’arrondi, voir [4] Chapitre 2 § 2.3.2.6.

ASTAT : 7 6 5 4 3 2 1 0
- * - - - - - -
des 1.
4.5.6 Multiplication/soustraction
4.5.6.1 Syntaxe
(SS)
(SU)
MR yop
[IF cond] = MR − xop ∗ (US) ;
MF xop
(UU)
(RND)

xop yop Condition
MX0 AR MY0 EQ LE AC
MR1 GE AV NOT MV
4.5.6.3 Exemple
IF LT MR = MR − MX1 * MY0 (SU) ;
MR = MR − MX0 ∗ MX0 (SS) ;
4.5.6.4 Description
que le registre MF est la destination du résultat, seul les bits N°31 à 16 sur les 40 du résultat
sont sauvés.
le même registre.
Si (RND) est spécifié, le MAC multiplie les deux opérandes, soustrait le contenu courant du
registre MR et arrondi le résultat pour ne prendre en compte que les 16 bits de poids fort qui
sont sauvés dans le registre de destination. Les deux opérandes sont considérés comme des
nombres en complément à deux. La fonction d’arrondi est décalée. Pour plus de détails sur
l’algorithme utilisé pour l’arrondi, voir [4] Chapitre 2 § 2.3.2.6.

ASTAT : 7 6 5 4 3 2 1 0
- * - - - - - -
MV Mise à 1 si le résultat arithmétique est en dépassement de capacité, sinon mise à 0
des 1.
4.5.7 Multiplication par 0 (mise à zéro des registres résultat MR ou MF)
4.5.7.1 Syntaxe
MR
[IF cond] = 0;
MF

Condition
EQ LE AC
NE NEG NOT AC
GT POS MV
GE AV NOT MV
LT NOT AV NOT CE
4.5.7.3 Exemple
IF GT MR = 0 ;
4.5.7.4 Description
Vrai : exécution de l’instruction de mise à « = ».
Faux : l’instruction de mise à « = » n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction de mise à « = ».
Le registre de 40 bits MR ou celui de 16 bits MF est mis à « 0 »

ASTAT : 7 6 5 4 3 2 1 0
- 0 - - - - - -
MV Mise à 0 inconditionnelle
4.5.8 Transfert
4.5.8.1 Syntaxe
MR
[IF cond] = MR (RND) ;
MF

xop yop Condition
- - EQ LE AC
NE NEG NOT AC
GT POS MV
GE AV NOT MV
LT NOT AV NOT CE
4.5.8.3 Exemple
IF EQ MF = MR (RND) ;
4.5.8.4 Description
Vrai : exécution de l’instruction de transfert.
Faux : l’instruction de transfert n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction de transfert.
Cette instruction correspond à une instruction de multiplication /addition avec yop=0. Le
résultat nul de la multiplication est additionner au contenu du registre MR. Le registre de
destination est soit MR, soit MF. En utilisant l’option (RND), un arrondi est effectué entre le
quinzième et le seizième bit de MR.

ASTAT : 7 6 5 4 3 2 1 0
- * - - - - - -
des 1.
4.5.9 Limitation conditionnelle du résultat dans MR (saturation)
4.5.9.1 Syntaxe
IF MV SAT MR ;
4.5.9.2 Description
Test du bit ASTAT[6] (MV) du registre ASTAT correspondant à un dépassement de capacité
sur une opération de multiplication. Si MV= « 1 », les 32 bits de poids les plus faibles (MR1
et MR0) sont forcés à leurs valeurs de limitation.
Cette instruction est prévue pour être utilisée à la suite d’une instruction de
multiplication/addition ou multiplication/soustraction afin d’éviter un dépassement de
capacité et donc un résultat erroné.
La valeur de saturation dépend du bit ASTAT[6] (MV) et du signe du résultat de la

multiplication/addition ou multiplication/soustraction stocké dans le registre MR (MSB de
MR2). Les résultats possibles après exécution de cette instruction sont les suivants :
MV MR2 MSB(MR1) Registre MR

Résultat du
0 00000000 0 R (sortie du MAC)
calcul
Résultat du
0 11111111 1 R (sortie de l’ALU)
calcul
Pleine échelle
1 OR{MR2}=1 0 00000000 0111111111111111 1111111111111111
positive
Pleine échelle
1 AND{MR2}=1 1 11111111 1000000000000000 0000000000000000
négative

ASTAT : 7 6 5 4 3 2 1 0
- - - - - - - -
Aucun bit du registre d’état n’est affecté par cette opération.
4.6 LE DÉCALEUR À BARILLET (BARREL SHIFTER)

16 bits DMD BUS
5 bits 16 bits
LSB Bank 2
Bank 1
SI REGISTER
MUX 1 x 16
8 bits
LSB Bank 2
Bank 1
SB REGISTER 16 bits 16 bits
1x5 MUX
SS X
8 bits
LSB
EXPONENT
COMPARE DETECTOR
I X 16 bits
HI/LO R
8 bits SHIFTER
ARRAY
C
O
MUX MUX
32 bits 32 bits
Bank 2
Bank 1
OR / PASS 16 bits
SE REGISTER
1x5 NEGATE
8 bits
MUX MUX
Bank 2 Bank 2
From INSTRUCTION Bank 1 Bank 1
SR1 REGISTER SR0 REGISTER MUX
1 x 16 1 x 16
16 bits
16 bits
R-BUS 16 bits
Figure 4-3 : Décaleur à barillet
4.6.1 Définition des registres xop autorisés pour les instructions du barrel shifter
X opérande : xop AR
MR0, MR1, MR2
SI, SR0, SR1

EQ Egale zéro AZ=1
4.6.3 Notation sur le registre d’état ASTAT


4.6.4 Décalage arithmétique
4.6.4.1 Syntaxe
(HI)
[IF cond] SR = [SR OR] ASHIFT xop ;
(LO)

xop Condition
SI AR EQ LE AC
SR1 MR2 NE NEG NOT AC
SR0 MR1 GT POS MV
MR0 GE AV NOT MV
LT NOT AV NOT CE
4.6.4.3 Exemple
IF LT SR = SR OR ASHIFT SI (LO) ;
4.6.4.4 Description
Vrai : exécution de l’instruction de décalage arithmétique.
Faux : l’instruction de décalage arithmétique n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction décalage arithmétique.
Le décalage arithmétique décale les bits de l’opérande xop de la valeur définie dans le
registre SE. SE est un registre de 8 bits dont la valeur stockée est en complément à deux
(-128 à +127). La valeur absolue donne le nombre de bits de décalage et le signe la direction
du décalage. Pour une valeur positive le décalage se fait à gauche (dans les sens des MSB)
pour une valeur négative le décalage se fait vers la droite (dans le sens des LSB).
L’option (LO) indique que la valeur d’entrée est placée dans les 16 bits inférieurs d’un
champ de 32bits puis décalée selon la valeur contenue dans le registre SE. Le résultat est
stocké dans le registre SR de 32 bits (SR1, SR0).
L’option (HI) indique que la valeur d’entrée est placée dans les 16 bits supérieurs d’un
Pour un décalage vers la droite (valeur négative dans le registre SE) les bits ajoutés à gauche
sont une extension du signe, les bits sortant du champ à droite sont perdus.
Pour un décalage vers la gauche (valeur positive dans le registre SE) les bits ajoutés à droite
sont des « 0 », les bits sortants du champ à gauche sont perdus.
Pour les décalages en double précision (32 bits), la valeur du registre SE restent identique
pour les deux demi-plages du nombre. Lors de la première instruction, la partie supérieure de
la plage est décalée en utilisant un décalage arithmétique ASHIFT avec l’option HI, la
seconde instruction provoque un décalage logique LSHIFT avec l’option LO et SR OR.

Aucun bit d’état n’est affecté par cette instruction
4.6.5 Décalage logique
4.6.5.1 Syntaxe
(HI)
[IF cond] SR = [SR OR] LSHIFT xop ;
(LO)

xop Condition
SI AR EQ LE AC
SR0 MR1 GT POS MV
MR0 GE AV NOT MV
LT NOT AV NOT CE
4.6.5.3 Exemple
IF GE SR = LSHIFT SI (HI) ;
4.6.5.4 Description
Vrai : exécution de l’instruction de décalage logique.
Faux : l’instruction de décalage logique n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction décalage logique.
Le décalage logique décale les bits de l’opérande xop de la valeur définie dans le registre SE.
SE est un registre de 8 bits dont la valeur stockée est en complément à deux (-128 à +127).
La valeur absolue donne le nombre de bit de décalage et le signe la direction du décalage.
Pour une valeur positive le décalage se fait à gauche (dans les sens des MSB) pour une valeur
négative le décalage se fait vers la droite (dans le sens des LSB).
Pour un décalage vers la droite (valeur négative dans le registre SE) les bits ajoutés à gauche
sont des « 0 », les bits sortant du champ à droite sont perdus.
Pour un décalage vers la gauche (valeur positive dans le registre SE) les bits ajoutés à droite
sont des « 0 », les bits sortants du champ à gauche sont perdus.
Pour les décalages en double précision (32 bits), la valeur du registre SE restent identique
la plage est décalée en utilisant un décalage arithmétique ASHIFT avec l’option HI, la
seconde instruction provoque un décalage logique LSHIFT avec l’option LO et SR OR.

4.6.6 Normalisation
4.6.6.1 Syntaxe
(HI)
[IF cond] SR = [SR OR] NORM xop ;
(LO)

xop Condition
SI AR EQ LE AC
SR0 MR1 GT POS MV
MR0 GE AV NOT MV
LT NOT AV NOT CE
4.6.6.3 Exemple
SR = NORM SI (HI) ;
4.6.6.4 Description
Cette instruction fait en principe suite à une instruction de définition de l’exposant (EXP). Le
registre SE contient le nombre de bit de signe moins un de l’opérande xop avec un signe
négatif.
Si le contenu du registre SE est négatif ou nul, cette instruction va faire un décalage logique
vers la gauche afin d’éliminer les bits de signe redondant.
champ de 32 bits puis décalée vers la gauche selon la valeur négative contenue dans le
registre SE. Le résultat est stocké dans le registre SR de 32 bits (SR1, SR0).
champ de 32bits puis décalée vers la gauche selon la valeur négative contenue dans le
registre SE. Le résultat est stocké dans le registre SR de 32 bits (SR1, SR0).
Les bits ajoutés à droite sont des « 0 ».
Pour la normalisation en double précision (32 bits), la valeur du registre SE restent identique
la plage est décalée vers la gauche avec l’option HI, la seconde instruction provoque
également un décalage vers la gauche avec l’option LO et SR OR.
Si le contenu du registre SE vaut 1 (option HIX de EXP), le décalage se fait vers la droite
avec le contenu de ASTAT[3] (AC) placé sur le MSB.

4.6.7 Définition de l’exposant
4.6.7.1 Syntaxe
(HI)
[IF cond] SE = EXP xop (LO) ;
(HIX)

xop Condition
SI AR EQ LE AC
SR0 MR1 GT POS MV
MR0 GE AV NOT MV
LT NOT AV NOT CE
4.6.7.3 Exemple
IF GT SE = EXP MR1 (HI) ;
4.6.7.4 Description
Cette instruction précède l’instruction de normalisation (NORM). Elle a pour but de définir le
nombre de bit correspondant à l’extension du signe de l’opérande. Le registre SE contient la
valeur négative du nombre de bits de signe redondant. Il s’agit donc ni plus ni moins que la
valeur de l’exposant.
Avec l’option (HI), l’entrée est considérée comme un nombre signé de simple précision ou
comme la moitié supérieure d’un nombre signé en double précision.
Avec le mode (HIX), l’entrée est interprétée comme le résultat d’une addition ou d’une
soustraction pouvant avoir un dépassement de capacité. Le bit ASSTAT[3] (AV) donnant le
dépassement de capacité est donc pris en compte. Si un dépassement de capacité existe, le
registre SE prend la valeur +1. S’il n’y a pas de dépassement de capacité alors le mode est
identique à celui de l’option (HI).
Avec l’option (LO), l’entrée est considérée comme la partie inférieure d’un nombre de
double précision. Il est alors possible d’ajuster la valeur de l’exposant si le nombre de bits de
signe redondant est supérieur à 15 (ou SE=-15 avant l’exécution de cet instruction). Dans le
cas contraire le contenu du registre SE reste inchangé.

ASTAT : 7 6 5 4 3 2 1 0
* - - - - - - -
SS Contient la valeur logique du bit MSB de l’entrée (extension du signe) si AV=0
Contient l’inverse logique du MSB de l’entrée si AV=1
4.6.8 Ajustement de l’exposant
4.6.8.1 Syntaxe
[IF cond] SB = EXPADJ xop ;

xop Condition
SI AR EQ LE AC
SR0 MR1 GT POS MV
MR0 GE AV NOT MV
LT NOT AV NOT CE
4.6.8.3 Exemple
IF GT SB = EXPADJ SI ;
4.6.8.4 Description
Cette instruction permet de définir l’exposant le plus grand (valeur négative) d’un groupe de
nombre. Cet exposant pourra par la suite être utilisé pour normaliser chaque nombre du
groupe avec le même exposant en vue d’une opération arithmétique.
Avant l’exécution de cette instruction, il faut assigner la valeur -16 au registre SB (5 bits),
soit la valeur minimale admissible. L’instruction EXPADJ est ensuite exécutée pour chaque
nombre du groupe. La valeur du registre SB n’est mise à jour que si la détection de
l’exposant donne une valeur supérieure à la valeur stockée. Aucun décalage n’est effectué, le
but étant uniquement la recherche de l’exposant le plus élevé.
Les nombres avec dépassement de capacité ou la partie inférieure des nombres double
précision ne sont pas pris en compte par cette instruction.

Aucun bit d’état n’est affecté par cette instruction.
4.6.9 Décalage arithmétique immédiat
4.6.9.1 Syntaxe
(HI)
SR = [SR OR] ASHIFT xop BY < exp > ;
(LO)

xop <exp>
SI AR Grandeur signée de 8 bits :
SR1 MR2 − 128 ≤ < exp > ≤ 127 ;
SR0 MR1
MR0
4.6.9.3 Exemple
SR = SR OR ASHIFT SR0 BY 3 (LO) ; {pour exp≥0 ne pas écrire le signe +}
4.6.9.4 Description
Vrai : exécution de l’instruction de décalage arithmétique
Faux : l’instruction de décalage arithmétique n’est pas exécutée
Pas de condition : exécution inconditionnelle de l’instruction décalage arithmétique
Le décalage arithmétique décale les bits de l’opérande xop de <exp>. La valeur absolue
donne le nombre de bit de décalage et le signe la direction du décalage. Pour une valeur
positive le décalage se fait à gauche (dans les sens des MSB) pour une valeur négative le
décalage se fait vers la droite (dans le sens des LSB).
champ de 32bits puis décalée selon <exp>. Le résultat est stocké dans le registre SR de 32
bits (SR1, SR0).
bits (SR1, SR0).
Pour un décalage vers la droite (<exp> négative) les bits ajoutés à gauche sont une extension
du signe, les bits sortant du champ à droite sont perdus.
Pour un décalage vers la gauche (<exp> positive) les bit ajoutés à droite sont des « 0 », les
bits sortants du champ à gauche sont perdus.
Pour les décalages en double précision (32 bits), <exp> restent identique pour les deux demi-
plages du nombre. Lors de la première instruction, la partie supérieure de la plage est décalée
en utilisant un décalage arithmétique ASHIFT avec l’option HI, la seconde instruction
provoque un décalage logique LSHIFT avec l’option LO et SR OR.

4.6.10 Décalage logique immédiat
4.6.10.1 Syntaxe
(HI)
SR = [SR OR] LSHIFT xop BY < exp > ;
(LO)

xop <exp>
SI AR Grandeur signée de 8 bits :
SR1 MR2 − 128 ≤ < exp > ≤ 127 ;
SR0 MR1
MR0
4.6.10.3 Exemple
SR = LSHIFT SR1 BY − 6 (HI) ; {pour exp≥0 ne pas écrire le signe +}
Vrai : exécution de l’instruction de décalage arithmétique.

Faux : l’instruction de décalage arithmétique n’est pas exécutée.
Pas de condition : exécution inconditionnelle de l’instruction décalage arithmétique.
Le décalage logique décale les bits de l’opérande xop de <exp>. La valeur absolue donne le
nombre de bit de décalage et le signe la direction du décalage. Pour une valeur positive le
décalage se fait à gauche (dans les sens des MSB) pour une valeur négative le décalage se fait
vers la droite (dans le sens des LSB).
bits (SR1, SR0).
bits (SR1, SR0).
Pour un décalage vers la droite (<exp> négative) les bits ajoutés à gauche sont des « 0 », les
bits sortant du champ à droite sont perdus.
Pour un décalage vers la gauche (<exp> positive) les bits ajoutés à droite sont des « 0 », les
bits sortants du champ à gauche sont perdus.
Pour les décalages en double précision (32 bits), <exp> restent identique pour les deux demi-
plages du nombre. Lors de la première instruction, la partie supérieure de la plage est décalée
en utilisant un décalage arithmétique ASHIFT avec l’option HI, la seconde instruction
provoque un décalage logique LSHIFT avec l’option LO et SR OR.

4.7 TRANSFERT DE DONNÉES
4.7.1 Transfert de données de registre à registre
4.7.1.1 Syntaxe
reg = reg ;
4.7.1.2 Définitions des registres

reg
AX016(S) MX016(S) SI16(S) I0-I714(U) SB5
AX116(S) MX116(S) SE8(S) M0-M714(S) PX8(U)
AX016(S) MY016(S) SR116(S) L0-L714(U) CNTR16(U)
AY116(S) MY116(S) SR016(S) ASTAT8(U) 0WRCNTR16 (écriture)
AR16(S) MR28(S) MSTAT7(U) RX016
MR116(S) SSTAT8(U) (lecture) TX016
MR016(S) IMASK10(U) RX116
ICNTL5(U) TX116
IFC16 (écriture)
16 : capacité du registre [bits]
(S) : contenu du registre signé
(U) : contenu du registre non signé
4.7.1.3 Exemple
I7 = AR ;
4.7.1.4 Description
Transfert le contenu d’un registre reg source dans un registre reg destination. Le contenu de
la source est toujours justifié à droite dans le registre de destination (reg[0]→reg[0],
reg[1]→reg[1], …).
Lorsque le transfert à lieu entre un registre source de capacité inférieure à celle du registre
destination (par exemple 8 bits → 16 bits), il y a extension du signe à gauche si la valeur est
signée ou adjonction de « 0 » si la valeur est non-signée.
Les registres ne pouvant contenir que des valeurs non-signées sont : I0 – I7, L0 – L7, CNTR,
PX, ASTAT, MSTAT, SSTAT, IMASK et ICNTL.
Lorsque le transfert à lieu entre un registre source de capacité supérieure à celle registre
destination (par exemple 16 bits → 8 bits), les bits de poids forts sont perdus.
Lorsque MR1 est le registre de destination, l’extension du signe se fait jusque dans le registre
MR2.

4.7.2 Chargement immédiat d’un registre
4.7.2.1 Syntaxe
reg =< data > ;
dreg =< data > ;
data : <constant>
‘%’<symbol>
‘^’<symbol>

dreg reg
AX016(S) MX016(S) SI16(S) I0-I714(U) SB5
MR116(S) SSTAT8(U) TX016
MR016(S) (lecture) RX116
IMASK10(U) TX116
ICNTL5(U)
IFC16 (écriture)
4.7.2.3 Exemple
I0 = ^ data _ buffer ;
L0 = %data _ buffer ;
4.7.2.4 Description
Transfert d’une valeur spécifique en complément à deux dans un registre dreg ou reg. La
valeur peut être une constante ou un symbole associé opérateur de type longueur de buffer
(%) ou pointeur de buffer (^). La valeur est contenue dans le format de l’instruction.
La valeur est toujours justifiée à droite dans le registre de destination (<data>[0]→(d)reg[0],
<data>[1]→ (d)reg [1], …).
Les registres I0 – I7, L0 – L7, CNTR, PX, ASTAT, MSTAT, SSTAT, IMASK et ICNTL ne
peuvent contenir que des valeur non-signées.
Pour cette instruction, les registres RX et TX peuvent être chargé avec une valeur de 14 bits
maximum. Pour charger ces registres avec une valeur de 16 bits il faut utiliser les instructions
de transfert de registre à registre reg=reg ou de mémoire de données à registre reg=DM(…)
MR2.

4.7.3 Lecture de la mémoire de données (adressage direct)
4.7.3.1 Syntaxe
reg = DM(< addr >) ;

reg
AX016(S) MX016(S) SI16(S) I0-I714(U) SB5
MR116(S) SSTAT8(U) (lecture) TX016
MR016(S) IMASK10(U) RX116
ICNTL5(U) TX116
IFC16 (écriture)
4.7.3.3 Exemple
SI = DM(ad _ port0) ;
4.7.3.4 Description
Transfert du contenu d’une position de la mémoire de données (DM) dans un registre reg
destinataire. Il s’agit ici d’un mode d’adressage direct, c’est-à-dire que l’adresse est donnée
sous la forme d’une valeur numérique ou d’une étiquette se rapportant à une constante.
L’adresse est contenue dans le format de l’instruction. Le contenu de la source est toujours
justifié à droite dans le registre de destination (DM[0]→reg[0], DM[1]→ reg [1], …).
MR2.

4.7.4 Lecture de la mémoire de données (adressage indirect)
4.7.4.1 Syntaxe
I0 M0
I1 M1
,
I2 M2
I3 M3
dreg = DM( );
I4 M4
I5 M5
,
I6 M6
I7 M7

dreg
AX016(S) MX016(S) SI16(S)
AX116(S) MX116(S) SE8(S)
AX016(S) MY016(S) SR116(S)
AY116(S) MY116(S) SR016(S)
AR16(S) MR28(S)
MR116(S)
MR016(S)
4.7.4.3 Exemple
AY0 = DM(I3, M1) ;
4.7.4.4 Description
Transfert du contenu d’une position de la mémoire de données (DM) dans un registre de
données dreg destinataire. Il s’agit ici d’un mode d’adressage indirect, c’est-à-dire que
l’adresse est donnée sous la forme du contenu d’un registre (pointeur Ix) et d’un registre
d’incrément (mise à jour du pointeur ou post-modification du pointeur My). Pour une
succession linéaire des adresses pointée, le registre Lx correspondant au registre pointeur Ix
doit être mis à « 0 ». Le contenu de la source est toujours justifié à droite dans le registre de
destination (DM[0]→ dreg[0], DM[1]→ dreg[1], …).
MR2.

4.7.5 Lecture de la mémoire de programme (adressage indirect)
4.7.5.1 Syntaxe
I4 M4
I5 M5
dreg = PM( , );
I6 M6
I7 M7

dreg
AX016(S) MX016(S) SI16(S)
AX116(S) MX116(S) SE8(S)
AX016(S) MY016(S) SR116(S)
AY116(S) MY116(S) SR016(S)
AR16(S) MR28(S)
MR116(S)
MR016(S)
4.7.5.3 Exemple
MX1 = PM(I6, M5) ;
4.7.5.4 Description
Transfert du contenu d’une position de la mémoire de programme (PM) dans un registre de
données dreg destinataire. Il s’agit ici d’un mode d’adressage indirect, c’est-à-dire que
succession linéaire des adresses pointées, le registre Lx correspondant au registre pointeur Ix
doit être mis à « 0 ». Les données de la mémoire de programme (PM) sont stockées sur 24
bits. Les MSB (PM[23…8]) sont chargés dans le registre destinataire avec les LSB alignés
(PM[8]→dreg[0], PM[9]→dreg[1], …). Si le registre dreg destinataire à une capacité
inférieure à 16 bits, les bits de poids fort de la source sont perdus. Les LSB (PM[7…0]) sont
toujours chargés dans le registre d’échange PX. Ces derniers peuvent être soit ignorés soit lus
au cycle suivant.
MR2.

4.7.6 Ecriture de la mémoire de données (adressage direct)
4.7.6.1 Syntaxe
DM(< addr >) = reg ;

reg
AX016(S) MX016(S) SI16(S) I0-I714(U) SB5(S)
AY116(S) MY116(S) SR016(S) ASTAT8(U) RX016
AR16(S) MR28(S) MSTAT7(U) TX016
MR116(S) SSTAT8(U) (lecture) RX116
MR016(S) IMASK10(U) TX116
ICNTL5(U)
4.7.6.3 Exemple
DM(ad _ port0) = AR ;
4.7.6.4 Description
Transfert du contenu d’un registre reg dans une position de la mémoire de données (DM)
destinataire. Il s’agit ici d’un mode d’adressage direct, c’est-à-dire que l’adresse est donnée
sous la forme d’une valeur numérique ou d’une étiquette se rapportant à une constante.
L’adresse est contenue dans le format de l’instruction.
Lorsque le transfert à lieu entre un registre source de capacité inférieure à 16 bits, il y a
extension du signe à gauche si la valeur est signée ou adjonction de « 0 » si la valeur est non-
signée.
Les registres non-signées sont : I0 – I7, L0 – L7, CNTR, PX, ASTAT, MSTAT, SSTAT,
IMASK et ICNTL.
Le contenu du registre source est toujours justifié à droite dans la position de la mémoire de
données (DM) de destination (reg[0]→DM[0], reg [1]→DM[1], …).

4.7.7 Ecriture de la mémoire de données (adressage indirect)
4.7.7.1 Syntaxe
I0 M0
I1 M1
,
I2 M2
I3 M3 dreg
DM( )= ;
I4 M4 < data >
I5 M5
,
I6 M6
I7 M7
data : <constant>
‘%’<symbol>
‘^’<symbol>

dreg
AX016(S) MX016(S) SI16(S)
AX116(S) MX116(S) SE8(S)
AX016(S) MY016(S) SR116(S)
AY116(S) MY116(S) SR016(S)
AR16(S) MR28(S)
MR116(S)
MR016(S)
4.7.7.3 Exemple
DM(I2, M0) = MR1 ;
4.7.7.4 Description
Transfert du contenu d’un registre de données dreg ou d’une valeur immédiate <data> dans
une position de la mémoire de données (DM) destinataire. Il s’agit ici d’un mode d’adressage
indirect, c’est-à-dire que l’adresse est donnée sous la forme du contenu d’un registre (pointeur
Ix) et d’un registre d’incrément (mise à jour du pointeur ou post-modification du pointeur
My). Pour une succession linéaire des adresses pointées, le registre Lx correspondant au
registre pointeur Ix doit être mis à « 0 ».
Lorsque le transfert à lieu entre un registre dreg source de capacité inférieure à 16 bits, il y a
extension du signe à gauche.
Le contenu de la source est toujours justifié à droite dans le registre de destination
(dreg[0]→PM[0], dreg[1]→PM[1], …)

4.7.8 Ecriture de la mémoire de programme (adressage indirect)
4.7.8.1 Syntaxe
I4 M4
I5 M5
PM( , ) = dreg ;
I6 M6
I7 M7

dreg
AX016(S) MX016(S) SI16(S)
AX116(S) MX116(S) SE8(S)
AX016(S) MY016(S) SR116(S)
AY116(S) MY116(S) SR016(S)
AR16(S) MR28(S)
MR116(S)
MR016(S)
4.7.8.3 Exemple
PM(I6, M5) = AR ;
4.7.8.4 Description
Transfert du contenu d’un registre de données dreg dans une position de la mémoire de
programme (PM) destinataire. Il s’agit ici d’un mode d’adressage indirect, c’est-à-dire que
succession linéaire des adresses pointées, le registre Lx correspondant au registre pointeur Ix
doit être mis à « 0 ». Les données de la mémoire de programme (PM) sont stockées sur 24
bits. Le contenu du registre dreg est chargé dans les MSB (PM[23…8]) de la mémoire
programme destinataire avec les LSB alignés (dreg[0]→PM[8], dreg[1]→PM[9], …). Les 8
LSB de la mémoire programme (PM[7…0]) sont chargé dans le registre d’échange PX,
Lorsque le transfert à lieu entre un registre dreg source de capacité inférieure à 16 bits, il y a
extension du signe à gauche.

4.8 DÉROULEMENT SÉQUENTIEL D’UN PROGRAMME
4.8.1 Saut
4.8.1.1 Syntaxe
(I4)
(I5)
[IF cond] JUMP (I6) ;
(I7)
< addr >
4.8.1.2 Définitions des conditions

Condition
EQ LE AC
NE NEG NOT AC
GT POS MV
GE AV NOT MV
LT NOT AV NOT CE
4.8.1.3 Exemple
IF NOT CE JUMP top _ loop ; {le compteur de boucle CNTR est décrémenté}
4.8.1.4 Description
Vrai : exécution de l’instruction de saut
Faux : l’instruction de saut n’est pas exécutée
Pas de condition : exécution inconditionnelle de l’instruction saut
L’instruction JUMP force l’exécution séquentielle du programme à une adresse spécifiée
dans l’instruction. Le mode d’adressage peut être direct ou indirect.
Pour un adressage direct (l’adresse est définie sous la forme d’une valeur ou d’une étiquette),
l’adresse programme est stockée directement dans l’instruction.
Pour un adressage indirect, le pointeur est un registre I du DAG (Data Address Generator).
Pour une instruction JUMP, le registre I n’est pas mis à jour (post modification par M).
Si l’instruction JUMP est la dernière instruction à l’intérieur d’une boucle DO UNTIL, il faut
s’assurer que la pile de boucle (loop stack) soit mise à jour correctement.
Si la condition NOT CE est utilisée (IF NOT CE JUMP top_loop), le compteur de boucle
CNTR est décrémenté.

4.8.2 Appel à un sous-programme
4.8.2.1 Syntaxe
(I4)
(I5)
[IF cond] CALL (I6) ;
(I7)
< addr >

Condition
EQ LE AC
NE NEG NOT AC
GT POS MV
GE AV NOT MV
LT NOT AV NOT CE
4.8.2.3 Exemple
IF AV CALL scale _ down ; {le compteur de boucle CNTR est décrémenté}
4.8.2.4 Description
Vrai : exécution de l’instruction d’appel à un sous-programme
Faux : l’instruction d’appel à un sous-programme n’est pas exécutée
Pas de condition : exécution inconditionnelle de l’instruction d’appel à un sous-
programme
L’instruction CALL est prévue pour les appels de sous-programme (saut avec retour). Le
pointeur de programme PC est sauvé dans la pile (PC stack) avec pour valeur l’adresse de
retour après exécution du sous-programme, puis le pointeur de programme prend la valeur de
l’adresse de la première instruction du sous-programme. Le mode d’adressage peut être direct
ou indirect.
Pour un adressage direct (l’adresse est définie sous la forme d’une valeur ou d’une étiquette),
l’adresse programme est stockée directement dans l’instruction.
Pour un adressage indirect, le pointeur est un registre I du DAG (Data Address Generator).
Pour une instruction CALL, le registre I n’est pas mis à jour (post modification par M).
Si l’instruction CALL est la dernière instruction à l’intérieur d’une boucle DO UNTIL, il faut
Si la condition NOT CE est utilisée (IF NOT CE JUMP top_loop), le compteur de boucle
CNTR est décrémenté.

4.8.3 Saut ou appel à un sous-programme sous condition externe
4.8.3.1 Syntaxe
FLAG _ IN JUMP
IF < addr > ;
NOT FLAG _ IN CALL
4.8.3.2 Exemple
IF FLAG _ IN JUMP service _ condition ;
4.8.3.3 Description
Test l’état de la pin FI du DSP et, si elle est à « 1 », exécute l’instruction JUMP ou CALL
spécifiée. Si la pin FI est à « 0 », l’instruction de saut n’est pas exécutée. Mis à par la
condition, l’exécution de cette instruction se réduit à un JUMP ou CALL classique.
L’instruction JUMP force l’exécution séquentielle du programme à une adresse spécifiée

dans l’instruction. Le mode d’adressage doit être direct.
L’instruction CALL est prévue pour les appels de sous-programme (saut avec retour). Le
pointeur de programme PC est sauvé dans la pile (PC stack) avec pour valeur l’adresse de
retour après exécution du sous-programme, puis le pointeur de programme prend la valeur de
l’adresse de la première instruction du sous-programme. Le mode d’adressage doit être
direct.
L’adresse est définie sous la forme d’une valeur ou d’une étiquette, l’adresse programme est
stockée directement dans l’instruction.
Si l’instruction JUMP ou CALL est la dernière instruction à l’intérieur d’une boucle DO

UNTIL, il faut s’assurer que la pile de boucle (loop stack) soit mise à jour correctement.

4.8.4 Retour d’un sous programme
4.8.4.1 Syntaxe
[IF cond] RTS ;

Condition
EQ LE AC
NE NEG NOT AC
GT POS MV
GE AV NOT MV
LT NOT AV NOT CE
4.8.4.3 Exemple
IF LE RTS ;
4.8.4.4 Description
Vrai : exécution de l’instruction de retour de sous-programme
Faux : l’instruction de retour de sous-programme n’est pas exécutée
Pas de condition : exécution inconditionnelle de l’instruction de retour de sous-
programme
L’instruction RTS exécute le retour d’un sous-programme à l’adresse définie dans la partie
supérieure de la pile (PC stack) et met à jour le pointeur de la pile. Seule la pile de
programme est utilisée.
Si l’instruction RTS est la dernière instruction à l’intérieur d’une boucle DO UNTIL, il faut

4.8.5 Retour d’une routine d’interruption
4.8.5.1 Syntaxe
[IF cond] RTI ;

Condition
EQ LE AC
NE NEG NOT AC
GT POS MV
GE AV NOT MV
LT NOT AV CE
4.8.5.3 Exemple
IF MV RTI ;
4.8.5.4 Description
Vrai : exécution de l’instruction de retour d’une routine d’interruption.
Faux : l’instruction de retour d’une routine d’interruption n’est pas
exécutée.
Pas de condition : exécution inconditionnelle de l’instruction de retour d’une
routine d’interruption.
L’instruction RTI exécute le retour d’une routine d’interruption à l’adresse définie dans la
partie supérieure de la pile (PC stack) et met à jour le pointeur de la pile.
Les registres d’état ASTAT, MSTAT, et le registre de masquage des interruptions IMASK
sont mis à jour avec les valeurs contenues dans la partie supérieure de la pile des registres
d’état (Status stack). Le pointeur de la pile des registres d’état est ensuite mis à jour.
Si l’instruction RTI est la dernière instruction à l’intérieur d’une boucle DO UNTIL, il faut

4.8.6 Boucle
4.8.6.1 Syntaxe
DO < addr > UNTIL term ;
4.8.6.2 Définitions des conditions de terminaison

Term
EQ LE AC FOREVER
NE NEG NOT AC
GT POS MV
GE AV NOT MV
LT NOT AV CE
4.8.6.3 Exemple
DO end _ loop UNTIL CE ; {le compteur de boucle CNTR}
{est décrémenté à chaque passage}
4.8.6.4 Description
DO UNTIL initie l’exécution d’une boucle dès l’instruction suivante. L’adresse <addr> de la
fin de boucle est également définie dans l’instruction. La boucle est répétée jusqu’à ce que la
condition de terminaison soit remplie. La condition de terminaison est testée durant la
dernière instruction de la boucle. L’adresse <addr> de la dernière instruction de la boucle est
directement contenue dans l’instruction.
Si CE est la condition de terminaison, le compteur de boucle CNTR est décrémenté à chaque
exécution de la boucle.
Lorsque l’instruction DO UNTIL est exécutée, l’adresse de la dernière instruction de la
boucle et la condition de terminaison est sauvée dans la pile de boucle (Loop stack). Le
contenu du compteur de programme PC est sauvé dans la pile de programme (PC stack)
après avoir été incrémenté de 1.
Les imbrications de boucle, sous-programmes, interruptions sont possibles dans les limites
des capacités des piles. La pile de boucle (Loop stack) peut contenir 4 niveaux d’imbrications
de boucle et la pile de programme (PC stack) peur contenir 16 niveaux pour les interruptions,
les appels de sous-programme et les boucles. Si une pile est pleine, le bit correspondant du
registre d’état SSTAT passe à « 1 » pour indiquer un dépassement de capacité et aucune
instruction de la boucle ne sera exécutée.

SSTAT : 7 6 5 4 3 2 1 0
LSO LSE SSO SSE CSO CSE PSO PSE
* 0 - - - - * 0
PSE Pile du pointeur de programme vide (PC Stack Empty).

Mise à 1 si la pile est vide suite à une instruction provoquant la lecture de la pile PC
(décrémentation du pointeur de pile PC), sinon mise à 0.
PSO Pile du pointeur de programme en dépassement de capacité (PC Stack Overflow).

Mise à 1 si la pile est en dépassement de capacité suite à une instruction provoquant
l’écriture de la pile du pointeur de programme, sinon mise à 0.
LSE Pile de boucle vide (Loop Stack Empty).
Mise à 1 si la pile est vide suite à une instruction provoquant la lecture de la pile
LOOP (décrémentation du pointeur de pile LOOP), sinon mise à 0.
LSO Pile de boucle en dépassement de capacité (Loop Stack Overflow).
l’écriture de la pile de boucle, sinon mise à 0.
4.8.7 Mise en veille
4.8.7.1 Syntaxe
IDLE ;
IDLE(n) ;
4.8.7.2 Condition sur n

n = 16,32,64 ou 128
4.8.7.3 Description
L’instruction IDLE permet de placer le DSP en mode basse consommation jusqu’à ce qu’une
interruption soit activée. Dans ce cas l’exécution du programme continue avec l’instruction
suivant l’instruction IDLE.
IDLE(n) est un cas particulier de IDLE ou la fréquence des horloges est réduite d’un facteur
n programmable. Cette instruction laisse le processeur fonctionnel mais à une cadence
d’horloge plus faible. Lorsque le mode IDLE(n) est actif, les horloges accessibles à
l’extérieur (SCLK et CLKOUT) ont également des fréquences réduites du facteur n.
Avec IDLE(n), le temps de réponse à une demande d’interruption est augmenté d’un facteur n.
Lors de l’activation d’une interruption, le retour au mode normal (suppression de la réduction
de la fréquence des horloges) prend n cycle de l’horloge CLKIN.
L’utilisation de IDLE(n) peut provoquer un fonctionnement incorrect des ports sériels
SPORT0 et SPORT1. En effet si l’horloge sérielle est externe, cette dernière peut avoir une
fréquence supérieure à la fréquence réduite SCLK et par conséquent une interruption de ces
ports peut ne pas être traitée suffisamment rapidement en raison du temps nécessaire pour
sortie du mode IDLE(n).

4.9 INSTRUCTIONS ADDITIONNELLES
4.9.1 Contrôle des piles (stack)
4.9.1.1 Syntaxe
PUSH
[ STS] [, POP CNTR] [, POP PC] [, POP LOOP] ;
POP
4.9.1.2 Exemple
POP CNTR, POP PC, POP LOOP ;
4.9.1.3 Description
PUSH STS (Push Status Stack) incrémente le pointeur de la pile des registres d’état et de
contrôle par 1 de manière à pointer une position libre et sauve le contenu des registres d’état
ASTAT, du contrôle de mode MSTAT et de masquage des interruptions IMASK.
Cette instruction est réalisée automatiquement lors d’un appel à une routine d’interruption.
POP STS (Pop Status Stack) permet la restitution des registres d’état ASTAT, du contrôle de
mode MSTAT et de masquage des interruptions IMASK, puis la mise à jour du pointeur de
pile par décrémentation de 1.
Cette instruction est réalisée automatiquement lors du retour d’une routine d’interruption
(RTI).
POP CNTR (Pop Counter Stack) permet la restitution du contenu du compteur de boucle
CNTR, puis la mise à jour du pointeur de pile par décrémentation de 1
POP LOOP (Pop Loop Stack) permet la mise à jour du pointeur de pile. Le contenu n’est pas
restitué et donc perdu.
POP PC (Pop PC Stack) permet la mise à jour du pointeur de pile. Le contenu n’est pas
restitué et donc perdu.
Cette instruction est réalisée automatiquement lors du retour d’une routine d’interruption
(RTI) ou d’un sous-programme (RTS) mais dans ce cas le contenu de la pile est restitué.
Plusieurs instructions peuvent être réalisées en un seul cycle d’horloge. Pour cela il suffit de
séparer chaque instruction par une virgule.

SSTAT : 7 6 5 4 3 2 1 0
LSO LSE SSO SSE CSO CSE PSO PSE
- * * * - * - *
PSE Pile du pointeur de programme vide (PC Stack Empty)

Mise à 1 si la pile est vide suite à une instruction provoquant la lecture de la pile PC
(décrémentation du pointeur de pile PC), sinon mise à 0
CSE Pile du compteur de boucle vide (Counter stack empty)
CNTR, (décrémentation du pointeur de pile CNTR), sinon mise à 0

SSE Piles des registres d’état vide (Status Stack Empty)
Lors d’une instruction PUSH STS, ce bit est mis à « 0 ».
des registres d’état, (décrémentation du pointeur de pile STATUS), sinon mise à 0
SSO Piles des registres d’état en dépassement de capacité (Status Stack Overflow)
l’écriture de la pile des registres d’état, sinon mise à 0
LSE Pile de boucle vide (Loop Stack Empty)
LOOP (décrémentation du pointeur de pile LOOP), sinon mise à 0
4.9.2 Lecture et écriture dans la pile du compteur de programme (PC stack)
4.9.2.1 Syntaxe
reg = TOPPCSTACK ;
NOP ;
4.9.2.2 Exemple
AX0 = TOPPCSTACK ; {restitution de la valeur supérieure de la pile dans le registre AX0}
NOP ; {permet une exécution correcte de la restitution}
TOPPCSTACK = I7 ; {sauvetage du contenu du registre I7 dans la pile}

reg
AX0 MX0 SI I0 I4 M0 M4 L0 L4
AX1 MX1 SE I1 I5 M1 M5 L1 L5
AY0 MY0 SR0 I2 I6 M2 M6 L2 L6
AY1 MY1 SR1 I3 I7 M3 M7 L3 L7
AR MR0
MR1
MR
4.9.2.4 Description
Une instruction spéciale de transfert de registre à registre permet de lire (restituer) ou écrire
(sauver) la valeur supérieure de la pile de programme (PC stack).
L’instruction POP PC met à jour le pointeur de pile de programme sans restituer la valeur
pointée. Pour obtenir cette restitution, il faut utiliser l’instruction suivante :
reg = POPPCSTACK ;
NOP ;
Il n’existe pas d’instruction de sauvetage du compteur de programme dans la pile PUSH PC.
Par contre il est possible d’utiliser l’instruction suivante :
TOPPCSTACK = reg ;
TOPOCSTACK ne doit pas être utilisé comme un registre dans des instructions autres que
celles mentionnées ici.
4.9.3 Activation/désactivation des bits du registre de mode de contrôle MSTAT
4.9.3.1 Syntaxe
BIT _ REV
AV _ LATCH
ENA AR _ SAT
SEC _ REG [, ...] ;
DIS G _ MODE
M _ MODE
TIMER
4.9.3.2 Registre de mode de contrôle MSTAT

Bit N° Nom Description
0 SEC_REG Choix d’un des deux banks de registres pour l’ALU, le MAC et
décaleur à barillet. (0 : registre primaires, 1 : registres secondaire).
1 BIT_REV Option d’inversion de bit pour le générateur d’adresse DAG1
(0 : pas d’inversions de bits, 1 : inversions de bits).
2 AV_LATCH Mémorisation du dépassement de capacité sur l’ALU. Le bit
MSTAT[2] (AV) ne peut être remis à « 0 » que par une écriture
directe. (0 : pas de mémorisation, 1 : mémorisation).
3 AR_SAT Permet de limiter le résultat de l’ALU en cas de dépassement de
capacité (positif 0x7FFF, négatif 0x8000). (0 : pas de contrôle de
saturation, 1 : contrôle de saturation).
4 M_MODE Définit si la multiplication se fait sur des nombres entiers ou
fractionnaires (décalage de 1 bit vers la gauche). (0 : décalage de 1
bits, 1 : pas de décalage).
5 TIMER Active la décrémentation du TIMER. (0 : Timer désactivé, 1 :
Timer activé).
6 G_MODE Autorise l’exécution des instructions internes(si possible) lorsque
les bus externes ne sont pas disponibles (Bus Grant). (0 : pas
d’exécution possible, 1 : exécution interne possible).
4.9.3.3 Exemple
DIS AR _ STAT, ENA M _ MODE ;
4.9.3.4 Description
Permet d’activer (ENA) ou de désactiver (DIS) les divers modes de fonctionnement du DSP
définis dans le registre de contrôle de mode MSTAT en forçant les bits désignés à « 1 »,
respectivement à « 0 ».
Plusieurs instructions de ce type peuvent être réalisée en un seul cycle d’horloge, il suffit de
séparer chaque instruction par une virgule.
4.9.4 Modification des pointeurs des générateurs d’adresses DAG
4.9.4.1 Syntaxe
I0 M0
I1 M1
,
I2 M2
I3 M3
MODIFY ( );
I4 M4
I5 M5
,
I6 M6
I7 M7
4.9.4.2 Exemple
MODIFY(I1, M1) ;
4.9.4.3 Description
Cette instruction permet de déterminer l’adresse suivante que doit pointer le contenu du
registre Ix.
La prochaine adresse du pointeur Ix est donnée par la relation :
Prochaine Adresse = ModuloLx {Ix + My − Bx} + Bx
avec Ix : adresse courante du pointeur Ix

My : valeur de modification (signée) du pointeur Ix
B : adresse de base
Lx : longueur du buffer pointé par Ix
M+I : adresse modifiée (adresse suivante)
et la condition My < Lx .Cette condition assure que la prochaine adresse sera comprise
dans le cycle suivant du buffer circulaire. L’adresse de base Bx d’un buffer circulaire x de
n −1
longueur Lx vaut 2n ou un multiple de 2n ou n satisfait la condition 2 < Lx ≤ 2 , soit
n
n
Bx = 2
En d’autres mots, l’adresse de base est L arrondie vers la puissance de 2 supérieure.
En pratique, il n’est pas nécessaire de calculer n. Le Linker place automatiquement les
buffers circulaires aux adresses adéquates.
La sélection des registres Ix et My doit être faites à l’intérieur d’un même générateur
d’adresse DAG1,2. Soit pour le DAG1, x et y sont compris entre 0 et 3 et pour DAG2, x et y
sont compris entre 4 et 7.

4.9.5 Cycle sans instruction
4.9.5.1 Syntaxe
NOP ;
4.9.5.2 Description
Cette instruction ne provoque aucune opération. Sa durée est de un cycle d’horloge.
L’exécution du programme continue avec l’instruction suivant l’instruction NOP.

4.9.6 Activation / désactivation des interruptions
4.9.6.1 Syntaxe
ENA INTS ;
DIS INTS ;
4.9.6.2 Description
Par défaut les interruptions ne sont pas masquées après un RESET.
DIS INTS permet de masquer toutes les interruptions, même l’interruption (non-masquable)
PWD (Power Down), ceci sans changement du registre de masquage des interruptions
IMASK.
ENA INTS permet de démasquer les interruptions selon l’état du registre IMASK.

4.10 EXÉCUTION DE PLUSIEURS INSTRUCTION EN UN CYCLE (MULTIFUNCTION)
4.10.1 Exécution d’une instruction ALU / MAC / SHIFTER

et lecture simultanée en mémoire
4.10.1.1 Syntaxe
I0 M0
I1 M1
,
I2 M2
I3 M3
DM( )
I4 M4
< ALU >
I5 M5
< MAC > , dreg = ,
I6 M6 ;
< SHIFT > I7 M7
I4 M4
I5 M5
PM( , )
I6 M6
I7 M7
4.10.1.2 Exemple
(1) → AR = AX0 + AY0 , AX0 = DM(I0, M0) ; {séquence exécutée de gauche à droite}
(2) → AX0 = DM(I0, M0) , AR = AX0 + AY0 ; {séquence exécutée de droite à gauche}

reg
AX0 MX0 SI
AX1 MX1 SE
AY0 MY0 SR0
AY1 MY1 SR1
AR MR0
MR1
MR
Exécution simultanée d’une instruction arithmétique au moyen de l’ALU, du MAC ou du
décaleur à barillet et d’un transfert de données entre la mémoire de données (DM) ou de
programme (PM) et un registre de données (dreg).
Lorsqu’il y a combinaison entre une opération arithmétique et un transfert de données,
l’adressage du transfert de données doit être indirect avec post-modification. Pour un
adressage indirect linéaire (non circulaire), le registre L correspondant au registre I doit être
mis à « 0 ». Le contenu de la source est toujours justifié à droite dans le registre de
destination
L’opération arithmétique doit être inconditionnelle. Toutes les opérations de L ‘ALU, du

MAC et du décaleur à barillet sont autorisées, exceptés le décalage immédiat et les
instructions de division DIVS et DIVQ.
La séquence fondamentale de déroulement des opérations sur un cycle d’instruction (tCLKOUT)
commence toujours par la lecture des sources en début de cycle et l’écriture dans les
destinations à la fin du même cycle. Il est donc possible d’utiliser le même registre comme
source et comme destination. Dans ce cas le registre fournit une valeur en début de cycle et
est écrit en fin de cycle.
Par exemple
(1) → AR = AX0 + AY0, AX0 = DM(I0, M0);
est une séquence correcte d’écriture d’une séquence d’opération multiple. Par contre
(2) → AX0 = DM(I0, M0) , AR = AX0 + AY0;
provoque un avertissement de l’assembleur, mais l’exécution (2) se déroule exactement

comme la première version (1). Il faut donc bien garder en tête dans quel ordre se fait les
opérations dans un même cycle. La ligne (2), par lecture de gauche à droite laisse penser que
le registre AX0 est chargé avec une donnée de la mémoire DM, puis cette valeur est utilisée
pour réaliser l’instruction d’addition. Or ce n’est pas le cas. Il y a toujours lecture au début du
cycle et écriture en fin de cycle.
L’utilisation du même registre comme destination pour les deux instructions provoque un
résultat indéterminé. Ce type d’écriture ne doit donc pas être utilisé. L’assembleur donne un
simple avertissement alors que le résultat n’est pas contrôlé
(3) AR = AX0 + AY0 , AR = DM(I0, M0); écriture illégale
4.10.1.5.1 <ALU>
ASTAT : 7 6 5 4 3 2 1 0
- - - * * * * *
AC Mise à 1 si il y a une retenue, sinon mise à 0, sinon mise à 0.
AS Est affecté seulement pour l’instruction ABS. Mise à 1 si l’opérande (source) est
négatif.
4.10.1.5.2 <MAC>
ASTAT : 7 6 5 4 3 2 1 0
- * - - - - - -
Il y a dépassement de capacité si les 9 bits de poids forts de MR ne sont pas tous des
0 ou tous des 1.
4.10.1.5.3 <SHIFT>
ASTAT : 7 6 5 4 3 2 1 0
* - - - - - - -
SS Est affecté seulement pour l’instruction EXP.
Contient la valeur logique du bit MSB de l’entrée (extension du signe) si AV=0
Contient l’inverse logique du MSB de l’entrée si AV=1.

et modification simultanée de registre
4.10.2.1 Syntaxe
< ALU >
< MAC > , dreg = reg ;
< SHIFT >
4.10.2.2 Exemple
(1) → AR = AX0 + AY0 , AX0 = MR1 ; {séquence exécutée de gauche à droite}
(2) → AX0 = MR1 , AR = AX0 + AY0 ; {séquence exécutée de droite à gauche}

reg
AX0 MX0 SI
AX1 MX1 SE
AY0 MY0 SR0
AY1 MY1 SR1
AR MR0
MR1
MR
Exécution simultanée d’une instruction arithmétique au moyen de l’ALU, du MAC ou du
décaleur à barillet et d’un transfert de données entre registres de données (dreg).
Le contenu du registre de source est toujours justifié à droite dans le registre de destination
L’opération arithmétique doit être inconditionnelle.
Toutes les opérations de L’ALU, du MAC et du décaleur à barillet sont autorisées, excepté le
décalage immédiat et les instructions de division DIVS et DIVQ.
Par exemple
(1) → AR = AX0 + AY0, AX0 = MR1;
(2) → AX0 = MR1 , AR = AX0 + AY0;

opération dans un même cycle. La ligne (2), par lecture de gauche à droite laisse penser que
le registre AX0 est chargé avec une donnée de MR1, puis cette valeur est utilisée pour
réaliser l’instruction d’addition. Or ce n’est pas le cas. Il y a toujours lecture au début du

cycle et écriture en fin de cycle.
L’utilisation du même registre comme destination pour les deux instructions provoque un
résultat indéterminé. Ce type d’écriture ne doit donc pas être utilisé. L’assembleur donne un
simple avertissement alors que le résultat n’est pas contrôlé
(3) AR = AX0 + AY0 , AR = MR1; écriture illégale
4.10.2.5.1 <ALU>
ASTAT : 7 6 5 4 3 2 1 0
- - - * * * * *
AV Mise à 1 si le résultat arithmétique est en dépassement de capacité, sinon mise à 0..
négatif.
4.10.2.5.2 <MAC>
ASTAT : 7 6 5 4 3 2 1 0
- * - - - - - -
0 ou tous des 1.
4.10.2.5.3 <SHIFT>
ASTAT : 7 6 5 4 3 2 1 0
* - - - - - - -

et écriture simultanée en DM / PM
4.10.3.1 Syntaxe
I0 M0
I1 M1
,
I2 M2
I3 M3
DM( )
I4 M4
< ALU >
I5 M5
,
I6 M6 = dreg , < MAC > ;
I7 M7 < SHIFT >
I4 M4
I5 M5
PM( , )
I6 M6
I7 M7
4.10.3.2 Exemple
(1) → DM(I0, M0) = AR , AR = AX0 + AY0 ; {séquence exécutée de gauche à droite}
(2) → AR = AX0 + AY0 , DM(I0, M0) ; {séquence exécutée de droite à gauche}

reg
AX0 MX0 SI
AX1 MX1 SE
AY0 MY0 SR0
AY1 MY1 SR1
AR MR0
MR1
MR
Exécution simultanée d’un transfert de données entre un registre de données (dreg) et la
mémoire de données (DM) ou de programme (PM) et d’une instruction arithmétique au
moyen de l’ALU, du MAC ou du décaleur à barillet.
Lorsqu’il y a combinaison entre un transfert de données et une opération arithmétique,
destination.
L’opération arithmétique doit être inconditionnel. Toutes les opération de L ‘ALU, du MAC
et du décaleur à barillet sont autorisées, exceptés le décalage immédiat et les instruction de
division DIVS et DIVQ.

Par exemple
(1) → DM(I0, M0) = AR, AR = AX0 + AY0;
(2) → AR = AX0 + AY0, DM(I0, M0) = AR ;
opération dans un même cycle. La ligne (2), par lecture de gauche à droite laisse penser que
le registre AR est chargé avec le résultat d’une opération arithmétique, puis cette valeur
sauvée en mémoire de données (DM). Or ce n’est pas le cas. Il y a toujours lecture au début
du cycle et écriture en fin de cycle.
4.10.3.5.1 <ALU>
ASTAT : 7 6 5 4 3 2 1 0
- - - * * * * *
négatif.
4.10.3.5.2 <MAC>
ASTAT : 7 6 5 4 3 2 1 0
- * - - - - - -
0 ou tous des 1.
4.10.3.5.3 <SHIFT>
ASTAT : 7 6 5 4 3 2 1 0
* - - - - - - -
4.10.4 Lecture simultanée en DM et PM
4.10.4.1 Syntaxe
AX0 I0 M0 AY0 I4 M4
AX1 I1 M1 AY1 I5 M5
= DM( , ), = PM( , )
MX0 I2 M2 MY0 I6 M6
MX1 I3 M3 MY1 I7 M7
Exécution simultanée de deux instructions de lecture en mémoire, l’une en mémoire de
données (DM) et l’autre en mémoire de programme (PM). Chaque opération de lecture
transfert le contenu d’une position mémoire dans un registre de données. Pour que ces
instructions puissent être exécutées simultanément il faut, selon la structure de l’ALU et du
MAC, que le registre de destination de la lecture de la mémoire de données (DM) soit en X et
que le registre de destination de la lecture de la mémoire de programme (PM) soit en Y.
L’adressage du transfert de données doit être indirect avec post-modification. Pour un
destination.
Cette multifonction fait appelle à trois états devant être chargés, soit l’instruction elle-même,
et les deux données. Il n’y a pas de cycle d’horloge supplémentaire pour autant que seul un
de ces trois états se trouve en mémoire externe.
Si deux accès en mémoire externe sont nécessaires, par exemple les données de la mémoire
de programme (PM) et de la mémoire de données (DM) ou l’instruction et une donnée, il y
aura un cycle d’horloge supplémentaire. Si trois accès en mémoires externes sont nécessaires
alors deux cycles d’horloge supplémentaires sont ajoutés.

4.10.5 Exécution d’une instruction ALU / MAC et lecture simultanée en DM et PM
4.10.5.1 Syntaxe
AX0 I0 M0 AY0 I4 M4
< ALU > AX1 I1 M1 AY1 I5 M5
, = DM( , ), = PM( , )
< MAC > MX0 I2 M2 MY0 I6 M6
MX1 I3 M3 MY1 I7 M7
4.10.5.2 Exemple
(1) → MR = MR + MX0 ∗ MY0 (UU) , MX0 = DM(I0, M0) , MY0 = PM(I4, M4) ;
(2) → MX0 = DM(I0, M0) , MY0 = PM(I4, M4) , MR = MR + MX0 ∗ MY0 (UU) ;
Exécution simultanée d’une instruction arithmétique au moyen de l’ALU, ou du MAC et
d’un double transfert de données entre la mémoire de données (DM) et un registre et la
mémoire de programme (PM) et un registre. Pour que ces instructions puissent être exécutées
simultanément il faut, selon la structure de l’ALU et du MAC, que le registre de destination
de la lecture de la mémoire de données (DM) soit en X et que le registre de destination de la
lecture de la mémoire de programme (PM) soit en Y
Lorsqu’il y a combinaison entre une opération arithmétique et un transfert de données,
destination
L’opération arithmétique doit être inconditionnelle. Toutes les opérations de L ‘ALU et du
MAC sont autorisées, excepté les instruction de division DIVS et DIVQ. Le résultat dans les
registres de résultats, soit AR pour une opération avec l’ALU et MR pour une opération avec
le MAC.
Cette multifonction fait appelle à trois états devant être chargés, soit l’instruction elle-même,
et les deux données. Il n’y a pas de cycle d’horloge supplémentaire pour autant que seul un
de ces trois états se trouve en mémoire externe.
Si deux accès en mémoire externe sont nécessaires, par exemple les données de la mémoire
de programme (PM) et de la mémoire de données (DM) ou l’instruction et une donnée, il y
aura un cycle d’horloge supplémentaire. Si trois accès en mémoires externes sont nécessaires
alors deux cycles d’horloge supplémentaires sont ajoutés.
Par exemple
(1) → MR = MR + MX0 ∗ MY0 (UU), MX0 = DM(I0, M0), MY0 = PM(I4, M4) ;
est une séquence correcte d’écriture d’une séquence d’opérations multiples. Par contre
(2) → MX0 = DM(I0, M0), MY0 = PM(I4, M4), MR = MR + MX0 ∗ MY0 (UU) ;

opérations dans un même cycle. La ligne (2), par lecture de gauche à droite laisse penser que
les registres MX0 et MY0 sont chargés avec des valeurs en provenance des mémoires de
données respectivement de programme puis l’opération de multiplication est effectuée. Or ce
n’est pas le cas. Il y a toujours lecture au début du cycle et écriture en fin de cycle.
4.10.5.4.1 <ALU>
ASTAT : 7 6 5 4 3 2 1 0
- - - * * * * *

AV Mise à 1 si le résultat arithmétique est en dépassement de capacité, sinon mise à 0
négatif.
4.10.5.4.2 <MAC>
ASTAT : 7 6 5 4 3 2 1 0
- * - - - - - -

0 ou tous des 1.
ADMC401 : 5. DIRECTIVES ASSEMBLEUR Page 71
5. DIRECTIVES ASSEMBLEUR
5.1 INTRODUCTION
L’assembleur traduit les fonctions écrites en code source dans plusieurs fichiers, lesquels sont
utilisés par un éditeur de lien afin de former un seul fichier exécutable. Les directives
assembleur sont utilisées pour définir la structure du programme en tenant compte de la
définition de macro instructions, de variables, …
Fichier application .dsp Fichiers d'entête files.h, ...

contenant le code source contenant le code source
du langage asembleur du langage asembleur
ASSEMBLEUR
Fichier listing
application.lst
Fichier
d'initialisation
application.int
Fichier objet
application.obj
Fichier de code
application.cde
Figure 5-1 : Fichiers d’entrée / sortie de l’assembleur
La Figure 5-1 montre que l’assembleur utilise les fichiers d’entrées écrits en code source
(*.dsp et *.h) pour générer quatre types de fichiers de sortie, soit
Un fichier objet *.OBJ : contient des informations au sujet des allocations
mémoires et de la définition des symboles. L’allocation
mémoire permet à l’éditeur de lien de définir les adresses
réelles de stockage du programme et des données.
Un fichier code *.CDE : contient les instructions dont une partie des symboles de
sont pas connus (définition dans d’autres programmes
source).
Un fichier listing *.LST : ce fichier (optionnel) donne des informations sur les
valeurs des variables et des buffers définis sous forme
symbolique. Il contient également des indications sur les
erreurs de compilation
Un fichier d’initialisation *.INT : contient des informations sur les valeurs initiales des
variables et des buffers.
Les fichiers *.OBJ, *.CDE, et *.INT sont des fichiers d’entrée pour l’éditeur de lien.
Le bloc assembleur définit à la Figure 5-1 contient trois parties distincts :
− Le préprocesseur pour langage C (C langage preprocessor)
− Le préprocesseur assembleur (Assembler preprocessor)
− Le corps de l’assembleur (Core assembler)
Les deux premiers préprocesseur sont pour le premier un préprocesseur compatible avec le
langage C (ANSI-standard C langage) et pour le second un préprocesseur de l’assembleur
proprement dit. Le préprocesseur C reconnaît les directives d’assembleur telles que #define,
#include, … Le préprocesseur de l’assembleur supporte les directives .MODULE, .VAR, …
La Figure 5-2 illustre le déroulement de l’exécution de l’assembleur.
"ASM21"
PREPROCESSEUR C
PREPROCESSEUR ASSEMBLEUR
CORPS DE L'ASSEMBLEUR
FICHIER *.CDE
FICHIER *.OBJ
FICHIER *.INT
FICHIER *.LST
Figure 5-2 : Déroulement d’un processus d’assemblage
5.2 DIRECTIVES DU PRÉPROCESSEUR C

L’assembleur pour la famille ADSP21xx inclut un préprocesseur C qui permet l’utilisation de
directives telles que #define, #ifdef, #include, …dans le fichier écrit en langage source. Les
directives disponibles, en plus de la définition de macro instructions, sont les suivantes :
Directives : Définition
#include : Insert un texte d’un autre fichier source.
#define : Définition d’une macro.
#undef : Enlève la définition d’une macro.
#if : Insertion conditionnelle de texte.
#ifdef : Insertion conditionnelle de texte. Si le nom de la macro suivant la
directive #ifdef est défini, il y a insertion.
#ifndef : Insertion conditionnelle de texte. Si le nom de la macro suivant la
directive #ifndef n’est pas défini, il y a insertion
#else : Insertion de texte si les tests conditionnels #if, #ifdef, ou #ifndef se sont
avérés faux
#endif : Termine l’insertion conditionnelle d’un texte.
5.2.1 Exemples de directive pour le préprocesseur C
5.2.1.1 Exécution conditionnelle

En lançant l’exécution de l’assembleur (ASM21) avec le paramètre (switch) –d il est possible
de définir une condition permettant de modifier le contenu des fichiers de sortie de
l’assembleur.
Si une portion du code source est définie seulement pour le debugage, il est possible d’insérer
ou non cette partie de code source en fonction de l’existence ou non du paramètre –d.
#ifdef debug /*assemble les lignes suivantes si la variable debug est définie*/
AR=AX0+AY0 ;
…; {code source}
…;
#endif
Commande et paramètre permettant l’exécution de l’assembleur

asm21 nom_du_fichier_source -ddebug
Dans ce cas, la variable debug existe et le préprocesseur C va effacer les deux directives
#ifdef debug et #endif et garder le texte compris entre les deux directives.
Commande et paramètre permettant l’exécution le lancement de l’assembleur
asm21 nom_du_fichier_source
Dans ce cas, la variable debug n’est pas définie et le préprocesseur C va effacer les deux
directives #ifdef debug et #endif et le texte compris entre les deux directives.
Il est également possible de modifier une variable du code source lors de l’exécution de
l’assembleur
.VAR/DM/RAM/CIRC data[n] ; {n : taille du buffer circulaire data}
I5=^data ; {pointeur sur la première position du buffer data}
L5=%data ; {longueur du buffer}

M4=1 ; {post modification du pointeur I5}
CNTR=%data {compteur de boucle initialisé à la longueur de buffer data}
DO loop UNTIL CE
AX0=DM(I5,M4 ) ;
…;
loop : …
Commande et paramètre permettant l’exécution le lancement de l’assembleur
asm21 nom_du_fichier_source –dn=100
Dans ce cas le buffer circulaire data aura une longueur de 100.
5.2.1.2 Définition d’une macro

Il existe plusieurs directives pour définir une macro. L’utilisation de la directive propre au
préprocesseur C est illustrée par les deux exemples suivants :
#define mac MR=MR+MX0*MY0 (RND)
{code source de l’application}
AR=AX1-AY1 ;
MY0=AR ;
MX0=DM(I1,M1) ;
mac ; {exécution de la macro définie en première ligne}
Il est également possible de passer des paramètres dans la macro
#define copy(src,dest) \
AX0=DM(src) ; \
PM(dest)=AX0 ;
Le caractère \ (backslash) indique que la définition de la macro continue à la ligne suivante.
La macro ainsi définie permet d’écrire le code source suivant :
copy(0x3F,0x0C) ; {copie le contenu de l’adresse 0x3F de la mémoire DM
à l’adresse 0x0C de la mémoire programme}
5.2.1.3 Insertion de fichiers « include » (*.h) dans les fichiers *.dsp

Cet exemple montre qu’il est possible d’inclure des macros seulement si elles n’ont pas déjà
été définies auparavant. La première directive #ifndef ADC_INCLUDED permettra d’insérer le
code qui suit seulement si les macro qui suivent n’ont pas encore été définies. La deuxième
directive #define ADC_INCLUDED permettra de définir la variable ADC_INCLUDED et d’insérer les
macros qui suivent.
#ifndef ADC_INCLUDED
#define ADC_INCLUDED
{*******************************************************
* lecture d’un registre ADC de conversion *
********************************************************}
.MACRO ADC_Read(%0,%1);
ar = DM(%0);
ay0 = DM(%1);
CALL ADC_Scale_; { Scale conversion to -1 to +1 format}
.ENDMACRO;
{*******************************************************
* initialisation du convertisseur AD *
********************************************************}
.MACRO ADC_INIT;
call ADC_INIT_;
.ENDMACRO;
#endif
5.2.2 Commentaires pour le préprocesseur C

Les commentaires placés sur une ligne de commande commençant par le caractère # doivent
être placés entre les caractères /* et */.
#directive /* commentaire */
5.3 DIRECTIVES DU PRÉPROCESSEUR DE L’ASSEMBLEUR

Les directives du préprocesseurs de l’assembleur commencent par un point (.) et finissent par
un point virgule ( ;). Certaines directives utilisent des attributs et des arguments. La directive
et les attributs sont séparés par le caractère slash (/). La forme générale d’une directive est la
suivante :
.DIRECTIVE/attribut/attribut/… argument ; {commentaire}
Le commentaire ne peut pas continuer sur la ligne suivante. Si la ligne est insuffisante pour le
commentaire, il faut impérativement ouvrir une nouvelle accolade à la ligne suivante.
Directives Définition
.MODULE : Définit le début d’un programme. Un fichier source (*.dsp) ne peut
contenir qu’une seule directive .MODULE.
.ENDMOD : Définit la fin d’un programme initié par la directive .MODULE.
.VAR : Définit un ensemble de positions mémoire.
.INCLUDE : Insert un fichier d’entête dans un fichier source.
.MACRO : Définit le début d’une macro.
.ENDMACRO : Définit la fin d’une macro.
.LOCAL : Utilisé dans une macro contenant une étiquette afin de créer une étiquette
différente pour chaque appel de la macro.
.GLOBAL : Permet à des variables et des buffers d’être reconnus hors du module
dans lesquels ils ont été crées.
.ENTRY : Permet à des étiquettes d’être reconnues hors du module dans lesquelles
elles ont été créées.
.EXTERNAL : Permet l’utilisation de variables, buffers ou étiquettes définies hors du
module en question.
.CONST : Définition d’une constante sous la forme d’un nombre.
.INT : Permet d’initialiser des variables de 16 bits.
.INT24 : Permet d’initialiser des variables de 24 bits.
Quelques directives sont associées aux format du fichier optionnel *.LST.
.NEWPAGE : Insertion d’un saut de page lors de l’impression.
.PAGELENGTH lines : Insertion d’un saut de page après un nombre de lignes défini.
.LEFTMARGIN columns : Retrait de la marge de gauche en nombre de colonnes.
.INDENT columns : Retrait du code source en nombre de colonnes.
.PAGEWIDTH columns : Largueur de la page ou insertion d’une marge à droite.
5.3.1 Directives de module de programme .MODULE

La directive .MODULE marque le début d’un module de programme et définit son nom. La
directive .ENDMOD marque la fin du module. Un fichier écrit en code source ne peut
contenir qu’une seule directive .MODULE. La directive .MODULE s’écrit sous la forme
.MODULE/condition/condition/… nom_du_module ;
Les attributs liés à la directive .MODULE sont les suivantes :

RAM ou ROM : Type de mémoire.
ABS=adresse : Adresse absolue de départ du module. Dans ce cas il n’y a pas de
déplacement possible (relocation). Ceci signifie que l’éditeur de lien
(linker) doit réserver de la place pour le module à partir d’adresse. Ne
doit pas être utilisé avec l’attribut STATIC.
SEG=nom du segment : Utilise la déclaration des segments de mémoire définie dans le fichier
d’architecture. Ce dernier dépend de l’implantation hardware des
mémoires (plan mémoire). L’éditeur de lien (linker) place le module
de programme dans le segment cité.
BOOT=0…7 : L’attribut BOOT est utilisé pour placer une copie du module dans une
ou plusieurs pages comprises en 0 et 7. Le module est stocké dans la
mémoire de boot jusqu’à son chargement dans la RAM et son
exécution. Une copie du module dans plusieurs page s’écrit
.MODULE/BOOT=0/BOOT=1/BOOT=5 ;
STATIC : Permet d’empêcher une surécriture lors de chargement des pages de
boot
Par défaut, c’est à dire sans mention d’attribut, le type de mémoire RAM est sélectionné.
5.3.1.1 Exemple : Déclaration d’un module dans un segment de mémoire défini

La directive suivante permet de placer un module le programme déclaré à une adresse
absolue définie
.MODULE/SEG=pmuser1 nom_du_module ;
pmuser1 correspond à un segment définit dans le fichier d’architecture *.ach. Si plusieurs
modules sont définit dans le même segment, l’éditeur de ligne (linker) placera les modules à
la suite les uns des autres avec pour seule exigence que qu’ils soient tous dans le segment
cité.
5.3.1.2 Exemple : Déclaration d’un module dans à une adresse absolue définie
La directive suivante permet de placer le début d’un module le programme à une adresse
absolue bien définie
.MODULE/RAM/ABS=0x0040 nom_du_module ;
Dans ce cas l’adresse de départ du module sera l’adresse absolue hexadécimale 0x0040.
5.3.2 Module chargé à partir de la mémoire de boot (ROM)
Lors du choix des attributs RAM, ROM, SEG et ABS pour les modules amorçables
(bootable), ceci implique que le code est se trouve dans la mémoire utilisée pour l’exécution
du programme et non pas dans la mémoire d’amorçage (Boot Memory). Ainsi lors de la
configuration de la mémoire à partir de laquelle le programme sera exécuté, il faut penser
mémoire de programme (PM) et mémoire de données (DM).
L’éditeur de lien (linker) détermine ou le code et les données seront placés dans la mémoire
de données (DM) et la mémoire de programme (PM) en accord avec les déclarations de
segment dans le fichier d’architecture *.ach et les attributs définis dans la directive
.MODULE du préprocesseur de l’assembleur. L’éditeur de lien définit également la structure
des pages de boot, il n’est donc pas possible pour le programmateur de spécifier ou le module
sera placé dans la mémoire de boot (BM).
Il faut également savoir que le programme ne peut être exécuté depuis la mémoire de boot
(BM). Une page complète de la mémoire de boot (BM) doit d’abord être chargée dans les
mémoires de programme (PM) et de données (DM) avant que le code puisse être exécuté.
Si un module spécifique doit se trouver en mémoire RAM interne ou externe durant
l’exécution d’une page particulière n, il faut avoir défini l’attribut BOOT avec le numéro de
la page n en question de manière à ce que l’éditeur de lien puisse réserver de la place
mémoire pour le module dans le cadre réservé à l’exécution de la page n.
L’éditeur de lien génère un fichier *.MAP montrant la disposition du programme en mémoire
de boot (BM) ainsi que la plan mémoire correspondant du code dans la mémoire d’exécution
(mémoire PM et DM, interne ou externe).
On cite ici deux exemples
.MODULE/RAM/PM/ABS=0x0060/BOOT=0/BOOT3 nom_du_programme ;
Dans ce cas le code du module nom_de_programme, placé en page 0 et en page 3 est

transféré dans la mémoire de programme (PM) à l’adresse de début 0x0060 lors de la
commande de boot des pages 0 et 3 (voir le registre de contrôle SYSCNTL[BFORCE,
BPAGE]).
5.3.3 Module défini avec l’attribut STATIC

Si le code d’un module doit être utilisé dans plusieurs pages de boot, comme par exemple un
sous programme, il est possible de garder en mémoire RAM le code en question lors du
chargement d’une nouvelle page en utilisant l’attribut STATIC.
L’attribut STATIC empêche l’écriture par-dessus un module déjà en mémoire RAM lors du
chargement d’une nouvelle page. C’est l’éditeur de lien qui assure cette fonction en
choisissant l’emplacement des divers modules définis dans les pages 0 à 7. Si un module ne
possède pas l’attribut STATIC, il peut être partiellement ou complètement éliminer par
l’écriture du code des pages de boot chargées subséquentes.
Lorsque l’éditeur de lien alloue les emplacements mémoires pour le stockage d’une
application, il considère 9 entités de code exécutables en mémoire RAM. La première
correspond à une application non chargée par une commande de boot, les 8 suivantes n’étant
rien d’autre que les 8 pages de boot (pages 0 à 7). On peut imaginé que la première entité
correspond à un chargement d’une application par la mémoire sérielle SPROM, application
qui commande le chargement d’une page en mémoire de boot (BM).
Si un module est utilisé par plusieurs entités, il existe deus solutions. La première consiste à
donner plusieurs attributs de pages au module, la seconde consiste en l’utilisation de l’attribut
STATIC.
La Figure 5-3 illustre le cas d’une surécriture lors du chargement d’une nouvelle page en
mémoire RAM. Le programme routine_0 a été chargé en RAM lors du chargement de la
page 0. Une commande force le chargement de la page 1 de la mémoire de boot (BM). Selon
les attributs lors de la déclaration des modules, il y a écriture du buffer coeff_1[16] par-dessus
le programme routine_0
En page 0 :
.MODULE/RAM/BOOT=0/SEG=pm_ext routine_0 {pm_ext est défini dans le fichier d’architecture} ;
En page 1 :
.MODULE/RAM/BOOT=1 routine_1 {pm_ext est défini dans le fichier d’architecture} ;
.VAR/RAM/PM/SEG=pm_ext coeff_1[16] {buffer déclaré en mémoire PM dans le segment pm_ext}
Boot page 1
ROM
Coeff_1[16]
ADSP -21xx routine_1 2k
Mémoire de programme
interne RAM Mémoire de programme
externe RAM
re
cr itu
s ur é routine_0
2k Coeff_1[16]
routine_1
pm_ext
Figure 5-3 : Surécriture lors du chargement d’une page de la mémoire de boot
Pour éviter cette surécriture, il faut utiliser l’attribut STATIC dans la directive du module du
programme routine_0
En page 0 :
.MODULE/RAM/BOOT=0/STATIC/SEG=pm_ext routine_0 {pm_ext est défini dans le fichier d’architecture} ;
En page 1 :
.MODULE/RAM/BOOT=1 routine_1 {pm_ext est défini dans le fichier d’architecture} ;
.VAR/RAM/PM/SEG=pm_ext coeff_1[16] {buffer déclaré en mémoire PM dans le segment pm_ext}
Boot page 1
ROM
Coeff_1[16]
ADSP -21xx routine_1 2k
Mémoire de programme
interne RAM Mémoire de programme
externe RAM
zone interdite
routine_0
d'écriture
2k
Coeff_1[16]
pm_ext
routine_1
Figure 5-4 : Chargement d’une page de la mémoire de boot avec préservation d’un module en RAM
5.3.4 Directives des variables et des buffers .VAR

La directive .VAR est utilisée pour déclarer des variables et des buffers. Une variable
correspond à une position mémoire alors qu’un buffer est un ensemble de position mémoire.
Il est nécessaire de déclarer toutes les variables et tous les buffers avant de les utiliser dans le
code. Si les variables ou les buffers sont initialisés avec la directive .INIT, les deux
déclarations doivent être faites dans le même module. La directive .VAR s’écrit sous la forme
.VAR/attribut/attribut/… nom_du_buffer[longueur], nom_de_la_variable… ;
Les attributs liés à la directive .VAR sont les suivantes :
PM ou DM : Emplacement en mémoire de programme (PM) ou en mémoire
de données (DM).
RAM ou ROM : Type de mémoire.
ABS=adresse : Adresse absolue de la première variable ou buffer déclaré. Dans
ce cas il n’y a pas de déplacement possible (relocation). Cela
signifie que l’éditeur de lien (linker) doit réserver de la place
mémoire pour la liste de variables et de buffer à partir
d’adresse. Ne doit pas être utilisé avec l’attribut STATIC.
SEG=nom du segment : Utilise la déclaration des segments de mémoire définie dans le
fichier d’architecture. Ce dernier dépend de l’implantation
hardware des mémoires (plan mémoire). L’éditeur de lien
(linker) place les variables et les buffers dans le segment cité
CIRC : Permet de définir des buffers circulaires et par conséquent le
calcul de l’adresse de base.
STATIC : Permet d’empêcher une surécriture lors de chargement des
pages de boot.
Par défaut, c’est à dire sans mention d’attribut, la variable ou le buffer seront placés (avec
possibilité d’être déplacé : relocatable) en mémoire RAM de données (DM). Plusieurs
variables et buffers peuvent être définis sur la même ligne, la seule limite est le nombre
maximum de caractères, fixé à 200.
Lors d’une déclaration multiple sur une même ligne, les variables et les buffers sont placés de
manière continue dans la mémoire. Dans ce cas, si l’attribut CIRC est ajouté, un seul buffer
circulaire est crée.
5.3.4.1 Exemple :Déclaration d’une variable à un emplacement donné

Déclaration d’une variable en mémoire RAM de données (DM) à un emplacement définit
(pas de possibilité de déplacement par l’éditeur de lien (linker).
.VAR/DM/RAM/ABS=0x000A theta ;
5.3.4.2 Exemple :Déclaration d’un buffer linéaire à un emplacement donné

Déclaration d’un buffer linéaire coefficients de 10 positions en mémoire RAM de programme
(PM) à un emplacement correspondant au segment pmdata (segment de données dans la
mémoire de programme). L’emplacement peut être modifié par l’éditeur de lien (linker) mais
le buffer doit rester dans le segment pmdata.
.VAR/DM/RAM/SEG=pmdata coefficients[10] ;
ou encore
.CONST longueur=10
.VAR/DM/RAM/SEG=pmdata coefficients[longueur] ;
5.3.4.3 Déclaration d’un buffer circulaire

L’adresse de base des buffers circulaires doit répondre à certaines exigences pour les DSP de
la famille ADSP21xx. En principe l’adresse de base doit correspondre à un multiple de 2n où
n représente le nombre de bit pour nécessaire pour définit la longueur du buffer (si longueur
=12, n=4). C’est l’éditeur de lien (linker) qui calcule l’adresse de base. Si l’attribut ABS est
utilisé, c’est au programmateur de faire ce calcul.
Dans ce cas, l’exemple suivant permet de comprendre les contraintes sur l’attribut CIRC.
Soit un buffer circulaire de 5 positions
.VAR/CIRC aa[5] ; {par défaut on a .VAR/DM/RAM/…}
La longueur du buffer est de 5 et donc la valeur de n=3. Dans ce cas les adresses de bases
valides doivent être un multiple de 8. On peut donc écrire
.VAR/CIRC/SEG=0x…8 aa[5] {ou SEG=0x…0}
5.3.4.4 Déclaration d’un ensemble de buffers circulaires

Si plusieurs buffers circulaires doivent être déclarés, deux cas peuvent se présenter
xxxx0000 aa xxxxx000 aa
xxxx0001 xxxxx001
xxxx0010 xxxxx010
xxxx0011 xxxxx011
xxxx0100 xxxxx100
xxxx0101 bb
xxxx0110
xxxx0111 bb
xxxxx000
xxxx1000
xxxxx001
xxxx1001
xxxxx010
xxxx1010 cc xxxxx011
xxxx1011 xxxxx100
xxxx1100
xxxx1101
xxxx1110
xxxxx000 cc
xxxxx001
xxxxx010
xxxxx011
xxxxx100
(a) déclaration sur une ligne (b) déclaration sur plusieurs lignes
Figure 5-5 : Buffers circulaires
− Déclaration des buffers sur une seule ligne

.VAR/CIR aa[5], bb[5], cc[5] ;
Dans ce cas, la déclaration correspond à un seul buffer circulaire dont la longueur est la
somme des buffers déclarés sur la ligne, soit 15. L’adresse de base est donc définie
pour n=4. L’adresse de base vaut donc 0x….0000
− Déclaration des buffers sur des lignes séparées
.VAR/CIR aa[5] ;
.VAR/CIR bb[5] ;
.VAR/CIR cc[5] ;
Dans ce cas, chaque buffer circulaire aura une adresse de base. Comme chaque buffer à
une longueur de 5, n=3 et par conséquent les adresses de base valent 0x….000
L’exemple suivant montre une application de deux lookup tables (buffers) définissant un sinus et
un cosinus.
.VAR/CIRC sin[256], cos[768] ; {déclaration sur une ligne donc un seul buffer circulaire}
La longueur du buffer circulaire est de 1024, donc n=10 et par conséquent l’adresse de bas B vaut
0x…0000000000.
Dans l’application, les pointeurs des buffers sont définit comme :
I0=^cos ; L0=%sin+%cos ; {L0=1024}
I1=^sin ; L1=%sin+%cos ; {L1=1024}
cos[xcos]
sin[xsin] Buffer circulaire sin[I1]
Origine sin
Buffer circulaire cos[I0]

Origine cos
xsin=[0...255] xcos=[0...768]
Adresse de base B
Figure 5-6 : Exemple de buffers circulaires trigonométriques
5.3.5 Directives d’initialisation des variables et des buffers .INIT

La directive .INIT permet d’initialiser une variable ou un buffer en ROM. Les valeurs
initiales sont transférées de la RAM en ROM durant la phase d’amorçage (boot).
La directive .INIT peut prendre les formes suivantes :
.INIT nom_du_buffer : constant_1, constante_2, …
.INIT nom_du_buffer[offset] constant_1, constante_2, …
.INIT nom_du_buffer : ^buffer
.INIT nom_du_buffer : %buffer
.INIT nom_du_buffer : <Disk\directoire\filename>
Pour les deux premières lignes, l’initialisation du buffer se fait à partir de l’adresse de base
nom_du_buffer ou de l’adresse de base plus un offset nom_du_buffer[offset].
Les opérateurs ^ et % sont utilisés pour initialiser un buffer avec l’adresse de base ou la
longueur d’un autre buffer.
5.3.6 Directive d’insertion d’autres fichier source .INCLUDE

La directive .INCLUDE est utilisée pour insérer un fichier source à l’emplacement de la
déclaration de la directive. L’assembleur ouvre lit et assemble le fichier mentionné. Le code
est insérer dans le fichier *.OBJ de sortie. Lorsque l’assembleur atteint la fin du fichier à
insérer, il retourne dans le fichier source original et continue de processus d’assemblage. La
directive .INCLUDE s’écrit sous la forme
.INCLUDE <Disk:\directoire\…\nom_du_fichier>
Si le fichier se trouve dans les directoires par défaut créés lors de l’installation des outils
d’Analog Devices, les directoires racines n’ont pas besoin d’être précisés.
L’insertion d’un fichier avec la directive .INCLUDE n’est pas utilisable si le fichier inséré
contient des directives du préprocesseur C. Dans ce cas on utilise la directive #include au lieu
de .INCLUDE.
Cette directive permet de créer des librairies de sous-routines et de macros génériques

(routine et macro de base utilisable par différents programmes d’applications).
Exemple
.INCLUDE <macro_lib> ;
5.3.7 Directives concernant la définition de macro .MACRO

Les macros sont définies par une directive de début .MACRO et une directive de fin
.ENDMACRO. Les macro permettent de simplifier l’écriture d’un groupe d’instruction.
Contrairement à une sous-routine, la référence à une macro dans un programme permet
d’insérer les instructions de cette dernière, il n’y a donc pas de gain de place.
.MACRO nom_de_la_macro(%0, %1)
AR=%1;
DM(%0)=AR;
.ENDMACRO
Les arguments optionnels %n (n=0,1,…9) permettent le passage de paramètres dans la
macro. Les arguments apparaissant dans la macro sont donc remplacés par les paramètres de
passage.
Le passage de paramètre doit répondre à un certain nombre d’exigences.
Paramètre → Argument Non autorisé
Constante et expression -
symbole Peut être un mot réservé sauf
MACRO, ENDMACRO, CONST, INCLUDE
^symbole ^%n n’est pas autorisé
%buffer %%n n’est pas autorisé
Les arguments %%n et ^%n ne sont pas autorisés dans les macros, par contre le passage de
paramètres peut se faire sous la forme
nom_de_la_macro(^input)
5.3.8 Directive concernant les étiquettes dans les macro .LOCAL

La directive .LOCAL permet l’utilisation d’étiquette dans la macro. Cette caractéristique est
importante pour éviter des erreurs lors d’utilisation multiple de la même macro.
.LOCAL macro_étiquette, … ;
L’exemple suivant illustre une macro avec passage de paramètres et étiquettes.
{Déclaration de la macro}
.MACRO transfert_memoire(%0, %1, %2, %3, %4) ; {passage de 5 arguments}
.LOCAL transf
I4=%0 ; {initialise I4 à l’adresse de départ du buffer source}
I5=%1 ; { initialise I5 à l’adresse de départ du buffer destination}
M4=1 ; {valeur d’incrémentation des pointeurs I4 et I5}
CNTR=%2 ; {définit la longueur des buffers}
DO transf UNTIL CE ; {boucle de transfert}
SI=%3(I4,M4) ; {transfert depuis la mémoire de type %3}
transf : %4(I5,M4)=SI ; {transfert dans la mémoire de type %4}
.ENDMACRO ;
{Appel de la macro}
transfert_memoire(^buffer_in, ^buffer_out, long_buffer, PM, DM)
5.3.9 Directive de déclaration globale de variables et buffers .GLOBAL

Lors de la déclaration de variables et / ou de buffers à l’intérieur d’un module (définit par les
directives .MODULE et .ENDMOD), il est possible de rendre ces derniers accessibles à
d’autres modules en utilisant la directive .GLOBAL. Cette directive à la forme :
.GLOBAL symbole-interne, …
L’exemple suivant illustre l’utilisation de la directive .GLOBAL
.VAR/PM/RAM coeffs[10] ;
.GLOBAL coeffs ; {rend le buffer coeffs visible à l’extérieur du module}
5.3.10 Directive de déclaration globale d’étiquettes de programme .ENTRY

La directive .ENTRY permet de rendre les étiquettes du module visible par d’autres
modules. Cette caractéristique permet les appels de sous programmes (CALL) ou les sauts
(JUMP) d’un module à un autre. Cette directive à la forme :
.ENTRY etiquette_de_programme, … ;
L’exemple suivant illustre l’utilisation de la directive .ENTRY
.ENTRY ADC_Scale_; {rend l’étiquette ADC_Scale_ visible à l’extérieur}
ADC_Scale_: ENA AR_SAT;
AR = AR - AY0;
DIS AR_SAT;
RTS;
5.3.11 Directive de déclaration externe de variables, de buffers et d’étiquettes .EXTERNAL

La directive .EXTERNAL permet de référencer des variables, des buffers et des étiquettes
utilisés dans un module et définit dans d’autres modules. Les variables et les buffers en
question doivent avoir été définis par la directive .GLOBAL et les étiquettes par la directive
.ENTRY dans les modules où ils ont été crées. Cette directive à la forme :
.EXTERNAL etiquette_de_programme, … ;
L’exemple suivant illustre l’utilisation de la directive .EXTERNAL

.EXTERNAL ADC_Scale ; {indique que l’étiquette est définie dans un autre module}
CALL ADC_Scale
5.3.12 Directive de déclaration de constante .CONST

La directive .CONST permet d’assigner un nom à un nombre, ce qui permet de rendre la
lecture du programme plus aisée. Cette directive à la forme :
.CONST nom_de_la_constante=nombre ou expression ;, … ;
L’exemple suivant illustre l’utilisation de la directive .CONST

.CONST tension=0x3AF2, courant=0x2D56 ; {assigne un nombre aux constantes tension et courant}
ADMC401 : 6. ARCHITECTURE MEMOIRE Page 85
6. CONSTRUCTION DE L’ARCHITECTURE MÉMOIRE (SYSTEM BUILDER)
6.1 INTRODUCTION
« System builder » est un outil software permettant de traduire la description de l’architecture
du hardware en information utilisable par l’éditeur de lien (linker)
Fichier de spécification du système

Cible.sys
SYSTEM BUILDER
Fichier de description de l'architecture

Cible.ach
Figure 6-1 : Fichiers d’entrée / sortie pour la construction de l’architecture
Le fichier source d’entrée (Cible.sys) doit être une description du plan d’adressage des
mémoires des périphériques propres à une application particulière. Le fichier de sortie est
utilisé par l’éditeur de lien pour l’implantation du programme d’application dans les
différents segments de mémoires de données (DM) et de programme (PM). Il est également
possible de définir les zones dédicacées à la mémoire de boot (BM).
6.2 DIRECTIVE DU « SYSTEM BUILDER »

Les directives du « system builder » commence par un point (.) et f finissent par un point
virgule ( ;). Certaines directives utilisent des attributs et des arguments. La directive et les
attributs sont séparés par le caractère slash (/). La forme générale d’une directive est la
suivante :
.DIRECTIVE/attribut/attribut/… argument ; {commentaire}
Le commentaire ne peut pas continuer sur la ligne suivante. Si la ligne est insuffisante pour le
commentaire, il faut impérativement ouvrir une nouvelle accolade à la ligne suivante.
Directives Définition
.SYSTEM : Définit le début de fichier source de spécifications du système.
.ENDSYS : Définit la fin de fichier source de spécifications du système.
.ADSP21xx : Cette directive permet l’identification du DSP de la famille ADSP21xx.
.MMAP : Cette directive spécifie l’état de la broche MMAP du système cible.
.SEG : Définit un segment de la mémoire de programme(PM) de données (DM)
ou de boot (BM).
6.2.1 Directive principale du ficher de description :SYSTEM

La directive .SYSTEM doit être la première déclaration du fichier source de description de
l’architecture. La directive .MODULE s’écrit sous la forme
.SYSTEM nom_du_système ;
La dernière déclaration du fichier source de description de l’architecture correspond à la

directive .ENDSYS.
6.2.2 Directive d’identification .ADSP21xx

Cette directive permet d’identifier le type de DSP utilisé. Ce DSP faisant partie de la famille
ADSP21xx. Dans le cas de l’ADMC401, on utilise la directive .ADSP2101 en lieu et place
de ADSP2171. Il est alors nécessaire de modifier le fichier de sortie en remplaçant
.ADSP2101 par ADSP2171.
6.2.3 Directive du plan mémoire .MMAP

Cette directive définit pour quel état de la broche MMAP ,l’architecture est valable. La
directive .MMAP s’écrit sous la forme :
.MMAP0 ;
.MMAP1 ;
Si .MMAP0 est utilisé, il y a chargement de la mémoire de boot après un RESET. Le

programme démarre à l’adresse 0x0000.
Si .MMAP1 est utilisé, il n’y pas de phase de chargement.
6.2.4 Directive de déclaration des segments de mémoire .SEG

La directive .SEG définit un segment spécifique de la mémoire du système décrit par ces
attributs. Il n’y a pas de plan mémoire par défaut, par conséquent chaque segment de la
mémoire doit être défini. C’est l’information la plus importante qui est passée à l’éditeur de
lien. La directive .SEG prend la forme suivante :
.SEG/condition/condition/… nom_du_segment[longueur_du_segment] ;
A chaque segment est assigné un nom. Ce nom peut être directement repris lors des
déclarations de directives assembleur .MODULE ou .VAR. La longueur du segment est
définie entre crochet (bracket). La longueur est définie comme un nombre de données (16
bits pour la mémoire de données (DM)) ou d’instruction (24bits pour la mémoire de
programme (PM)).
Les deux attributs suivants doivent accompagnés la directive .SEG :
PM ou DM ou BOOT=0 … 7 : allocation mémoire
RAM ou ROM : type de mémoire
Les attributs suivants sont optionnels :
ABS=adresse : adresse initiale du segment
DATA ou CODE ou DATA/CODE : type de valeur à stocker dans le segment considéré
Les segments de mémoire déclarés avec l’attribut PM peuvent stocker des données (DATA),
des instructions (CODE) ou des deux (DATA/CODE).
Les segments de mémoire déclarés avec l’attribut DM ne peuvent stocker que des données
(DATA).
Les segments de mémoire déclarés avec l’attribut BOOT sont par défaut des segments des
données et des instructions (DATA/CODE).
Les attributs BOOT doivent être référencés à une page par segment.
6.2.4.1 Exemple de déclaration d’un segment

Exemple 1 : déclaration d’un segment de mémoire de programme
.SEG/PM/RAM/ABS=0/CODE/DATA restart[2048] ;
Il s’agit ici d’une déclaration d’un segment de mémoire de programme (PM) dont l’adresse
de départ est 0x0000 et la longueur de 2048 mots de 24 bits.
Exemple 2 : déclaration d’un segment de mémoire de boot
.SEG/ROM/BOOT=0 boot_mem[1536] ;
Il s’agit ici d’une déclaration d’un segment de mémoire de boot situé dans la page 0 dont la
longueur est de 1536 mots de 8 bits.
6.3 FICHIER DE DESCRIPTION D’ARCHITECTURE DU KIT D’ÉVALUATION DE L’ADMC401

L’architecture du KIT d’évaluation de l’ADMC401 est définit par le plan mémoire illustré
par la Figure 6-2 pour MMAP=0 et BMODE=0, et ROMENABLE=1 c’est-à-dire lors de
l’utilisation du debugger.
0x0000 0x0000
VECTOR TABLE
0x005F
0x0060 EXTERNAL MEMORY 8Kx16
INTERNAL RAM 2Kx24
(Booted from
0x1FFF
SPORT1) 0x2000
0x07FF
0x0800 INTERNAL ROM PERIPHERAL REGISTERS 1Kx16
(ROMEENABLE 0x23FF
0x2400
defaults to 1 2Kx24
0x0FEF during RESET) EXTERNAL MEMORY 5Kx16
0x0FF0
RESERVED 0x37FF
0x0FFF 0x3800
0x1000
INTERNAL USER RAM
0x3B5 F 1Kx16
0x3B6 0
RESERVED BY MONITOR
EXTERNAL RAM 12Kx24 0x3BFF
0x3C0 0
RESERVED BY DSP CORE

0x3FEE 1Kx16
0x3FEF
DSP CORE REGISTERS

0x3FFF 0x3FFF
24 Bits wide 16 Bits wide

(a) Plan de la mémoire de programme (PM) (b) Plan de la mémoire de données (DM)
Figure 6-2 : Plan mémoire pour le KIT d’évaluation
La Figure 6-3 montre le contenu du fichier source de description de l’architecture de la

mémoire ainsi que sa traduction par le « System Builder »
SYSTEM ADMC401; ADMC401
$ADSP2171
.ADSP2101; $MMAP0
.MMAP0; $0000 005F paxVECTOR t
$0060 07FF paxUSER_PM1 t
{ User Program Memory Area } $1000 3FFF paxUSER_PM2 t
.SEG/PM/RAM/ABS=0x0000/CODE/DATA VECTOR[96]; $0800 0FFF pomROMCODE t
.SEG/PM/RAM/ABS=0x0060/CODE/DATA USER_PM1[1952]; $0000 1FFF dadUSER_DM1 t
$3800 3B5F dadUSER_DM3 t
{ Rom Code Program Memory Area } $3B60 3BFF dadROMDATA t
.SEG/PM/ROM/ABS=0x0800/CODE ROMCODE[2048]; $
{ User Data Memory Area }

.SEG/DM/RAM/ABS=0x0000/DATA USER_DM1[8192]; Remarques :
.SEG/DM/RAM/ABS=0x2400/DATA USER_DM2[5120];
.SEG/DM/RAM/ABS=0x3800/DATA USER_DM3[864]; pax : Program memory rAm data or code
.SEG/DM/RAM/ABS=0x3B60/DATA ROMDATA[160]; dad : Data memory rAm Data
pom : Program memory rOm
.ENDSYS;
(a) Description de l’architecture ADMC401.sys (b) Fichier d’architecture ADMC401.ach
Figure 6-3 : Plan mémoire pour le Kit d’évaluation
6.4 FICHIER DE DESCRIPTION D’ARCHITECTURE DE LA CARTE CHPSE

L’architecture de la carte DSP nommée CHPSE est définit par le plan mémoire illustré par la
Figure 6-4 pour MMAP=0 et BMODE=0, et ROMENABLE=1 c’est-à-dire lors de
l’utilisation du debugger
0x0000 0x0000
VECTOR TABLE
0x005F EXTERNAL MEMORY
0x0060 8Kx16
INTERNAL RAM 2Kx24
0x1FFF
0x2000
(Booted from
SPORT1) PERIPHERAL REGISTERS 1Kx16
0x07FF 0x23FF
0x0800 0x2400
INTERNAL ROM
(ROMEENABLE DUAL PORT RAM
defaults to 1 2Kx24 0x2BFF
0x2C00 5Kx16
0x0FEF during RESET)
EXTERNAL UART
0x0FF0 0x2C07
RESERVED 0x2C08
0x0FFF
0x1000 EXTERNAL MEMORY
0x37FF
0x3800
INTERNAL USER RAM
0x3B5F 1Kx16
0x3B60
EXTERNAL RAM 12Kx24 RESERVED BY MONITOR
0x3BFF
0x3C00
RESERVED BY DSP CORE
0x3FEE 1Kx16
0x3FEF
DSP CORE REGISTERS
0x3FFF
0x3FFF
16 Bits wide
24 Bits wide
(a) Plan de la mémoire de programme (PM) (b) Plan de la mémoire de données (DM)
Figure 6-4 : Plan mémoire pour la carte CHPSE
La Figure 6-5 montre le contenu du fichier source de description de l’architecture de la

mémoire ainsi que sa traduction par le « System Builder »
SYSTEM ADMC401; $ADMC401

$ADSP2171
.ADSP2101; $0000 005F paxVECTOR t
.MMAP0; $0060 07FF paxUSER_PM1 t
$1000 3FFF paxUSER_PM2 t
{ User Program Memory Area } $0800 0FFF pomROMCODE t
.SEG/PM/RAM/ABS=0x0000/CODE/DATA VECTOR[96]; $0000 03FF dadUSER_DM1 t
.SEG/PM/RAM/ABS=0x0060/CODE/DATA USER_PM1[1952]; $0400 07FF dadUSER_DM2 t
$2400 2BFF dadDPRAM_DM t
{ Rom Code Program Memory Area } $2C00 2C07 dadEXT_UART t
.SEG/PM/ROM/ABS=0x0800/CODE ROMCODE[2048]; $2C08 37FF dadEXT_PERIPH t
$3800 3B5F dadINT_DM t
{ User Data Memory Area } $3B60 3BFF dadROMDATA t
.SEG/DM/RAM/ABS=0x0000/DATA USER_DM1[1024]; $
.SEG/DM/RAM/ABS=0x2400/DATA DPRAM_DM[2048]; Remarques :
.SEG/DM/RAM/ABS=0x2C00/DATA EXT_UART[7];
.SEG/DM/RAM/ABS=0x2C08/DATA EXT_PERIPH[3064] pax : Program memory rAm data or code
.SEG/DM/RAM/ABS=0x3800/DATA INT_DM[864]; dad : Data memory rAm Data
.SEG/DM/RAM/ABS=0x3B60/DATA ROMDATA[160]; pom : Program memory rOm
box : Boot memory rOm data or code
.ENDSYS;
(a) Description de l’architecture CHP401.sys (b) Fichier d’architecture CHP401.ach
Figure 6-5 : Plan mémoire pour la carte CHPSE
ADMC401 : 7. EDITEUR DE LIEN Page 90
7. EDITEUR DE LIEN (LINKER)
7.1 INTRODUCTION
L’éditeur de lien utilise les fichiers de sortie de l’assembleur suivants :
− Le fichier objet *.OBJ
− Le fichier de code *.CDE
− Le fichier d’initialisation *.INT
Fichier
d'initialisation
application.int
Fichier objet
application.obj
Fichier de code
application.cde
Fichier d'initialisation
des données
application.dat
Ficher de description
de l'architecture
ADMC401.ach
LINKER
Fichier
exécutable Fichier
de plan mémoire Fichier d'assignation
application.exe
application.map des symboles
application.sym
Figure 7-1 : Fichiers d’entrée / sortie de l’éditeur de lien
Une description de ces fichiers a été donnée au §5.1. L’éditeur de lien examine chaque
module assemblé et détermine la valeur des symboles définie par les directives .GLOBAL,
.ENTRY et .EXTERNAL. Il assigne des adresses absolues aux fragments de code et de
données définis comme réimplantable (relocatable). L’éditeur de lien lit également le fichier
d’architecture *.ACH qui donne des informations sur les adresses des divers segments de
mémoire en fonction du design de la carte électronique (hardware). L’emplacement du fichier
d’architecture doit être définit à l’aide du paramètre (switch) -a.
L’éditeur de lien peut générer trois fichiers différents. Le fichier exécutable *.EXE, qui est
une image du contenu de la mémoire, est toujours généré. Il contient le code opératoire
(opcode) et les variables devant être stockés en mémoire. Le fichier de plan mémoire (map
listing file)*.MAP, optionnel, donne des informations condensées du programme lié. Le
fichier *.SYM (symbol table file), optionnel, donne une liste exhaustive, avec leur valeur
absolue et leur emplacement de référence, de tous les symboles utilisés rencontrés et assignés
par l’éditeur de lien.
7.2 FONCTIONNEMENT DE L’ÉDITEUR DE LIEN

Il est important d’avoir une bonne compréhension du fonctionnement de l’éditeur de lien
pour pouvoir structurer l’utilisation de la mémoire de la manière la plus efficace possible.
Le travail principal de l’éditeur de lien est de combiner le code des divers modules assemblés
et l’initialisation des données pour créer un fichier exécutable qui est une image du contenu
de l’espace mémoire. Les deux tâches élémentaires sont l’allocation mémoire et la traduction
des symboles en adresses absolues ou en valeurs.
7.2.1 Allocation mémoire d’exécution

L’éditeur de lien lit les déclarations faites dans chaque module afin de déterminer
l’emplacement du code et des données en fonction du type de mémoire (RAM, ROM) et de
sa désignation (PM, DM). L’éditeur de lien lit également le fichier d’architecture *.ach afin
de déterminer les caractéristiques et l’emplacement des divers mémoires (type et
désignation).
L’éditeur de lien place des différents objets selon la séquence suivante :
1. Module, variables et buffers donc l’emplacement est fixé de manière absolue

Il s’agit ici des modules, des variables et des buffers définis par l’attribut ABS des
directives .MODULE et .VAR.
2. Buffers circulaires placés dans un segment
La directive .VAR suivit des l’attributs SEG=pm_seg/CIRC impose un segment de
mémoire particulier à un buffer circulaire. Par contre la position absolue à l’intérieur du
segment n’est pas fixée.
3. Modules variables et buffers non circulaires placés dans un segment
Les directives :MODULE et .VAR suivis de l’attribut SEG=pm_seg impose un segment
de mémoire particulier à un module, une variable ou un buffer circulaire. Par contre la
position absolue à l’intérieur du segment n’est pas fixée.
4. Buffers circulaires
Il s’agit ici de buffers circulaires dont l’emplacement n’est pas défini dans un segment
particulier.
5. Modules variables et buffers non circulaires
Enfin, les modules, variables et buffers non circulaires n’entrant pas dans les catégories
définies sous les positions 1, 2, 3, 4, c’est-à-dire dont les contraintes d’emplacements ne
sont pas définies dans un segment particulier.
Dans le but d’obtenir un temps d’exécution minimal du code, l’éditeur de lien va placer un
prioritairement un maximum d’objets dans les mémoires internes de programme (PM) et de
données (DM) avant l’utilisation de la mémoire externe.
7.2.2 Allocation de la mémoire de stockage

Un concept important qu’il faut garder en mémoire est la différence qu’il existe entre une
allocation mémoire pour le stockage de l’application en mémoire de boot (BM) et l’allocation
de la mémoire d’exécution (RAM). Les modules déclarés par l’attribut BOOT sont placés
dans la mémoire de boot (BM) par l’éditeur de lien sans que le programmateur puisse
intervenir. Ce dernier a par contre la possibilité de fixer l’emplacement du module en
mémoire d’exécution (RAM). De pus en utilisant l’attribut STATIC, il est possible de
réserver de la place mémoire d’exécution (RAM) qui ne pourra être utilisé lors du
chargement ultérieures des pages de la mémoire de boot (BM) à la mémoire d’exécution
(RAM).
Le fichier *.MAP généré par l’éditeur de lien permet donne le plan mémoire du programme
d’application autant dans la mémoire de boot (BM) que dans la mémoire d’exécution
(RAM). Ce fichier est donc très important pour comprendre comment le transfert des pages
se fait entre les mémoires.
7.2.3 Traduction des symboles

Les symboles (variables, buffers, étiquettes de programme) définis lors de l’édition du code
source ne peuvent pas toujours être traduits (resolution) en adresses absolues ou valeurs.
L’assembleur va donc passer ces symboles à l’éditeur de lien qui a pour tâche de traduire ces
symboles après avoir défini le placement de chaque module en mémoire d’exécution (RAM).
Lorsque l’éditeur de lien rencontre la directive .EXTERNAL, il recherche les directives
.ENTRY et .GLOBAL ou les symboles sont définis. Si aucune ou une définition multiple est
rencontrée, l’éditeur de lien génère une erreur. Dans le cas contraire un fichier *.SYM activé
par le paramètre -g est généré. Ce fichier contient une liste de tous les symboles rencontrés
dans les différents modules ainsi que les valeurs correspondantes.
7.3 UTILISATION DE LIBRAIRIES AVEC DES APPLICATIONS SPÉCIFIQUES

L’utilisateur a la possibilité de lier ses programmes d’applications à une librairie de sous-
programmes contenant par exemple des fonctions mathématiques, les commandes génériques
de périphériques, etc…. Pour pouvoir agir de la sorte, il faut suivre les étapes suivantes :
1. Placer dans chaque sous programme, routine d’interruption une étiquette au début de
chacun d’eux et déclarer ces étiquettes comme public (visible de l’extérieur) à l’aide de
la directive assembleur .ENTRY. De même tout variables ou buffers accessibles de
l’extérieur doit être déclarés avec la directive assembleur .GLOBAL.
2. Déclarer chaque étiquette, en relation avec des appels de sous programmes (CALL) des
sauts (JUMP) et des références à des variables et buffers de la librairie à l’aide de la
directive assembleur .EXTERNAL.
3. Assembler la librairie en un ou plusieurs modules (il ne peut y avoir qu’un seul module
par fichier).
4. Indiquer à l’éditeur de lien l’emplacement de la ou des librairies. Le chemin de chaque
fichier doit être clairement défini.
Maintenant lorsqu’un programme d’application utilise la ou les librairies, l’éditeur de lien
réalise les tâches suivantes
1. Alloue des emplacements mémoire au programme.
2. Réuni tous les symboles non résolus et essaie de déterminer les adresses absolues
correspondant à chaque étiquette.
3. Recherche et ouvre les fichiers objet *.OBJ de la ou des librairies afin de déterminer la
valeur des symboles non définie. Tous les symboles déclarés comme publics, soit par les
directives assembleur .ENTRY pour les étiquettes et .GLOBAL pour les variables et les
buffers.
7.3.1 Construction d’une librairie unique pour un accès rapide

Les outils de développement d’Analog Devices permettent l’intégration d’un groupe de
librairies dans un seul fichier, assurant du même coup un accès plus rapide à l’examen des
symboles pour leur résolution. Une fois ce fichier crée, l’éditeur de lien, suite aux paramètres
de commande -user nom_de_la_librairie, recherche, extrait et lie seulement les sous-
programmes nécessaires à l’application. La commande de base est la suivante
LIB21 nom_de_la_librairie fichier_librarie1, [fichier_librarie2, …][-v version]
ou
LIB21 nom_de_la_librairie -i tous_les_fichiers [-v version]
Le fichier de sortie, contenant la librairie unique nom_de_la_librairie.a crée par la
commande LIB21, combine les fichiers assemblés en modules individuels. Les fichiers
d’entrées doivent être listés sans extension (i.e. .OBJ, .CDE, .INT).
En utilisant le switch -i, le nom qui suit (i tous_les_fichiers) correspond à un fichier contenant
les divers noms des fichiers assemblés en modules individuels. La liste est écrite en mode
texte avec un nom de fichier par ligne.
Le switch -v permet d’insérer, sous forme de caractère une identification de version dans le
fichier nom_de_la_librairie.
La commande d’édition de lien en rapport avec les commandes précédentes prend la forme
suivante :
LD21 nom_du_fichier_exécutable fichier1, fichier2, -user nom_de_la_librarie
Avec fichier1, fichier2 correspondant à des fichiers assemblés (sortie de la commande
ASM21) et le switch -user indiquant que le nom de fichier qui suit correspond à un fichier de
sortie de LIB21.
Il existe bien entendu plusieurs autres façons de procéder qui ne sont pas abordés ici.
ADMC401 : 8. CREATION DE FICHIERS DE COMMANDE Page 94
8. CRÉATION DE FICHIERS DE COMMANDE

Dans le but de simplifier l’utilisation des outils d’assemblage, et de lien, deux fichiers (batch
files) de commande ont été crées. Pour pouvoir les utiliser, il faut travailler avec
l’arborescence définie à la Figure 8-1
_incl401 : file_1.h
Disk
file_2.h
...
DSP_LABO s _lib401 : file_1.dsp
tête
d 'en file_2.dsp
rs m es
h ie ram
Manip_1 F ic o g ...
s-pr
d e sou
s _Template : Build.bat
_incl401 hier ipal
Fic e princ Make.bat
a m m an de
_lib401 Progr d e co m m Main.dsp
ie r s
et fich Main.h
_Template
Fichiers d'architecture _TgtFiles : admc401.ach
_TgtFiles admc401.sys
Figure 8-1 : Structure de l’arborescence d’un projet
Le fichier de commande Build.bat doit contenir le chemin du directoire dans lequel se trouve
le projet. Il fait référence au fichier Make.bat qui lui contient toutes les commandes pour
l’assemblage et lien des fichiers d’entêtes, de sous-programmes avec le programme principal.
make Disk:\DSP_LABO\Manip_1
Le fichier de commande Make.bat commence par assembler le programme principal par la commande
ASM21 -UI%1\_incl401 -2171 -l -dADMC401 Main
-UI%1 représente le chemin pour arriver au directoire –incl401
Les commandes suivantes permettent d’assembler tous les fichiers de librairie utiles à
l’application.
ASM21 -UI%1\_incl401 -2171 -l -dADMC401 %1\_lib401\file_1
Une fois que tous les fichiers nécessaires à l’application ont été assemblés, la commande
suivante permet de faire le lien entre tous les fichiers de librairie afin de créer un fichier de
librairie unique nommée library.
LIB21 library %1\_lib401\file_1 %1\_lib401\file_2 ……
Enfin l’éditeur de lien proprement dit va faire le lien entre la librairie utilisateur library et le
programme principal Main pour générer entre autre un fichier exécutable.
LD21 Main -user library -a %1\_TgtFiles\admc401.ach -g -e Main -x > errors.err
La signification exacte de chaque fichier et switch peut être connue à l’aide des commandes
ASM21 -h, LIB21 -h, LD -h.
Disk Build.bat
@echo off
echo usage : MAKE LIBRARY_INSTALLATION_DIR
echo modify the directory to your case in the following command!
DSP_LABO echo type the whole path including driveletter:\
make Disk:\DSP_LABO\Manip_1
Manip_1
Make.bat
_incl401 @echo off
del main.obj
_lib401 del %1\_lib401\*.obj
rem ************************************************************************************
_Template rem COMPILE APPLICATION FILE
rem ADD the following lines FOR EACH ADDITIONAL FILE YOU NEED TO COMPILE
rem ASM21 -UI%1\_incl401 -2171 -l -dADMC401 filemane > errors.err
_TgtFiles rem IF ERRORLEVEL 2 GOTO ERROR
rem IF ERRORLEVEL 1 GOTO ERROR
rem ************************************************************************************
_Template : Build.bat ASM21 -UI%1\_incl401 -2171 -l -dADMC401 Main > errors.err
Make.bat IF ERRORLEVEL 2 GOTO ERROR
IF ERRORLEVEL 1 GOTO ERROR
Main.dsp
Main.h echo Application Files compiled sucessfully ...
rem ************************************************************************************
_incl401 : file_1.h rem COMPILE ALL THE LIBRARY FILES
rem ************************************************************************************
file_2.h
copy Main.h %1\_lib401\Main.h
... ASM21 -UI%1\_incl401 -2171 -l -dADMC401 %1\_lib401\file_1 > errors.err
_lib401 : file_1.dsp IF ERRORLEVEL 1 GOTO ERROR
file_2.dsp ASM21 -UI%1\_incl401 -2171 -l -dADMC401 %1\_lib401\file_2 > errors.err
... IF ERRORLEVEL 1 GOTO ERROR
…..
_TgtFiles : admc401.ach LIB21 library %1\_lib401\file_1 %1\_lib401\file_2 …… > errors.err
admc401.sys IF ERRORLEVEL 2 GOTO ERROR
echo Library built sucessfully ...
rem *************************************************************************************************************************
rem LINK APPLICATION WITH LIBRARY
rem Usage: LD21 filename1 [filename2,...] -user library -a %1\_TgtFiles\admc401.ach -g -e Main -x > errors.err
rem **************************************************************************************************************************
LD21 Main -user library -a %1\_TgtFiles\admc401.ach -g -e Main -x > errors.err

@ECHO OFF
ECHO **********************************************
ECHO * Compilation completed successfully *
ECHO **********************************************
GOTO END
:ERROR
@ECHO OFF
ECHO **********************************************
ECHO * Errors in the compilation *
ECHO **********************************************
notepad errors.err
:END
del %1\_lib401\Main.h
Figure 8-2 : Fichiers d’entrée / sortie de l’éditeur de lien
L’assembleur ASM21 est n’est pas très riche en informations lorsqu’il détecte une erreur.
Dans ce cas, il arrive qu’il ne donne aucun message et qu’il ne crée pas de fichier de sortie
*.OBJ. Dans ce cas, c’est le dernier fichier assemblé avec succès qui sera utilisé par l’éditeur
de lien. Les modifications ne sont donc pas prises en compte. Pou éviter ce problème, il est
vivement conseillé d’effacer tous les fichiers portant l’extension .OBJ avant les commandes
d’assemblage.
del main.obj
del %1\_lib401\*.obj
BIBLIOGRAPHIE
[1] Single-Chip, DSP-Based
High Performance Motor Controller
REV. B
[2] ADMC401 DSP Motor Controller
Developer’s Reference Manual
Rev. 2.1, 11 Septembre 2000
[3] ADSP-2100 Family
Assembler Tools & Simulator Manual
Second Edition (11/94)
[4] ADSP-2100 Family
User’s manual
Third Edition (9/95)

Chapitre 4-8 - Set D'instructions, Directives Assembleur, Architecture Mémoire

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 4-8 - Set D'instructions, Directives Assembleur, Architecture Mémoire

Transféré par

Droits d'auteur :

Formats disponibles

DSP et temps réel

DSP ORIENTÉ APPLICATIONS INDUSTRIELLES

4.2 NOTATIONS ET CONVENTIONS

4.3 LES OPÉRATIONS DE TYPE MULTIFONCTION

Le codage de la multifonction correspond à un format d’instruction de type 4

G Générateur d’adresse dreg Registres de données

4.3.1 Opération ALU / MAC avec lecture de la mémoire PM et DM

− Lecture de deux opérandes pour la multiplication suivante.

La première instruction de cette ligne de programmation (jusqu’à la première virgule)

4.3.2 Lectures simultanées en mémoire de données (DM et de programme (PM)

4.3.3 Opération avec l’ALU, le MAC ou le décaleur à barillet et lecture en mémoire

4.3.4 Opération avec l’ALU, le MAC ou le décaleur à barillet et écriture en mémoire

4.3.5 Opération avec l’ALU, le MAC ou le décaleur à barillet et un transfert de

4.4 L’UNITÉ ARITHMÉTIQUE ET LOGIQUE (ARITHMETIC/LOGIC UNIT)

24 bits PMD BUS

16 bits DMD BUS 16 bits

MUX MUX 16 bits

Figure 4-1 : Unité Arithmétique et logique

4.4.2 Conditions autorisées

4.4.3 Notation sur les registres ASTAT, SSTAT, MSTAT

* Le bit en question est modifié en fonction du résultat de l’instruction.

4.4.4 Addition X+Y simple et addition avec report

4.4.4.2 Définitions des opérandes et des conditions

4.4.4.5 Etats générés par l’instruction

4.4.5 Soustraction X-Y simple et soustraction avec report

4.4.5.2 Définitions des opérandes et des conditions

4.4.5.5 Etats générés par l’instruction

4.4.6 Soustraction Y-X simple et soustraction avec report

4.4.6.2 Définitions des opérandes et des conditions

4.4.6.5 Etats générés par l’instruction

4.4.7 Fonction logique AND, OR, XOR

4.4.7.2 Définitions des opérandes et des conditions

4.4.7.5 Etats générés par l’instruction

4.4.8 Instruction sur un bit

4.4.8.2 Définitions des opérandes et des conditions

4.4.8.5 Etats générés par l’instruction

4.4.9 Test de l’état d’une variable sans la modifier

4.4.9.2 Définitions des opérandes et des conditions

4.4.9.5 Etats générés par l’instruction

4.4.10 Complément à deux

4.4.10.2 Définitions des opérandes et des conditions

4.4.10.5 Etats générés par l’instruction

4.4.11.2 Définitions des opérandes et des conditions

4.4.11.5 Etats générés par l’instruction

4.4.12 Valeur absolue

4.4.12.2 Définitions des opérandes et des conditions

4.4.12.5 Etats générés par l’instruction

4.4.13.2 Définitions des opérandes et des conditions

4.4.13.5 Etats générés par l’instruction

AZ Mise à 1 si le résultat est nul, sinon mise à 0.

4.4.14.2 Définitions des opérandes et des conditions

4.4.14.5 Etats générés par l’instruction

AZ Mise à 1 si le résultat est nul, sinon mise à 0.

4.4.15.3 Définitions des opérandes et des conditions

4.4.15.5 Etats générés par l’instruction

AQ Chargé avec la valeur du bit AQ calculé à chaque exécution de DIVs ou DIVQ

4.4.16 Génération d’un état de l’ALU

4.4.16.4 Etats générés par l’instruction

4.5 LE MULTIPLIEUR ET ACCUMULATEUR (MULTIPLIER/ACCUMULATOR)

16 bits DMD BUS 16 bits

MUX MUX 16 bits

MUX MUX MUX

8 bits 16 bits 16 bits 16 bits