‫الجمهورية الجزائرية الديمقراطية الشعبية‬

République Algérienne Démocratique et Populaire

‫وزارة التعليم العالي والبحث العلمي‬
Ministère de l'Enseignement Supérieur et de la Recherche
Scientifique

Université des Sciences et de la Technologie Houari

Boumediene USTHB

Faculté de Génie Electrique

Département Electronique
Master Electronique des Systèmes Embarqués ESE

LES INSTRUCTIONS DANS LE

PROCESSEUR TMS320C6713
Présenté par : K. BOUDJIT

B.P. 32 El-Alia, Bab-Ezzouar, Alger 16111 Tél : 213 (0) 21 24 79 12 Poste 805
Fax : 213 (0) 21 24 71 87http://www.usthb.dz/
1. FORMAT DU CODE ASSEMBLEUR ........................................................................................... 1
1.1. Types d'instructions ....................................................................................................... 1
1.1.1 Add/Subtract/Multiply ................................................................................................. 1
1.1.2 Charger / stocker (Load/Store) ...................................................................................... 2
branche / déplacer (Branch/Move) : ...................................................................................... 2
2. DIRECTIVES D'ASSEMBLEUR (ASSEMBLER DIRECTIVES) ........................................................... 3
3. ASSEMBLEUR LINEAIRE (LINEAR ASSEMBLY) .......................................................................... 3
4. DECLARATION ASM EN C ....................................................................................................... 5
5. FONCTION D'ASSEMBLEUR C-CALLABLE ................................................................................. 5
6. CHEMINS CROISEES (Cross-Paths) .......................................................................................... 5
7. CONTRAINTES........................................................................................................................... 6
7.1 Contraintes de mémoire ...................................................................................................... 6
7.2 Contraintes de chemins croisés............................................................................................ 6
7.3 Contraintes de chargement / stockage (Load/Store)............................................................. 6
 ENSEMBLE D'INSTRUCTIONS TMS320C6713 DSP

1. FORMAT DU CODE ASSEMBLEUR

Un format de code assembleur est représenté par le champ
Label || [] Instruction Unit Operands ;comments
Une étiquette (Label), si présente, représente une adresse spécifique ou un emplacement de
mémoire contenant une instruction ou des données. L'étiquette doit être dans la première
colonne. Les barres parallèles (||) sont présentes si l'instruction est exécutée parallèlement à
l'instruction précédente. Le champ suivant est facultatif pour rendre l'instruction associée
conditionnelle. Cinq des registres (A1, A2, B0, B1 et B2) peuvent être utilisés comme registres
conditionnels. Par exemple, [ !A2] spécifie que l'instruction associée s'exécute si A2 n'est pas
zéro. Toutes les instructions C6x peuvent être conditionnées avec les registres A1, A2, B0, B1
et B2 en déterminant à quel moment le registre conditionnel est à zéro. Le champ d'instruction
peut être une directive assembleur ou une mnémonique. Une directive assembleur est une
commande pour l'assembleur. Par exemple,
.word value
réserve 32 bits en mémoire et remplit avec la valeur spécifiée. Une mnémonique est une
instruction réelle qui s'exécute au moment de l'exécution. L'instruction (directive mnémonique
ou assembleur) ne peut pas commencer dans la colonne 1. Le champ Unit, qui peut être l’une
des huit unités du CPU, est facultatif. Les commentaires commençant par la colonne 1 peuvent
commencer par un astérisque ou un point-virgule, alors que les commentaires commençant par
une autre colonne doivent commencez par un point-virgule. Le code des processeurs à virgule
flottante C3x / C4x n'est pas compatible avec le code des processeurs à virgule fixe C1x, C2x
et C5x / C54x. Cependant, le code pour les processeurs à virgule fixe C62x est compatible avec
le code pour C67x à virgule flottante. Le code C62x est en réalité un sous-ensemble du code
C67x. Des instructions supplémentaires permettant de gérer les opérations en double précision
et en virgule flottante ne sont disponibles que sur le processeur C67x. De plus, certaines
instructions supplémentaires ne sont disponibles que sur le processeur C64x à virgule fixe.
Plusieurs segments de code sont présentés pour illustrer le jeu d'instructions C6x. Le code
d'assemblage des processeurs C6x est très similaire au code C3x / C4x. Les types d'instructions
à tâche unique disponibles pour le C6x facilitent la programmation par rapport à la génération
précédente de processeurs à virgule fixe ou à virgule flottante. Cela contribue à un compilateur
efficace. Des instructions supplémentaires disponibles sur le C64x (mais pas sur le C62x)
ressemblent aux types d'instructions multitâches des processeurs C3x / C4x.
1.1.Types d'instructions
Ce qui suit illustre une partie de la syntaxe du code d'assembleur. Il est facultatif de spécifier
les huit unités fonctionnelles, bien que cela puisse être utile lors du débogage et pour l’efficacité
et l’optimisation du code
1.1.1 Add/Subtract/Multiply
a) L'instruction
ADD .L1 A3, A7, A7 ;add A3 + A7 A7 (accum in A7)
Ajoute des valeurs dans les registres A3 et A7 et place le résultat dans le registre A7. L'unité
.L1 est optionnelle. Si la destination ou le résultat est en B7, l’unité serait .L2.

