Vous êtes sur la page 1sur 28

Chapitre 4 :

Instructions du TMS320C64
Instructions C6000 C62/C64/C67
.S Unit .L Unit
ADD MVKLH ABS NOT
ADDK NEG ADD OR
ADD2 NOT AND SADD
AND OR CMPEQ SAT
B SET CMPGT SSUB
CLR SHL CMPLT SUB
EXT SHR LMBD SUBC
MV SSHL MV XOR
MVC SUB NEG ZERO
MVK SUB2 NORM
MVKL XOR
MVKH ZERO .D Unit
.M Unit ADD STB/H/W
ADDA SUB
MPY SMPY LDB/H/W SUBA
MPYH SMPYH MV ZERO
Other NEG

NOP IDLE
Chapitre 4 Cours DSP 2
Instructions C64
Dual/Quad Arith Data Pack/Un Compares Dual/Quad Arith Data Pack/Un
.S SADD2 PACK2 CMPEQ2 .L ABS2 PACK2
SADDUS2 PACKH2 CMPEQ4 ADD2 PACKH2
SADD4 PACKLH2 CMPGT2 ADD4 PACKLH2
PACKHL2 CMPGT4 MAX PACKHL2
Bitwise Logical UNPKHU4 MIN PACKH4
ANDN UNPKLU4 Branches/PC SUB2 PACKL4
SWAP2 BDEC SUB4 UNPKHU4
Shifts & Merge BPOS
SHR2 SPACK2 SUBABS4 UNPKLU4
SPACKU4 BNOP SWAP2/4
SHRU2 ADDKPC
SHLMB
SHRMB Multiplies Average
.M MPYHI AVG2
MPYLI AVG4
Dual Arithmetic Mem Access MPYHIR
.D ADD2 LDDW MPYLIR Bit Operations
SUB2 LDNW MPY2 BITC4
LDNDW SMPY2 BITR
Bitwise Logical STDW
AND DOTP2 DEAL
STNW DOTPN2 SHFL
ANDN STNDW
OR DOTPU4 Move
XOR Load Constant DOTPSU4 MVD
MVK (5-bit)
Chapitre 4 Cours DSP 3
Nb de cycles
ADD / SUB
d’exécution
Arithmétique
1 ADD(U) : ADD / ADDU Addition entière 32/40 bits signée (non signée)
ADD2 2 additions entières 16 bits
ADD4 4 additions entières 8 bits
SUB(U) : SUB / SUBU Soustraction entière 32/40 bits signée (non signée)
SUB2 2 soustractions entières 16 bits
SUB4 4 soustractions entières 8 bits

Chapitre 4 Cours DSP 4


Nb de cycles
ADD / SUB
d’exécution
Arithmétique
1 ADD(U) Addition entière 32/40 bits signée (non signée)
ADD2 2 additions entières 16 bits
ADD4 4 additions entières 8 bits
SUB(U) Soustraction entière 32/40 bits signée (non signée)
SUB2 2 soustractions entières 16 bits
SUB4 4 soustractions entières 8 bits

Chapitre 4 Cours DSP 5


Nb de cycles
MPY
d’exécution
Multiplication entières
2 MPY : LSB x LSB 16 LSB signés x 16 LSB signés => 32 bits
MPYH : MSB x MSB 16 MSB signés x 16 MSB signés => 32 bits
MPYLH : LSB x MSB 16 LSB signés x 16 MSB signés => 32 bits
MPYHL : MSB x LSB 16 MSB signés x 16 LSB signés => 32 bits

Exemple 1 :

MPYLH .M1 A1 , A2 , A3

Before instruction 2 cycles after instruction

A1 0900 000E h 14 A1 0900 000E h

A2 0029 00A7 h 41 A2 0029 00A7 h

XXXX XXXX h 0000 023E h 574


A3 A3
Chapitre 4 Cours DSP 6
Nb de cycles
MPY
d’exécution
Multiplication entières
2 MPY 16 LSB signés x 16 LSB signés => 32 bits
MPYH 16 MSB signés x 16 MSB signés => 32 bits
MPYLH 16 LSB signés x 16 MSB signés => 32 bits
MPYHL 16 MSB signés x 16 LSB signés => 32 bits

Exemple 2 :

MPYHL .M1 A1 , A2 , A3

Before instruction 2 cycles after instruction

A1 008A 003E h 138 A1 008A 003E h

A2 21FF 00A7 h 167 A2 21FF 00A7 h

XXXX XXXX h 0000 5A06 h 23046


A3 A3
Chapitre 4 Cours DSP 7
Nb de cycles
MPY
d’exécution
Multiplication entières
4 MPY2 2 Multiplication 16 bits par 16 bits
4 MPY4 4 Multiplication 8 bits par 8 bits

Chapitre 4 Cours DSP 8


Nb de cycles
MPY
d’exécution
Multiplication entières
4 MPY2 2 Multiplication 16 bits par 16 bits
4 MPY4 4 Multiplication 8 bits par 8 bits

Chapitre 4 Cours DSP 9