1 Master Electronique des Systèmes Embarqués ESE – USTHB/FGE

 ENSEMBLE D'INSTRUCTIONS TMS320C6713 DSP

b) L’Instruction
SUB .S1 A1, 1, A1 ;subtract 1 from A1
Soustrait 1 de A1 pour le décrémenter à l'aide de l'unité .S.
c) Les instructions parallèles
MPY .M2 A7, B7, B6 ;multiply 16 LSBs of A7, B7  B6
|| MPYH .M1 A7, B7, A6 ;multiply 16MSBs of A7, B7  A6
Multiplie les 16 bits les plus faibles ou les moins significatifs (LSB) de A7 et B7 et place le
produit dans B6, en parallèle (simultanément dans le même paquet d'exécution) avec une
seconde instruction multipliant les 16 bits les plus significatifs (MSB) de A7 et B7 et place le
résultat dans A6. De cette manière, deux opérations MAC peuvent être exécutées au cours d’un
seul cycle d’instruction. Ceci peut être utilisé pour décomposer une somme de produits en deux
ensembles de somme de produits : un ensemble utilisant les 16 bits inférieurs pour fonctionner
sur le premier, le troisième, le cinquième,. . . numéro. et un autre ensemble utilisant les 16 bits
les plus élevés pour agir sur les deuxième, quatrième, sixième,. . . nombre. Notez que le symbole
parallèle ne figure pas dans la colonne 1.
1.1.2 Charger / stocker (Load/Store)
a) L'instruction
LDH .D2 *B2++,B7 ;load (B2)  B7, increment B2
|| LDH .D1 *A2++,A7 ;load (A2)  A7, increment A2
Charge (loads) dans B7 le demi-mot (half-word) (16 bits) dont l'adresse en mémoire est
spécifiée / indiquée par B2.Le registre B2 est alors incrémenté (postincrémenté) pour pointer
vers l'adresse de mémoire immédiatement supérieure. En parallèle, une autre instruction de
mode d'adressage indirect permet de charger dans A7 le contenu en mémoire dont l'adresse est
spécifiée par A2. Ensuite, A2 est incrémenté pour pointer vers l'adresse mémoire la plus haute
suivante.

L'instruction LDW charge un mot de 32 bits. Deux chemins utilisant .D1 et .D2 permettent le
chargement de données de la mémoire dans les registres A et B à l’aide de l’instruction LDW.
L’instruction à virgule flottante à double mot LDDW sur le C6713 peut charger simultanément
deux registres 32 bits dans la face A et deux registres 32 bits dans le côté B.

b) L'instruction
STW .D2 A1,*+A4[20] ;store A1  (A4) offset by 20
Stocke le mot A1 de 32 bits en mémoire dont l'adresse est spécifiée par A4 décalée de 20 mots
(32 bits) ou 80 octets. Le registre d’adresse A4 est pré-incrémenté avec offset, mais il n’est pas
modifié (deux signes plus sont utilisés si A4 doit être modifié).
branche / déplacer (Branch/Move) :
Le segment de code suivant illustre la création de branches et le transfert de données :
Loop MVKL .S1 x,A4 ;move 16 LSBs of x address A4
MVKH .S1 x,A4 ;move 16 MSBs of x address A4
.
.
.

2 Master Electronique des Systèmes Embarqués ESE – USTHB/FGE

 ENSEMBLE D'INSTRUCTIONS TMS320C6713 DSP

SUB .S1 A1,1,A1 ;decrement A1

[A1] B .S2 Loop ;branch to Loop if A1 # 0
NOP 5 ;five no-operation instructions
STW .D1 A3,*A7 ;store A3 into (A7)
La première instruction déplace les 16 bit inférieurs (LSB) de l'adresse x dans le registre A4.
La deuxième instruction déplace les 16 bit les plus élevés (MSB) de l'adresse x vers A4, qui
contient maintenant l'adresse complète à 32 bits de x. Il faut utiliser les instructions MVKL /
MVKH pour obtenir une constante 32 bits dans un registre.
Le registre A1 est utilisé comme compteur de boucle. Après qu'il soit décrémenté avec
l'instruction SUB, il est testé pour une branche conditionnelle. L'exécution se branche sur
l'étiquette ou l'adresse Loop si A1 n'est pas nul. Si A1 = 0, l'exécution continue et les données
du registre A3 sont enregistrées dans la mémoire dont l'adresse est spécifiée par A7.

2. DIRECTIVES D'ASSEMBLEUR (ASSEMBLER DIRECTIVES)

Une directive assembleur est un message pour l'assembleur (pas le compilateur) et n'est pas une
instruction. Il est résolu pendant le processus d'assemblage et n'occupe pas d'espace mémoire,
comme le fait une instruction. Il ne produit pas de code exécutable.
Les adresses de différentes sections peuvent être spécifiées avec les directives assembleur. Par
exemple, la directive assembler .sect “my_buffer” définit une section de code ou de données
nommées my_buffer. Les directives .text et .data indiquent une section pour le texte et les
données, respectivement. D'autres directives d'assembleur, telles que .ref et .def, sont utilisées
pour les symboles indéfinis et définis, respectivement. L'assembleur crée plusieurs
sections indiquées par des directives telles que .text pour le code et .bss pour les variables
globales et statiques.
Les autres directives d'assembleur couramment utilisées sont :
1. .short: pour initialiser un entier de 16 bits.
2. .int: pour initialiser un entier 32 bits (également .word ou .long). Le compilateur
traite une valeur de donnée longue comme 40 bits, alors que l'assembleur C6x la
traite comme 32 bits.
3. .float: pour initialiser une constante simple précision IEEE 32 bits.
4. .double: pour initialiser une constante double précision IEEE 64 bits.
Les valeurs initialisées sont spécifiées à l'aide des directives d'assembleur .byte, .short ou .int.
Les variables non initialisées sont spécifiées à l'aide de la directive .usect, qui crée une section
non initialisée (comme la section .bss), alors que la directive .sect crée une section initialisée.
Par exemple, .usect «variable», 128 désigne une section non initialisée nommée variable d’une
taille de section de 128 en octets.

3. ASSEMBLEUR LINEAIRE (LINEAR ASSEMBLY)

Une alternative au C, ou code d'assembleur, est l'assembleur linéaire. Un optimiseur
d’assembleur (au lieu d’un compilateur C) est utilisé avec un programme source linéaire codé
par un assembleur (avec extension .sa) pour créer un programme source d’assembleur (avec
extension .asm) de la même manière qu’un compilateur C optimiser est utilisé avec un
programme source codé en C. Le programme résultant codé en assembleur produit par
l’optimiseur d’assembleur est généralement plus efficace que celui résultant de l’optimiseur de
compilateur C. Le programme codé en assembleur résultant d’un programme source codé en C
3 Master Electronique des Systèmes Embarqués ESE – USTHB/FGE
 ENSEMBLE D'INSTRUCTIONS TMS320C6713 DSP