Nb de cycles
LD / ST
d’exécution

Accès mémoire
5 LD(B/H/W/DW)(U) Chargement (octet, demi mot, mot,2 mots) signé (non signé)
1 ST(B/H/W/DW)(U) Stockage (octet, demi mot, mot, 2 mots) signé (non signé)

Exemple :
100 AF A0 = 100 = adresse
101 11 Instruction A0 A1
102 22 LDB *A0 , A1 100 AF
103 D0 LDH *A0 , A1 100 11AF ou AF11
104 33 LDW *A0 , A1 100 D02211AF
105 44
LDDW *A0 , A1:A2 100 A1 : D02211AF
106 BB A2 : 55BB4433
107 55

8 bits
Chapitre 4 Cours DSP 10
Nb de cycles
MVK
d’exécution

Affectation
1 MV : x=y Transfère d’un registre vers un autre registre
1 MVK : x=0 Transfère une constante 16 bits LSB signée vers un registre
1 MVKH Transfère une constante 16 bits MSB signée vers le MSB
d’un registre

Exemple 1 :
MVK .S1 293 , A1
Before instruction 1 cycle after instruction

A1 XXXX XXXX h A1 0000 0125 h

MVK .S2 125h, B1


Before instruction 1 cycle after instruction

B1 XXXX XXXX h B1 0000 0125 h


Chapitre 4 Cours DSP 11
MVK
Exemple 2 :
MVKH .S1 0A32 9123h , A1

Before instruction 1 cycle after instruction

A1 0000 7634 h A1 0A32 7634 h

MVKL .S1 5678h , A8

Before instruction 1 cycle after instruction

A8 FFFF 7634 h A8 FFFF 5678 h

Chapitre 4 Cours DSP 12


MVK
Exemple 3 :
MVKHL .S1 0A32 9123h , A3

Before instruction 1 cycle after instruction

A3 FFFF F25A h A3 FFFF 0A32 h

MVKLH .S1 07A8h, A4

Before instruction 1 cycle after instruction

A4 FFFF F25A h A4 07A8 F25A h

Chapitre 4 Cours DSP 13


Nb de cycles
SHL / SHR
d’exécution

Décalage
1 SHL Décalage gauche 32/40 bits
SHR Décalage droite 32/40 bits
SHR2 Décalage droite 16 bits

Exemple 1 :
SHL .S1 A0 , 1 , A1

Before instruction 1 cycle after instruction

A0 0000 0010 h 16 A0 0000 0010 h

A1 XXXX XXXX h A1 0000 0020 h 32

n/-n
SHL / SHR : *2
Chapitre 4 Cours DSP 14
SHL / SHR
Exemple 2 : 1000 h = 0001 0000 0000 0000 b
1000 h = 0000 1000 0000 0000 b
SHR .S2 B0 , 4 , B1
Before instruction 1 cycle after instruction

B0 0000 0010 h 16 B0 0000 0010 h

B1 XXXX XXXX h B1 0000 0008 h 8

Exemple 3 :
SHR2 .S2 B2 , 1 , B3
Before instruction 1 cycle after instruction
16
B2 0200 0010 h B2 0200 0010 h
512
4
B3 xxxx xxxx h B3 0080 0004 h
128
Chapitre 4 Cours DSP 15
Nb de cycles
B
d’exécution

Branchement
6 B = goto ; Branchement conditionnel

Exemple 1 :
B loop ; sans condition
[ B1 ] B loop ; branchement si B1 != 0
[ !B2 ] B loop ; branchement si B2 = 0

Chapitre 4 Cours DSP 16


B
Exemple 2 : MVK 100 , i
Loop :
for ( i = 0 ; i < 100 ; i++ ) ….
{ SUB i,1,i
…. [i] B Loop
}
i = 0 ; For i = 100; B
i = 1 ; For i = 99 ; B
… ….
i = 99 ; For ; FIN Boucle i = 0 : FIN Boucle
Chapitre 4 Cours DSP 17
Jeu d’instructions et Unités
.L .M .S .D
ABS MPY ADD2 ADD(U)
ABS2 MPYSU4 AND ADD2
ADD(U) MPYUS4 B AND
ADD2 MPYU4 MVK LDB
ADD4 …… MVKH LDDW
AND OR MVK
MVK SHL OR
OR SHLMB STH
SHLMB SHR2 STDW
SHRMB SHRMB SUB(U)
SUB(U) SUB2 SUB2
SUB2 XOR XOR
SUB4 …… …...
XOR
……

Chapitre 4 Cours DSP 18