ou d’un programme source en assembleur linéaire doit être assemblé pour produire un code
objet.
La programmation de code d’assembleur linéaire offre un compromis entre l’effort de codage
et l’efficacité du codage. L’optimiseur d’assembleur attribue l’unité fonctionnelle et le registre
à utiliser (facultatif à spécifier par l’utilisateur), recherche les instructions pouvant être
exécutées en parallèle et exécute le traitement en pipeline de logiciels à des fins d’optimisation.
Les instructions parallèles ne sont pas valides dans un programme d'assembleur linéaire. La
spécification de l'unité fonctionnelle est facultative dans un programme d'assembleur linéaire
ainsi que dans un programme d'assembleur.
Au cours des dernières années, l'optimiseur du compilateur C est devenu de plus en plus
efficace. Bien que le code C soit moins efficace (performances de rapidité) que le code
assembleur, il implique généralement moins d’effort de codage que le code assembleur, qui
peut être optimisé manuellement pour atteindre une efficacité de 100% mais avec un effort de
codage beaucoup plus important.
Il est intéressant de noter que la syntaxe du code d'assembleur C6x n'est pas aussi complexe
que celle des processeurs C2x / C5x ou C3x. Il est en réalité plus simple de "programmer" le
C6x en langage assembleur.
DBNZD AR4,LOOP
Décrémente (en raison du premier D) un compteur de boucle AR4 et branche (B) de manière
conditionnelle (si AR4 est différent de zéro) à l'adresse spécifiée par LOOP, avec un retard (en
raison du deuxième D). L'instruction de branchement avec retard permet effectivement à
l'instruction de branchement de s'exécuter en un seul cycle (en raison du traitement en pipeline).
Ces instructions multitâches ne sont pas disponibles sur les processeurs C62x et C67x, bien
qu'elles aient été récemment introduites sur le processeur C64x. En fait, les types d'instructions
C6x sont plus simples. Par exemple, des instructions séparées sont disponibles pour
décrémenter un compteur (avec une instruction SUB) et créer des branches. Les types
d'instructions plus simples se prêtent mieux à un compilateur C plus efficace.
Cependant, bien qu'il soit plus simple de programmer en code assembleur pour exécuter une
tâche souhaitée, cela ne signifie ni ne se traduit en un programme efficace codé en assembleur.
Il peut être relativement difficile d'optimiser manuellement un programme pour obtenir un
programme codé par un assembleur totalement efficace (et significatif).
Le code d'assembleur linéaire est un croisement entre assemblage et C. Il utilise la syntaxe des
instructions de code d'assembleur telles que ADD, SUB et MPY, mais avec des opérandes /
registres utilisés en C. Dans certains cas, cela constitue un bon compromis entre C et
l’assembleur.
Les directives d'assembleur linéaire incluent
.cproc
.endproc
Pour spécifier une procédure C-appelable (C-callable) ou une section de code à optimiser par
l’optimiseur d’assembleur. Une autre directive, .reg, est utilisée pour déclarer des variables et
utiliser des noms descriptifs pour les valeurs qui seront stockées dans des registres.

4 Master Electronique des Systèmes Embarqués ESE – USTHB/FGE

 ENSEMBLE D'INSTRUCTIONS TMS320C6713 DSP

4. DECLARATION ASM EN C
Les instructions d'assembleur et les directives peuvent être incorporées dans un programme C
à l'aide de l'instruction asm. L'instruction asm peut fournir un accès à des fonctionnalités
matérielles qui ne peuvent pas être obtenues à l'aide du code C uniquement. La syntaxe est
asm (“assembly code”);
La ligne d'assembleur de code dans l'ensemble de guillemets a le même format qu'une
instruction d'assembleur valide. Notez que si l'instruction a une étiquette, le premier caractère
de l'étiquette doit commencer après le premier guillemet pour qu'il soit dans la colonne 1.
L'instruction assembleur doit être valide, car le compilateur ne recherche pas l'erreur de syntaxe
mais la copie directement. Dans le fichier de sortie compilé. Si l'instruction d'assembleur a une
erreur de syntaxe, l'assembleur le détectera.
Évitez d’utiliser des instructions asm dans un programme C, en particulier dans un programme
d’assembleur linéaire. En effet, l'optimiseur d'assembleur pourrait réorganiser des lignes de
code proches des instructions asm susceptibles de générer des résultats indésirables.

5. FONCTION D'ASSEMBLEUR C-CALLABLE

Le registre B3 est conservé et est utilisé pour contenir l'adresse de retour de la fonction
appelante. Une déclaration externe d'une fonction d'assembleur appelée dans un programme C
à l'aide de extern est facultative. Par exemple
extern int func();
est optionnel avec la fonction assembleur func renvoyant une valeur entière.

6. CHEMINS CROISEES (Cross-Paths)

Des instructions croisées de données et d'adresses sont utilisées pour augmenter l'efficacité du
code. L'instruction
MPY .M1x A2,B2,A4
illustre un cheminement de données multipliant les deux sources A2 et B2 de deux côtés
différents, A et B, avec le résultat en A4. Si le résultat est dans le fichier de registre B, un
chemin croisé 2x est utilisé avec l'instruction
MPY .M2x A2,B2,B4
avec le résultat en B4. L'instruction
LDW .D1T2 *A2,B2
illustre une adresse croisée. Il charge le contenu dans le registre A2 (à partir d'un fichier de
registre A) dans le registre B2 (fichier de registre B). Seuls deux chemins transversaux sont
disponibles sur le C6x, ainsi, pas plus de deux instructions utilisant des chemins transversaux
sont autorisées dans un cycle.

5 Master Electronique des Systèmes Embarqués ESE – USTHB/FGE

 ENSEMBLE D'INSTRUCTIONS TMS320C6713 DSP

7. CONTRAINTES
7.1 Contraintes de mémoire
La mémoire interne est organisée selon différentes banques de mémoire afin que des
chargements et des stockages puissent avoir lieu simultanément. Étant donné que chaque
banque de mémoire est à port unique, un seul accès à chaque banque est effectué par cycle.
Deux accès à la mémoire par cycle peuvent être effectués s’ils n’accèdent pas à la même banque
de mémoire. Si plusieurs accès sont effectués sur la même banque de mémoire (dans le même
espace), le pipeline est bloqué. Cela entraîne l'exécution de cycles supplémentaires.
7.2 Contraintes de chemins croisés
Comme il y a un chemin croisé de part et d'autre des deux chemins de données, il peut y avoir
au plus deux instructions par cycle utilisant des chemins croisés. Le segment de code suivant
est valide car les deux chemins transversaux disponibles sont utilisés :
ADD .L1x A1,B1,A0
|| MPY .M2x A2,B2,B3
Alors que ce qui suit n'est pas valide, car un chemin croisé est utilisé pour les deux instructions :
ADD .L1x A1,B1,A0
|| MPY .M1x A2,B2,A3
Le x associé à l'unité fonctionnelle désigne un chemin croisé.
7.3 Contraintes de chargement / stockage (Load/Store)
Le registre d’adresses à utiliser doit se trouver du même côté que l’unité .D. Le segment de
code suivant est valide :
LDW .D1 *A1,A2
|| LDW .D2 *B1,B2
Alors que ce qui suit n'est pas valide :
LDW .D1 *A1,A2
|| LDW .D2 *A3,B2
De plus, le chargement et le stockage ne peuvent pas provenir du même fichier de registre. Un
chargement (ou stockage) utilisant un fichier de registre en parallèle avec un autre chargement
(ou stockage) doit utiliser un fichier de registre différent. Par exemple, le segment de code
suivant est valide :
LDW .D1 *A0,B1
|| STW .D2 A1,*B2
Ce qui suit est également valide :
LDW .D1 *A0,B1
|| LDW .D2 *B2,A1
Toutefois, les éléments suivants ne sont pas valides :
LDW .D1 *A0,A1
|| STW .D2 A2,*B2

6 Master Electronique des Systèmes Embarqués ESE – USTHB/FGE