LD / ST
Supposant que R est un registre d’adresse :
*R : Le registre R pointe sur une adresse mémoire.
LDB *A0 , A1 ; A1 = * A0
*R++(d) : Le registre R contient une adresse mémoire en plus
il y aura une post-incrémentation c.à.d après une lecture R va
s’auto incrémenter par une valeur (d) qui est 1 par défaut.
LDB *A0++ , A1 ; A1 = *A0 puis A0=A0+1
LDB *A0++(2), A1 ; A1 = *A0 puis A0=A0+2
*++R(d) : Même chose que le cas précédent mais maintenant
une pré-incrémentation.
LDB *++A0 , A1 ; A0++ puis A1= *A0
*+R(d) : L’adresse est pré-incrémentée de tel sorte que
l’adresse actuelle est R+d. Par contre, R ne va pas être
modifier.
LDB *+A0 , A1 ; A0++ puis A1= *A0 puis A0--
Chapitre 4 Cours DSP 19
LD / ST
Exemple :
A0 = 100
100 AF
Instruction A0 A1
101 11
102 22 LDB *A0 , A1 100 AF 8 bits
103 D0 LDB *A0++ , A1 101 AF
104 33 LDB *++A0 , A1 101 11
105 44 LDH *A0 , A1 100 11AF 16 bits
106 BB LDH *A0++ , A1 102 11AF
107 55 LDH *++A0[2] , A1 104 4433
108 66 LDW *A0 , A1 100 D02211AF 32 bits
109 CC LDW *+A0 , A1 100 55BB4433
LDW *++A0 , A1 104 55BB4433
8 bits
Chapitre 4 Cours DSP 20
Syntaxe des instructions

Add / Soustraction / Multiplication :


ADD .L1 A3, A7, A8 ; A3 + A7  A8
Si le résultat est stocké dans B8 : ADD .L2 A3, A7, B7

SUB .S1 A1, 1, A2 ; A1 – 1  A2

2 instructions en parallèle :
MPY .M2 A7, B7, B6 ; LSB(A7) * LSB(B7)  B6

|| MPYH .M2 A7, B7, A6 ; MSB(A7) * MSB(B7)  A6

.M1 ou bien B9
Le choix de l’unité de traitement (1 ou 2) dépend de la destination.

Chapitre 4 Cours DSP 21


Syntaxe des instructions

Load / Store :
LDH .D2 *B2++, B7 ; Charger (B2)  B7, Incrémenter B2

LDH .D1 *A2++, A7 ; Charger (A2)  A7, Incrémenter A2


LDH : chargement de 16 bits (H: half word).
LDW : chargement de 32 bits (W: word).

STW .D1 A1, *+A4[20] ; Store A1  (A4) offset par 20


stocké 32 bits de A1 dans une mémoire dont l’adresse est spécifiée par
A4 décalé par 20 mots (32 bits) c.à.d. 80 octets.
Noté que le continu de A4 ne va pas changer après le stockage puisque
une seule + est utilisée.

Chapitre 4 Cours DSP 22


Syntaxe des instructions
Branchement / Move :
MVK .L1 0x20, A1 ; Move 16 LSBs de 0x20  A1

Loop: MVK .L2 0x10, B4 ; Move 16 LSBs de 0x10  B4

MVKH .S1 0x15, A4 ; Move 16 MSBs de 0x15  16 MSBs A4



SUB .S1 A1, 1, A1 ; Décrémenter A1

[A1] B .S2 Loop ; Branchement à Loop si A1≠0

NOP 5 ; 5 instructions de No-operation

STW .D1 A3, *A7 ; Stocker A3 dans (A7)

Chapitre 4 Cours DSP 23


Contraintes
Contrainte chemin croisé :
Le code suivant est valide :
ADD .L1x A1, B1, A0
|| MPY .M2x A2, B2, B3

Le code suivant n’est pas valide :


ADD .L1x A1, B1, A0 oui
|| MPY .M1x A2, B2, B3 non
.M2x
Chapitre 4 Cours DSP 24
Contraintes

Contrainte stockage/chargement :
Les registres adresses utilisés doivent être du même chemin que
l’unité .D :
Le code suivant est valide :
LDW .D1 *A1, A2
|| LDW .D2 *B1, B2
Le code suivant n’est pas valide :
LDW .D1 *A1, A2 oui
|| LDW .D2 *A3, B2 non
*B3

Chapitre 4 Cours DSP 25


Contraintes
Le chargement et le stockage en parallèle ne peuvent pas être
du même chemin de registres (les registres A et les registres B) :
Le code suivant est valide :
LDW .D1 *A0, B1
|| STW .D2 A1, *B2
Le code suivant est valide :
LDW .D1 *A0, B1
|| LDW .D2 *B2, A1
Le code suivant n’est pas valide :
LDW .D1 *A0, A1 oui
|| STW .D2 A2 ,*B2 oui

Chapitre 4 Cours DSP 26


Contraintes

Le code suivant est valide :


LDW .D1T2 *A0, B1 .D1T1
|| STW .D2T1 A1, *B2 || .D2T2
Le code suivant est valide :
.D1T2
LDW .D1T2 *A0, B1
|| .D2T1
|| LDW .D2T1 *B2, A1
Le code suivant n’est pas valide :
.D1T1
LDW .D1T1 *A0, A1 oui
|| STW .D2T1 A2 ,*B2 oui || .D2T1
.D2T2 B3

Chapitre 4 Cours DSP 27


FIN
Chapitre 4

Chapitre 4 Cours DSP 28