FR2752965A1 - Traitement de donnees multiples a une seule instruction utilisant des rangees multiples de registres vectoriels - Google Patents

Traitement de donnees multiples a une seule instruction utilisant des rangees multiples de registres vectoriels Download PDF

Info

Publication number
FR2752965A1
FR2752965A1 FR9710436A FR9710436A FR2752965A1 FR 2752965 A1 FR2752965 A1 FR 2752965A1 FR 9710436 A FR9710436 A FR 9710436A FR 9710436 A FR9710436 A FR 9710436A FR 2752965 A1 FR2752965 A1 FR 2752965A1
Authority
FR
France
Prior art keywords
register
vector
instruction
data
srb
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Granted
Application number
FR9710436A
Other languages
English (en)
Other versions
FR2752965B1 (fr
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Samsung Electronics Co Ltd
Original Assignee
Samsung Electronics Co Ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Samsung Electronics Co Ltd filed Critical Samsung Electronics Co Ltd
Publication of FR2752965A1 publication Critical patent/FR2752965A1/fr
Application granted granted Critical
Publication of FR2752965B1 publication Critical patent/FR2752965B1/fr
Anticipated expiration legal-status Critical
Expired - Lifetime legal-status Critical Current

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F15/00—Digital computers in general; Data processing equipment in general
    • G06F15/16—Combinations of two or more digital computers each having at least an arithmetic unit, a program unit and a register, e.g. for a simultaneous processing of several programs
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30003—Arrangements for executing specific machine instructions
    • G06F9/30007—Arrangements for executing specific machine instructions to perform operations on data operands
    • G06F9/30025—Format conversion instructions, e.g. Floating-Point to Integer, decimal conversion
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F15/00—Digital computers in general; Data processing equipment in general
    • G06F15/76—Architectures of general purpose stored program computers
    • G06F15/80—Architectures of general purpose stored program computers comprising an array of processing units with common control, e.g. single instruction multiple data processors
    • G06F15/8053—Vector processors
    • G06F15/8076—Details on data register access
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30003—Arrangements for executing specific machine instructions
    • G06F9/30007—Arrangements for executing specific machine instructions to perform operations on data operands
    • G06F9/30036—Instructions to perform operations on packed data, e.g. vector, tile or matrix operations
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30098—Register arrangements
    • G06F9/30105—Register structure
    • G06F9/30109—Register structure having multiple operands in a single register
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30098—Register arrangements
    • G06F9/30105—Register structure
    • G06F9/30112—Register structure comprising data of variable length
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30098—Register arrangements
    • G06F9/3012—Organisation of register space, e.g. banked or distributed register file
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30098—Register arrangements
    • G06F9/3012—Organisation of register space, e.g. banked or distributed register file
    • G06F9/3013—Organisation of register space, e.g. banked or distributed register file according to data content, e.g. floating-point registers, address registers
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30145—Instruction analysis, e.g. decoding, instruction word fields
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30145—Instruction analysis, e.g. decoding, instruction word fields
    • G06F9/3016—Decoding the operand specifier, e.g. specifier format
    • G06F9/30167—Decoding the operand specifier, e.g. specifier format of immediate specifier, e.g. constants
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30181—Instruction operation extension or modification
    • G06F9/30189—Instruction operation extension or modification according to execution mode, e.g. mode flag

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Software Systems (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Computer Hardware Design (AREA)
  • Mathematical Physics (AREA)
  • Computing Systems (AREA)
  • Complex Calculations (AREA)
  • Advance Control (AREA)
  • Memory System (AREA)
  • Executing Machine-Instructions (AREA)

Abstract

L'invention concerne un processeur vectoriel. Selon l'invention, il comprend deux rangées de registres vectoriels, chaque registre vectoriel pouvant enregistrer des éléments de données multiples ainsi qu'un registre de contrôle avec une zone indiquant une rangée de défaut. Un groupe d'instructions pour le processeur vectoriel comprend des instructions qui utilisent un numéro de registre pour identifier un registre vectoriel dans la rangée de défaut qui utilise un numéro de registre pour identifier un registre vectoriel double grandeur comprenant un registre de la première rangée et un registre de la seconde rangée et des instructions qui comprennent un bit de rangée et un numéro de registre pour accéder à un registre vectoriel de chaque, rangée. L'invention s'applique notamment au traitement de données.

Description

Ce document de brevet est en rapport à et incorpore par référence, dans
leur totalité, les demandes de brevet concurremment déposées qui suivent: Demande de brevet U.S. No. INCONNU1, dossier du mandataire No. M-4354 intitulé "Multiprocessor Operation in a Multimedia Signal Processor;" Demande de brevet U.S. No. INCONNU2, dossier du
mandataire No. M-4355 intitulé "Single-Instruction-
Multiple-Data Processing in a Multimedia Signal Processor;" Demande de brevet U.S. No. INCONNU3, dossier du mandataire No. M-4365 intitulé "Efficient Context Saving and Restoring in Multiprocessors;" Demande de brevet U.S. No. INCONNU4, dossier du mandataire No. M-4366 intitulé "System and Method for Handling Software Interrupts with Argument Passing"; demande de brevet U.S. No. INCONNU5, dossier du mandataire No.M-4367, intitulé "System and Method for Handling Interrupts and Exception Events in an Asymetric Multiprocessor Architecture"; Demande de brevet U.S. No. INCONNU6, dossier du mandataire No. M-4368 intitulé "Methods and Apparatus for Processing Vidéo Data "; and Demande de brevet U.S. No. INCONNU8, dossier No. M-4370 intitulé "Single-Instruction-Multiple-Data Processing with
combined Scalar/Vector Operations".
Cette invention se rapporte à des processeurs de signaux numériques et, en particulier, à des procédés pour le traitement en parallèle d'éléments de données multiples par instruction pour des fonctions multimédia, comme le
codage et le décodage vidéo et audio.
Les processeurs de signaux numériques programmables (DSP) pour des applications multimédia comme le codage et le décodage vidéo en temps réel, nécessitent une puissance considérable de traitement pour la grande
quantité de données qu'il faut traiter en un temps limité.
Plusieurs architectures pour les processeurs de signaux numériques sont connues. Une architecture d'utilité générale, qui est employée dans la plupart des microprocesseurs, nécessite typiquement de hautes fréquences de fonctionnement pour donner un DSP ayant une puissance suffisante de calcul pour un codage ou un décodage vidéo en
temps réel. Cela rend ce DSP coûteux.
Un processeur à très long mot d'instruction (VLIW) est un DSP ayant de nombreuses unités fonctionnelles dont la plupart accomplissent des tâches différentes et relativement simples. Une seule instruction pour un DSP à VLIW peut être de 128 octets ou plus et a des parties séparées que les unités fonctionnelles séparées exécutent en parallèle. Les DSP à VLIW ont une grande puissance de calcul, parce que de nombreuses unités fonctionnelles peuvent fonctionner en parallèle. Les DSP à VLIW ont également un prix relativement bas, parce que chaque unité fonctionnelle est relativement petite et simple. Un problème pour les DSP à VLIW est l'inefficacité de la manipulation du contrôle d'entrée/sortie, de la communication avec un ordinateur hôte et autres fonctions qui ne se prêtent pas à une exécution en parallèle sur les unités fonctionnelles du DSP à VLIW. De plus, le logiciel de VLIW diffère du logiciel conventionnel et peut être difficile à développer, parce-que les outils de programmation et programmeurs familiers des architectures à
logiciel à VLIW sont rares.
Un DSP qui donnera un prix raisonnable, une grande puissance de calcul et un environnement familier de programmation est recherché pour des applications multimédia. Selon un aspect de l'invention, un processeur de signaux numériques multimédia (DSP) comporte un processeur vectoriel qui manipule des données vectorielles (i.e. des éléments de données multiples par opérande) pour donner une haute puissance de traitement. Le processeur utilise une architecture à données multiples à une seule instruction avec un groupe d'instructions du type RISC. Les programmeurs peuvent facilement s'adapter à l'environnement de programmation du processeur vectoriel, parce qu'il est similaire aux environnements de programmation des processeurs d'utilité générale avec lesquels la plupart des
programmeurs sont familiers.
Le DSP comporte un groupe de registres vectoriels d'utilité générale. Chaque registre vectoriel a une grandeur fixe, mais il est réparti en éléments séparés de données,
d'une grandeur pouvant être sélectionnée par l'utilisateur.
En conséquence, le nombre d'éléments de données stockés dans un registre vectoriel dépend de la grandeur sélectionnée pour les éléments. Par exemple, un registre à 32 octets peut être divisé en trente deux éléments de données à 8 bits, seize éléments de données à 16 bits ou huit éléments de données à 32 bits. La sélection de la grandeur des données et du type est faite par une instruction qui traite les données associées au registre vectoriel et un trajet de données d'exécution pour l'instruction accomplit un certain nombre d'opérations en parallèle qui dépendent de la
grandeur des données indiquées par une instruction.
Les instructions pour le processeur vectoriel peuvent avoir des registres vectoriels ou registres scalaires en tant qu'opérandes, et manipuler des éléments de données multiples de registres vectoriels en parallèle, donc la puissance de calcul est élevée. Un exemple de groupe d'instructions pour un processeur vectoriel selon l'invention comprend: des opérations d'interface du coprocesseur; des opérations de contrôle de circulation; des opérations de charge/enregistrement; et des opérations logiques/arithmétiques. Les opérations logiques/ arithmétiques comprennent des opérations qui combinent des éléments de données d'un registre vectoriel avec des éléments correspondants de données d'un ou plusieurs autres registres vectoriels pour générer les éléments de données d'un vecteur résultant de données. D'autres opérations logiques/arithmétiques mélangent divers éléments de données d'un ou plusieurs registres vectoriels ou combinent les éléments de données d'un registre vectoriel
avec des quantités scalaires.
Une extension de l'architecture du processeur vectoriel ajoute des registres scalaires, dont chacun contient un élément de données scalaire. La combinaison des registres scalaires et vectoriels facilite l'extension du groupe d'instructions du processeur vectoriel pour inclure des opérations qui, en parallèle, combinent chaque élément de données d'un vecteur avec une valeur scalaire. Une instruction, par exemple, multiplie les éléments de données d'un vecteur par une valeur scalaire. Les registres scalaires fournissent également un emplacement pour l'enregistrement d'un seul élément de données à extraire de, ou à enregistrer dans, un registre vectoriel. Le registre scalaire est également commode pour le passage de l'information entre le processeur vectoriel et un coprocesseur ayant une architecture qui ne prévoit que des registres scalaires et des calculs des adresses effectives
pour les opérations de charge/enregistrement.
Selon un autre aspect de l'invention, des registres vectoriels dans le processeur vectoriel sont organisés en rangées, chaque rangée peut être sélectionnée pour être la rangée "courante" alors que l'autre rangée est la rangée "alternative". Un bit de la "rangée courante" dans un registre de contrôle du processeur vectoriel indique que l'on est dans la rangée courante. Pour réduire le nombre de bits requis pour identifier un registre vectoriel, certaines instructions ne donnent qu'un numéro de registre pour identifier un registre vectoriel dans la rangée courante. Les instructions de charge/enregistrement ont un bit additionnel pour identifier un registre vectoriel de chaque rangée. En conséquence, les opérations de charge/enregistrement peuvent extraire la donnée de la rangée alternative pendant la manipulation de la donnée dans la rangée courante. Cela facilite une mise en pipeline du logiciel pour le traitement de l'image et des processus graphiques et cela réduit les retards du processeur lorsque l'on extrait des données parce que les opérations logiques/arithmétiques peuvent être accomplies en désordre avec les opérations de charge/enregistrement accédant à l'autre rangée de registre. Dans d'autres instructions, l'autre rangée permet l'utilisation de registres vectoriels de double grandeur, qui comprennent un registre vectoriel de la rangée courante et un registre vectoriel correspondant de l'autre rangée. De tels registres de double grandeur peuvent être identifiés par une syntaxe d'instructions. Un bit de contrôle dans le processeur vectoriel peut être établi de manière que la grandeur du vecteur de défaut soit un ou deux registres vectoriels. L'autre rangée permet également l'utilisation de moins d'opérandes explicites identifiés dans la syntaxe des instructions complexes comme battre, débattre, saturer et transferts conditionnels, qui ont deux
registres de source et deux de destination.
Le processeur vectoriel réalise de plus de nouvelles instructions comme moyenne quadratique, battre, débattre, maximum par paire et échange et saturé. Ces instructions accomplissent des opérations courantes dans les fonctions des multimédia comme le codage et le décodage vidéo et prennent la place de deux instructions ou plus, lesquels autres groupes d'instruction nécessiteraient de réaliser la même fonction. En conséquence, le groupe d'instructions du processeur vectoriel améliore l'efficacité et la vitesse des
programmes dans des applications multimédia.
L'invention sera mieux comprise et d'autres buts, caractéristiques, détails et avantages de celle-ci
apparaîtront plus clairement dans la description explicative
qui va suivre faite en référence aux dessins schématiques annexés donné à titre d'exemple illustrant plusieurs modes de réalisation et dans lesquels: La figure 1 donne un schéma blocs d'un processeur multimédia selon un mode de réalisation de l'invention. La figure 2 donne un schéma blocs d'un processeur vectoriel
pour le processeur multimédia de la figure 1.
La figure 3 donne un schéma blocs d'une unité d'extraction d'instruction pour le processeur vectoriel de
la figure 2.
La figure 4 donne un schéma blocs d'une unité d'extraction d'instructions pour le processeur vectoriel de
la figure 2.
les figures 5A, 5B et 5C montrent les stades d'exécution de pipelines pour une instruction registre à registre, une instruction de charge et une instruction d'enregistrement pour le processeur
vectoriel de la figure 2.
La figure 6A donne un schéma blocs pour un trajet de données d'exécution pour le processeur vectoriel de la
figure 2.
La figure 6B donne un schéma blocs d'un fichier de registre pour le trajet de données d'exécution de la
figure 6A.
La figure 6C donne un schéma blocs pour des unités logiques de traitement parallèle pour le trajet de
données d'exécution de la figure 6A.
La figure 7 donne un schéma blocs pour une unité de charge/enregistrement pour le processeur
vectoriel de la figure 2.
La figure 8 illustre des formats pour un groupe d'instructions d'un processeur vectoriel selon
un mode de réalisation de l'invention.
L'utilisation des mêmes symboles de référence sur les différentes figures indique des articles similaires ou identiques. La figure 1 montre un schéma blocs d'un mode de réalisation d'un processeur de signaux multimédia (MSP) 100 selon un mode de réalisation de l'invention. Le processeur multimédia 100 comporte un noyau de traitement 105 contenant un processeur 110 d'utilité générale et un processeur vectoriel 120. Le noyau de traitement 105 est connecté au restant du processeur multimédia 100 par un sous-système d'antémémoire 130, qui contient des SRAM 160 et 190, une ROM 170 et un contrôle d'antémémoire 180. Le contrôle d'antémémoire 180 peut configurer la SRAM 160, comme une antémémoire d'instructions 162 et une antémémoire de données 164 pour le processeur 110, et configurer la SRAM 190 comme une antémémoire d'instructions 192 et une antémémoire
de données 194 pour le processeur vectoriel 120.
Une ROM 170 sur puce contient des données et des instructions pour les processeurs 110 et 120, et elle peut également être configurée comme une antémémoire. Dans l'exemple de mode de réalisation, la ROM 170 contient: des processus de remise à l'état initial et d'initialisation; des processus de diagnostic d'auto-test; des manipulateurs d'interruption et d'exception, et des sous-routines pour l'émulation du programmateur; des sous-routines pour le traitement de signaux du modem V.34; les fonctions de téléphonie générale; des bibliothèques de sous-routines graphiques 1D et 3D; et des bibliothèques de sous-routines pour les standards audio et vidéo, comme MPEG-1, MPEG-2,
H.261, H.263, G.728 et G.723.
Le sous-système d'antémémoire 130 connecte les processeurs 110 et 120 à deux bus de système 140 et 150 et fonctionne à la fois comme une antémémoire et une station de commutation pour les processeurs 110 - et 120 et les dispositifs couplés aux bus 140 et 150. Le bus 150 du système fonctionne à une plus haute fréquence d'horloge que le bus 140 et il est connecté à un contrôleur de mémoire 158, une interface de bus local 156, un contrôleur de DMA 154 et une interface de dispositif 152 qui, respectivement, forment des interfaces pour une mémoire locale externe, un bus local d'un ordinateur hôte, les accès directs à une mémoire et divers convertisseurs analogiques à numériques et numériques à analogiques. Au bus 140 sont connectés un temporisateur du système 142, un UART 144 (émetteur récepteur asynchrone universel), un processeur 146 de train de bits et un contrôleur d'interruption 148. Les demandes de brevet incorporées ci-dessus, intitulées "Multiprocessor Operation in a Multimedia Signal Processor" et "Methods and Apparatus for Processing Video Data" décrivent mieux le fonctionnement du sous-système d'antémémoire 130 et les exemples de dispositif auxquels les processeurs 110 et 120 ont accès, par
le sous-système d'antémémoire 130 et les bus 140 et 150.
Les processeurs 110 et 120 exécutent des chemins séparés de programme, sont différents par leur structure pour l'exécution plus efficace de tâches particulières qui leur sont assignées. Le processeur 110 est principalement pour des fonctions de contrôle comme l'exécution d'un système de fonctionnement en temps réel et fonctions similaires ne nécessitant pas de grands nombres de calculs répétitifs. En conséquence, le processeur 110 ne nécessite pas une forte puissance de calcul et il peut être réalisé en utilisant une
architecture de processeur conventionnel d'utilité générale.
Le processeur vectoriel 120 accomplit pour la plus grande part un certain nombre d'écrasements qui impliquent des opérations répétitives sur des blocs de données courantes dans le traitement multimédia. Pour une forte puissance de calcul et une programmation relativement simple, le processeur vectoriel 120 a une architecture de SIMD (données multiples à une seule instruction); et dans l'exemple de mode de réalisation, la plupart des trajets de données dans le processeur vectoriel 120 ont soit 288 ou 576 bits de large, pour supporter la manipulation des données vectorielles. De plus, le groupe d'instructions pour le processeur vectoriel 120 comprend des instructions particulièrement
adaptées aux problèmes multimédia.
Dans l'exemple de mode de réalisation, le processeur 110 est un processeur RISC à 32 bits qui fonctionne à 40 MHz et se conforme à l'architecture d'un processeur ARM7 comprenant
un groupe de registres tel que défini par le standard ARM7.
Une architecture et un jeu d'instructions pour un processeur RISC de ARM7 sont décrits dans le "ARM7DM Data Sheet" Numéro de Document: ARM DDI 001OG qui est disponible auprès de Advance RISC Machines Ltd. La Feuille de Données de ARM7DM
est incorporée ici par référence dans sa totalité.
L'Appendice A décrit l'extension du groupe d'instructions
d'ARM7 dans l'exemple de mode de réalisation.
Le processeur vectoriel 120 manipule des quantités vectorielles et scalaires. Dans l'exemple de mode de réalisation, le processeur vectoriel de données se compose d'un moteur RISC à pipeline qui fonctionne à 80 MHz. Les registres du processeur vectorielle 120 comprennent des registres scalaires à 32 bits, des registres d'utilité spéciale à 32 bits, et deux rangées de registres vectoriels 288 et deux registres accumulateurs vectoriels double grandeur (i.e. 576 bits). L'Appendice C décrit le groupe de registres pour l'exemple de mode de réalisation du processeur vectoriel 120. Dans l'exemple de mode de réalisation, le processeur 120 comprend 32 registres scalaires qui sont identifiés dans les instructions par des numéros de registre à 5 bits allant de 0 à 31. Il y a également 64 registres vectoriels de 288 bits qui sont organisés en deux rangées de 32 registres vectoriels. Chaque registre vectoriel peut être identifié par un numéro de la rangée à 1 bit (0 ou 1) et un numéro du registre vectoriel à 5 bits allant de 0 à 31. La plus grande partie de l'instruction n'accède qu'au registre vectoriel dans une rangée courante, comme cela est indiqué par un bit de rangée de défaut CBANK stocké dans un registre de contrôle VCSR du processeur vectoriel 120. Un second bit de contrôle VCSR 64 indique si les numéros de registre par défaut identifient un registre vectoriel double grandeur comprenant un registre de chaque rangée. La syntaxe des instructions permet de faire la distinction entre les numéros de registre identifiant un registre vectoriel et les numéros de registre identifiant un
registre scalaire.
Chaque registre vectoriel peut être réparti en éléments de données de grandeur programmable. Le tableau 1 montre les types de données supportés pour des éléments de données dans
un registre vectoriel à 288 bits.
Tableau 1:
Type Donnée Grandeur Interprétation donnée int8 8 bits 8 bits complément à 2 entre -128 (octet) et 127 int9 9 bits 9 bits complément à 2 entre -256 (octet 9) et 255 intl6 16 bits 16 bits complément à 2 entre _ ___ (demimots) -32 768 et 32 767 int32 32 bits 32 bits complément à 2 entre (mot) -2147483648 et 2147483647 flottement 32 bits 32 bits format précision unique (mot) IEEE 754
L'appendice D donne de plus amples descriptions des grandeurs
des données et des types supportés dans l'exemple de mode de
réalisation de l'invention.
Pour le type de données int9, des octets de 9 bits sont tassés consécutivement dans un registre vectoriel à 288 bits, mais, pour les autres types de données, tous les neuvièmes bits d'un registre vectoriel à 288 bits sont inutilisés. Un registre vectoriel à 288 bits peut contenir 32 éléments de données entier 8 et 9 bits, 16 éléments de données entier de 16 bits ou 8 éléments de données entier ou à virgule flottante de 32 bits. De plus, deux registres vectoriels peuvent être combinés pour introduire les éléments de données dans un vecteur double grandeur. Dans l'exemple de mode de réalisation de l'invention, l'établissement d'un bit de contrôle VEC64 dans un registre de contrôle et d'état VCSR place le processeur vectoriel 120 en mode VEC64 o la double grandeur (576 bits)
est la grandeur de défaut des registres vectoriels.
Le processeur multimédia 100 contient également un groupe de registres étendus 115 à 32 bits qui sont accessibles aux deux processeurs 110 et 120. L'Appendice B 1l décrit le groupe de registres étendus ainsi que leur fonction dans l'exemple de mode de réalisation de cette invention. Les registres étendus et les registres scalaires et d'utilité spéciale du processeur vectoriel 120 sont accessibles au processeur 110 dans certaines circonstances. Deux registres étendus, spéciaux à "l'utilisateur", ont deux ports de lecture pour permettre aux processeurs 110 et 120 de lire simultanément les registres. On ne peut accéder simultanément
à d'autres registres étendus.
Le processeur vectoriel 120 a deux états alternatifs VPRUN et VPIDLE qui indiquent si le processeur vectoriel 120 fonctionne ou est inactif. Le processeur 100 peut lire ou écrire les registres scalaires ou d'utilité spéciale du processeur vectoriel 120 quand le processeur vectoriel 120 est à l'état VPIDLE mais les résultats du processeur 110 lisant ou écrivant un registre du processeur vectoriel 120 alors que le processeur vectoriel 120 est à un
état VP_ RUN ne sont pas définis.
L'extension du groupe d'instructions de ARM7 pour le processeur 110 comprend des instructions qui accèdent aux registres étendus et aux registres scalaires ou d'utilité spéciale du processeur vectoriel 120. Les instructions MFER et MFEP déplacent respectivement les données d'un registre étendu et d'un registre scalaire ou d'utilité spéciale dans le processeur vectoriel 120 vers un registre général dans le processeur 110. Les instructions MTER et MTEP déplacent respectivement les données d'un registre général dans le processeur 110 à un registre étendu et un registre scalaire ou d'utilité spéciale dans le processeur vectoriel 120. Une instruction TESTSET à la fois lit un registre étendu et établit le bit 30 du registre étendu à 1. L'instruction TESTSET facilite la synchronisation utilisateur/producteur en établissant le bit 30 pour signaler au processeur 120 que le
processeur 110 a lu (ou utilisé) un résultat produit.
D'autres instructions pour le processeur 110 comme STARTVP et INTVP contrôle l'état de fonctionnement du processeur
vectoriel 120.
Le processeur 110 agit comme un processeur maitre pour contrôler le fonctionnement du processeur vectoriel 120. En utilisant une division asymétrique du contrôle entre les processeurs 110 et 120, cela simplifie le problème de la synchronisation des processeurs 110 et 120. Le processeur 110 initialise le processeur vectoriel 120 en écrivant une adresse d'instruction à un compteur du programme pour le processeur vectoriel 120, tandis que le processeur vectoriel 120 est à l'état VP IDLE. Le processeur 110 exécute alors une instruction STARTVP qui fait passer le processeur vectoriel 120 à l'état VP_RUN. A l'état VP_RUN, le processeur vectoriel 120 extrait les instructions à travers un sous-système d'antémémoire 130 et exécute ces instructions en parallèle avec le processeur 110 continuant à exécuter son propre programme. Après départ, le processeur vectoriel 120 continue l'exécution jusqu'à ce qu'il rencontre une exception, exécutant une instruction VCJOIN ou VCINT avec une condition appropriée satisfaite ou étant interrompu par le processeur 110. Le processeur vectoriel 120 peut faire passer les résultats de l'exécution de programme vers le processeur 110 en écrivant les résultats dans un registre étendu en écrivant les résultats à l'espace d'adresse partagé des processeurs 110 et 120 ou en laissant le résultat dans un registre scalaire ou d'utilisation spéciale, auquel processeur 110 a accès quand le processeur vectoriel 120
entre à nouveau à l'état VP _IDLE.
Le processeur vectoriel 120 ne traite pas ses propres exceptions. Lors de l'exécution d'une instruction qui provoque une exception, le processeur vectoriel 120 entre à l'état VPIDLE et signale une demande d'interruption par une ligne directe au processeur 110. Le processeur vectoriel 120 reste à l'état VP _IDLE jusqu'à ce que le processeur 110 exécute une autre instruction STARTVP. Le processeur 110 est responsable de la lecture d'un registre VISCR du processeur vectoriel 120 pour déterminer la nature de l'exception, du traitement de l'exception éventuellement par réinitialisation du processeur vectoriel 120, puis de la direction du processeur vectoriel 120 pour reprendre l'exécution, si cela
est souhaitable.
Une instruction INTVP exécutée par le processeur 110 interrompt le processeur vectoriel 120, forçant le processeur
vectoriel 120 à entrer à l'état inactif VPIDLE.
L'instruction INTVP peut par exemple être utilisée dans un système multitâches pour commuter le processeur vectoriel de l'accomplissement d'une tâche comme un décodage vidéo à
d'autres tâches comme une émulation de carte son.
Les instructions du processeur vectoriel VCINT et VCJOIN sont des instructions de contrôle de circulation qui, si une condition indiquée par l'instruction est satisfaite, arrêtent l'exécution par le processeur vectoriel 120, placent le processeur vectoriel 120 à l'état VP IDLE et émettent une demande d'interruption pour le processeur 110, à moins que de telles demandes soient masquées. Le compteur de programme (registre VPC d'utilité spéciale) du processeur vectoriel 120 indique l'adresse d'instruction après l'instruction VCINT ou VCJOIN. Le processeur 110 peut vérifier un registre de source d'interruption VISRC du processeur vectoriel 120, pour déterminer si une instruction VCINT ou VCJOIN a provoqué la demande d'interruption. Comme le processeur vectoriel 120 a de grands bus de données et est plus efficace pour mettre en réserve et restaurer ses registres, le logiciel exécuté par le processeur vectoriel 120 doit mettre en réserve et restaurer les registres pendant la commutation de contexte. La demande de brevet incorporée ci-dessus, intitulée "Efficient Context Saving and Restoring in Multiprocessors", décrit un exemple
d'un système pour la commutation de contexte.
La figure 2 montre les blocs fonctionnels primaires de
l'exemple de mode de réalisation du processeur vectoriel 120.
Le processeur vectoriel 120 comprend une unité d'extraction d'instruction (IFU) 210, un décodeur 220, un planificateur 230, un trajet de données d'exécution 240 et une unité de charge/enregistrement (LSU) 250. IFU 210 extrait les instructions et traite les instructions de contrôle de circulation, comme les branchements. Le décodeur d'instruction 220 décode une instruction par cycle dans l'ordre d'arrivée de la IFU 210 et écrit des valeurs de zone décodées de l'instruction dans une FIFO dans le planificateur 230. Le planificateur 230 sélectionne les valeurs de zone qui sont émises vers les registres de contrôle d'exécution, comme cela est requis pour les stades d'exécution des opérations. La sélection de sortie dépend de la dépendance des opérandes et de la disponibilité des ressources de traitement, comme le trajet des données d'exécution 240, ou l'unité de charge/enregistrement 250. Le trajet de données d'exécution 240 exécute des instructions logiques/arithmétiques, qui manipulent les données vectorielles ou scalaires. L'unité de charge/enregistrement 250 exécute des instructions de charge/enregistrement qui
accèdent à l'espace d'adresse du processeur vectoriel 120.
La figure 3 donne un schéma blocs d'un mode de réalisation de la IFU 210 qui contient un tampon d'instructions qui est divisé en un tampon principal d'instructions 310 et un tampon secondaire d'instructions 312. Le tampon principal 310 contient huit instructions consécutives, comprenant l'instruction correspondant au compte du programme courant. Le tampon secondaire 312 contient les huit instructions qui suivent immédiatement les instructions dans le tampon 310. La IFU 210 comprend également un tampon cible de branchement 314 contenant huit instructions consécutives comprenant la cible de l'instruction de contrôle de circulation suivante dans le tampon 310 ou 312. Dans l'exemple de mode de réalisation, le processeur vectoriel 120 utilise un groupe d'instructions du type RISC, o chaque instruction a 32 bits de long et les tampons 310, 312 et 314 sont des tampons à 8x32 bits et ils sont connectés au sous-système d'antémémoire 130 par un bus d'instructions de 256 bits. LaIFU 210 peut charger huit instructions du sous-système d'antémémoire 130 dans tout tampon 310, 312 ou 314 dans un seul cycle d'horloge. Les registres 340, 342 et 344 indiquent respectivement les adresses de base pour les instructions chargées dans les
tampons 310, 312 et 314.
Un multiplexeur 332 sélectionne l'instruction courante d'un tampon principal d'instructions 310. Si l'instruction courante n'est pas une instruction du contrôle de circulation et qu'une instruction stockée dans le registre d'instructions 330 avance à un stade d'exécution de décodage, l'instruction courante est stockée dans un registre
d'instructions 330 et le compte du programme est incrémenté.
Après avoir été incrémenté, le compte du programme sélectionne la dernière instruction dans le tampon 310, le groupe suivant de huit instructions est chargé dans le tampon 310. Si le tampon 312 contient les huit instructions souhaitées, les contenus du tampon 312 et du registre 342 sont immédiatement déplacés au tampon 310 et au registre 340 et huit instructions de plus sont pré-extraites du système d'antémémoire 130 dans le tampon secondaire 312. Un additionneur 350 détermine l'adresse du groupe suivant d'instructions de l'adresse de base dans le registre 342 et un décalage sélectionné par un multiplexeur 352. L'adresse résultante de l'additionneur 350 est enregistrée dans le registre 342, pendant ou après le passage de l'adresse du registre 342 au registre 340. L'adresse calculée est également envoyée au sous-système d'antémémoire 130 avec la demande pour huit instructions. Si un appel précédent au système de contrôle d'antémémoire n'a pas encore fourni les huit instructions suivantes vers le tampon 312, comme cela est requis par le tampon 310, les instructions demandées au préalable sont immédiatement enregistrées dans le tampon 310
quand elles sont reçues du sous-système d'antémémoire 130.
Si l'instruction courante est une instruction de contrôle de circulation, IFU 210 traite l'instruction en évaluant une condition pour l'instruction de contrôle de circulation et en remettant au point le compte du programme à
la suite de l'instruction du contrôle de circulation.
L'IFU 210 est maintenue si la condition est indéterminée, parce qu'une instruction précédente, qui peut changer la condition, n'a pas abouti. Si un branchement n'est pas effectué le compteur du programme est incrémenté et l'instruction suivante est sélectionnée comme décrit ci-dessus. Si un branchement est effectué et que le tampon cible de branchement 314 contient la cible du branchement, les contenus du tampon 314 et du registre 344 sont déplacés au tampon 310 et au registre 340, donc la IFU 210 peut continuer à appliquer les instructions au décodeur 220 sans
attendre les instructions du sous-système d'antémémoire 130.
Pour pré-extraire les instructions du tampon cible de branchement 314, un scanner 320 explore les tampons 310 et 312 pour localiser l'instruction de contrôle de circulation suivante, suivant le compte du programme courant. Si une instruction de contrôle de circulation est trouvée dans le tampon 310 ou 312, le scanner 320 détermine le décalage par rapport à l'adresse de base du tampon 310 ou 312 contenant l'instruction à un groupe aligné de huit instructions comprenant l'adresse cible de l'instruction de contrôle de circulation. Des multiplexeurs 352 et 354 procurent le décalage par rapport à l'instruction du contrôle de circulation et l'adresse de base du registre 340 ou 342 à l'additionneur 350, qui génère une nouvelle adresse de base pour le tampon 314. La nouvelle adresse de base passe au sous-système d'antémémoire 130 qui produit subséquemment les huit instructions pour le tampon cible de
branchement 314.
Dans la manipulation des instructions de contrôle de circulation comme les instructions "décrément et branchement conditionnel" VDlCBR, VD2CBR et VD3CBR et l'instruction "changement registre contrôle" VCHGCR, l'IFU 210 peut changer les valeurs des registres en plus du compte du programme. Quand la IFU 210 trouve une instruction qui n'est pas une instruction de contrôle de circulation, cette instruction passe vers le registre d'instructions 330 et, de
là, au décodeur 220.
Le décodeur 220 décode une instruction en écrivant les valeurs de contrôle dans les zones d'un tampon 410 FIFO dans le planificateur 230, comme le montre la figure 4. Le tampon 410 FIFO contient quatre rangées de flip-flops, dont chacune peut contenir cinq zones d'information pour contrôler l'exécution d'une instruction. La rangée 0 à 3 contient l'information respectivement pour les instructions de la plus ancienne à la plus nouvelle et l'information dans le tampon 410 FIFO décale vers le bas jusqu'aux rangées inférieures quand l'information la plus ancienne est retirée en tant qu'instruction complète. Le planificateur 230 émet une instruction pour un étage d'exécution en sélectionnant les zones nécessaires de l'instruction à charger dans un tuyau de contrôle 420 comprenant des registres d'exécution 421 à 427. La plupart des instructions peuvent être planifiées pour une émission et une exécution sans ordre. En particulier, l'ordre des opérations logiques/arithmétiques relatives et des opérations de charge/enregistrement est arbitraire, à moins qu'il n'y ait des dépendances des opérandes entre les opérations de charge/enregistrement et des opérations logiques / arithmétiques. Les comparaisons des valeurs des zones dans le tampon 410 FIFO indiquent s'il existe des dépendances des opérandes. La figure 5A illustre un pipeline d'exécution à six étages ou stades pour une instruction qui accomplit une opération registre à registre sans accéder à l'espace d'adresse du processeur vectoriel 120. Dans un étage 511 d'extraction d'instruction, la IFU 210 extrait une instruction comme décrit ci-dessus. L'étage d'extraction nécessite un cycle d'horloge à moins que la IFU 210 ne soit retenue par un retard dans le pipeline, une condition de branchement non résolue ou un retard dans le sous-système
d'antémémoire 130 produisant les instructions pré-extraites.
Dans l'étage de décodage 512, le décodeur 220 décode l'instruction de la IFU 210 et écrit l'information pour l'instruction au planificateur 230. L'étage de décodeur 512 nécessite également un cycle d'horloge, à moins qu'aucune rangée dans la FIFO 410 ne soit disponible pour une nouvelle opération. L'opération peut être émise pour le tuyau de contrôle 420 pendant le premier cycle dans FIFO 410, mais peut être retardée par l'émission d'opérations plus anciennes. Le trajet de données d'exécution 240 accomplit des opérations registre à registre et procure des données et des adresses pour les opérations de charge/enregistrement. La figure 6A donne un schéma blocs d'un mode de réalisation du trajet de données d'exécution 240 et est décrite en conjonction avec les étages d'exécution 514, 515 et 516. Le registre d'exécution 421 produit des signaux identifiant deux registres dans un fichier de registres 610 qui sont lus dans un cycle d'horloge pendant le stade de lecture 514. Le fichier de registres 610 comprend 32 registres scalaires et 64 registres vectoriels. La figure 6B donne un schéma blocs du fichier de registres 610. Le fichier de registres 610 a deux ports de lecture et deux ports d'écriture pour permettre jusqu'à deux lectures et deux écritures à chaque cycle d'horloge. Chaque port comporte un circuit de sélection 612, 614, 616 ou 618 et un bus de données à 288 bits 613, 615, 617 ou 619. Les circuits de sélection, tels que les circuits 612, 614, 616 et 618, sont bien connus et utilisent un signal d'adresse WRADDR1, WRADDR2, RDADDR1 OU RDADDR2, que le décodeur 220 dérive d'un numéro de registre à 5 bits qui est typiquement extrait d'une instruction, d'un bit de rangée du registre d'état de contrôle ou d'instructions VCSR et d'une syntaxe d'instructions qui indiquent si les registres sont des registres vectoriels ou des registres scalaires. La donnée lue peut être acheminée par le multiplexeur 656 vers l'unité de charge/enregistrement 250 ou par les multiplexeurs 622 et 624, par un multiplicateur 620, une unité logique arithmétique 630 ou un accumulateur 640. La plupart des opérations lisent deux registres et le stade de lecture 514 est terminé en un cycle. Cependant, certaines instructions, comme l'instruction de multiplication et d'addition VMAD et des instructions qui manipulent des vecteurs double grandeur, nécessitent des données de plus de deux registres, donc le stade de lecture 514 est plus long qu'un cycle d'horloge. Pendant le stade d'exécution 515, le multiplicateur 620, l'unité logique/arithmétique 630 et l'accumulateur 640
traitent les données déjà lues du fichier de registres 610.
Le stade d'exécution 515 peut recouvrir le stade de lecture 514 si un cycle multiple est requis pour lire la donnée nécessaire. La durée du stade d'exécution 515 dépend du type d'éléments de données (entier ou virgule ou point flottant) et de la quantité (nombre de cycles de lecture) des données traitées. Les signaux de registre d'exécution 422, 423 et 425 contrôlent l'entrée de données vers l'unité logique/arithmétique 630, l'accumulateur 640 et le multiplicateur 620 pour les premières opérations accomplies pendant le stade d'exécution. Les signaux des registres d'exécution 432, 433 et 435 contrôlent les secondes opérations accomplies pendant le stade
d'exécution 515.
La figure 6C donne un schéma blocs d'un mode de réalisation du multiplicateur 620 et de l'ALU 630. Le multiplicateur 620 est un multiplicateur d'entier qui
contient huit multiplicateurs indépendants de 36x36 bits.
Chaque multiplicateur 626 contient quatre multiplicateurs de 9x9 bits qui sont connectés ensemble par un ensemble de circuits de contrôle. Pour la grandeur d'élément de données de 8 bits et 9 bits, les signaux de contrôle du planificateur 230 déconnectent les quatre multiplicateurs de 9x9 bits les uns des autres, de manière que chaque multiplicateur 626 accomplisse quatre multiplications et que le multiplicateur 620 accomplisse 32 multiplications indépendantes pendant un cycle. Pour les éléments de données à 16 bits, l'ensemble de circuits de contrôle connecte les paires de multiplicateurs de 9x9 bits pour fonctionner ensemble et le multiplicateur 620 accomplit 16 multiplications en parallèle. Pour le type d'élément de données entier à 32 bits, huit multiplicateurs 626 accomplissent 8 multiplications en parallèle par cycle d'horloge. Les résultats d'une multiplication donnent 576 bits pour une grandeur d'élément de données de 9 bits et 512 bits pour les autres grandeurs de données. ALU 630 peut traiter le résultat obtenu de 276 bits
ou 512 bits du multiplicateur 620 en deux cycles d'horloge.
ALU 630 contient huit ALU indépendantes 636 de 36 bits.
Chaque ALU 636 contient une unité à point flottant de 32x32 bits pour des additions et multiplications à point flottant. Des éléments de circuit additionnels réalisent les
fonctions de décalage d'entiers, arithmétiques et logiques.
Pour des manipulations d'entiers, chaque ALU 636 contient quatre unités capables de manipulations indépendantes sur huit bits et neuf bits et est capable d'être enchaînée en groupes de deux ou quatre pour des éléments de données
entier à 16 bits et 32 bits.
L'accumulateur 640 accumule les résultats et comprend deux registres de 576 bits pour une précision supérieure des
résultats intermédiaires.
Pendant le stade d'écriture 516, les résultats du stade
d'exécution sont stockés dans le fichier de registres 610.
Deux registres peuvent être écrits pendant un seul cycle d'horloge, et les multiplexeurs d'entrée 602 et 605 sélectionnaient deux valeurs de données à écrire. La durée du stade d'écriture 516 pour une opération dépend de la quantité de données à écrire par suite de l'opération et de la compétition de la LSU 250 qui peut accomplir une instruction de charge en l'écrivant dans le fichier de registres 610. Les signaux des registres d'exécution 426 et 427 sélectionnent le registre dans lequel est écrite la donnée de l'unité logique 630, de
l'accumulateur 640 et du multiplicateur 620.
La figure 5B montre un pipeline d'exécution 520 pour l'exécution d'une instruction de charge. L'étage d'extraction d'instruction 511, l'étage de décodage 512 et l'étage d'émission 513 pour le pipeline d'exécution 520 sont les mêmes que ceux décrits pour une opération registre à registre. L'étage de lecture 514 est également le même que décrit ci-dessus, à l'exception que le trajet de données d'exécution 240 utilise les données du fichier de registres 610 pour déterminer une adresse pour un appel au sous-système d'antémémoire 130. Dans l'étage d'adresse 525, des multiplexeurs 652, 654 et 656 sélectionnent l'adresse qui est appliquée à l'unité de charge/enregistrement 250 pour les étages d'exécution 526, 527. L'information pour l'opération de charge reste dans FIFO 410 pendant les stades 526 et 527, alors que l'unité de
charge/enregistrement 250 traite l'opération.
La figure 7 montre un mode de réalisation de l'unité de charge/enregistrement 250. Pendant le stade 256, un appel est fait au sous-système d'antémémoire 130 pour la donnée de l'adresse déterminée à l'étage 525. cet exemple de réalisation utilise des appels d'antémémoire basés sur une transaction, o des dispositifs multiples comprenant des processeurs 110 et 120 peuvent accéder à l'espace d'adresse local par le sous-système d'antémémoire 130. La donnée requise peut ne pas être disponible pendant plusieurs cycles après un appel au sous-système d'antémémoire 130, mais l'unité de charge/enregistrement 250 peut effectuer des appels au sous-système d'antémémoire, alors que d'autres appels sont en cours. En conséquence, l'unité de charge/enregistrement 250 n'est pas retenue. Le nombre de cycles d'horloge requis pour que le soussystème d'antémémoire 130 produise la donnée requise dépend du fait qu'il y a une correspondance ou une absence d'information
dans l'antémémoire de données 194.
A l'étage d'entraînement 527, le sous-système d'antémémoire 130 revendique un signal de données pour l'unité de charge/enregistrement 250. Le sous-système d'antémémoire 130 peut produire 256 bits (32 octets) de
données par cycle pour l'unité de charge/enregistrement 250.
Un aligneur d'octets 710 aligne chacun des 32 octets dans un emplacement de stockage correspondant de 9 bits, pour produire une valeur de 288 bits. Le format de 288 bits est commode pour des applications multimédia, comme un codage et un décodage MPEG qui, quelquefois, emploient des éléments de données de 9 bits. La valeur de 288 bits est écrite dans un tampon de données de lecture 720. Pour l'étage d'écriture 528, le planificateur 230 transfère la zone 4 du tampon 410 FIFO au registre d'exécution 426 ou 427 pour écrire la quantité de 288 bits du tampon de données 720 dans
le fichier de registres 610.
La figure 5C montre un pipeline d'exécution 530 pour l'exécution d'une instruction d'enregistrement. L'étage d'extraction d'instruction 511, l'étage de décodage 512 et l'étage d'émission 513 pour le pipeline d'exécution 530 sont les mêmes que décrits ci-dessus. L'étage de lecture 514 est également le même que décrit ci-dessus, à l'exception que l'étage de lecture lit les données à enregistrer et les données pour les calculs d'adresse. La donnée à enregistrer est écrite dans le tampon de données d'écriture 730 dans l'unité de charge/enregistrement 250. Des multiplexeurs 740 convertissent la donnée qui est sous un format produisant des octets de 9 bits en un format conventionnel ayant des octets de 8 bits. La donnée convertie du tampon 730 et l'adresse associée de l'étage de calcul d'adresse 525 sont envoyées en parallèle au sous-système d'antémémoire 130
pendant le stade de SRAM 536.
Dans l'exemple de mode de réalisation de processeur vectoriel 120, chaque instruction a 32 bits de long et a l'un des neuf formats montrés à la figure 8 marqués REAR, REAI, RRRM5, RRRR, RI, CT, RRRM9, RRRM9* et RRRM9**. L'Appendice E décrit le groupe d'instructions pour
le processeur vectoriel 120.
Certaines opérations de charge, enregistrement et antémémoire, qui utilisent des registres scalaires lors de
la détermination d'une adresse effective ont le format REAR.
Les instructions au format REAR sont identifiées par les bits 29-31 comme étant 00Ob et ont trois opérandes identifiés par deux numéros de registre SRb et SRi pour les registres scalaires et un numéro de registre Rn d'un registre qui peut être un registre scalaire ou vectoriel selon un bit D. Un bit de rangée B soit identifie une rangée pour le registre Rn ou bien indique si le registre vectoriel Rn est un registre vectoriel double grandeur si la grandeur du registre du vecteur de défaut est double. Une zone Op-code, Opc, identifie l'opération accomplie sur les opérandes et une zone TT indique un type de transfert comme charge ou enregistrement. Une instruction au format REAR typique est l'instruction VL qui charge le registre Rn à partir d'une adresse déterminée en ajoutant les contenus des registres scalaires SRb et Sri. Si un bit A est établi, l'adresse calculée est enregistrée dans le registre
scalaire SRb.
Les instructions au format REAI sont les mêmes que les instructions REAR, à l'exception qu'une valeur immédiate de 8 bits de la zone IMM est utilisée à la place des contenus du registre scalaire SRi. Les formats REAR et REAI
n'ont pas de zone à la grandeur de l'élément de données.
Le format RRRM5 est pour des instructions ayant deux opérandes de source et un opérande de destination. Ces instructions ont soit trois opérandes de registre ou deux opérandes de registre et une valeur immédiate de 5 bits. Un codage des zones D, S et M, comme le montre l'Appendice E, détermine si le premier opérande de source Ra est un registre scalaire ou vectoriel; si le second opérande de source Rb/IM5 est un registre scalaire, un registre vectoriel ou une valeur immédiate à 5 bits; et si le registre de destination Rd est un registre scalaire ou vectoriel. Le format RRRR est pour des instructions ayant quatre opérandes de registre. Les numéros de registre Ra et Rb indiquent les registres de source. Le numéro de registre Rd indique un registre de destination et le numéro de registre Rc indique soit un registre de source ou de destination selon Opc de la zone. Tous les opérandes sont des registres vectoriels à moins que le bit S ne soit établi pour indiquer que le registre Rb est un registre scalaire. La zone DS indique la grandeur de l'élément de données pour les registres vectoriels. La zone Opc sélectionne le type de
données pour des éléments de données à 32 bits.
Une instruction au format RI charge une valeur immédiate dans un registre. La zone IMM contient une valeur immédiate pouvant atteindre 18 bits. Le numéro de registre Rd indique le registre de destination qui est soit un registre vectoriel dans la rangée courante, soit un registre scalaire selon le bit D. Les zones DS et F indiquent respectivement une grandeur d'élément de données et un type. Pour des éléments de données entiers à 32 bits, la valeur immédiate de 18 bits est étendue au signe avant d'être chargée dans le registre Rd. Pour des éléments de données à point flottant, le bit 18, les bits 17 à 10 et les bits 9 à 0 indiquent respectivement le signe, l'exposant
et la mantisse d'une valeur à point flottant de 32 bits.
Le format CT est pour les instructions du contrôle d'écoulement et comprend une zone de code-op, Opc, une zone
de condition, Cond, et une valeur immédiate de 23 bits, IMM.
Un branchement est pris quand une condition indiquée par la zone de condition est vraie. Les codes possibles de condition sont "toujours", "moins que", "égal", "moins que ou égal", "plus grand que", "non égal", "plus grand que ou égal" et "débordement". Les bits GT, EQ, LT et SO dans le registre d'état et de contrôle VCSR sont utilisés pour
évaluer les conditions.
Le format RRRM9 prévoit soit trois opérandes de registre soit deux opérandes de registre et une valeur immédiate de 9 bits. Une combinaison des bits D, S et M indique lesquels des opérandes sont des registres vectoriels, des registres scalaires ou des valeurs immédiates à 9 bits. La zone DS indique une grandeur d'élément de données. Les formats RRRM9* et RRRM9** sont des cas spéciaux du format RRRM9 et distingués par la zone de code-Op Opc. Le format RRRM9* remplace un numéro de registre
de source Ra par un code de condition Cond et une zone ID.
Le format RRRM9** remplace les bits de poids fort de la valeur immédiate par un code de condition Cond et un bit K.
Une plus ample description de RRRM9 et RRRM9** est donnée à
l'Appendice E, pour ce qui concerne l'instruction de mouvement conditionnel VCMOV, les instruction de mouvement conditionnel avec le masque d'élément CMOVM et de
comparaison et d'établissement du masque CMPV.
APPENDICE A
Dans l'exemple de mode de réalisation, le processeur 110 est un processeur d'utilité générale qui est en accord avec le standard pour un processeur ARM7. On peut se référer à un document d'architecture d'ARM ou à la Feuille de Données de ARM7 (document numéro ARM DDI 0020C,
publié en décembre 1994) pour la description des registres
dans 1'ARM7.
Pour coopérer avec le processeur vectoriel 120, le processeur 110: démarre et arrête le processeur vectoriel; teste l'état du processeur vectoriel, comprenant la synchronisation; transfère les données d'un registre scalaire/ d'utilité spéciale dans le processeur vectoriel 120 à un registre général dans le processeur 110; et transfère les données d'un registre général à un registre
scalaire/d'utilisation spéciale d'un processeur vectoriel.
Il n'y a pas de moyen direct de transfert entre un registre
général et un registre vectoriel d'un processeur vectoriel.
De tels transferts nécessitent une mémoire intermédiaire.
Le tableau A.1 décrit l'extension au groupe d'instructions d'ARM7 pour les interactions du processeur vectoriel. Tableau A.1: Extension du groupe d'instructions d'ARM7 Instruction Résultat STARTVP Cette instruction force le processeur vectoriel à entrer dans l'état VPRUN mais n'a pas d'effet si le processeur vectoriel est déjà à l'état VP RUN. STARTVP est réalisée en tant que classe d'opération de données de processeur (CDP) dans l'architecture de ARM7. Aucun résultat n'est recommuniqué à ARM7 et ARM7 continue son exécution. INTVP Cette instruction force le processeur vectoriel à entrer dans l'état VPIDEL mais n'a pas d'effet si le processeur vectoriel est déjà à l'état VPIDLE. INTVP est réalisée en tant que classe d'opération (CDP) de données du processeur dans l'architecture de ARM7. Aucun résultat n'est recommuniqué à ARM7 et ARM7 continue son exécution. TESTSET Cette instruction lit un registre étendu à l'utilisateur et établit le bit 30 du registre à 1 pour produire un type de synchronisation producteur/consommateur entre les processeurs vectoriel et de ARM7. TESTSET est réalisée en tant que classe de transfert de registre du processeur (MRC) dans l'architecture de ARM7. L'ARM7 est à l'arrêt jusqu'à ce que l'instruction soit
exécutée (le registre est transféré).
MFER Passe d'un registre étendu à un registre général de ARM. MFER est réalisée en tant que classe de transfert de registre du
processeur (MRC) dans l'architecture de ARM7.
ARM7 est à l'arrêt jusqu'à ce que l'instruction soit exécutée (le registre est transféré). MFVP Passe d'un registre scalaire/d'utilité spéciale du processeur vectoriel à un registre général de ARM7. Contrairement aux autres instructions de ARM7, cette instruction doit être exécutée uniquement lorsque le processeur vectoriel est à l'état VPIDLE. Le résultat est autrement non défini. MFVP est réalisée en tant que classe de transfert du registre du processeur (MRC) dans l'architecture de ARM7. ARM7 est à l'arrêt jusqu'à ce que l'instruction soit
exécutée (le registre est transféré).
Instruction Résultat MTER Passe à un registre étendu à partir d'un registre général de ARM7. MTER est réalisé en tant que classe de transfert du registre du coprocesseur (MCR) dans l'architecture de ARM7. ARM7 est à l'arrêt jusqu'à ce que l'instruction soit exécutée (le registre est transféré). MTVP Passe à un registre scalaire/d'utilité spéciale du processeur vectoriel à partir d'un registre général de ARM7. Contrairement aux autres instructions de ARM7, cette instruction ne doit être attendue que lorsque
le processeur vectoriel est à l'état VPIDLE.
Le résultat est autrement non défini. MTVP est réalisé en tant que classe de transfert du registre du coprocesseur (MCR) dans l'architecture de ARM7. ARM7 est à l'arrêt jusqu'à ce que l'instruction soit
exécutée (le reqistre est transféré).
CACHE Produit la gestion du logiciel de
l'antémémoire de données de ARM7.
PFTCH Pré-extrait une ligne d'antémémoire dans
l'antémémoire de données de ARM7.
WBACK Réécrit une ligne d'antémémoire de l'antémémoire de données de ARM7 dans la mémoire. Le tableau A.2 donne la liste des exceptions de ARM7, qui sont détectées et rapportées avant exécution de l'instruction défaillante. L'adresse du vecteur d'exception
est donnée en notation hexadécimale.
Tableau A.2: Exceptions de ARM7
Vecteur d'exception Description
OxOOOO00000000 Remise Etat Initial ARM7 0x00000004 Exception Instruction Non Définie ARM7 0x00000004 Exception Processeur Vectoriel Non Disponible 0x00000008 Interruption Logiciel ARM7 OxOOO0000000C Exception Seule Etape ARM7 OxOOO0000000C Exception Point de Rupture Adresse Instruction ARM7 OxO0000010 Exception Point de Rupture Adresse Donnée ARM7 OxO0000010 Exception Point de Rupture Adresse Donnée Incorrecte ARM7 0x00000018 Exception Violation Protection ARM7 Ce qui suit décrit la syntaxe de l'extension au groupe d'instructions de ARM7. Se référer à un document d'architecture de ARM ou à la feuille de Données de ARM7 (document numéro ARM DDI 0020C, publié en
décembre 1994) pour une description de la nomenclature et
les formats d'instruction.
L'architecture de ARM offre trois formats d'instructions pour une interface avec un coprocesseur: 1. opérations pour des données de coprocesseur (CDP) 2. transferts pour des données de coprocesseur
(LDC,STC)
3. Transferts registre au processeur (MRC, MCR) Les extensions d'architecture de MSP utilisent les trois formes. Le format des opérations de données du coprocesseur (CDP) est utilisé pour les opérations qui ne
nécessitent pas une recommunication avec ARM7.
Format CDP
25 20 15 10 5 0
1 1C11o1ni till lt l l l tl iI1 1 I i t I i t It I 7iI - iI t 7 I fCond jl1,i 1j0PUINIWILRn! CRn CP# 1 décalage i jI I IIII J11 1I I I tI I I II I I I Les zones dans le format CDP ont les conventions suivantes: Zone |Siqnification Cond Zone condition. Cette zone spécifie la condition
dans laquelle l'instruction doit être exécutée.
Opc Code fonctionnement coprocesseur.
CRn Registre opérande coprocesseur.
CRd Reqistre destination coprocesseur.
CP# Numéro coprocesseur. Les numéros suivants de coprocesseur sont couramment utilisés: 1111 - antémémoire données de ARM7 0111 - processeur vectoriel, registres étendus
CP Information coprocesseur.
CPm Registre opérande coprocesseur. Le format de transfert de données du coprocesseur (LDC, STC)est utilisé
pour charger ou enregistrer un sous-groupe de registres du processeur vectoriel directement dans la mémoire. Le processeur de ARM7 est responsable de la fourniture de l'adresse du mot et le processeur vectoriel fournit ou accepte les données et contrôle le nombre de mots transférés. Se référer à la
Feuille de Données de ARM7 pour plus de détails.
Format LDC, STC
25 20 15 10 5 0
I i I t I I j j f, [ t iI] I I t I t, Cond Il11i0PlIUINIWILI Rn Crn CP# i décalage It f I I 1 t i iI I I I I I 1 1 tI I I Les zones aans ie format ont les conventions suivantes Zone Siqnification Cond Zone condition. Cette zone spécifie la condition
dans laquelle l'instruction doit être exécutée. P Bit indexage pré/post.
U Bit haut/bas. N Longueur transfert. Comme il n'y a pas suffisamment de bits dans la zone CRd, le bit N est utilisé comme partie de l'identificateur du registre de source ou
de destination. W Bit réécriture.
L Bit charqe/enreqistrement. Rn Registre de base. CRn Reqistre source/destination coprocesseur. CP# Numéro coprocesseur. Les numéros suivants de coprocesseur sont couramment utilisés: 1111-antémémoire données ARM7 0111-reqistres étendus, processeur vectoriel
Offset Décalaqe immédiat 8 bits sans siqne.
Le format de transfert de registre du coprocesseur (MRC, MCR) est utilisé pour communiquer l'information directement entre ARM7 et le processeur vectoriel. Ce format est utilisé pour un déplacement entre un registre de ARM7 et un registre scalaire ou d'utilité
spéciale du processeur vectoriel.
Format MRC, MCR
*25 20 15 10 5 0
C nIIi II i I I I IL I t II R I C I I I P I I I I t I I I I I I I I I t I I I I I I I I I t I t I I I t I ICond I1I111H01 Opc ILI CRn! Rd I CP# I CP I11 CRm I IIl t t [ I I
!I I II I I I [
Les zones dans le format ont les conventions suivantes: Zone Signification Cond Zone condition. Cette zone spécifie la condition
dans laquelle l'instruction doit être exécutée.
Opc Code opération coprocesseur.
L Bit charge/enregistrement.
L=0 signifie passage au processeur vectoriel L=1 siqnifie passage du processeur vectoriel CRn:Crm Registre source/destination coprocesseur. On
n'utilise que CRn<1:0>:CRm<3:0>.
Rd Registre source/destination ARM.
CP# Numéro coprocesseur. Les numéros suivants de coprocesseur sont couramment utilisés: 1111 - antémémoire données ARM7 0111 - registres étendus, processeur vectoriel
CP Information coprocesseur.
DESCRIPTION INSTRUCTIONS ETENDUES ARM
Les instructions étendues de ARM sont décrites par
ordre alphabétique.
ANTEMEMOIRE Opération antémémoire Format
25 20 15 10 5 0
IJD-C décalageI I I LD ó| t i I I I; I I l I I I I I I II iI l!!! STC iCond W0 Rn I Opc | 1111 i décalage I, I t! II, II,, Syntaxe Assembleur STC{cond} p15, cOpc, <adresse> CACHE{cond} Opc, <adresse> o cond = {eq, he, cs, cc, mi, pl, vs, vc, hi, Is, ge, It, gt, le, ai, nv} et Opc = {0, 1, 3}. Noter que, comme la zone CRn du format LDC/STC est utilisé pour spécifier Opc, la représentation décimale du code op doit être précédée par la lettre ' c ' (i.e. utiliser cO au lieu de O) dans la première syntaxe. Se référer à la Feuille de Données de ARM7 pour la syntaxe de mode d'adresse.
Description
Cette instruction est exécutée uniquement si Cond est vraie. Opc<3:0> spécifie les opérations suivantes: Opc<3:0> Siqnification 0000 Réécrire et invalider la ligne sale d'antémémoire spécifiée par EA. Si la ligne d'adaptation contient des données propres la ligne est invalidée sans la réécriture. Si l'on ne trouve aucune ligne d'antémémoire contenant EA, l'antémémoire de
données reste intacte.
0001 Réécrire et invalider la ligne sale d'antémémoire spécifiée par l'indice de EA. Si la ligne d'adaptation contient des données propres, la ligne
est invalidée sans la réécriture.
Utilisé par les instructions PFTCH et WBACK.
0011 Invalider la ligne d'antémémoire spécifiée par EA.
La ligne d'antémémoire est invalidée (sans
réécriture même si la ligne est sale).
C'est une opération privilégiée et provoquant une Violation de la Protection de ARM7 si elle est
tentée en mode utilisateur.
Autres Réservé.
Opération Se référer à la Feuille de Données de ARM7 pour la
façon dont on calcule EA.
Exception
Violation de la Protection de ARM7.
INTVP Interruption Processeur Vectoriel Format
25 20 15 10 5 0
ii i I I I I I J 1 1I t iI I I I t i ' tI, t ]I 1 11 1I IliI IIIIl I-II titi lit.J CDP ICond 111111101 00011 I I 0111 loi l I'l!!i I I ' 'I'
, I I I I I I, I
Syntaxe Assembleur CDP{cond} p7, 1, cO, cO, co INTVP{cond} o cond = {eq, ne, es, cc, mi, pl, vs, vc, hi, ls, ge, it, gt, le, ai, ns}
Description
Cette instruction n'est exécutée que si Cond est vraie.
Cette instruction signale au processeur vectoriel qu'il doit s'arrêter. ARM7 continue à exécuter l'instruction suivante sans attendre que le processeur vectoriel s'arrête. Une boucle occupé-attente MFER devrait être utilisée pour voir si le processeur vectoriel s'est arrêté après exécution de cette instruction. Cette instruction n'a pas d'effets si le processeur vectoriel est déjà à
l'état VPIDLE.
Les bits 19:22, 7:15 et 3:0 sont réservés.
Exception
Processeur vectoriel non disponible.
MFER Passer du Registre Etendu Format
23 20 15 10 5 0
-l IIII I ---,II, I I I1T I I,T I I mi!Cond 11010 1 I Rl l u 1 McR I odRj!l, Syntaxe Assembleur MRC{cond} p7, 2, Rd, cP, cER, 0 MFER {cond} Rd, RNAME o cond = {eq, he, cs, cc, mi, pl. rs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd = {rO,..r15}, P={0, 1}, ER = {0,..15} et RNAME se rapporte à la mnémonique du registre spécifiée par l'architecture (i.e., PERO ou CSR).
Description
Cette instruction n'est exécutée que si Cond est vrai.
Le registre Rd de ARM7 est déplacé du registre ER étendu spécifié avec P:ER<3:0>, commune le montre le tableau ci-dessous. Se référer à la Section 1.2 pour
des descriptions de registres étendus.
ER<3:0> P = 0 P = 1
0000 UERO PERO
0001 UER1 PER1
UER2 PER2
0011 UER3 PER3
UER4 PER4
0101 UER5 PER5
UER6 PER6
0111 UER7 PER7
1000 UER8 PER8
1001 UER9 PER9
1010 UER10 PER10
1011 UER11 PER11
1100 UER12 PER12
1101 UER13 PER13
1110 UER14 PER14
1111 UER15 PER15
Bits 19:17 et 7:5 réservés.
Exception Violation de la protection lors d'une tentative d'accès
à PERx en mode d'utilisateur.
MFVP Passer du Processeur Vectoriel Format MRC I I I II | II i t MCR ICond 111111101 010 Ill CRn I Rd i 0111 I 111 CRm I,II , I ' i I ' EII
I I I I! I | I
Syntaxe Assembleur MRC{cond} p7.1.Rd.Crn.CRm.O MFVP { cond} Rd. RNAME o cond = {eq, ne, cs, cc, mi, pl, vs, vc, hi, ls, ge, lt, gt, le, ai, nv}, Rd={rO,...r15}, Crn=({cO,...c15}, Crm={cO,...c15} et RNAME se rapporte à la mnémonique du registre spécifiée par l'architecture (i.e., SPO ou VCS).
Description
Cette instruction n'est exécutée que si Cond est vraie.
Le registre Rd de ARM7 passe du registre d'utilité spéciale/scalaire du processeur vectoriel CRn<1:O>:CRm<3:0>. Se référer à la section 3.2.3 pour l'affectation du numéro de registre du processeur
vectoriel pour les transferts des registres.
Les bits 7:5 ainsi que CRn<3:2> sont réservés.
La topographie des registres du processeur vectoriel est montrée cidessous. Se référer au tableau 15 pour les registres d'utilité spéciale du processeur
vectoriel (SPO-SP15).
CRM<3:0> CRn<1:0≥00 CRn<1:0≥01 CRn<1:0≥10 CRn<1:0≥111
0000 SRO SR16 SPO RASRO
0001 SR1 SR17 SPO RASR1
SR2 SR18 SPO RASR2
0011 SR3 SR19 SPO RASR3
SR4 SR20 SPO RASR4
0101 SR5 SR21 SPO RASR5
SR6 SR22 SPO RASR6
0111 SR7 SR23 SPO RASR7
1000 SR8 SR24 SPO RASR8
1001 SR9 SR25 SPO RASR9
1010 SR10 SR26 SPO RASR10
1011 SR11 SR27 SPO RASR11
1100 SR12 SR28 SPO RASR12
1101 SR13 SR29 SPO RASR13
1110 SR14 SR30 SPO RASR14
1111 SR15 SR31 SPO RASR15
SRO se lit toujours comme 32 bits de zéros et une écriture
en est ignorée.
Exception
Processeur vectoriel indisponible.
MTER Passer à Registre Etendu Format
25 20 15 10 5 0
T--T-! 10 5 I IilJi I I I' I I tIi I i IIIl I I i i I iiI ll MCRCn 1111110I010 1li IPI Rd 01,11111 ERI tI l liI I lI tII I} MCR IIIn
I:I I II I,
Syntaxe Assembleur MRC{cond} p7, 2, Rd, cP, cER, 0 MFER{cond} Rd, RNAME o cond = {eq, he, cs, cc, mi, pl. rs,vc,hi, ls,ge, lt, gt, le, al, nv}, Rd = {rO,...r15}, p={0, 1}, ER = {0,..15} et RNAME se rapporte à la mnémonique du registre spécifiée dans l'architecture (i.e., PERO ou CSR).
Description
Cette instruction n'est exécutée que si Cond est vraie.
Le registre Rd de ARM7 passe du registre étendu spécifié ER avec P:ER<3:0>, comme le montre le tableau ci-dessous.
ER<3:0> P = 0 P. = 1
0000 UER0 PER0
0001 UER1 - PERi
UER2 PER2
0011 UER3 PER3
UER4 PER4
0101 UER5 PER5
UER6 PER6
0111 UER7 PER7
1000 UER8 PER8
1001 UER9 PER9
1010 UER10 PER10
1011 UER11 PER11
1100 UER12 PER12
1101 UER13 PER13
1110 UER14 PER14
1111 UER15 PER15
Les bits 19:17 et 7:5 sont réservés.
Exception Violation de la protection lorsque l'on tente d'accéder
à PERx en mode d'utilisateur.
GIUSVU oas úIdS Glus Tl _E__S_ o as 6 ZS ú1S 1011 ZIS__ o0S 8zuS ZIuS 0011 IIUSVU OdS LZ_ S IIS 110 O0USTI o0S 9sIs O0IS 0101 6USVU ods _ _s_ 6US 1001 8SU 0aoS tzs 8dS 0001 LúS_ E O as ú ZS LUS I10 9USU 0Oas zzus 9US 0110 USVU 0ias TZUs sS 1010 7ska 0as OzS0$ s _ 0010 _ Es_ U 0oas 61US úES 1100 zs__ ods 81iS ZuS 0100 ISV'U oas LIúS lIS 1000 ouS__ - 0_oS 9luS 0ous 0000 I1=<0: I>uD 0o=<o: î>uD 10=<0: î>UEO 00=<0:>UMD <0: >NUD snossep-To aaauo qsa aTaoqDaA znasseoozd np GsaTs6aba sap GTqdEaBodo- -e ÀsaAaasz quos <E:ú>uzD enb TsuT S:L SIq sGI <0: ú>u<ro: <:>uW iaaoqoaA anassasood np GI-eleos/sIeToGCds gqTITFn,pGs- 5Ta np assidLN'UVap p a.tsT5Fol r aTeaA qsa puoD TS anb aannoexa qsa,u uoToniasuT GqD UOTqdTaosaG (SOA no oSs "G*a F) al4aF4aIled GGa Z;FDads DaaST6eal np fnbTuouwuui e1 a a odd? as e Xs N s.a. {Io' ' '0o})=wli { '''0 o}})=uD '{ x'' ''0}=pa '{AU 'Ie 'l1 '5b '4 a6 'sT 'qI 'OA 'SA '1id 'TUI 'DO) 'SD 'au 'ba} = puoo no
WVNU'* PU {pUOD} IdA-
0'urI'D' uDPU' I ' Ld {puoo} D rn@IquIss axeuXs
I IO I I IT
uRIaD jI}1110I Io puoDj.J
I! IIII I I,III II I I II I II I I IDI
II IIII I I i j î IL D
O S 01 1 OZ SZ 0ú
IGaFOlOGA, znGssGO02d V lassed ^z zi S96ZSgZ Exception Processeur vectoriel indisponible PFTCH Pré-extraction Format
25 20 15 10 5
o _ I i II I I I I I I I I I I I I I I I I I I I I LDC l i l l J l l l l l l I1 [ STC ICond 11J101PIUi0IWill Rn 0010 L 1111 | décalage 1 I i I l l l l, ] l I I I Syntaxe Assembleur LDC{cond} p15, 2, <Adresse> PFTCH{cond} <Adresse> o cond = { eq, he, cs, cc, mi, pl, rs, vc, hi, Is, ge, lt, gt, le, al, nv}. Se référer à la feuille de
données de ARM7 pour la syntaxe du mode d'adresse.
Description
Cette instruction n'est exécutée que si Cond est vrai.
La ligne d'antémémoire spécifiée par EA est pré-
extraite dans l'antémémoire de données de ARM7.
Opération Se référer à la Feuille de Données de ARM7 pour la façon
dont on calcule EA.
Exception: aucune.
STARTVP Départ Processeur Vectoriel Format
25 20 15 10 5
_ I t II II I 1 I I Il I I 3 CDP | Cond 01111111010000 i f 0111 loi
I I I
I I I
!II I II|! _I t Syntaxe Assembleur CDP{cond} p7, 0, cO, cO, cO STARTVP {cond} o cond = {eq, he, cs, cc, mi, pl, vs, vc, hi, Is, ge,
it, gt, le, ai, nv}.
Description
Cette instruction n'est exécutée que si Cond est vrai.
Cette instruction signale au processeur vectoriel qu'il doit commencer l'exécution et s'efface automatiquement VISCR<vjp> et VISCR<vip>. ARM7 continue à exécuter l'instruction suivante sans attendre que le processeur
vectoriel commence l'exécution.
L'état du processeur vectoriel doit être réinitialisé à l'état souhaité avant que cette instruction ne soit exécutée. Cette instruction n'a pas d'effet si le
processeur vectoriel est déjà à l'état VPRUN.
Les bits 19:12, 7:5 et 3:0 sont réservés.
Exception
Processeur vectoriel indisponible.
TESTSET Tester et positionner Format
25 20 15 10 5
] l I i l 1 I l II I B 11 1.
1 I I
MCR Goid 111111101 000 il 0f Rd f 0111 I Con tI 0I 00 1 I II II I I l I I IIIER Syntaxe Assembleur MRC{cond} p7, 0, Rd, CO, cER, O TESTSET{cond} Rd, RNAME o cond = {eq, he, cs, cc, mi, pl, rs, re, hi, ls, ge, It, gt, le, al, nv}, Rd = {rO,..r15}, ER={0,..15} et RNAME se rapporte à la mnémonique des registres spécifiée par l'architecture (i.e., UER1 ou VASYNC)
Description
Cette instruction n'est exécutée que si Cond est vraie.
Cette instruction retourne les contenus de UERx à Rd et établit UERx<30> à 1. Si le registre 15 de ARM7 est spécifié en tant que registre de destination, UERx<30> retourne au bit Z de CPSR, on peut donc réaliser une
courte boucle d'attente occupée.
Couramment, seul UER1 est défini pour travailler avec
cette instruction.
Les bits 19:17 et 7:5 sont réservés.
Exception: aucune.
APPENDICE B
L'architecture du processeur multimédia 100 définit les registres étendus auxquels le processeur 110 a accès avec les instructions MFER et MTER. Les registres étendus comprennent des registres étendus privilégiés et des
registres étendus de l'utilisateur.
Les registres étendus privilégiés sont utilisés pour la plupart pour contrôler l'opération du Processeur de Signaux
multimédia. Ils sont montrés dans le Tableau B.1.
Tableau B.1: Registres étendus privilégiés
Numéro Mnémonique Description
PERO CTR Registre de Contrôle PERI PVR Reqistre Version Processeur PER2 VIMSK Reqistre Masque Interruption Vectoriel PER3 AIABR Registre Point de Rupture Adresse Instruction ARM7 PER4 ADABR Registre Point de Rupture Adresse Donnée ARM7 PER5 SPREG Registre Zone de Travail PER6 STR Registre Etat Le Registre de Contrôle contrôle l'opération de MSP 100. Tous les bits dans CTR sont effacés à la à l'état initial. La définition des registres est montrée
au Tableau B.2.
Tableau B.2: Définition de CTR
Bit Mnémonique Description
31-13 réservé - toujours lu en tant que Os.
12 VDCI Bit Invalidation Antémémoire Données Vectorielles. Lorsqu'il est établi, cela force toute l'antémémoire de données du
processeur vectoriel à devenir invalide.
Comme l'opération d'invalidation de l'antémémoire est usuellement en conflit avec les opérations normales d'antémémoire, seule une séquence de
code d'invalidation est supportée.
11 VDE Bit Validation Antémémoire Données Vectorielles. A l'état effacé, cela inhibe l'antémémoire de données du
processeur vectoriel.
VICI Bit Invalidation Antémémoire Instructions Vectorielles. Lorsqu'il est établi, cela force toutes l'antémémoire d'instructions du processeur vectoriel à devenir invalide. Comme l'opération d'invalidation de l'antémémoire est usuellement en conflit avec les opérations normales de l'antémémoire, seule une séquence de code
d'invalidation est supportée.
9 VICE Bit Validation Antémémoire Instructions vectorielles. A l'état effacé, inhibe l'antémémoire d'instructions du
processeur vectoriel.
8 ADCI Bit Invalidation Antémémoire de Données ARM7. A l'état établi, force l'antémémoire de données de ARM7 à être invalide. Comme l'opération d'invalidation d'antémémoire est usuellement en conflit avec les opérations normales d'antémémoire, seule une séquence de code d'invalidation est supportée.
7 ADCE Bit Validation Antémémoire Données ARM7.
L'état effacé inhibe l'antémémoire de
données de ARM7.
Bit Mnémonique Description
6 AICI Bit Invalidation Antémémoire Instructions ARM7. A l'état établi, force toute l'antémémoire d'instructions de ARM7 à devenir invalide. Comme l'opération d'invalidation de l'antémémoire est usuellement en conflit avec des opérations normales d'antémémoire, seule une séquence de
code d'invalidation est supportée.
AICE Bit Validation Antémémoire Instructions ARM7. A l'état effacé, inhibe
l'antémémoire d'instruction de ARM7.
4 APSE Bit validation Seule Etape Processeur ARM7. A l'état établi, force le processeur de ARM7 à prendre l'exception d'une seule étape du processeur de ARM7 après exécution d'une instruction. La fonction de seule étape n'est disponible qu'en mode Utilisateur ou mode Superviseur. 3 SPAE Bit Validation Accès Zone de Travail. A l'état établi, permet à un procédé de ARM7 de charger de ou enregistrer dans la zone de travail. A l'état effacé, une tentative de charge ou d'enregistrement dans la zone de travail provoque l'exception d'Adresse de Donnée
Incorrecte de ARM7.
2 VPSE Bit Validation Seule Etape Processeur Vectoriel. A l'état établi, force le processeur vectoriel à prendre l'Exception d'une $eule Etape du Processeur Vectoriel après exécution
d'une instruction.
1 VPPE Bit Validation Pipeline Processeur Vectoriel. A l'état effacé, configure le processeur vectoriel pour fonctionner en mode non pipeline dans lequel seule une instruction est active dans le pipeline
d'exécution du processeur vectoriel.
0 VPAE Bit Validation Accès Processeur Vectoriel. A l'état établi, permet à un procédé de ARM7 d'exécuter les instructions étendues de ARM7, décrites ci-dessus. A l'état effacé, empêche un procédé de ARM7 d'exécuter les instructions étendues de ARM7. Une telle tentative provoque une exception de
_ _Processeur Vectoriel Indisponible.
Le Registre d'Etat indique l'état de MSP 100. Tous les bits dans STR de zone sont effacés à la remise à état initial. La définition du registre est montrée au
Tableau B.3.
Tableau B.3: Définition de STR
Bit Mnémonique Description
31:23 réservé - toujours lu comme Os.
22 ADAB Bit exception Point de Rupture Adresse Données ARM7 établi quand une correspondance du point de rupture
d'adresse de données de ARM7 se produit.
Cette exception est reportée par
l'interruption de Suspension de Données.
21 AIDA Une exception d'Adresse de Données Incorrectes de ARM7 se produit quand une instruction de charge ou d'enregistrement de ARM7 tente d'accéder à une adresse qui n'est pas définie ni réalisée pour une version particulière de MSP ou quand elle tente d'accéder à la zone de travail lorsque cela n'est pas permis. Cette exception est reportée par l'interruption de Suspension de Données. AIAB Bit d'exception du Point de Rupture d'Adresse d'Instruction de ARM7 établi quand une correspondance du point de rupture d'adresse d'instruction de ARM7 se produit. Cette exception est reportée
par l'interruption de Suspension de Pré-
I_ _ extraction.
19 AIIA Exception Adresse Instruction ARM7 Incorrecte. Cette exception est reportée
par l'interruption de Suspension Pré-
extraction. 18 ASTP Exception Seule Etape ARM7. Cette exception est reportée par
l'interruption de Suspension de Pré-
extraction. 17 APV Violation Protection ARM7. Cette exception est reportée par
l'interruption IRQ.
16 VPUA Exception Processeur vectoriel Indisponible. Cette exception est reportée par l'interruption de
Coprocesseur Indisponible.
-0 réservé - toujours lu comme Os.
Le Registre Version Processeur identifie la version particulière du processeur particulier de la famille de
processeurs du Processeur de Signaux Multimédia.
Le Registre de Masque d'Interruption du Processeur Vectoriel VIMSK contrôle le report des exceptions du processeur vectoriel au processeur 110. Chaque bit dans VIMSK, quand il est établi avec le bit correspondant dans le
registre VISRC, permet à l'exception d'interrompre ARM7.
Cela n'affecte pas la façon dont l'exception du processeur vectoriel est détectée mais n'affecte que le cas o l'exception doit interrompre ARM7. Tous les bits dans VIMSK sont effacés à la remise à l'état initial. La définition du
* registre est montrée au Tableau B.4.
Tableau B.4: Définition de VIMSK
Bit Mnémonique Description
31 DABE Validation Interruption Point de Rupture
Adresse Donnée.
IABE Validation Interruption Point de Rupture
Adresse Instruction.
29 SSTPE Validation Interruption Seule Etape.
28-14 ____ réservé - toujours lu comme Os.
13 FOVE Validation Interruption Débordement
Point Flottant.
12 FINVE Validation Interruption Opérande
Incorrecte Point Flottant.
11 FDIVE Validation Interruption Division par
Zéro Point Flottant.
IOVE Validation Interruption Débordement Entier. 9 IDIVE Validation Interruption Division par
Zéro Entier.
8-7 réservé - toujours lu comme 0.
6 VIE Validation Interruption VCINT.
VJE Validation Interruption VCJOIN.
4-1 réservé - toujours lu comme zéro.
0 CSE Validation Commutateur Contexte.
Le Registre du Point de Rupture d'Adresse d'Instruction de ARM7 aide à dépanner les programmes de ARM7. La
définition du registre est montrée au Tableau B.5.
Tableau B.5: Définition de AIABR
Bit Mnémonique Description
31 - 2 IADR Adresse Instruction ARM7.
1 T _réservé - toujours lu comme zéro.
0 IABE Validation Point de Rupture Adresse instruction. Effacé à la remise à l'état initial. Si établi, force l'exception du Point de Rupture de l'Adresse d'Instruction de ARM7 à se produire quand une adresse d'accès d'instruction de ARM7 correspond à AIABR<31:2> et que VCSR<AIAB> est effacé. VCSR<AIAB> est établi pour indiquer l'exception. Si VCSR<AIAB> est déjà établi quand la correspondance se produit, VCSR<AIAB> est effacé et une correspondance est ignorée. L'exception est reportée avant
que l'instruction ne soit exécutée.
Le Registre du Point de Rupture d'Adresse de Données de ARM7 aide à dépanner les programmes de ARM7. La définition
du registre est montrée au Tableau B.6.
Tableau B.6: Définition de ADABR
Bit Mnémonique Description
31-2 DADR Adresse Donnée ARM. Non définie lors de
. la remise à l'état initial.
1 SABE Stocker Validation Point de Rupture Adresse. Effacé à la remise à l'état initial. Si établi, force l'exception du Point de Rupture de l'Adresse de Donnée de ARM7 à se produire quand les 30 bits supérieurs d'une adresse d'accès d'enregistrement de ARM7 correspondent avec ADABR<31:2> et que VCSR<ADAB> est effacé. VCSR<ADAB> est établi pour indiquer l'exception. Si VCSR<ADAB> est déjà établi quand une correspondance se produit, VCSR<ADAB> est effacé et la correspondance est ignorée. L'exception est reportée avant que l'instruction
d'enreqistrement ne soit exécutée.
Bit Mnémonique Description
0 LABE Validation Point de Rupture d'Adresse de Charge. Effacé à la remise à l'état initial. Si établi, force l'exception du Point de Rupture d'Adresse de Donnée de ARM7 à se produire quand les 30 bits supérieurs d'une adresse d'accès de charge de ARM7 correspondent à ADABR<31:2> et que VCSR<ADAB> est effacé. VCSR<ADAB> est établi pour indiquer l'exception. Si VCSR<ADAB> est déjà établi quand une correspondance se produit, VCSR<ADAB> est effacé et la correspondance est ignorée. L'exception est reportée avant que l'instruction de
charge ne soit exécutée.
Le Registre de Zone de Travail configure l'adresse et la grandeur de la zone de travail formée en utilisant la SRAM dans le sous-système d'antémémoire 130. La définition
du registre est montrée au Tableau B.7.
Tableau B.7: Définition de SPREG
Bit Mnémonique Description
31-11 SPBASE Base Zone de Travail indique les 21 bits supérieurs de l'adresse de départ de la zone de travail. Cette valeur doit être le décalage de 4M octets par rapport à
la valeur dans le reqistre de MSP BASE.
-2 réservé
1-0 SPSIZE Grandeur Zone de Travail.
00->OK (avec antémémoire données processeur vectoriel 4K) 01-> 2K (avec antémémoire données processeur vectoriel 2K) ->3K (avec antémémoire données processeur vectoriel 1K) 11->4K (pas d'antémémoire donnée processeur vectoriel) Les registres étendus à l'utilisateur sont utilisés pour la plupart pour la synchronisation des processeurs 110 et 120. Les registres étendus à l'utilisateur sont couramment définis comme n'ayant qu'un bit, implanté au bit 30 et des instructions telles que " MFER R15, UERx " par exemple, retournent la valeur du bit dans le drapeau Z. Les bits UERx<31> et UERx<29:0> sont toujours lus comme des zéros. Les registres étendus à l'utilisateur sont décrits au
tableau B.8.
Tableau B.8: Registre Etendu à l'Utilisateur
Numéro Mnémonique Description
UERO VPSTATE Drapeau Etat Processeur Vectoriel. Bit , quand il est établi, indique que le processeur vectoriel est à l'état VPRUN, exécutant des instructions. Si il est effacé, cela indique que le processeur vectoriel est à l'état VP IDLE et qu'il s'est arrêté avec VPC adressant
l'instruction suivante à exécuter.
VPSTATE<30> est effacé à la remise à
l'état initial.
UER1 VASYNC Drapeau synchronisation vecteur et ARM7.
Le bit 30 est produit pour le type de synchronisation producteurconsommateur entre les processeurs vectoriel et de ARM7 120 et 110. Le processeur vectoriel 120 peut établir ou effacer ce
drapeau en utilisant l'instruction VMOV.
Ce drapeau peut également être établi ou effacé par un procédé de ARM7 en
utilisant une instruction MFER ou MTER.
De plus, le drapeau peut être lu et établi en utilisant une instruction
TESTSET.
Le Tableau B.9 montre les états des registres étendus à
la remise à l'état initial de mise en circuit.
Tableau B.9: Etat de Mise en Circuit des Registres Etendus Reqistre Remise à l'état initial
CTR 0
PVR TBD
VIMSK 0
AIABR AIABR<0≥0, tous les autres sont non définis ADABR ADABR<l:0≥0, tous les autres sont non définis
STR 0
VPSTATE VPSTATE<30≥0, tous les autres sont non définis VASYNC VASYNC<30≥0, tous les autres sont non définis
APPENDICE C
L'état d'architecture du processeur vectoriel 120 comprend: 32 registres scalaires de 32 bits; 2 rangées de 32 registres vectoriels de 288 bits; une paire de registres accumulateurs vectoriels de 576 bits; un groupe de registres d'utilité spéciale de 32 bits. Les registres scalaires, vectoriels et accumulateurs sont destinés à une programmation d'utilité générale et ils supportent de
nombreux types différents de données.
Les notations qui suivent sont utilisées dans cette section et les suivantes: VR indique un registre vectoriel; VRi indique le ième registre vectoriel (décalage zéro); VR[i] indique le ième élément de donnée dans un registre vectoriel VR; VR<a:b> indique les bits a à b dans un registre vectoriel VR; et VR[i]<a:b> indique les bits a à b
du ième élément de donnée dans un registre vectoriel VR.
Une architecture vectorielle a une dimension ajoutée de types et grandeurs de données pour les éléments multiples dans un registre vectoriel. Comme un registre vectoriel est d'une grandeur fixe, le nombre d'éléments de données qu'il
peut contenir dépend de la grandeur des éléments. L'architecture de MSP défini cinq grandeurs d'éléments comme
le montre le Tableau C.1.
Tableau C.1: Grandeur des Eléments de Données Nom Grandeur Largeur Grandeur (bits) Booléenne 1 Octet 8 Octet 9 9 Demi-mot 16 Mot 32 L'architecture de MSP interprète la donnée vectorielle selon le type et la grandeur spécifiés de la donnée dans une instruction. Couramment, deux formats en complément à deux (entier) sont supportés pour les grandeurs d'éléments d'octet, octet 9, demi-mot et mot sur la plupart des instructions arithmétiques. De plus, le format à simple précision IEEE 754 est supporté par la grandeur de l'élément
de mot pour la plupart des instructions arithmétiques.
Un programmeur est libre d'interpréter les données de toute manière souhaitée tant que la séquence d'instructions produit un résultat ayant une signification. Par exemple, le programmeur est libre d'utiliser la grandeur de l'octet 9 pour stocker des chiffres sans signe à 8 bits et qui est également libre de stocker des chiffres sans signe à 8 bits dans les éléments de données, de grandeur de l'octet et d'opérer sur eux en utilisant les instructions arithmétiques de complément à deux prévues, tant que le programme peut
traiter des résultats de " faux " débordement.
Il y a 32 registres scalaires qui sont appelés SRO à SR31. Les registres scalaires ont 32 bits de large et ils peuvent contenir un élément de donnée de toute grandeur définie. Le registre scalaire SRO est spécial par le fait que le registre SRO se lit toujours sous la forme de 32 bits
de zéros et une écriture dans le registre SRO est ignorée.
Les types de données octet, octet 9 et demi-mot sont enregistrés dans les bits de moindre poids des registres scalaires avec les bits de poids fort ayant des valeurs non définies. Comme les registres n'ont pas d'indicateur du type de donnée, les programmeurs doivent connaître le type de donnée pour les registres qui sont utilisés pour chaque instruction. Ceci est différent des autres architectures o un registre de 32 bits est supposé contenir une valeur de 32 bits. L'architecture de MSP spécifie qu'un résultat d'un type A de donnée ne modifie correctement que les bits définis pour le type de donnée A. Par exemple, le résultat d'une addition d'un octet 9 ne modifie que les 9 bits
inférieurs du registre scalaire de destination à 32 bits.
Les valeurs des 23 bits supérieurs sont non définies à moins
qu'autre chose ne soit indiqué pour une instruction.
Les 64 registres vectoriels sont organisés en deux rangées, chacune ayant 32 registres. La rangée O contient les 32 premiers registres et la rangée 1 contient les 32 seconds registres. Les deux rangées sont utilisées d'une manière o une rangée est établie en tant que rangée courante et l'autre est établie en tant que rangée alternative. Toutes les instructions vectorielles emploient les registres de la rangée courante par défaut, à l'exception des instructions de charge/enregistrement et déplacement registre qui peuvent accéder aux registres vectoriels dans l'autre rangée. Le bit CBANK dans le Registre de Contrôl61e et d'Etat Vectoriel VCSR est utilisé pour positionner la rangée O ou la rangée 1 à la rangée
courante. (L'autre rangée devient la rangée alternative).
Les registres vectoriels dans la rangée courante sont appelés VRO à VR31 et dans la rangée alternative, ils sont
appelés VRAO à VRA31.
Alternativement, les deux rangées peuvent étre conceptuellement fusionnées pour produire 32 registres vectoriels de double grandeur de 576 bits chacun. Le bit
VEC64 dans le VCR du registre de contrôle spécifie ce mode.
En mode VEC64, il n'y a pas de rangée courante ni alternative et un numéro de registre vectoriel désigne une paire correspondantes de registres vectoriels de 288 bits des deux rangées. En effet, VRi<575:0≥VRli<287:0>:VR0i<287:0> o VR0i et VR1i désignent les registres vectoriels ayant le numéro de registre Vri dans la rangée 1 et dans la rangée 0, respectivement. Les registres vectoriels à double grandeur
sont appelés VRO à VR31.
Les registres vectoriels peuvent recevoir des éléments multiples des grandeurs octet, octet 9, demi-mot ou mot
comme montré au Tableau C.2.
Tableau C.2: Nombre d'Eléments par Registre Vectoriel Grandeur Longueur Nombre Maximum Nombre Total Elément Elément (bits) d'Eléments de Bits Utilisés Octet 9 9 32 288 Octet 8 32 256 Demi-mot 16 16 256 Mot 32 8 256 Le mélange des grandeurs d'éléments dans un registre vectoriel n'est pas supporté. A l'exception de la grandeur
de l'élément Octet 9, l'on n'utilise que 256 des 288 bits.
En particulier, chaque neuvième bit est inutilisé.
Les 32 bits inutilisés dans les grandeurs octet, demi-mot et mot sont réservés et les programmeurs ne doivent effectuer
aucune supposition concernant leur valeur.
Le registre accumulateur vectoriel est destiné à permettre l'enregistrement d'un résultat intermédiaire qui à un degré plus haut de précision que le résultat dans un registre de destination. Le registre accumulateur vectoriel se compose de quatre registres de 288 bits, nommés VAC1H, VAClL, VACOH et VACOL. La paire VACOH:VACOL est utilisée par les trois instructions par défaut. Seulement, en mode VEC64, la paire VAClH:VAClL est utilisée pour l'émulation des 64 opérations vectorielles des octets 9. Même si la rangée 1 est établie pour être la rangée courante en mode
VEC32, la paire VACOH:VACOL est utilisée.
Pour produire un résultat de précision étendue avec le même nombre d'éléments que dans les registres vectoriels de source, des éléments de précision étendue sont réservés à travers une paire de registres, comme le montre le
Tableau C.3.
Tableau C.3: Format accumulateur vectoriel Grandeur Vue Logique Format VAC Elément Octet 9 VAC[i]<17:0> VACOH[i]<8>: VACOL[i]<8:0> pour i=0..31 et VAClH[i-32]<8:0>: __ ____VAC1L[i-32]<8:0> pour i=32..63 Octet VAC[i]<15:0> VACOH[i]<7:0>: VACOL[i]<7:0> pour i=0..31 et VAC1H[i-32]<7:0>: VAC1L[i32]<7:0> pour i=32..63 Demi-mot VAC[i]<31:0> VACOH[i]<15:0>: VACOL[i]<15:0> pour i=0..15 et VAC1H[i-16]<15:0>: VAC1L[i-161 pour i=16..31 Mot VAC[i]<63:0> VACOH[i]<31:0>: VACOL[i]<31:0> pour
i=0.7 et VAClH[i-8]<31:0>: VAClL[i-
8]<31:0> pour i=8..15 La paire VAC1H:VAClL n'est utilisée qu'en mode VEC64 o le nombre des éléments peut être aussi grand que 64, 32 ou 16 pour l'octet 9 (et l'Octet), le Demi-mot et le Mot, respectivement. Il y a 33 registres d'utilité spéciale qui ne peuvent être chargés directement par la mémoire ou enregistrés directement dans la mémoire. Seize registres d'utilité spéciale, appelés RASRO à RASR15, forment une pile d'adresses de retour interne et ils sont utilisés par les instructions d'appel et de retour de sous-routine. Dix- sept registres d'utilité spéciale à 32 bits de plus sont montrés
au Tableau C.4.
Tableau C.4: Registres d'Utilité Spéciale.
Numéro Mnémonique Description
SP0 VCSR Registre Vectoriel Contrôle et Etat SPA VPC Compteur Programme Vectoriel SP2 VEPC Compteur Programme Exception Vectoriel SP3 VISCR Registre Source Interruption Vectoriel SP4 VIINS Registre Instruction Interruption Vectoriel SP5 VCR1 Reqistre Compte Vectoriel 1 SP6 VCR2 Registre Compte Vectoriel 2 SP7 VCR3 Registre Compte Vectoriel 3 SP8 VGMR0 Registre Masque Global Vectoriel 0 SP9 VGMR1 Registre Masque Global Vectoriel 1 SP10 VOR0 Registre Débordement Vectoriel 0 SP11 VOR1 Registre Débordement Vectoriel 1 SP12 VIABR Registre Point Rupture Adresse !__ _ Instruction Vectoriel SP13 VDABR Registre Point Rupture Adresse Donnée i__ _ Vectoriel SP14 VMMRO Registre Masque Déplacement Vectoriel 0 SP15 VMMR1 Reqistre Masque Déplacement Vectoriel 1 SP16 VASYNC Registre Synchronisation Vectoriel et ARM7 La définition du Registre de Contrôle et d'Etat
Vectoriel VCSR est montrée au tableau C.5.
Tableau C.5: Définition de VCSR
Bit Mnémonique Description
31:18 réservé 17:13 VSP<4:0> Indicateur pile adresses retour. VSP est utilisé par les instructions saut à sous-routine et retour de sous-routine pour maintenir une trace du haut de la pile d'adresses retour interne. Il n'y a que 16 entrées dans la pile d'adresses de retour - VSP<4> est utilisé pour détecter la condition de débordement de
la pile.
Bit Mnémonique Description
12 SO Drapeau d'état de débordement récapitulatif. Ce bit est établi quand une opération arithmétique a pour résultat un débordement. Ce bit est collant - une fois établi, il reste établi jusqu'à ce qu'il soit effacé par
une écriture de 0 à ce bit.
11 GT Drapeau plus grand que l'état. Ce bit est établi par l'instruction VSUBS quand SRa>SRb. EQ Drapeau état égal. Ce bit est établi par
l'instruction VSUBS quand on a SRa=SRb.
9 LT Drapeau moins grand que l'état. Ce bit est établi par l'instruction VSUBS quand
on a SRa<SRb.
8 SMM Sélection Déplacement Masque. Lorsque ce bit est établi, la paire VMMR0/1 devient le masque de l'élément pour les
opérations arithmétiques.
7 CEM Masque Elément Complément. Lorsque ce bit est établi, le masque d'élément est défini comme étant le complément de VGMR0/1 ou VMMR0/1, selon lequel il est configuré pour être le masque d'élément
pour une opération d'arithmétique.
Ce bit ne change pas les contenus de VGMR0/1 ou VMMR0/1 - il ne change que l'usage de ces registres. Les codages SMM:CEM spécifient: 00 - utiliser VGMR0/1 comme masque d'élément pour tout sauf VCMOVM 01 - utiliser -VGMR0/1 comme masque
d'élément pour tout sauf VCMOVM-
- utiliser VMMR0/1 comme masque d'élément pour tout sauf VCMOVM 11 utiliser -VMMR0/1 comme masque d'élément pour tout sauf VCMOVM 6 OED Inhibition Exception Débordement. Quand ce bit est établi, le processeur 120 continue l'exécution lors de la détection d'une condition de débordement. ISAT Mode saturation entier. La combinaison des bits OED:ISAT spécifie: 00 - pas de saturation, report quand exception débordement se produit xl - saturation, ne peut provoquer de débordement - pas de saturation, pas de rapport quand exception débordement se produit
Bit Mnémonique Description
4:3 RMODE Mode arrondissement pour opérations avec
point flottant IEEE 754.
00 arrondir vers infini 01 arrondir vers zéro arrondir vers le plus proche 11 arrondir vers +infini 2 FSAT Bit mode saturation point flottant (mode
IEEE rapide).
1 CBANK Bit Rangée Courante. Lorsqu'il est établi, il indique que la rangée 1 est la rangée courante. Quand il est effacé il indique que la rangée 0 est la rangée courante. CBANK est ignoré quand le bit
VEC64 est établi.
0 VEC64 Bit mode vectoriel 64 octets 9.
Lorsqu'il est établi, il spécifie que les registres vectoriels et accumulateurs doivent avoir 576 bits. Le mode de défaut spécifié 32 de la grandeur de l'octet 9 que l'on appelle
mode VEC32.
Registre Compteur Programme Vectoriel VPC est l'adresse de l'instruction suivante à exécuter par le processeur vectoriel 120. Le processeur ARM7 110 doit charger le registre VPC avant d'émettre l'instruction STARTVP pour
commencer le fonctionnement du processeur vectoriel 120.
Compteur Programme Exception Vectoriel VEPC spécifie l'adresse de l'instruction qui aura le plus probablement provoqué l'exception la plus récente. MSP 100 ne supporte pas d'exceptions précises, d'o le terme "le plus
probablement ".
Reaistre Source Interruption Vectoriel VISRC indique les sources d'interruption pour le processeur ARM7 110. Le ou les bits appropriés sont établis par le matériel lors de la détection de la ou des exceptions. Le logiciel doit effacer le registre VISRC avant que le processeur vectoriel 120 ne puisse entreprendre l'exécution. Tout bit établi dans le registre VISRC force le processeur vectoriel 120 à entrer à l'état VPIDLE. Si le bit de validation de l'interruption correspondant est établi dans VIMSK, une interruption au processeur 110 est signalée. Le
Tableau C.6 définit les contenus du registre VISRC.
Tableau C.6:Définition de VISRC
Bit Mnémonique Description
31 DAB Exception Point Rupture Adresse Donnée IAB Exception Point Rupture Adresse Instruction 29 SSTP Exception Seule Etape 28-18 réservé 17 IIA Exception Adresse Instruction Incorrecte 16 IINS Exception Instruction Incorrecte IDA Exception Adresse Donnée Incorrecte 14 UDA Exception Adresse Donnée Non Aliqnée 13 FOV Exception Débordement Point Flottant 12 FINV Exception Opérande Incorrecte Point Flottant 11 FDIV Exception Division par Zéro Point Flottant IOV Exception Débordement Entier 9 IDIV Exception Division par Zéro Entier 48 RASO Exception Débordement Pile Adresses retour 7 RASU Exception sous-débordement pile adresses Retour 6 VIP Exception VCINT en cours. Exécution
instruction STARTVP efface ce bit.
VJP Exception VCJOIN en cours. Exécution
instruction STARTVP efface ce bit.
4-0 VPEV Vecteur Exception Processeur Vectoriel.
Le Registre Instruction Interruption Vectoriel VIINS est remis au point par l'instruction VCINT ou VCJOIN quand l'instruction VCINT ou VCJOIN est exécutée pour interrompre
le processeur ARM7 110.
Les Reaistres de Compte Vectoriels VCR1 VCR2. et VCR3 sont pour l'instruction Décrément Et Branchement VD1CBR, VD2CBR, et VD3CBR et ils sont initialisés par des comptes de boucles à exécuter. Quand l'instruction VD1CBR est exécutée, le registre VCR1 est décrémenté de 1. Si la valeur de compte n'est pas zéro et que la condition spécifiée dans l'instruction correspond à VFLAG, alors le branchement est pris. Sinon le branchement n'est pas pris. Le registre VCR1 est décrémenté de 1 dans chaque cas. Les registres VCR2 et
VCR3 sont utilisés de la même manière.
Le Registre de Masque Global Vectoriel VGMR0 indique les éléments du registre vectoriel de destination qui doivent être affectés en mode VEC32 et les éléments dans VR<287:0> en mode VEC64. Chaque bit dans VGMR0 contrôle la remise au point des 9 bits dans le registre de destination vectoriel. Plus particulièrement, VGMR0 indique<i> contrôle la remise au point de Vrd<9i+8:9i> en mode VEC32 et de VR0d<9i+8:9i> en mode VEC64. I1 faut noter que VR0d désigne le registre de destination dans la rangée 0 en mode VEC64 et que VRd se rapporte au registre de destination dans la rangée courante, qui peut être soit la rangée 0 soit la rangée 1, en mode VEC32. Le registre de masque global vectoriel VGMR0 est utilisé pour l'exécution de toutes les
instructions, à l'exception de l'instruction VCMOVM.
Le Registre du Masque Global Vectoriel VGMR1 indique les éléments dans VR<575:288> qui sont affectés dans le mode VEC64. Chaque bit dans le registre VGMR1 contrôle la mise au point de 9 bits dans le registre de destination vectoriel dans la rangée 1. Plus particulièrement, VGMRl<i> contrôle la remise au point de VR1<9i+8:9i>. Le registre VGMR1 n'est pas utilisé en mode VEC32 mais, en mode VEC64, il effectue l'exécution de toutes les instructions à l'exception de
l'instruction VCMOVM.
Le Registre de Débordement Vectoriel VOR0 indique les éléments en mode VEC32 et les éléments dans VR<287:0> en mode VEC64 qui contiennent des résultats de débordement après une opération arithmétique vectorielle. Ce registre
n'est pas modifié par une opération arithmétique scalaire.
Le bit VOR0<i> étant positionné indique que le ième élément de l'octet ou de l'octet 9, le (i idiv 2)ième élément du demi-mot, ou le (i idiv 4)ième élément du mot contient un résultat de débordement. Par exemple, le bit 1 et le bit 3 seront positionnés pour indiquer un débordement du premier demi-mot et de l'élément de mot, respectivement. Cette implantation des bits dans VOR0 est différente de
l'implantation des bits dans VGMR0 ou VGMR1.
Le Registre de Débordement Vectoriel VORi est utilisé pour indiquer les éléments dans VR<575:288> en mode VEC64 qui contiennent des résultats en débordement après une opération arithmétique vectorielle. Le registre VOR1 n'est pas utilisé en mode VEC32 ni modifié par une opération arithmétique scalaire. Le bit VORl<i> étant établi indique que le ième élément de l'octet ou de l'octet 9, le (i idiv 2)ième élément du demi-mot, ou le (i idiv 4)ième élément du mot contient un résultat de débordement. Par exemple, le bit 1 et le bit 3 seront positionnés pour indiquer un débordement du premier demi-mot et du mot, respectivement, dans VR<575:288>. L'implantation des bits dans VOR1 est différente de l'implantation des bits dans
VGMR0 ou VGMR1.
Le Registre du Point de Rupture d'Adresse d'Instruction
Vectoriel VIABR aide à dépanner les programmes vectoriels.
La définition du registre est montrée au Tableau C.7.
Tableau C.7: Définition de VIABR
Bit Mnémonique Description
31-2 IADR Adresse Instruction Vectorielle. Non
défini à la remise à l'état initial.
1 réservé 0 IABE Validation Point de Rupture Adresse instruction. Non défini à la remise à l'état initial. Si établi, force l'exception du Point de Rupture de l'Adresse de l'Instruction Vectorielle à se produire quand une adresse d'accès d'instruction vectorielle correspond à VIABR<31:2>. Le bit VISCR<IAB> est
établi pour indiquer l'exception.
L'exception est reportée avant que
l'instruction ne soit exécutée.
Le Registre du Processeur de Rupture d'Adresse de Donnée Vectoriel VDABR aide à dépanner les programmes vectoriels. La définition de registre est montrée au
Tableau C.8.
Tableau C.8: Définition de VDABR
Bit Mnémonique Description
31-2 DADR Adresse Donnée Vectorielle. Non défini à
la remise à l'état initiale.
1 SABE Validation Point de Rupture Adresse Enregistrement. Non défini à la remise à l'état initiale. Si établi, force l'exception du Point de Rupture de l'Adresse de la Donnée Vectorielle à se produire quand une adresse d'accès d'enregistrement vectoriel correspond à VDABR<31:2>. Le bit VISRC<DAB> est
établi pour indiquer l'exception.
L'exception est reportée avant que l'instruction d'enregistrement ne soit exécutée. 0 LABE Validation Point de Rupture Adresse Charge. Effacé à la remise à l'état initial. Si établi, force l'exception du Point de Rupture de l'Adresse de Donnée Vectorielle à se produire quand une adresse d'accès de charge vectorielle correspond à VDABR<31:2>. VISRC<DAB> est
établi pour indiquer l'exception.
L'exception est reportée avant que l'instruction de charge ne soit exécutée. Le Registre Déplacement Masque Vectoriel VMMR0 est utilisé par l'instruction VCMOVM en tout moment ainsi que quand VCSR<SMM> = 1 pour toutes les instructions. Le registre VMMR0 indique les éléments du registre vectoriel de destination qui doivent être affectés en mode VEC32 et les éléments dans VR<287:0> en mode VEC64. Chaque bit dans VMMR0 contrôle la remise au point de 9 bits dans le registre vectoriel de destination. Plus particulièrement, VMMR0<i> contrôle la remise au point de Vrd<9i+8:9i> en mode VEC32 et de VR0d<9i+8:9i> en mode VEC64. VROd désigne le registre de destination dans la rangée 0 en mode VEC64 et que VRd se rapporte au registre de destination dans la rangée courante, qui peut être soit la rangée 0 soit la rangée 1 en mode
VEC32.
Le Registre Déplacement Masque Vectoriel VMMR1 est utilisé par l'instruction VCMOVM en tout moment ainsi que quand VCSR<SMM> = 1 pour toutes les instructions. Le registre VMMR1 indique les éléments dans VR<575:288> qui doivent être affectés en mode VEC64. Chaque bit dans VBMMR1 contrôle la remise au point des 9 bits dans le registre vectoriel de destination dans la rangée 1. Plus particulièrement, VGMR1<i> contrôle la remise au point de VRld<9i+8:9i>. Le registre VGMR1 n'est pas utilisé en mode
VEC32.
Le Registre de Synchronisation Vectoriel et de ARM7 VASYNC produit un type de synchronisation
producteur/consommateur entre les processeurs 110 et 120.
Couramment, seul le bit 30 est défini. Un processeur de ARM7 peut accéder au registre VASYNC en utilisant les instructions MFER, MTER, et TESTSET alors le processeur vectoriel 120 est à l'état VPRUN ou l'état VPIDLE. Le registre VASYNC n'est pas accessible au processeur ARM7 par les instructions de TVP ou MFVP car ces instructions ne peuvent accéder au-delà des seize premiers registres d'utilité spéciale du processeur vectoriel. Un processeur vectoriel peut accéder au registre VASYNC par une
instruction VMOV.
Le Tableau C9 montre l'état du processeur vectoriel
lors d'une remise à l'état initial avec mise en circuit.
Tableau C.9: Etat Remise à l'Etat Initial avec Mise en Circuit du Processeur Vectoriel Registre Etat Remise à l'état initial
SR0O 1
tous les autres non définis Les registres d'utilité spéciale sont initialisés par le processeur ARM7 110 de avant que le processeur vectoriel ne
puisse exécuter une instruction.
APPENDICE D
Chaque instruction soit implique soit spécifie le type
de donnée des opérandes de source et de destination.
Certaines instructions ont une sémantique qui s'applique également à plus d'un type de donnée. Certaines instructions ont une sémantique qui prend un type de donnée pour la source et produisent un type de données différentes pour le résultat. Cet appendice décrit les types de données supportés par l'exemple de mode de réalisation. Le Tableau 1 dans la demande décrit les types de données int8, int9, int 16, int 32 et flottante qui sont supportés. Les formats d'entier sans signe ne sont pas supportés et une valeur d'un entier sans signe doit d'abord être convertie en un format de complément à 2 avant d'être utilisée. Le programmeur est libre d'utiliser les instructions arithmétiques avec un entier sans signe ou tout autre format de son choix, tant que les débordements sont bien traités. L'architecture définit les débordements uniquement des types de données d'entier en complément à 2 et à point flottant à 32 bits. L'architecture ne détecte pas la sortie de report des opérations à 8, 9 16 ou 32 bits qui est nécessaire pour détecter des débordements
sans signe.
Le Tableau D.1 montre les grandeurs des données
supportées par les opérations de charge.
Tableau D.1: Grandeurs des Données Supportées par les Opérations de Charge Grandeurs Grandeurs Opération de Charge Donnée en Donnée en mémoire reqistre 8 bits 9 bits charger 8 bits, étendre signe à 9 bits (pour chargement de 8 bits en complément à deux) 8 bits 9 bits charger 8 bits, étendre avec zéro à 9 bits (pour chargement 8 bits sans ___ __ _siqne) 16 bits 16 bits charger 16 bits (pour chargement 16 bits sans signe ou complément à deux) 32 bits 32 bits charger 32 bits (pour chargement 32 bits sans signe, entier en complément à deux ou point flottant à 32 bits) L'architecture spécifie l'alignement des adresses de mémoire sur les limites des types de données. En effet, pour un octet, il n'y a pas de condition d'alignement. Pour un demi-mot, la condition d'alignement est la limite du demi-mot. Pour un mot, la condition d'alignement est la
limite du mot.
Le Tableau D.2 montre les grandeurs des données
supportées par les opérations d'enregistrement.
Tableau D.2: Grandeurs des Données Supportées par les Opérations d'Enregistrement Grandeurs Grandeurs Opération d'Enregistrement Données en Données en Reqistre Mémoire 8 bits 9 bits enregistrer 8 bits (enregistre 8 bits sans signe ou en complément à deux) 8 bits 9 bits tronquer aux 8 bits inférieurs, enregistrer 8 bits (enregistre 9 bits en complément à deux ayant une valeur entre 0 et 255 - sans siqne) 16 bits 16 bits enregistrer 16 bits (enregistrer 16 bits sans signe ou en complément à deux) 32 bits 32 bits enreqistrer 32 bits Comme plus d'un type de données est implanté dans un registre, qu'il soit scalaire ou vectoriel, il peut y avoir des bits dans le registre de destination qui n'ont pas de résultat défini pour certains types de données. En fait, à part les cas d'une opération sur une grandeur de donnée d'octet 9 sur un registre vectoriel de destination et pour une opération sur une grandeur de données du mot sur un registre de destination scalaire, il y a des bits dans un registre de destination dont les valeurs ne sont pas définies par l'opération. Pour ces bits, l'architecture spécifie que leur valeur sera non définie. Le Tableau D.3 montre les bits
qui sont non définis pour chaque grandeur de donnée.
Tableau D.3: Bits non Définis pour les Grandeurs de Données Grandeur Donnée Registre Vectoriel Registre Scalaire Destination Destination Octet VR<9i+8>, pour i=0 SR<31:8> à 31 Octet 9 rien SR<31:9> Demi-mot VR<9i+8>, pour i=0 SR<31:16> à 31 Mot VR<9i+8>, pour i=0 rien à 31 Les programmeurs doivent être au courant des types de données des registres de source et de destination ou de la mémoire lors de la programmation. Une conversion du type de données d'une grandeur d'élément à une autre peut avoir pour résultat potentiel un nombre différent d'éléments enregistrés dans un registre vectoriel. Par exemple, la conversion d'un registre vectoriel du type de données en demi-mot au mot demande que deux registres vectoriels enregistrent le même nombre d'éléments convertis. Inversement, une conversion du type de données en mot, qui peut avoir un format défini par l'utilisateur dans le registre vectoriel, au format de demi-mot, produit le même nombre d'éléments dans une moitié d'un registre vectoriel et les bits résiduels dans l'autre moitié. Dans chaque cas, les conversions des types de données créent une issue architecturale avec l'arrangement des éléments convertis qui sont d'une grandeur différente par
rapport aux éléments de source.
En principe, l'architecture de MSP ne prévoit pas d'opérations qui changent implicitement le nombre d'éléments en résultat. L'architecture voit que le programmeur doit être au courant des conséquences du changement du nombre des éléments dans le registre de destination. L'architecture prévoit seulement des opérations qui convertissent un type de donnée à un autre type de donnée de la même grandeur et demande que le programmeur ajuste les différences des grandeurs de données lorsqu'il convertit d'un type de donnée
à un autre, d'une grandeur différente.
Des instructions spéciales, telles que VSHFLL et VUNSHFLL, telles que décrites à l'Appendice E, simplifient la conversion d'un vecteur ayant une première grandeur de donnée à un second vecteur ayant une seconde grandeur de donnée. Les étapes de base impliquées dans la conversion en un type de donnée en complément à deux d'une plus petite grandeur d'élément, int8 par exemple, dans le vecteur VRa à une plus grande grandeur, intl6 par exemple, sont: 1. Brasser les éléments dans Vra avec un autre vecteur VRb en deux vecteurs VRC:VRd en utilisant le type de donnée en octet. Les éléments dans VRa sont déplacés aux octets les plus faibles des éléments de données intl6 dans un registre à deux grandeurs VRC:VRd et les éléments de Vrb, dont les valeurs ne sont pas en rapport, sont déplacés aux octets supérieurs de VRC:VRd. Cette opération déplace effectivement une moitié des éléments de VRa dans VRc et l'autre moitié dans VRd, tout en doublant la grandeur de chaque élément de
l'octet au demi-mot.
2. Décaler arithmétiquement les éléments dans VRC:VRd
de 8 bits pour les étendre au signe.
Les étapes de base impliquées dans la conversion d'un style de donnée en complément à deux d'une grandeur plus importante d'élément, intl6 par exemple, dans le vecteur VRa à une plus petite grandeur, int8 par exemple,sont: 1. Vérifier pour s'assurer que chaque élément dans le type de donnée intl6 peut être représenté dans la grandeur de l'octet. Si nécessaire, saturer les éléments aux extrémités
pour s'adapter à la plus petite grandeur.
2. Supprimer le brassage des éléments dans VRa avec un autre vecteur VRb en deux vecteurs VRC:VRd. Les moitiés supérieures de chaque élément dans VRa et VRb sont déplacées à VRc et les moitiés inférieures sont déplacées à VRd. Cela rassemble efficacement les moitiés inférieures de tous les
éléments dans VRa dans la moitié inférieure de VRd.
Des instructions spéciales sont données pour les conversions de types de données qui suivent: int32 en point flottant simple précision; point flottant simple précision en point fixe (notation X.Y); point flottant simple précision en
int32; int8 en int 9; int9 en intl6; et intl6 en int9.
Pour obtenir une flexibilité dans la programmation vectorielle, la plupart des instructions vectorielles utilisent un masque d'éléments pour n'opérer que sur les éléments sélectionnés dans un vecteur. Les Registres Vectoriels à Masque Global VGMRO et VGMR1 identifient les éléments qui sont modifiés dans le registre de destination et
l'accumulateur vectoriel par les instructions vectorielles.
Pour les opérations sur les grandeurs de données de l'octet et de l'octet 9, chacun des 32 bits dans VGMRO (ou VGMR1) identifie un élément sur lequel il faut opérer. Le bit VGMRO<i> étant établi indique que l'élément i de la grandeur de l'octet doit être affecté, i étant O à 31. Pour des opérations sur la grandeur de donnée du demi-mot, chaque paire des 32 bits dans VGMRO (ou VGMR1) identifie un élément sur lequel il faut opérer. Les bits VGMRO<2i:2i+1> étant établis, cela indique que l'élément i doit être affecté, i étant O à 15. Si un seul bit d'une paire dans VGMRO est
établi pour une opération sur la grandeur de donnée du demi-
mot, seuls les bits dans l'octet correspondant sont modifiés.
Pour des opérations de la grandeur de donnée du mot, chaque groupe de quatre bits dans VGMRO (ou VGMR1) identifie un élément sur lequel il faut opérer. Les bits VGMRO<4i:4i+3> étant établis, cela indique que l'élément i doit être affecté, i étant égal à O à 7. Si tous les bits dans un groupe de quatre dans VGMRO ne sont pas établis pour une opération de la grandeur du mot de donnée, seuls les bits
dans l'octet correspondant sont modifiés.
* On peut établir VGMRO et VGMR1 en comparant un registre vectoriel avec un registre vectoriel ou scalaire ou avec une valeur intermédiaire en utilisant l'instruction VCMPV. Cette instruction établit bien le masque selon la grandeur de donnée spécifiée. Comme un registre scalaire est défini comme ne contenant qu'un seul élément de donnée, les opérations scalaires (c'est-à-dire que les registres de destination sont
scalaires) ne sont pas affectées par le masque d'éléments.
Pour la flexibilité dans la programmation vectorielle, la plupart des instructions de MSP supporte trois formes d'opérations vectorielles et scalaires. Ce sont: 1. Vecteur = vecteur op vecteur 2. Vecteur = vecteur op scalaire 3. Scalaire = scalaire op scalaire Pour le cas 2 o un registre scalaire est spécifié en tant qu'une opérande B, le seul élément dans le registre scalaire est reproduit autant de fois que cela est nécessaire pour adapter le nombre d'éléments dans l'opérande du vecteur A. Les éléments reproduits ont la même valeur que l'élément dans l'opérande scalaire spécifié. L'opérande scalaire peut être d'un registre scalaire ou de l'instruction, sous la forme d'un opérande immédiat. Dans le cas d'un opérande immédiat, l'extension appropriée au signe est appliquée si le type de donnée spécifié utilise une grandeur plus importante de donnée que celle disponible avec la grandeur de zone immédiate. Dans de nombreuses applications multimédia, une attention spéciale doit être portée à la précision du résultat de la source, intermédiaire et finale. De plus, les instructions de multiplication d'entiers produisent des résultats intermédiaires "double précision" qui peuvent
être enregistrés dans deux registres vectoriels.
L'architecture de MSP supporte couramment des formats d'entiers en complément à deux pour des éléments à 8, 9, 16 et 32 bits et le format simple précision IEEE 754 pour des éléments à 32 bits. Un débordement est défini comme étant un résultat qui est au-delà de la valeur la plus positive ou la
plus négative représentable par le type spécifié de donnée.
Quand un débordement se produit, la valeur écrite dans le registre de destination n'est pas un nombre correct. Un sous-débordement n'est défini que pour des opérations à point flottant. A moins qu'autre chose ne soit indiqué, toutes les opérations à point flottant utilisent l'un des quatre modes
d'arrondissement spécifiés dans les bits VCSR<RMODE>.
Certaines instructions utilisent ce que l'on connaît comme un mode d'arrondissement en partant de zéro (pair rond). Ces
instructions sont indiquées explicitement.
La saturation est une fonction importante dans de nombreuses applications multimédia. L'architecture de MSP supporte la saturation dans les quatre opérations sur entiers et à point flottant. Le bit ISAT dans le registre VCSR spécifie le mode de saturation du nombre entier. Le mode de saturation à point flottant, qui est également connu comme
mode IEEE rapide, est spécifié avec le bit FSAT dans le VCSR.
Quand le mode de saturation est validé, un résultat qui est au-delà des valeurs la plus positive ou la plus négative est établi aux valeurs la plus positive ou la plus négative, respectivement. Un débordement ne peut se produire dans ce
cas et un bit de débordement ne peut être établi.
Le Tableau D.4 donne la liste des exceptions précises, qui sont détectées et reportées avant exécution de l'instruction de défaillance. L'adresse du vecteur
d'exception est donnée en notation hexadécimale.
Tableau D.4: Exceptions Précises
Vecteur Description
d'Exception 0x00000018 Exception Point de Rupture Adresse Instruction Processeur Vectoriel 0x00000018 Exception Point de Rupture Adresse Données Processeur Vectoriel 0x00000018 Exception Instruction Incorrecte Processeur Vectoriel 0x00000018 Exception Seule Etape Processeur Vectoriel 0x00000018 Exception Débordement Pile Adresses Retour Processeur Vectoriel 0x00000018 Exception Sous- débordement Pile Adresses Retour Processeur Vectoriel 0x00000018 Exception VCINT Processeur Vectoriel 0x00000018 Exception VCJOIN Processeur Vectoriel Le Tableau D.5 donne la liste des exceptions imprécises qui sont détectées et reportées après exécution d'un certain nombre d'instructions qui tombent plus tard dans l'ordre du
programme que l'instruction de défaillance.
Tableau D.5: Exceptions Imprécises
Vecteur Description
d'exception 0x00000018 Exception Adresse Instruction Incorrecte Processeur Vectoriel 0x00000018 Exception Adresse Donnée Incorrecte Processeur Vectoriel 0x00000018 Exception Accès Donnée non alignée Processeur Vectoriel 0x00000018 Exception Débordement Entier Processeur Vectoriel 0x00000018 Exception Débordement Point Flottant Processeur Vectoriel 0x00000018 Exception Opérande Incorrecte Point Flottant Processeur Vectoriel 0x00000018 Exception Division par Zéro Point Flottant Processeur Vectoriel 0x00000018 Exception Division par Zéro Entier Processeur Vectoriel
APPENDICE E
Le groupe d'instructions pour le processeur vectoriel
comprend onze classifications comme le montre le Tableau E.1.
Tableau E.1: Récapitulatif classe instructions vectorielles
Classe Description
Contrôle Cette classe comprend les instructions qui Circulation contrôlent la circulation du programme comprenant les instructions d'interfaces de
branchement et de ARM7.
Logique Cette classe comprend les instructions logiques (mode en mode binaire. Bien que le type de données binaire, (mode binaire, masque) soit booléen, les masque) instructions logiques utilisent le masque d'éléments pour modifier les résultats et, par
conséquent, nécessite le type de donnée.
Décaler & Cette classe comprend les instructions qui Tourner décalent et font tourner le masque dans chaque (mode élément. Cette classe différencie les grandeurs élément, d'éléments et est affectée par le masque
masque) d'éléments.
Arithméti- Cette classe comprend les instructions que (mode arithmétiques en mode d'élément. Ce (mode élément, élément, masque) est le résultat du ième élément
masque) calculé à partir des ièmes éléments des sources.
Cette classe différencie les types d'éléments et
elle est affectée par le masque d'éléments.
Multimédia Cette classe comprend des instructions qui sont (masque par optimisées pour des applications multimédia (par élément) élément, masque). Cette classe différencie les types d'éléments et est affectée par le masque d'éléments. Conversion Cette classe comprend des instructions qui Type Donnée convertissent les éléments d'un type de donnée (par (par élément, pas de masque) à un autre. Les élément, instructions de cette classe supportent un pas de groupe spécifique de types de données et elles masque) ne sont pas soumises au masque d'éléments car l'architecture ne supporte pas d'avoir plus d'un
type de données dans un reqistre.
Arithméti- Cette classe comprend des instructions qui que prennent deux éléments de positions différentes Interélé- dans les vecteurs pour produire des résultats
ments arithmétiques.
Déplacement Cette classe comprend des instructions qui Interélé- prennent deux éléments de positions différentes
ments dans les vecteurs pour réarranger les éléments.
Classe Description
Charge/Enre- Cette classe comprend des instructions qui gistrement chargent ou enregistrent les registres. Ces instructions ne sont pas affectées par le
masque d'éléments.
Opération Cette classe comprend des instructions qui d'Anté- contrôlent les antémémoires d'instructions et mémoire de données. Ces instructions ne sont pas
affectées par le masque d'éléments.
Déplacement Cette classe comprend des instructions qui
Registre transfèrent les données entre deux registres.
Ces instructions ne sont normalement pas affectées par le masque d'éléments et certaines
ont l'option d'utiliser le masque d'éléments.
Le Tableau E.2 donne la liste des instructions de
contrôle de circulation.
Tableau E.2: Instructions de contrôle de Circulation
Mnémonique Description
VCBR Branchement Conditionnel VCBRI Branchement Conditionnel Indirect VDICBR Décrément VCR1 et Branchement Conditionnel VD2CBR Décrément VCR2 et Branchement Conditionnel VD3CBR Décrément VCR3 et Branchement Conditionnel VCJSR Saut Conditionnel à Sous-routine VCJSRI Saut Conditionnel à Sousroutine indirecte VCRSR Retour Conditionnel de Sous-routine VCINT Interruption Conditionnelle de ARM7 VCJOIN Jonction Conditionnelle avec ARM7 VCCS Commutateur Contexte Conditionnel VCBARR Barrière Conditionnelle VCHGCR Chanqement Reqistre Contrôle (VCSR) La classe logique supporte les types de données booléennes, qui sont affectées par le masque d'éléments. Le Tableau E.3 donne la liste des instructions de contrôle de circulation. Tableau E.3: Instructions Logiques
Mnémonique Description
VNOT NON - B
VAND ET- (A & B)
VCAND ET Complément - (-A & B) VANDC Complément ET - (A & - B)
VNAND NON-ET - (A & B)
VOR OU - (A I B)
VCOR OU Complément - (-A I B) VORC Complément OU - (A I - B)
VNOR NON-OU - - (A I B)
VXOR OU Exclusif - (A ^ B) VXNOR NON-OU Exclusif - - (A ^ B) Les instructions de la classe décaler/tourner opèrent sur les types de données int8, int9, intl6 et int32 (pas de types de donnée flottante) et sont affectées par le masque d'éléments. Le Tableau E.4 donne la liste des instructions de
le classe décaler/Tourner.
Tableau E.4: Classe Décaler & Tourner
Mnémonique Description
VDIV2N Division par Puissance de 2 VLSL Décalaqe Logique à Gauche VLSR Décalaqe Loqique à Droite VROL Rotation à Gauche VROR Rotation à Droite Les instructions de la classe arithmétique, en général, supportent les types de données int8, int9, intl6 et int32 et flottante et sont affectées par le masque d'éléments. Pour des limitations spécifiques des types de données non
supportées, il faut se référer à la description détaillée de
chaque instruction ci-dessous. L'instruction VCMPV n'est pas affectée par le masque d'éléments car elle opère sur le masque d'éléments. Le Tableau E.5 donne la liste des
instructions de la classe arithmétique.
Tableau E.5: Classe Arithmétique
Mnémonique Description
VASR Décalaqe Arithmétique vers la Droite VADD Addition VAVG Moyenne VSUB Soustraction VASUB Valeur Absolue de Soustraction VMUL Multiplication VMULA Multiplication à Accumulateur VMULAF Multiplication à Fraction Accumulateur VMULF Multiplication Fraction VMULFR Multiplication Fraction et Arrondissement VMULL Multiplication Valeur Basse VMAD Multiplication et Addition VMADL Multiplication et Addition Valeur Basse VADAC Addition et Accumulation VADACL Addition et Accumulation Valeur Basse VMAC Multiplication et Accumulation VMACF Multiplication et Accumulation Fraction VMACL Multiplication et Accumulation Valeur Basse VMAS Multiplication et Soustraction de l'Accumulateur VMASF Multiplication et Soustraction de la Fraction de l'Accumulateur VMASL Multiplication et Soustraction de l'Accumulateur Valeur Basse VSATU Saturation à Limite Supérieure VSATL Saturation à Limite Inférieure VSUBS Soustraction Condition Scalaire et Etablie VCMPV Comparaison Vecteur et Masque Etabli VDIVI Initialisation Division VDIVS Etape Division VASL Décalaqe Arithmétique vers la Gauche VASA Décalage Arithmétique Accumulateur de 1 bit Les instructions de MPEG sont une classe d'instructions spécialement adaptée à un codage et à un décodage MPEG, mais on peut les utiliser d'une grande variétés de façons. Les instructions de MPEG supportent les types de données int8, int9, intl6 et int32 et sont affectées par le masque d'éléments. Le Tableau E.6 donne la liste des instructions de MPEG. Tableau E.6: Classe MPEG
Mnémonique Description
VAAS3 Addition et Addition Siqne de (-1, 0, 1) VASS3 Addition et Soustraction Signe de (-1, 0, 1) VEXTSGN2 Extraction Signe de (-1, 1) VEXTSGN3 Extraction Signe de (-1, 0, 1) VXORALL Réunion Logique du bit de moindre poids de tous les éléments Chaque instruction de conversion de type de donnée supporte des types de données spécifiques et n'est pas affectée par le masque d'éléments car l'architecture ne supporte pas plus d'un type de donnée dans un registre. Le Tableau E.7 donne la liste des instructions de conversion de
types de donnée.
Tableau E.7: Classe Conversion Type de Donnée
Mnémonique Description
VCVTIF Convertir Entier en Point Flottant VCVTFF Convertir Point Flottant en Point Fixe VROUND Arrondir Point Flottant à Entier (supporte 4 modes d'arrondissement IEEE) VCNTLZ Compte Zéros en-tête VCVTB9 Convertir un Type de Donnée Octet 9 La classe d'instructions arithmétiques interéléments supporte les types de données int8, int9, intl6 et int32 et flottantes. Le Tableau E.8 donne la liste des instructions
dans la classe arithmétique interéléments.
Tableau E.8: Classe Arithmétique Interéléments
Mnémonique Description
VADDH Ajouter deux Eléments Adjacents VAVGH Faire la moyenne de deux Eléments Adjacents VAVGQ Faire la moyenne des Eléments Quad VMAXE Echange maximum Eléments Pair/Impair La classe d'instructions déplacement interéléments supporte les grandeurs de données octet, octet 9, demi-mot et mot. Le Tableau E. 9 donne la liste de la classe
d'instructions de déplacement interéléments.
Tableau E.9: Classe Déplacement Interéléments
Mnémonique Description
VESL Décalaqe Elément à Gauche de 1 VESR Décalage Elément à Droite de 1 VSHFL Brassage à Elément Pair/Impair VSHFL Brassage à Elément Pair/Impair VSHFLH Brassage à Elément Pair/Impair Valeur Haute VSHFLL Brassage à Elément Pair/Impair Valeur Basse VUNSHFL Débrassage à Elément Pair/Impair VUNSHFLH Débrassage à Elément Pair/Impair Valeur Haute VUNSHFLL Débrassaqe à Elément Pair/Impair Valeur Basse Les instructions de charge/enregistrement supportent, en plus des grandeurs de données de l'octet, du demi-mot et du mot, des opérations sur les grandeurs de données en rapport avec l'octet 9 spéciales et ne sont affectées par le masque d'éléments. Le Tableau E.10 donne la liste des instructions
en classe de charge/enregistrement.
Tableau E.10: Classe Charge/Enregistrement
Mnémonique Description
VL Charge VLD Charge Double VLQ Charge Quad VLCB Charge de Tampon Circulaire VLR Charge Ordre Elément Inverse VLWS Charge avec Chevauchement VST Enreqistrement VSTD Enregistrement Double VSTQ Enregistrement Quad VSTCB Enregistrement à Tampon Circulaire VSTR Enregistrement Ordre Elément Inverse VTSWS Enreqistrement Avec Chevauchement La plupart des instructions de déplacement de registre supportent les types de données int8, int9, intl6, int32 et
flottante et ne sont pas affectées par le masque d'éléments.
Seule l'instruction VCMOVM est affectée par le masque d'éléments. Le Tableau E.11 donne la liste de la classe
d'instructions de déplacement de registre.
Tableau E.11: Classe Déplacement Registre
Mnémonique Description
VLI Charqe Immédiate VMOV Déplacement VCMOV Déplacement Conditionnel VCMOVM Déplacement Conditionnel avec Masque D'Eléments VEXTRT Extraire Un Elément VINSERT Insérer Un Elément Le Tableau E.12 donne la liste des instructions dans la classe d'opérations d'antémémoire qui contrôle le
sous-système d'antémémoire 130.
Tableau E.12: Classe Opérations Antémémoire
Mnémonique Description
VCACHE Opération antémémoire à antémémoire données ou instructions VPFTCH Pré-extraction dans antémémoire données VWBACK Réécriture de antémémoire données
NOMENCLATURE DESCRIPTION INSTRUCTIONS
Pour simplifier la spécification du groupe d'instructions, une terminologie spéciale est utilisée dans tous les appendices. Par exemple, les opérandes d'instructions sont des entiers en complément à deux avec signe des grandeurs octet, octet 9, demi-mot ou mot, à moins qu'autre chose ne soit noté. Le terme " registre " est utilisé pour désigner un registre d'utilité générale (scalaire ou vectoriel). D'autres types de registres sont décrits explicitement. Dans la syntaxe du langage d'assemblage, les suffixes b, b9, h et w désignent à la fois les grandeurs des données (octet, octet 9, demi-mot et mot) et les types de données en entier (int8, int9, intl6 et int32). Par ailleurs, la terminologie et les symboles utilisés pour décrire les opérandes d'instructions, les opérations et la syntaxe du langage d'assemblage sont comme suit. Rd registre destination (vectoriel, scalaire ou d'utilité spéciale) Ra, Rb registres de source a et b (vectoriel, scalaire ou d'utilité spéciale) Rc registre de source ou de destination c (vectoriel ou scalaire) Rs registre de source de données d'enregistrement (vectoriel ou scalaire) S registre scalaire ou d'utilité spéciale à 32 bits VR registre vectoriel rangée courante VRA registre vectoriel rangée alternative VRO registre vectoriel rangée 0 VR1 registre vectoriel rangée 1 VRd registre vectoriel destination (défaut à rangée courante à moins que VRA ne soit spécifié) VRa,VRb registres vectoriels source a et b VRc registre vectoriel source ou destination c VRs registre vectoriel source donnée enregistrement VACOH Registre Accumulateur Vectoriel 0 Etat Haut VACOL Registre Accumulateur Vectoriel 0 Etat Bas VAC1H Registre Accumulateur Vectoriel 1 Etat Haut VAC1L Registre Accumulateur Vectoriel 1 Etat Bas SRd registre scalaire destination SRa, SRb registres scalaires source a et b SRb+ remettre registre de base au point avec l'adresse effective SRs registre source données enregistrement scalaire SP registre utilité spéciale VR[i] ième élément dans registre vectoriel VR VR[i]<a:b> bits a à b du ième élément dans registre vectoriel VR VR[i]<msb> le bit le plus significatif du ième élément dans le registre vectoriel VR EA adresse effective pour accès mémoire MEM mémoire BYTE[EA] un octet en mémoire adressé par EA HALF[EA] demi-mot en mémoire adressé par EA. bits <15:8>
adressés par EA+1.
WORD[EA] un mot en mémoire adressé par EA. bits <31:24>
adressés par EA+3.
NumElem désigne le nombre d'éléments pour un type donné de donnée. Il est de 32, 16 ou 8 pour l'octet et l'octet 9, le demi-mot ou le mot, respectivement en mode VEC32. Il est de 64, 32 ou 16 pour les grandeurs de données de octet et octet 9, demi-mot ou mot, en mode VEC64. Pour les
opérations scalaires NumElem est de 0.
EMASK[i] désigne le masque d'éléments pour le ième élément. Il représente 1, 2, ou 4 bits dans VGMR0/1, -VGMR0/1, VMMR0/1 ou - VMMR0/1 pour les grandeurs de données d'octet et octet 9, demi-mot ou mot, respectivement. Pour les opérations scalaires, le masque d'éléments est supposé être
établi même si EMASK[i] = 0.
MMASK[i] désigne le masque d'éléments pour le ième élément. Il représente 1, 2, ou 4 bits dans VMMR0 ou VMMR1 pour les grandeurs de données de l'octet et de l'octet 9, du demi-mot ou du mot respectivement. VCSR le Registre de Contrôle Vectoriel et d'Etat VCSR<x> désigne un bit ou des bits dans VCSR. " x " est
un nom de zone.
VPC compteur programme processeur vectoriel VECSIZE la grandeur du registre vectoriel est de 32 en
mode VEC32 et 64 en mode VEC64.
SPAD zone de travail Les constructions de programmation C sont utilisées pour décrire la circulation de contrôle des opérations. Les exceptions sont notées ci-dessous: = affectation : concaténation {x I I Y} indique une sélection entre x ou y (pas un ou logique) sex étendre signe à grandeur spécifiée donnée sex_dp étendre au signe à double précision de grandeur de donnée spécifiée sign" décalage à droite avec extension signe (arithmétique) zex étendre à zéro à la grandeur spécifiée de donnée zéro" décalage à droite étendu au zéro (logique) " décalage à gauche (remplissage zéro) trnc7 tronquer 7 bits menants (à partir d'un demi-mot) trncl tronquer 1 bit menant (à partir de l'octet 9) % opérateur modulo I expression I valeur absolue de l'expression / diviser (pour type donnée flottante utiliser l'un des quatre modes d'arrondissement IEEE) // diviser (utiliser l'arrondissement à partir du mode d'arrondissement à zéro) saturer() saturer à la valeur la plus négative ou la plus positive, au lieu de générer un débordement pour des types de données d'entier. Pour un type de donnée flottante, la saturation peut être à l'infini positif, au zéro positif, au zéro
négatif ou à l'infini négatif.
Les formats d'instructions générales sont montrés à la
figure 8 et décrits ci-dessous.
Format REAR utilisé par les instructions d'opérations de charge, enregistrement et antémémoire et les zones dans le format REAR ont les significations suivantes, telles que
données au Tableau E.13.
Tableau E.13: Format REAR Champ Signification Opc<4:0> Opcode
B Identificateur rangée pour le registre Rn.
D Registre scalaire destination/source. Quand il est établi Rn<4:0> indique un registre scalaire. Les valeurs légales pour les codages B:D en mode VEC32 sont: 00 Rn est un registre vectoriel dans la rangée courante 01 Rn est un registre scalaire (dans la rangée courante) Rn est un registre vectoriel dans l'autre rangée 11 non défini Les valeurs légales pour les codages B:D en mode VEC64 sont: 00 uniquement 4, 8, 16 ou 32 octets dans le registre vectoriel Rn sont utilisés 01 Rn est un registre scalaire les 64 octets du registre vectoriel Rn sont utilisés 11il non défini TT <1:0> Type Transfert indique une opération spécifique de charge ou d'enregistrement. Voir les Tableaux de
codaqe LT et ST ci-dessous.
C Antémémoire hors ligne. Etablir ce bit pour court- circuiter l'Antémémoire de données pour la charge. Ce bit est établi avec la Mnémonique d'Antémémoire hors circuit des instructions de charge et enregistrement (concaténer hors ligne à la mnémonique) A Mise à jour adresse. Etablir ce bit pour remettre SRb à jour avec l'adresse effective. L'adresse
effective est calculée comme SRb+SRi.
Rn <4:0> Numéro reqistre destination/source SRb <4:0> Numéro reqistre base scalaire SRi <4:0> Numéro reqistre indice scalaire Les bits 17:15 sont réservés et doivent être des zéros pour assurer la compatibilité avec des extensions futures dans l'architecture. Certains codages des zones B:D et TT sont
non définis.
Le programmeur ne doit pas utiliser ces codages car l'architecture ne spécifie par le résultat attendu lorsqu'un tel codage est utilisé. Le Tableau E.14 montre des opérations de charge scalaire supportées (codées dans la
zone TT comme LT) dans les deux modes VEC32 et VEC64.
Tableau E.14: Opérations charge REAR en modes VEC32 et VEC64 D:LT Mnémonique Signification 1 00.bs9 charger 8 bits dans grandeur du __________ octet 9, en étendant au signe 1 01. h charger 16 bits dans la grandeur du __________ Idemi- mot 1 10.bz9 charger 8 bits dans la grandeur de l'octet 9, en étendant au zéro 1 11.w charger 32 bits dans la grandeur du mot Le Tableau E.15 montre les opérations de charge vectorielle supportées (codées dans la zone TT en tant que LT) en mode VEC32 qui se présente quand le bit VCSR<0> est effacé. Tableau E.15: opérations charge REAR en mode VEC32 D:LT Mnémonique Signification 0 00.4 Charger 4 octets de la mémoire dans les 4 octets 9 inférieurs dans le registre et laisser les octets 9 restants non modifiés. Tous les 9èmes bits des octets 9 sont étendus au signe à partir du
8ème bit correspondant.
0 01.8 Charger 8 octets de la mémoire dans les 8 octets 9 inférieurs dans le registre et laisser les octets 9 restants non modifiés. Tous les 9èmes bits des octets 9 sont étendus au signe à partir du
8ème bit correspondant.
0 10.16 charger 16 octets de la mémoire dans les 16 octets 9 inférieurs du registre et laisser les octets 9 restants non modifiés. Tous les 9èmes bits, des 16 octets 9 sont étendus au signe à partir du
8ème bit correspondant.
D:LT Mnémonique Signification O 11il.32 charger 32 octets de la mémoire dans les 32 octets 9 inférieurs, dans le registre et laisser les
octets 9 restants non modifiés.
Tous les 9èmes bits des 32 octets 9, sont étendus au signe à partir
du 8ème bit correspondant.
Le bit B est utilisé pour indiquer la rangée courante ou l'autre. Le Tableau E.16 montre des opérations de charge vectorielle supportées (codées en zone TT en tant que LT) en mode VEC64 ce qui se présente quand le bit VCSR <O> est établi. Tableau E.16: Opérations Charqe REAR en mode VEC32 B:D:LT Mnémonique Signification O O 00.4 charger quatre octets de la mémoire dans les quatre octets 9 inférieurs du registre et laisser les octets 9 restants non modifiés. Tous les 9èmes bits des 4 octets 9 sont étendus au signe à partir du
8ème bit correspondant.
0 0 01.8 Charger 8 octets de la mémoire dans les 8 octets 9 inférieur du registre et laisser les octets 9 restants non modifiés. Tous les 9èmes bits des 8 octets 9 sont étendus au signe à partir du
8ème bit correspondant.
O O 10.16 Charger 16 octets de la mémoire dans les 16 octets 9 inférieurdans le registre et laisser les
octets 9 restants non modifiés.
Tous les 9èmes bits des 16 octets 9 sont étendus au signe à partir du
8ème bit correspondant.
O O 11il.32 Charger 32 octets de la mémoire dans les 32 octets 9 inférieurs du registre et laisser les octets 9 restants non modifiés. Tous les 9èmes bits des 32 octets 9 sont étendus au signe à partir du
8ème bit correspondant.
B:D:LT Mnémonique Signification 1 0 00 non défini 1 0 01 non défini 1 0 10 non défini 1 0 11.64 Charger les 64 octets de la mémoire dans les 64 octets 9 inférieurs du registre et laisser les octets 9 restants non modifiés. Tous les 9èmes bits des 64 octets 9, sont étendus au signe à partir du
8ème bit correspondant.
Le bit B est utilisé pour indiquer une opération vectorielle de 64 octets car le concept de la rangée courante et
alternée n'existe pas en mode VEC64.
Le Tableau E.17 donne la liste des opérations d'enregistrement scalaires supportées (codées dans la zone
TT en tant que ST) en mode VEC32 et VEC64.
Tableau E.17: opérations d'Enregistrement Scalaire REAR D:ST Mnémonique Signification 1 00.b Enregistrer grandeurs octet ou octet 9 dans 8 bits (tronquer 1 bit ____ _ de l'octet 9) 1 01.hEnregistrer grandeur demi-mot dans 16 bits
1 10 non défini -
1 11.w Enregistrer grandeur mot dans
__ __ _ _32 bits.
Le Tableau E.18 donne la liste des opérations d'enregistrement vectoriel supportée (codées en zones TT en tant que ST) en mode VEC32 ce qui se présente quand le bit
VCSR <0> est effacé.
Tableau E.18: opérations d'Enregistrement Vectoriel
REAR en mode VEC32.
D:ST Mnémonique Siqnification O 00.4 Enregistrer 4 octets du registre dans la mémoire. Tous les neuvièmes bits des 4 octets 9 dans
le registre sont iqnorés.
O 01.8 Enregistrer 8 octets du registre dans la mémoire. Tous les neuvièmes bits des 8 octets 9 dans
le reqistre sont ignorés.
O 10.16 Enregistrer 16 octets du registre dans la mémoire. Tous les 9ème bits des 16 octets 9 dans le registre
sont ignorés.
O 11.32 Enregistrer 32 octets du registre dans la mémoire. Tous les 9èmes bits des 32 octets 9 dans le
reqistre sont iqnorés.
Le Tableau E.19 donne la liste des opérations d'enregistrement vectoriel supportées (codées en zone TT en tant que ST) en mode VEC64, ce qui se présente quand le bit
VCSR <O> est établi.
Tableau E.19: Opérations d'Enregistrement Vectoriel REAR en mode VEC32 B:D:ST Mnémonique Signification 0 0 00.4 Enregistrer 4 octets du registre dans la mémoire. Tous les 9èmes bits des 4 octets 9 dans le
reqistre sont ignorés.
0 0 01.8 Enregistrer 8 octets du registre dans la mémoire. Tous les 9èmes bits des 8 octets 9 dans le
registre sont ignorés.
0 0 10.16 Enregistrer 16 octets du registre dans la mémoire. Tous les neuvièmes bits des 16 octets 9 dans
le registre sont ignorés.
0 0 11.32 Enregistrer 32 octets du registre dans la mémoire tous les 9èmes bits des 32 octets 9 dans le registre
sont ignorés.
1 O 00 non défini 1 0 01 X=_ non défini 1 0 10 non défini 1 0 11.64 Enregistrer 64 octets du registre dans la mémoire. Tous les 9èmes bits des 64 octets 9 dans le
_________ _registre sont ignorés.
Le bit B est utilisé pour indiquer une opération vectorielle à 64 octets car le concept de la rangée courante et alternée
n'existe pas en mode VEC64.
Le format REAI est utilisé par les instructions des opérations de charge, enregistrement et antémémoire. Le Tableau E.20 montre les significations des zones en format REAI. Tableau E.20: Format REAI Zone Signification Opc<4:0> Code opération B Identificateur rangée du registre Rn. Quand il est établi en mode VEC32, Rn<4:0> désigne un numéro de registre vectoriel dans l'autre rangée. Quand il est établi en mode VEC64, cela désigne une
opération vectorielle complète (64 octets).
D Registre scalaire destination/source. Quand il est
établi, Rn<4:0> désigne un registre scalaire.
Les valeurs correctes pour les codages B:D en mode VEC32 sont: 00 Rn est un registre vectoriel dans la rangée courante 01 Rn est un registre scalaire (dans la rangée courante) Rn est un registre vectoriel dans l'autre rangée 11 non défini Les valeurs correctes pour les codages B:D en mode VEC64 sont: 00 seuls 4, 8, 16 ou 32 octets du registre vectoriel Rn sont utilisés 01 Rn est un registre scalaire les 64 octets de registre vectoriel Rn sont utilisés 11 non défini TT<1:0> Type Transfert indique une opération spécifique de charge ou d'enregistrement. Voir les Tableaux de
codage de LT et ST ci-dessous.
C Antémémoire hors ligne. Etablir ce bit pour court- circuiter l'antémémoire de données pour la charge. Ce bit est établi avec la mnémonique d'antémémoire circuit des instructions de charge et d'enregistrement hors circuit(concaténer hors ligne
à la mnémonique).
A Mise à jour adresse. Etablir ce bit pour remettre à jour SRb avec l'adresse effective. L'adresse
effective est calculée en tant que SRb+IMM <7:0>.
Rn<4:0> Numéro reqistre destination/source SRb<4:0> Numéro reqistre base scalaire IMM<7:0> Un décalage immédiat de 8 bits, interprété comme un
nombre en complément à deux.
Les formats REAR et REAI utilisent des codages identiques pour les types de transfert. Se référer au format REAR pour
d'autres détails de codage.
Le format RRRM5 prévoit trois registres ou deux registres et un opérande immédiat de 5 bits. Le Tableau E.21
définit la zone pour le format RRRM5.
01 no I0 'oo00 se <0:I>Sa puenb w:s:a sabepoo sep aISTI l auuop zz' nealql a -gnbypuF iFos au esoqo a.7nnnb suToUI '(I aeBute PI Iros '0 a8bu- e I PT a4os oaa;nd Tnb) auvnoo aabuez e I uaIoddea as TT-o0o0A oZsT5a9 ap sapueGdo saI snoj, suep sa.n.n; suoTsua;xa sep DAie Tqedwor ansse anod sozaz sap azq; -uSATop 4; sgA-osGa quos Sl:61 sqTq saq aubTs sués 5aquiou un euwoo,glZdzGUT;ss sqTq S ap PTPgUIXTqI :s:a aeBpoo al xed uTmwIgp 'sTq S <0:>SI ap eTpgmuu1T un ans E 9oanos azIST6o o-umnN no <0:P>ql ÀV aolnos GasSTba oiewn <0:_>_ a UOTqFUTIsep azlsTba oaeWnN <0:_>P_ snossap-TO w:S:a ap abepoo ep neaTqel GI JTOA 's:a sqTq sal inod inoqOT3TPoN N I (aGueol; ) no zuF auuop adAq apd GSTTTqn) qow i1 (9gluT auuop adA; ed 9sTITCn) qOW-TWp 01 (61uT auuop adA zed sTITfn) 6 qaqDo 10 (8qUT auuop adAq avd 9sTTThn);oo 00oo : uos sabepoD séq 'aeuuoa anapueD <0:T>Sc ITeToQoea aGsT6el un -sa <O:j>q'[ 'aoe;;a s IFT puenô Àa T2elDs DaqsFba: un;sa <0:P>qU anb enbTpuT Tlqea Is IT punh 'alTl'eTs o r lsT6TU S aZSTBúaz un aubTsap <0:j>pU '9eo;;a sa IT puPnô ÀaaTPiQos eaisTBai un aU.6STap <0:P>Pu 'TIqe9 Ise IT pueno 'uoTqVUTqsp GalTeleOSGzSTbau a uoTqeGdo 9poD <0:Z>dO uoTqWoTTubTs auoz { 6=o: 'Z neIq S6 Tableau E. 22: codages D:S:M de RRRM5 pour DS qui n'est pas 'éal à 11 Codage Rd Ra Rb/IM5 Commentaires 000 VRd VRa VRb Trois opérandes de registre vectoriel 001 Non défini VRd VRa SRb L'opérande B est un registre scalaire 011 VRd VRa IM5 L'opérande B est un immédiat à bits Non défini 101 Non défini SRd SRa SRb Trois opérandes de registre scalaire 111 SRd SRa IM5 L'opérande B est un immédiat à _ _ _ _ _ __ _5 bits Les codages D:S:M ont les significations suivantes quand DS<l:0> est 11: Tableau E.23: Codaqes D:S:M de RRRM5 pour DS égal à 11 D:S:M Rd Ra Rb/IM5 Commentaires 000 VRd VRa VRb Trois opérandes registre vectoriel (int32) 001 VRd VRa VRb Trois opérandes registre vectoriel (flottant) VRd VRa SRb L'opérande B est un registre scalaire (int32) 011 VRd VRa IM5 L'opérande B est un immédiat à bits (int32) VRd VRa SRb L'opérande B est un registre scalaire (flottant) 101 SRb SRa SRb Trois opérandes de registre scalaire (flottant) SRd SRa SRb Trois opérandes de registre scalaire (int32) 111 SRd SRa IM5 L'opérande B est un immédiat à bits (int32) Le format RRRR prévoit quatre opérandes de registre. Le
Tableau E.24 montre les zones dans le format RRRR.
Tableau E.24: Format RRRR Zone Signification Op<4:0> Code opération Registre Rb scalaire. Quand il est établi, cela
indique que Rb<4:0> est un registre scalaire.
Quand il est effacé, Rb<4:0> est un registre vectoriel. DS<1:0> Grandeur Donnée. Les codages sont: 00 octet (utilisé par type donnée int8) 01 octet 9 (utilisé par type donnée int9) demi-mot (utilisé par type donnée intl6) 11 mot (utilisé par type donnée int32 ou flottante) Rc<4:0> Numéro reqistre source/destination C Rd<4:0> Numéro registre destination D Rd<4:0> Numéro reqistre source A Rb<4:0> Numéro reqistre source B Tous les opérandes de registre vectoriel se rapportent à la rangée courante (qui peut être soit la rangée O ou la rangée
1) à moins qu'autre chose ne soit indiqué.
Le format RI n'est utilisé que par l'instruction immédiate de charge. Le Tableau E.25 indique les zones dans
le format RI.
Tableau E.25: format RI Zone Siqnification D Registre scalaire destination. Quand il est
établi, Rd<4:0> désigne un registre scalaire.
Quand il est effacé, Rd<4:0> désigne un registre
vectoriel dans la rangée courante.
F Type donnée flottante. Quand il est établi, désigne le type de donnée à point flottant et
nécessite DS<1:0> pour être 11.
DS<1:0> Grandeur Donnée. Les codages sont: 00 octet (utilisé par type donné int8) 01 octet 9 (utilisé par type donné int9) demi-mot (utilisé par type donné intl6) 11 mot (utilisé par type donné int32 ou flottante) Rd<4:0> Numéro reqistre destination D IMM<18:0> Valeur immédiate 19 bits Certains codages de la zone F:DS<1:0> sont non définis. Le programmeur ne doit pas utiliser ces codages car l'architecture ne spécifie pas le résultat attendu quand un tel codage est utilisé. La valeur chargée dans Rd dépend du
type de donnée comme le montre le Tableau 26.
Tableau E.26: valeurs chargées format RI Format Type donnée Opérande registre b octet (8 bits) Rd<7:0>:=Imm<7:0> b9 octet 9 (9 bits) Rd<8:0>:=Imm<8:0> h demi-mot (16 bits) Rd<15:0> :=Imm<15:0> mot (32 bits) Rd<31:0>:= Imm<18> étendu au siqne f point flottant Rd<31>:0>:=Imm<18>(signe) (32 bits) Rd<30:23>:=Imm<17:0>(exposant) Rd<22:13>:=Imm<9:0>(mantisse) Rd<12:0> :=zéros Le format CT comprend les zones montrées au Tableau E.27 Tableau E.27: format CT Zone Signification Opc<3:0> Code opération Cond<2:0> Condition branchement: 000 toujours 001 moins que égal 011 moins que ou égal plus que 101 pas égal plus que ou égal 111 débordement IMM<22:0> Un décalage de mot immédiat de 23 bits,
interprété comme un nombre en complément à deux.
Les conditions de branchement utilisent la zone VCSR [GT:EQ:LT]. La condition de débordement utilise les bits VCSR [SO] qui précédent les bits GT, EQ et LT qu'il est établi. VCCS et VCBARR interprètent la zone Cond<2:0> différemment de ce qui a été décrit ci-dessus. Se référer en
détail à leur description d'instructions.
Le format RRRM9 spécifie trois registres ou deux registres et un opérande immédiat à 9 bits. Le Tableau E.28
indique les zones du format RRRM9.
6Z' nealqel al aiuow al arwwoo '<0:I>Sa aBpoo np quapuadap aqeTpauwwT auoz el ap sa4-Fexa saepaunwwT sInaeA saI anb uoTpdaoxa,i e '%uu 4ewuo; al anod úZ -4a zzS xnealqe xne s9azuow xnao e senbTIuapT quos W:S:a sabiepoo sarl gnbTpuT)Tos au asoqo a--ne,nb suTow P (I a96bue QI no 0 aga6ue QI 4Fos aqú) q1vinod Tnb) aqupanoo aaBue QI e quaaoddea as TaTIooaA aisTba.i ap sapupedo sal snol À TlTqTwdwoo aenqn; aun zaanssp znod sogz sap az9;uaATop -a eTpguUIT apuperdo un sed ae; Toads au X:S:a abpoo ail puenb sGAIasG2 quos 51:61 sqTq sag W:S:G abepoo al Zed auTwa$,ap sTFq 6 e;ePpguxTF un;Tnpozd '<O:t>SNI oaAV <0:ú>6WI *Nq:S:Ga abepoO al aed guTwiaqgp <0:> wI saTq S s?; eTpgwwT no S azonos act;sTBa.QT ozawnN no <O:D>pu V aoanos aaqsTbai ozawnN <O:>u uoTeuTqsap aqsTbaa oQawnN <:>P snossap-To w:S:a abepoo ap nialqel ai aTOA S:a sq!q sal =nod anawoT;TpoN (auue;oI; no ZEuT auuop adAq aed esTTiTn) jow iT (9gluT euuop adAq zed 9sTITCn) qow- Twap 01 (6quT auuop adÀq ed eSTiTqn) 6 qaGoo 10 (8WuT auuop adAq rd 9sTITCn) qa;oo 00oo : uos sa5epoo sa 'aauuoaG anapuezj <0:I> Sa *IaTooaOaA ar;sTbai un aubTsap <o:t>pU 'goe;;a -sa IT puenO 'azTuies aJ;sTbai un 4sa <0:>pU Tiqa qsa IT pupnô 'q} aGZTelos aasT5au S IaTIOIDGA aqasTba un aufTsap <0:>pU '9ao;;a qsa IT pupno ÀaGTleTos aiqsB6aZ un aU5FSsP <0:>PU 'Tlqi9g Isa IT puenô uoTIuTIsap aTeleos a.IsT au ci uoTqaedo apoD <0: >DdO uoTweD;TUbTFS auoz 66T emoz: 8Z'A neaIqei Tableau E.29: valeurs immédiates en format RRRM9 Format Type données Opérande B concordantes 00 int8 Source B<7:0>:=Imm9<2:0>:IM5<4:0> 01 int9 Source B<8:0>:=Imm9<3:0>:IM5<4:0> intl6 Source B<15:0>:=sex(<IM9<3:0>:IM5<4:0>) 11 int32 Source B<31:0> :=sex(<IM9<3:0>:IM5<4:0>) Le format immédiat n'est pas disponible avec le type de
donnée flottante.
Dans ce qui suit, les instructions du vecteur MSP apparaissent en ordre alphabétique. Noter: 1. Une instruction est affectée par le masque d'éléments, à moins qu'autre chose ne soit noté. Les instructions au format CT ne sont pas affectées par le masque d'éléments. Les instructions au format REAR et REAI, qui consistent en les instructions de charge, enregistrement et antémémoire, ne sont pas non plus
affectées par le masque d'éléments.
2. L'opérande immédiat à 9 bits n'est pas disponible avec
le type de donnée flottante.
3. Dans la description des Opérations, seule la forme
vectorielle est donnée. Pour l'opération scalaire, on
* suppose qu'un seul élément, le Oème, est défini.
4. Pour les formats RRRM5 et RRRM9, les codages suivants sont utilisés pour les types de données entières (b, b9, h, w): D:S:M | 000 I 010 I 011 | 110 | 111 l DS 00 01 10 il 5. Pour les formats RRRM5 et RRRM9, les codages suivants sont utilisés pour les types de données flottantes: D:S:M I 001 I 100 I n/a I 101 I n/a I DS il11 6. Pour toutes les instructions qui peuvent provoquer un débordement, une saturation à int8, int9, intl6, int32, des limites maximales ou minimales sont appliquées quand le bit VCSR<ISAT> est établi. De manière correspondante, le résultat à point flottant est saturé à -infini, -zéro, +zéro ou +infini quand le bit
VCSR<FSAT> est établi.
7. Syntactiquement,.n peut être utilisé au lieu de.b9
pour désigner la grandeur de données d'octet 9.
8. Pour toutes les instructions, le résultat à point flottant retourné au registre de destination ou à l'accumulateur vectoriel est au format simple précision IEEE 754. Le résultat à point flottant est écrit à la portion inférieure de l'accumulateur et la portion
supérieure n'est pas modifiée.
VAAS3 Addition et signe d'addition de (-1 0. 11 Format -,,, 20 l. Io 5 o RRRM 0 1 00001 |SSH | Rd Ra JRb Syntaxe Assembleur VAAS3.dt VRd, VRa, VRb VAAS3.dt VRd, VRa, SRb VAAS3.dt SRd, SRa, SRb o dt = {b, b9, h, w} Modes supportés
D:S:M I V<-V @ V | V<-V @ S | | S<-S @ S |
DS îint8 (b) int9 (b9) intl6 (h) int32 (w)
Description
Le contenu du registre vectoriel/scalaire Ra est ajouté à Rb pour produire un résultat intermédiaire, le résultat intermédiaire est alors additionné avec le signe de Ra; et le résultat final enregistré dans le registre
vectoriel/scalaire Rd.
Opération pour (i=0;l<NumElem && EMASK[i];i++){ si (Ra[i]>0) extsgn3 = 1; autrement si (Ra[i]<0) extsgn3 = -1; autrement extsgn3 = 0; Rd[i]=Ra[i]+Rb[i]+extsgn3; } Exception Débordement. VADAC Addition et accumulation Format 25 20 1|O5 1b0 i| 0 RRRR 110 01!00 DSS RC Rd Ra Rb Syntaxe Assembleur VADAC. dt VRc, VRd, VRa, VRb VADAC.dt SRc, SRd, SRa, SRb o dt = {b, b9, h, w} Modes supportés
S I VRI SR
DS 1 int8 (b) int9 (b9) intl6 (h) int32 (w)
Description
Ajouter chaque élément des opérandes Ra et Rb avec chaque élément double précision de l'accumulateur vectoriel; enregistrer la somme double précision de chaque élément à l'accumulateur vectoriel et aux registres de destination Rc et Rd. Ra et Rb utilisent le type de donnée spécifié tandis que VAC utilise le type de donnée double précision approprié (16, 18, 32 et 64 bits pour int8, int9, intl6 et int32, respectivement). Les portions supérieures de chaque élément double précision sont enregistrées dans VACH et Rc. Si Rc = Rd,
le résultat dans Rc est non défini.
Opération pour (i = 0;i < NumElem && EMASK[i];i++){ Aop[i] = {VRa[i] Il SRa} Bop[i] = {VRb[i] Il SRb} VACH[i]:VACL[i] = sex(Aop[i] + Bop[i]) + VACH[i]:VACL[i]; Rc[i] = VACH[i]; RD[i] = VACL[i]; } FADACL Addition et aceumulation valeur basse Format
M 20 1I05
so RRRM9 1 1 0000 ilS 91 Ds9 Rd Syntaxe Assembleur VADACL.dt VRd, VRa, VRb VADACL.dt VRd, VRa, VRb VADACL.dt VRd, VRa, #IMM VADACL. dt SRd, SRa, SRb VADACL.dt SRd, SRa, #IMM
o dt = {b, b9, h, w}.
Modes supportés D:S:M TV<-V @ V V<-V @ S V<-V @ I S<-iS @S S<-S @ I DS int8 ( b) int96 (b9)hint632 (w)
Description
Ajouter chaque élément des opérandes Ra et Rb/immédiats à chaque élément à précision étendue de l'accumulateur vectoriel; enregistrer la somme à la précision étendue dans l'accumulateur vectoriel; retourner la plus basse précision au registre de destination Rd. Ra et Rb/immédiat utilisent le type de donnée spécifié tandis que VAC utilise le type de donnée double précision approprié (16, 18, 32 et 64 bits pour int8, int9, intl6 et int32, respectivement). Les portions supérieures de chaque élément à précision
étendue sont enregistrées dans VACH.
Opération pour (i=0;l< NumElem && EMASK[i];i++){ Bop[i]={VRb[i] |I SRb Il sex(IMM<8:0>)}; VACH[i]:VACL[i] = sex(Ra[i] + Bop[i] + VACH[i]:VACL[i]; Rd[i] = VACL[i]; } VADD Addition Format
25 20 15 10 S 0
RRR.M9 1 1000000 DISIDSI MI v!9M Rd Ra Rb/IM5 Syntaxe Assembleur VADD. dt VRd, VRa, VRb VADD.dt VRd, VRa, SRb VADD.dt VRd, VRa, #IMM VADD.dt SRd, SRa, SRb VADD.dt SRd, SRa, #IMM o dt = {b, b9, h, w, f} Modes supportés jD:S:M V<-V @ V V<-V @ S I V<-V @ I S<-S @ S I - S<-S @ I _ DS int8 B> int9 Lb91 intl6 (h) int32 (w1 flottant(f
Description
Ajouter les opérandes Ra et Rb/immédiats et retourner la somme au registre de destination Rd. Opération pour (i=0;i<NumElem && EMASK[i];i++ ){ Bop[i]={VRb[i] Il SRb Il sex(IMM<8:0>)}; Rd[i]=Ra[i]+Bop[i]; Exception Débordement, opérande.point flottant incorrect. VADDH Addition de Deux Eléments Adjacents Format
O ?5 20 15 10 S O
o1 100 IDSDSr Rd Rai 1 Rb Syntaxe Assembleur VADDH.dt VRd, VRa, VRb VADDH.dt VRd, VRa, SRb
o dt = {b, b9, h, w, f}.
Modes supportés
D:S:M V<-V @ V V<-V @ S I
DS int8 (b) int9 (b9) intl6 (h) int32 (w) flottant (f)
Description
Rb Ra BO B 0 An-, 1 AD-2 I | A2 AI 1AO DaiDO.21... 1D2 1Dl1 Do Opération pour (i=0;i<NumElem -l;i++){ Rd[i]=Ra[i]+Ra[i+l]; } Rd[NumElem-l]=Ra[NumElem-l]+{VRb[0] I SRb}; Exception Débordement, opérande point flottant incorrect. Note de programmation Cette instruction n'est pas affectée par le
masque d'éléments.
VAND ET
Format
25 2O 15
RR.RPM9 i101 0110 DSDSh D MI Rd Ra RbI Syntaxe Assembleur VAND.dt VRd, VRa, VRb VAND.dt VRd, VRa, SRb VAND.dt VRd, VRa, #IMM VAND. dt SRd, SRa, SRb VAND.dt SRd, SRa, #IMM o dt = {b, b9, h, w}. Noter que.w et.f
spécifient la même opération.
Modes supportés D:S:M V<-V @ V V<-V @ S V<-V @ I S<-S @ S I S<- S @ I DS int8 (b) int9 (b9) intl6 (h) int32 (w)
Description
Faire subir une opération ET logique aux opérandes Ra et Rb/immédiats et retourner le
résultat au registre de destination Rd.
Opération pour (i=0;i<NumElem && EMASK[i];i++){ Bop[i]={VRb[i] Il SRb Il sex(IMM<8:0>)} Rd[i]<k≥Ra[i]<k> & Bop[i]<k>, k= pour tous les bits dans l'élément i; } Exception Aucune. VANDC Complément ET Format RRRM9 I 1 110 00 DS S I 191 | RId Ra Rb/IIM Syntaxe Assembleur VANDC.dt VRd, VRa, VRb VANDC.dt VRd, VRa, SRb VANDC.dt VRd, VRa, #IMM VANDC.dt SRd, SRa, SRb VANDC.dt SRd, SRa, #IMM o dt = {b, b9, h, w}. Noter que.w et .f
spécifient la même opération.
Modes su portés D:S:M V<-V @V V<-V @ S V<-V@ I S<-S@ S S<- S @ i DS int8 (b) int9 (b9) intl6 (h) int32 (w)
Description
Faire subir une opération ET logique aux opérandes Ra et complément de Rb/immédiat et retourner le résultat au registre de
destination Rd.
Opération pour (i=0;i<NumElem && EMASK[i];i++){ Bop[i]={VRb[i] Il SRb Il sex(IMM<8:0>)} Rd[i]<k≥Ra[i]<k> & Bop[i]<k>, k= pour tous les bits dans l'élément i; } Exception Aucune. VASA Accumulateur Décalage Arithmétique Format 25 20 15 10 5 o
RRRR O 0 1 01100 IRI DS
Syntaxe Assembleur VASAL.dt VASAR.dt o dt = {b, b9, h, w} et R désigne la direction de décalage vers la gauche ou vers
la droite.
Modes supportés R Gauche Droite DS int8 b) int9 (b9) intl6 (h) int32 (wX
Description
Chaque élément de donnée du registre accumulateur vectoriel est décalé vers la gauche d'une position d'un bit avec remplissage par zéro à partir de la droite (si R=O0) ou vers la droite à une position de un bit avec extension de signe (si R=1). Le résultat est enregistré dans l'accumulateur vectoriel. Opération pour (i=0; i<NumElem && EMASK[i];i++){ si (R = 1) VACOH[i]:VACOL[i]= VACOH[i]:VACOL[i] signe"1; autrement VACOH[i]:VACOL[i]= VACOH[i]:VACOL[i] "1; } Exception Débordement. VASL Décalage Arithmétique à Gauche Format 't 20 15 1O 5 RRR.M5 0!0 001 01 IDSDS Rd Ra SRb/IM5 lil Syntaxe Assembleur VASL. dt VRd, VRa, SRb VASL.dt VRd, VRa, #IMM VASL.dt SRd, SRa, SRb VASL.dt SRd, SRa, #IMM o dt = {b, b9, h, w} Modes su ortés D:S:M V<V @ S V<-V @ I s<-S @ S S<-S @ I DS int8 (b int9 (b9) intl6 (h) int32 (w)
Description
Chaque élément de donnée du registre vectoriel/scalaire Ra est décalé vers la gauche avec remplissage par zéro à partir de la droite, de la quantité de décalage donnée dans le registre scalaire Rb ou la zone IMM et le résultat est enregistré dans le registre vectoriel/scalaire Rd. Pour les éléments qui subissent un débordement, le résultat est saturé à la valeur la plus positive ou la plus négative, selon le signe. La quantité de décalage est défini comme étant un entier sans signe.
Opération -
quantité_décalage = {SRb % 32 Il IMM<4:0>}; pour (i=0;i<NumElem && EMASK[i];i++){ Rd[i]=saturer(Ra[i] "quantité_décalage); } Exception Aucune Note de programmation Noter que quantité décalage est pris en tant que nombre à 5 bits à partir de SRb ou IMM<4:0>. Pour les types de données en octet, octet 9, demi-mot, le programmeur est responsable de la spécification correcte de la quantité de décalage qui est plus petite que ou égale au nombre de bits dans la grandeur de donnée. Si la quantité de décalage est plus grande que la grandeur de donnée spécifiée les
éléments sont remplis de zéros.
VASR Décalage Arithmétique à Droite Format 2.5 20 1: lO Foi IO _0 S7S Rd. Ra1 SR/M RRR.M5Ioitoi, 101 " I"I I" i'"'"' 1 Syntaxe Assembleur VASR.dt VRd, VRa, SRb VASR.dt VRd, VRa, #IMM VASR.dt SRd, SRa, SRb VASR.dt SRd, SRa, #IMM o dt = {b, b9, h, w} Modes su portés D:S:M _ EV:< -V @ S Vc-V @ I _S<-S @ S S<-S @ I DS int8 (b)int9 (b9) int16 (h) int32 (w)
Description
Chaque élément de donnée du registre vectoriel/scalaire Ra est arithmétiquement décalé vers le droite avec extension du signe aux emplacements du bit le plus significatif, de la quantité de décalage donnée dans le bit le moins significatif de registre scalaire Rb ou la zone IMM est le résultat est enregistré dans le registre vectoriel/scalaire Rd. La quantité de décalage est définie comme étant
l'entier sans signe.
Opération quantité_décalage = {SRb % 32 Il IMM<4:0>}; pour (i=0; i<NumElem && EMASK[i];i++){ Rd[i]= Ra[i] signe>>quantité_décalage; } Exception Aucune. Note de programmation Noter que la quantité décalage est prise en
tant que nombre à 5 bits de SRb ou IMM<4:0>.
Pour les types de données octet, octet 9, demi-mot le programmeur est responsable d'une spécification correcte de la quantité de décalage qui est plus petite que ou égale au nombre de bits dans la grandeur de donnée. Si la quantité de décalage est plus grande que la grandeur de donnée spécifiée, les éléments
sont remplis des bits de signe.
Format 25 20 15 o 5 0 RRR.MS5 |0|10Ol 1000 iDISI ISH 1 I i | iI d i | IRaI 51 11 I| RRI.M1H1111 R Rb Syntaxe Assembleur VASS3.dt VRd, VRa, VRb VASS3.dt VRd, VRa, SRb VASS3.dt SRd, SRa, SRb o dt = {b, b9, h, w} Modes supportés !I - D:S:MV< v<- V <- @ S S<-S @ S DS |int8 b) int9 (b9) Iintl6 (h) int32 (w)
Description
Le contenu du registre vectoriel/scalaire Ra est ajouté à Rb pour produire un résultat intermédiaire,le signe de Ra est alors soustrait du résultat intermédiaire; et le résultat final est enregistré dans le registre
vectoriel/scalaire Rd.
Opération pour (i=0;i<NumElem && EMASK[i];i++){ si (Ra[i]>0) extsgn3 = 1; autrement si (Ra[i]<0) extsgn3 =-1; autrement extsgn3 = 0; Rd[i]=Ra[i]+Rb[i]- extsgn3; } Exception Débordement. VASUB Absolu de Soustraction Format
2 20 15 10 5 0
RRM9 |11111 001000 1 DS DSH I'I9 ' Rd Ra Syntaxe Assembleur VASUB.dt VRd, VRa, VRb VASUB.dt VRd, VRa, SRb VASUB.dt VRd, VRa, #IMM VASUB. dt SRd, SRa, SRb VASUB.dt SRd, SRa, #IMM o dt = {b, b9, h, w} Modes supportés D:S:M l V<-V @ V i V<-V @ S V<-V I S<-S @ S S<-S @ I DS |int8 (b) int9 (b9) intl6 (h) int32 (w) flottant (f)
Description
Le contenu du registre vectoriel/scalaire Rb ou de la zone IMM est soustrait du contenu du registre vectoriel/scalaire Ra et le résultat absolu est enregistré dans le registre
vectoriel/scalaire Rd.
Opération pour (i=O;i<NumElem && EMASK[i];i++){ Bop[i]={VRb[i] Il SRb I| sex(IMM<8:0>)} Rd[i]= | Ra[i]-Bop[i] |; } Exception Débordement, opérande point flottant incorrect Note de programmation Si le résultat de la soustraction est le nombre le plus négatif, alors un débordement se produira après l'opération absolue. Si le mode de saturation est validé, le résultat de l'opération absolue sera le nombre le plus positif. VAVG Moyenne Deux Eléments Format
Z _ 20 15 10 50
RR R M5 I 0 10 01 DS DSV | Rd Ra Rb Syntaxe Assembleur VAVG. dt VRd, VRa, VRb VAVG.dt VRd, VRa, SRb VAVG.dt SRd, SRa, SRb o dt = {b, b9, h, w}. Utiliser VAVGT pour spécifier le mode d'arrondissement " tronqué "
pour des types de données en entiers.
Mode supportés
D:S:M V<-V @ V V<-V @ S S<-S @ S
=DS int8 (b) int9 (b9 intl6 (h) int32 (w) flottant (f
Description
Le contenu du registre vectoriel/scalaire Ra est ajouté au contenu du registre vectoriel/scalaire Rb pour produire un résultat intermédiaire; le résultat intermédiaire est alors divisé par 2 et le résultat final est enregistré dans le registre vectoriel/scalaire Rd. Pour des types de données entières, le mode d'arrondissement est tronqué si T = 1 et arrondi à partir de 0 si T = 0 (défaut). Pour le type de donnée flottante, le mode d'arrondissement est spécifié
dans VCSR<RMODE>.
Opération pour (i=0;i<NumElem && EMASK[i];i++){ Bop[i]l={VRb[i] Il SRb U sex(IMM<8:0>)} Rd[i]=(Ra[i]+Bop[i] //2; } Exception Aucune. VAVGH Moyenne deux Eléments Adiacents Format ei 20 15 10 5 o RRRM:- 10 1101 10ol1 Ti Rd Ra R R | b | Syntaxe Assembleur VAVGH.dt VRd, VRa, VRb VAVGH.dt VRd, VRa, SRb o dt = {b, b9, h, w}. Utiliser VAVGHT pour spécifier le mode d'arrondissement " tronqué"
pour les types de données entières.
Modes supportés I D:S-M I V<-V V V<-V S I DS int8 (b) int9 (b9) intl6 (h) int32 (w) flottant (f)
Description
Pour chaque élément, moyenne de deux paires d'éléments adjacents. Pour les types de données entières, le mode d'arrondissement est tronqué si T = 1 et on arrondit à partir de zéro si T = 0 (défaut). Pour le type de donnée flottante, le mode d'arrondissement est
spécifié dans VCSR<RMODE>.
Rb Ra Bo B LA. *.-... A,__ Al1Ao Rd D0E D>2| *-- Di Do Opération pour(i=0;i<NumElem -1;i++){ Rd[i]=(Ra[i]+ Ra[i+1])//2 Rd[NumElem -1]=(Ra[NumElem -1]+{VRb[0] | SRb})//2; ) Exception Aucune. Note de programmation Cette instruction n'est pas affectée par le
masque d'éléments.
VAVGQ Moyenne Quad Format
5 20 15 I0 5 0
i oi oi o, s t i ' I' 11 ' HT '' I RRRM5 101101 01 JIs DS DHT \VRa VR'bR Syntaxe Assembleur VAVGQ.dt VRd, VRa, VRb o dt = {b, b9, h, w}. Utiliser VAVGQT pour spécifier le mode d'arrondissement <" tronqué "
pour les types de données entières.
Modes supportés D:S:M |V<-V @ V DS int8 (b) lint9 (b9) intl6 (h) int32 (w)
Description
Cette instruction n'est pas supportée dans le
mode VEC64.
Calculer la moyenne de quatre éléments, comme montré au diagramme cidessous en utilisant le mode d'arrondissement spécifié dans T (1 pour tronquer et 0 pour arrondir à partir de 0, le défaut), noter que l'élément le plus à gauche
(Dn_1) est non défini.
Ra, I A,-11 A1 *.. A2- AI As Rb\\ IDBIoI.-2 o1 Rd 1..1 D11.2... D2I1Dl Do Opération Opération pour (i=0;i<NumElem - 1;i++){ Rd[i]=(Ra[i]+Ra[i+l]+Rb[i+l])//4; } Exception Aucune. VCACHE Opération Antémémoire Format
25 20 15 10 5 0
REAR [ 01 01 1 | 10IF F _A SRb 1 SRi 1
25 20 15 5 0
REAI 11111 011i 0 1 1 IFC [,ilMM 1 SIRI IMM I L.t t i 11<7:5> 1 <4.0 j Syntaxe Assembleur VCACHE.fc SRb, SRi VCACHE.fc SRb, #IMM VCACHE.fc SRb+, SRi VCACHE.fc SRb+, #IMM o fc = {0, 1}
Description
Cette instruction est prévue pour la gestion du logiciel de l'antémémoire de données vectorielles. Quand une portion ou la totalité de l'antémémoire de données est configurée en tant que zone de travail, cette instruction
n'a pas d'effet sur la zone de travail.
Les options suivantes sont supportées: FC<2:0> Siqnification 000 Réécrire et invalider la ligne d'antémémoire sale dont l'étiquette correspond à EA. Si la ligne de correspondance contient une donnée propre, la ligne est invalidée sans la réécriture. Si aucune ligne d'antémémoire n'est trouvée comme contenant EA,
l'antémémoire de données reste intacte.
001 Réécrire et invalider la ligne d'antémémoire sale spécifiée par l'indice de EA. Si la ligne de correspondance contient une donnée propre, la ligne
est invalidée sans la réécriture.
autres non définis Opération Exception Aucune. Note de programmation Cette instruction n'est pas affectée par le
masque d'éléments.
* aunonv uoTqdaoxs { :T quauall.Ig suEp sqTq sel snoq znod = '<X> [F] do <> [] =<> [] p {(<O: >I) xas Il qEIS I [ T]q A}=[T]doS } (++ F:[7}IS uIaTgwnN>fT!O=T) anod UoT:ie2ado PU uoTWuT:saP ap aeasTbea ns eqlnsez np anoqaX q sTpgwunwT/qa qa eu sepuezagdo sep anbTbol IL quauwa1duIoD UoT dTiosaa (M) zú uT (q) 9I4uT | (6q) 64uT (q)> 8U u S a I 0 S->S S 0 S->S I 0 A->A S 0 A->A A 0 A->A H: S: a seaodd.ns sepow * uoTeado u1au[I sl queTjToads e m- anb zaoN '{m 'q '6q 'q} =; p nto wwi# '"eS 'PuS aP'GNVOA qus 'eus 'PuS 1P'GNVOA
NNI# '-IA 'PEA P' QN'VDA
qES 'ea 'PEA P'QNANVA q'CA ' FA 'PUA 4P' (NVOA analquassGV axquAS ) 3 G I p' _ 6i01 1 1 b _ 6 4elullog qua9duIaOD '.(K
996ZE9Z
VCBARR Barrière Conditionnelle Format 25 20 15 Io l 0 Cr 1'1l 1010,Cond IIi Syntaxe Assembleur VCBARR.cond o cond = {0 - 7}. Chaque condition recevra
ultérieurement une mnémonique.
Description
Arrêter l'instruction et toutes les instructions ultérieures (celles qui apparaissent ultérieurement dans l'ordre du programme) tant que la condition tient. La zone Cond<2:0> est interprétée différemment des autres instructions conditionnelles du
format CT.
Les conditions suivantes sont généralement définies: Cond<2:0> Signification 000 Attendre pour toutes les instructions antérieures (celles qui apparaissent avant dans l'ordre du programme) pour terminer l'exécution avant d'exécuter l'une des instructions ultérieures. autres non définis Opération alors que (Cond == vrai) arrêter toutes les instructions ultérieures; Exception Aucune. Note de programmation Cette instruction est prévue pour le logiciel pour forcer la sérialisation d'exécution des instructions. Cette instruction doit être utilisée pour forcer un reportage précis d'une exception imprécise. Par exemple, si cette instruction est utilisée immédiatement après une instruction arithmétique qui pourrait provoquer une exception, l'exception sera rapportée avec le compteur de programme
adressant cette instruction.
VCBR Branchement Conditionnel Format 20 15 Io 5 CT 1101 100101 ILIdj 1 ey CT i ol l ndi 8Pa>ge Syntaxe Assembleur VCBR.cond #décalage o cond = {un, lt, eq, le, gt, ne, ge, ov}
Description
Branchement si Cond est vrai. Cela n'est pas
un branchement retardé.
Opération Si((Cond == VCSR[SO,GT,EQ,LT]) | (Cond == un)) VPC = VPC + sex(offset<22:0>*4); autrement VPC = VPC + 4; Exception
Adresse instruction incorrecte.
VCBRI Branchement Conditionnel Indirect Format
1025 20 15 10 0
CT CoI0 1cond SRb| Syntaxe Assembleur VCBRI.cond SRb o cond = {un, lt, eq, le, gt, ne, ge, ov}
Description
Branchement si Cond est vrai. Cela n'est pas
un branchement retardé.
Opération Si((Cond == VCSR[SO,GT,EQ,LT]) I (Cond == un)) VPC = SRb<31:2> :b'00 autrement VPC = VPC + 4; Exception
Adresse instruction incorrecte.
VCCS Commutateur Contexte Conditionnel Format 20,î ' Iîll 5 CT 1lol 1101 |"a;e II Syntaxe Assembleur VCCS #Décalage
Description
Sauter à la sous-routine de commutateur de contexte si VIMSK<cse> est vrai. Cela n'est
pas un branchement retardé.
Si VMISK<cse> est vrai, VPC+4 (l'adresse de retour) est mis en réserve sur la pile d'adresses de retour. Sinon l'exécution
continue avec VPC+4.
Opération si (VIMSK<cse> == 1){ si (VSP<4"15){
VISRC<RASO≥1;
Signal ARM7 avec exception RASO;
VPSTATE = VP_IDLE;
$ autrement {
RSTACK[VSP<3:0>]=VPC+4;
VSP<4:0≥VSP<4:0>+1;
VPC=VPC + sex(décalage<22:0>*4); } } autrement VPC=VPC+4 Exception
Débordement pile adresses retour.
VCHGCR Registre Contrôle Changement Format
25 20 15 10 5
l Il I 'liI I I I I1 1i 1 1 1 1 111I i CT 11 l 1001 Mode Syntaxe Assembleur VCHGCR Mode
Description
Cette instruction change le mode de
fonctionnement du processeur vectoriel.
Chaque bit en Mode spécifie ce qui suit: Mode Signification bit 1:0 Ces deux bits contrôlent le bit VCSR<CBANK>. Les codages spécifient: 00 - pas de changement 01 - effacer le bit VCSR<CBANK> - établir le bit VCSR<CBANK> 11 - basculer le bit VCSR<CBANK> bit 3:2 Ces deux bits contrôlent le bit VCSR<SMM>. Les codages spécifient: 00 - pas de changement 01 - effacer le bit VCSR<SMM> - établir le bit VCSR<SMM> 11 - basculer le bit VCSR<SMM> bit 5:4 Ces deux bits contrôlent le bit VCSR<CEM>. Les codages spécifient: 00 - pas de changement 01 - effacer le bit VCSR<CEM> - établir le bit VCSR<CEM>
11 - basculer le bit VCSR<CEM>.
autres non définis Opération Exception Aucune. Note de programmation Cette instruction est prévue pour le matériel pour changer les bits de contrôle dans VCSR d'une manière plus efficace que possible par
une instruction VMOV.
VCINT Interruption Conditionnelle ARM7 Format CT nd 1 1 1 1 1 1 1 1 1 1 1 1I Il I I Iil i i i
J | | L 1201 -15 5ICODE
Syntaxe Assembleur VCINT.cond #ICODE o cond = {un, lt, eq, le, gt, ne, ge, ovi
Description
Si Cond est vrai, arrêter l'exécution et
interrompre ARM7 si elle est validée.
Opération Si((Cond == VCSR[SO,GT,EQ,LT])] (Cond == un)) VISRC<vip≥ 1; VIINS = [VCINT.cond #ICODE instruction];
VEPC = VPC;
si (VIMSK<vie> == 1)interruption signal ARM7;
VPSTATE = VPIDLE
} autrement VPC = VPC + 4; Exception
Interruption VCINT.
VCJOIN Jonction Conditionnelle avec Tâche ARM7 Format J l l, ,, i t,_t_ jl l| l l r l,,,"l
À5 13,0 0
*cr 0110 Cond <daageI Syntaxe Assembleur VCINT.cond #Décalage o cond = {un, lt, eq, le, gt, ne, ge, ov}
Description
Si Cond est vrai, arrêter l'exécution et
interrompre ARM7 si elle est validée.
Opération Si((Cond == VCSR[SO7, GT,EQ,LT]) | (Cond == un)) VISRC<vjp≥ 1; VIINS = [VCJOIN.cond #Décalage instruction];
VEPC = VPC;
si (VIMSK<vje> == 1)interruption signal ARM7;
VP STATE = VP IDLE
} autrement VPC = VPC + 4; Exception
Interruption VCJOIN.
VCJSR Saut Conditionnel à Sous-Routine Format 3O zs 20 15 10 CT (ol ÈI'o0ô IondIlg T I Il Syntaxe assembleur VCJSR.cond #Décalage o cond = {un, it, eq, le, gt, ne, ge, ov}
Description
Saut à sous-routine si Cond est vrai. Cela
n'est pas un branchement retardé.
Si Cond est vrai, VPC + 4 (l'adresse de retour) est mis en réserve sur la pile d'adresses de retour. Sinon l'exécution
continue avec VPC + 4.
Opération Si((Cond == VCSR[SO,GT,EQ,LT]) I (Cond == un)) si (VSP<4>>15) {
VISRC<RASO> = 1;
signal ARM7 avec exception RASO
VP _STATE = VPIDLE;
} autrement {
RSTACK[VSP<3:0>]=VPC + 4;
VSP<4:0> = VSP<4:0> + 1;
VPC = VPC + sex(Décalage<22:0>*4); } } autrement VPC = VPC + 4; Exception
Débordement pile adresses de retour.
VCJSRI Saut Conditionnel ià Sous-Routine IndireczL Format
'5 20 105
CT 11 Cond SRb cr|0 I Syntaxe assembleur VCJSRI.cond SRb o cond = {un, lt, eq, le, gt, ne, ge, ov}
Description
Saut indirect à sous-routine si Cond est vrai.
Cela n'est pas un branchement retardé.
Si Cond est vrai, VPC + 4 (l'adresse de retour) est mis en réserve sur la pile d'adresses de retour. Sinon l'exécution
continue avec VPC + 4.
Opération Si((Cond == VCSR[SO,GT,EQ,LT]) I (Cond == un)) si (VSP<4:0> 15){
VISRC<RASO> = 1;
signal ARM7 avec exception RASO
VPSTATE = VPIDLE;
} autrement {
RSTACK[VSP<3:0>]=VPC + 4;
VSP<4:0> = VSP<4:0> + 1;
VPC = SRb<31:2>:b'00; } }autrement VPC = VPC + 41 Exception
Débordement pile adresses de retour.
VCMOV Déplacement Conditionnel Format
-30. 55 10 S O
1 T,I I I M I I I 1
Syntaxe Assembleur VCMOV.dt Rd, Rb, cond VCMOV.dt Rd, #IMM, cond o dt = {b; b9, h, w}, cond = {un, it, eq, le, gt, ne, ge, ov}. Noter que.f et.w spécifient la même opération à l'exception que le type de donnée.f n'est pas supporté avec l'opérande
immédiat à 9 bits.
Modes supportés D:S:M V<-V ' V<-S V<-I I S<-S I S<- I DS int8 (b) int9 (b9) intl6 (h) int32 (w
Description
Si Cond est vrai, le contenu du registre Rb est déplacé au registre Rd. ID<1:0> spécifie de plus les registres de source et de destination: VR registre vectoriel rangée courante SR registre scalaire SY registre de synchronisation VAC registre accumulateur vectoriel (se
référer à la description de VMOV pour le
codage du registre VAC)
D:S:M ID<1:0≥00 ID<1:0≥01 ID<1:0≥10 ID<1:0≥11
V <- V VR <- VR VR <- VAC VAC<- VR
*V <- S VR <- SR VAC<- SR
V <- I VR <- I
S <- S SR<- SR
S <- I SR <- I
Opération Si((Cond == VCSR[SOV,GT,EQ,LT]) | (Cond == un)) pour (i=0; 1<NumElem;i++) Rd[i]={Rb[i] I| SRb Il sex(IMM<8:0>)}; Exception Aucune. Note de programmation Cette instruction n'est pas affectée par le masque d'éléments - VCMOVM est affecté par le
masque d'éléments.
La représentation de précision à point flottant étendu dans l'accumulateur vectoriel utilise les 576 bits pour les 8 éléments. Par conséquent, un déplacement de registre vectoriel impliquant l'accumulateur doit
spécifier la grandeur de donnée.b9.
VCMOVM Déplacement Conditionnel avec Masque d' Elément Format
25 20 15 10,
RRI;LM9*erIII Il 1 1111111 RRRM9e0111| 01 DISIDS M9 1Cond RLJ Syntaxe Assembleur VCMOVM.dt Rd, Rb, cond VCMOVM.dt Rd, #IMM, cond o dt = {b, b9, h, w}, cond = {un, lt, eq, le, gt, ne, ge, ov}. Noter que.f et. w spécifient la même opération, à l'exception que le type de donnée.f n'est pas supporté par l'opérande
immédiat à 9 bits.
Modes su portés DS:MI V<-V V<i-S V< I DS int8 (b) int9 (b9) intl6 (h) int32 (w)
Description
Le contenu du registre Rb est déplacé au registre Rd si Cond est vrai. ID<1:0> spécifie de plus les registres de source et de destination: VR registre vectoriel rangée courante SR registre scalaire VAC registre accumulateur vectoriel (se
référer à la description de VMOV pour le
codage du registre VAC)
D:S:M ID<1:0≥00 ID<1:0≥01 | ID<1:0≥10 ID<1:0≥11
V <- V VR <- VR VR <- VAC VAC<- VR
V <- S VR <- SR _____ VAC<- SR
V <- I VR <- I
S <- S
S <- I
Opération Si((Cond == VCSR[SO,GT,EQ,LT]) I (Cond == un)) pour (i=0; 1<NumElem && MMASK;i++) Rd[i]={Rb[i] Il SRb Il sex(IMM<8:0>)}; Exception Aucune. Note de programmation Cette instruction est affectée par le masque d'éléments VMMR. VCMOV n'est pas affecté par
le masque d'éléments.
La représentation à précision à point flottant étendu dans l'accumulateur vectoriel utilise les 576 bits pour les 8 éléments. Par conséquent, un déplacement de registre vectoriel impliquant l'accumulateur doit
spécifier la grandeur de données.b9.
VCMPV Comparer et Positionner Manque Format s 11o 0,0 0, i Iii ,,li v0i 10 >JDSS |ond| |VRa Rb Syntaxe Assembleur VCMPV.dt VRa, SRb, cond, masque VCMPV.dt VRa, SRb, cond, masque o dt = {b, b9, h, w, f}, cond = { lt, eq, le, gt, ne, ge}, masque = {VGMR, VMMR}. Si aucun
masque n'est spécifié, on suppose VGMR.
Modes supportés
D:S:M | M<-V @ V | V<-V @ S
DS int8 (b) int9 (b9) intl6 (h) int32 (w) flottant (f)
Description
Les contenus des registres vectoriels VRa et VRb sont comparés par éléments en accomplissant une opération de soustraction (VRa[i] - VRb[i]), et le bit #1 correspondant dans le registre de VGMR (si k=0) ou VMMR (si k=1) est établi si le résultat de la comparaison correspond à la zone Cond de l'instruction de VCMPV. Par exemple si la zone Cond est plus petite que (LT), le bit VGMR[i]
ou VMMR[i] sera établi si VRa[i]<VRb[i].
Opération pour (i = 0;1l<NumElem;i+,)){ Bop[i]={Rb[i] || SRb Il sex(IMM<8:0>)} relation[i]=Ra[i] ? Bop[i]; si (K ==1) MMASK[i]=(relation[i]==Cond) ? Vraie:Fausse; autrement EMASK[i]=(relation[i]==Cond) ? Vraie:Fausse; } Exception Aucune. Note de programmation Cette instruction n'est pas affectée par le
masque d'éléments.
VCNTLZ Compte Zéros en Tête Format d 2,I I0 I | 0 -t RRRR 0 1 l0 1100 101 Rd Rb Syntaxe Assembleur VCNTLZ.dt VRd, VRb VCNTLZ.dt SRd, SRb
o dt = {b; b9, h, w}.
Modes supportés s X v<-v T s<-s DS int8 (b) int9 (b9) intl6 (h) int32 (w)
Description
Pour chaque élément dans Rb compter le nombre
de zéros en tête; retourner le compte dans Rd.
Opération pour (i = 0;l<NumElem &&EMASK[i];i++){ Rd[i]=nombre de zéros en tête(Rb[i]); } Exception Aucune. Note de programmation Si tous les bits dans un élément sont des zéros, alors le résultat est égal à la grandeur de l'élément (8, 9, 16 ou 32 pour l'octet, l'octet 9, le. demi- mot ou le mot, respectivement). Le compte des zéros en tête est en relation inverse avec l'indice des positions des éléments (si on l'utilise après instruction VCMPR). Pour convertir à une position d'élément, soustraire le résultat de VCNTLZ de
NumElem pour le type donné de donnée.
VCOR OU Complément Format
Y 20 15 10 5 0
RRRM9 Ii IlllAl 11 SDIH JM 191 1 Rd Ra Rb/IM5 Syntaxe Assembleur VCOR. dt VRd, VRa, VRb VCOR.dt VRd, VRa, SRb VCOR.dt VRd, VRa, #IMM VCOR.dt SRd, SRa, SRb VCOR.dt SRd, SRa, #IMM o dt = {b, b9, h, w}. Noter que.w et .f
spécifient la même opération.
Modes supportés
D:S:M V<-V @ V V<-V @ S V<-V @ I S<-S @ S S<-S @ I
DS int8 (B) int9 (b9) intl6 (h) int32 (w)
Description
Complément OU logique des opérandes Ra et Rb/immédiats et retour de résultat au registre
de destination Rd.
Opération pour (i = 0;1<NumElem &&EMASK[i];i++){ Bop[i]={VRb[i] Il SRb Il sex(IMM<8:0>)}; Rd[i]<k≥-Ra[i]<k> I Bop[i]<k>, k= pour tous les bits dans l'élément i; Exception Aucune. VCRSR Retour Conditionnel de Sous-Routine Format 3025 20 15 Io À r= I II oIoII 1III iIIi III III i iII1 'I Syntaxe Assembleur VCRSR.cond
o cond = {un, lt, eq, le, gt, ne, ge, ov}.
Description
Retour de sous-routine si Cond est vrai. Cela
n'est pas un branchement retardé.
Si Cond est vrai, l'exécution continue à partir de l'adresse de retour mise en réserve dans la pile d'adresses de retour. Sinon,
l'exécution continue avec VPC + 4.
Opération Si((Cond == VCSR[SO,GT,EQ,LT]) | (Cond == un)){ si (VSP<4> == 0){
VISRC<RASU> = 1;
signal ARM7 avec exception RASU
VPSTATE = VPIDLE;
} autrement {
VSP<4:0> = VSP<4:0> - 1;
VPC = RSTACK[VSP<3:0>];
VPC<1:0> = b'00 } }autrement VPC = VPC + 4; Exception
Adresse instruction incorrecte sous-
débordement pile adresses retour.
VCVTB9 Convertir Type Donnée Octet 9 Format
I I I III IIIII 0
RRRR 011111(0 MI. ISIMDI | S Rb Syntaxe Assembleur VCVTB9.md VRd, VRb VCVTB9.md SRd, SRb o md = {bb9, b9h, hb9} Modes supportés S s v<-v I S<S MD bb9 b9h hb9
Description
Chaque élément de Rb est converti de l'octet & l'octet 9 (bb9), de l'octet 9 au demi-mot
(b9h) ou de demi-mot à l'octet 9 (hb9).
Opération si (md<l:0≥=0){ //bb9 pour conversion d'octet à octet 9 VRd = VRb; VRd<9i+8≥VRb<9i+7>,i=O à 31 (ou 63 dans le mode VEC64)} autrement si (md<l:0≥=2){ //b9h pour conversion octet 9 à demi-mot VRd=VRb; VRd<18i+16:18i+9≥VRb<18i+8>,i=0 à 15 (ou 31 en mode VEC64)} autrement si (md<1:0≥=3) //hb9 pour conversion demi- mot à octet-9 VRd<18i+8≥VRb<18i+9>,i=0 à 15 (ou 31 en mode VEC64) autrement VRd = non défini; Exception Aucune Note de programmation Avant d'utiliser cette instruction avec le mode b9h, le programmeur doit ajuster pour le nombre diminué d'éléments dans le registre
vectoriel avec une opération de brassage.
Après avoir utilisé cette instruction avec le mode hb9, le programmeur doit ajuster pour le nombre augmenté d'éléments dans le registre vectoriel de destination avec une opération de débrassage. Cette instruction n'est pas
affectée par le masque d'éléments. -
VCVTFF Convertir Point Flottant à Point Fixe Format O0 t 0 15 0 5 0 RRR0M5 0lLtO 01011 DISI 11H iRd Ra. SRb/. M5f Syntaxe Assembleur VCVTFF VRd, VRa, SRb VCVTFF VRd, VRa, #IMM VCVTFF SRd, SRa, SRb VCVTFF SRd, SRa, #IMM Modes supportés l D:S:M Iv <- V, slv<-V, i1S <- S, sis <- S, I
Description
Les contenus de registres vectoriels/scalaires Ra sont convertis du point flottant à 32 bits à un nombre réel à point fixe du format <X.Y>, o la largeur de Y est spécifiée par Rb (modulo 32) ou par la zone IMM et o la largeur de X est définie par (32 - largeur de Y). X désigne la partie entière et Y désigne la partie fractionnée. Le résultat est enregistré dans le registre vectoriel/scalaire Rd. Opération grandeur_Y = {SRb % 32 Il IMM<4:0>}; pour (i=0;l<NumElem;i++){ Rd[i]=convertir au format <32-grandeurY.grandeur_Y> (Ra[i]); } Exception Débordement Note de programmation Cette instruction ne supporte que la grandeur du mot de donnée. Cette instruction n'utilise pas le masque d'éléments car l'architecture ne supporte pas des types de données multiples dans un registre. Cette instruction utilise le mode d'arrondissement à partir de zéro pour
les types de données entières.
VCVTIF Convertir Entier à Point Flottant Format 1 1 1 1o 1o RId Fis 1 1 1| RJ b
RRR.M5.01_'11 I 11 S1,
Syntaxe Assembleur VCVTIF VRd, VRb VCVTIF VRd, SRb VCVTIF SRd, SRb Modes supportés
D:S:M V<- V V<- S S<-S
Description
Le contenu du registre vectoriel/scalaire Rb est converti du type de donnée int32 à flottant et le résultat est enregistré dans le
registre vectoriel/scalaire Rd.
Opération pour (i=0;1<NumElem;i++){ Rd[i]=convertir à format point flottant (Rb[i]); } Exception Aucune. Note de programmation Cette instruction ne supporte que la grandeur du mot de donnée. Cette instruction n'utilise pas le masque d'éléments car l'architecture ne supporte pas de types,de- données multiples
dans un registre.
VDlCBR Décrment VCR1 et Branchement Conditionnel Format 25 20 15 io 5 0 CT 10 0001 Cond <dage Syntaxe Assembleur VD1CBR.cond #Décalage o cond = {un, lt, eq, le, gt, ne, ge, ov},
Description
Décrément VCR1 et branchement si Cond est
vrai. Cela n'est pas un branchement retardé.
Opération
VCR1 = VCR1 - 1;
si ((VCR1>0) & (Cond==VCSR[SO,GT,EQ,LT,]) I (Cond==un))) VPC = VPC + sex(Décalage<22:0>*4); autrement VPC = VPC + 4; Exception
Adresse instruction incorrecte.
Note de programmation Noter que VCR1 est décrémenté avant que la
condition de branchement ne soit vérifiée.
L'exécution de cette instruction quand VCR1 est 0 établit effectivement le compte en
boucle à 232 -1.
VD2CBR âDcrément VCR2 et Branchement Conditionnel Format
302 15 10 5 0
CT 1|0 00 10 |Contd jqeg l Syntaxe Assembleur VD2CBR. cond #Décalage
o cond = {un, lt, eq, le, gt, ne, ge, ov}.
Description
Décrément VCR2 et branchement si Cond est
vrai. Cela n'est pas un branchement retardé.
Opération
VCR2 = VCR2 - 1;
si ((VCR2>0) & (Cond==VCSR[SO,GT,EQ,LT]) (Cond==un))) VPC = VPC + sex(Décalage<22:0>*4); autrement VPC = VPC + 4; Exception
Adresse instruction incorrecte.
Note de programmation Noter que VCR2 est décrémenté avant que la
condition de branchement ne soit vérifiée.
L'exécution de cette instruction quand VCR2 est 0 établit effectivement le compte en boucle à 232 -1 VD3CBR Décrément VCR3 et Branchement Conditionnel Format 5 20 t isl 10 5 O CT 1a 0011 Cond age Syntaxe Assembleur VD3CBR.cond #Décalage
o cond = {un, lt, eq, le, gt, ne, ge, ov}.
Description
Décrément VCR3 et branchement si Cond est
vrai. Cela n'est pas un branchement retardé.
Opération
VCR3 = VCR3 - 1;
si ((VCR3>0) & (Cond==VCSR[SO,GT,EQ,LT]) | (Cond==un))) VPC = VPC + sex(Décalage<22:0>*4); autrement VPC = VPC + 4; Exception
Adresse instruction incorrecte.
Note de programmation Noter que VCR3 est décrémenté avant que la
condition de branchement ne soit vérifiée.
L'exécution de cette instruction quand VCR3 est 0 établit effectivement le compte en
boucle à 232 -1.
VDIV2N Diviser par 2 Format
20 15 10 5 O
RRRM5)LOj À 1-1 FjSDI'S|H | Rd |. SRb/1M5 Syntaxe Assembleur VDIV2N. dt VRd, VRa, VRb VDIV2N.dt VRd, VRa, #IMM VDIV2N.dt SRd, SRa, SRb VDIV2N.dt SRd, SRa, #IMM o dt = {b, b9, h, w} Modes supportés D:S:M V<- S V<-V @ I S<-S @ s S<-S @ I DS int8 (b) int9 (b9) intl6 (h) int32 (w)
Description
Le contenu du registre vectoriel/scalaire Ra est divisé par 2n o n est le contenu en entiers positifs du registre scalaire Rb ou IMM et le résultat final est enregistré dans le registre scalaire/vectoriel Rd. Cette instruction utilise le mode tronqué (arrondissement vers zéro) en tant que mode d'arrondissement. Opération N = {SRb % 32 Il IMM<4:0>}; pour (i=0;i<NumElem && EMASK[i];i++){ Rd[i] = Ra[i]/2N; } Exception Aucune. Note de programmation Noter que N est pris comme nombre à 5 bits à partir de SRb ou IMM<4:0>. Pour les types de données en octet, octet 9, demi-mot, le programmeur est responsable d'une spécification correcte de la valeur de N qui est plus petite que ou égale au degré de précision dans la grandeur de donnée. Si elle est plus grande que la précision de la grandeur de donnée spécifiée, les éléments sont remplis avec les bits de signe. Cette instruction utilise le mode d'arrondissement
vers zéro.
VDIV2N.F Diviser par 2- Flottant Format
0 5 210
R.RJM5 0| 00111 p1sjZ M'î k Ifi -1|,IS j RRRM5 10 1 0f lo, Il Syntaxe Assembleur VDIV2N.f VRd, VRa, SRb VDIV2N.f VRd, VRa, #IMM VDIV2N.f SRd, SRa, SRb VDIV2N.f SRd, SRa, #IMM Modes suportés
D:S:M I I V<-V @ S 1 V<-V @ I S<-S @ S I S<-S @ I
Description
Le contenu du registre vectoriel/scalaire Ra est divisé par 2" o n est le contenu en entiers positifs du registre scalaire Rb ou IMM et le résultat final est enregistré dans
le registre scalaire/vectoriel Rd.
Opération N = {SRb % 32 il IMM<4:0>}; pour (i=0;i<NumElem && EMASK[i];i++ ){ Rd[i] = Ra[i]/2N; } Exception Aucune. Note de programmation Noter que N est pris comme nombre à 5 bits de
SRb ou IMM<4:0>.
VDIVI Initialisation Division Incomplète Format w As20: ' 10 5 R.RRR 0111 10 IDSi! R Syntaxe Assembleur VDIVI.ds VRb VDIVI.ds SRb o ds = {b, b9, h, w} Modes su portés S VRb SRb I DS int8 (b) int9 (b9) intl6 (h) int32 (w)
Description
Accomplir l'étape initiale d'une division d'entier avec signe sans restauration. Le dividende est un entier avec signe à double précision dans l'accumulateur. Si le dividende est à simple précision, il doit être étendu au signe pour doubler la précision et être enregistré dans VACOH et VACOL. Le diviseur est un entier à signe à simple position dans Rb. Si le signe du dividende est le même que le signe du diviseur, Rb est soustrait de l'accumulateur à l'état haut. Sinon Rb est
ajouté à l'accumulateur à l'état haut.
Opération pour (i=O;i<NumElem && EMASK[i];i++){ Bop[i] = {VRb[i] Il SRb} si (VACOH[i]<msb≥=Bop[i]<msb>) VACOH[i]=VACOH[i] -Bop[i]; autrement VACOH[i]=VACOH[i]-Bop[i]; } Exception Aucune. Note de programmation Le programmeur est responsable de la détection de cas de débordement ou de division par zéro
avant les étapes de division.
VDIVS Etape Division Incompiète Format 3 o 20 15 IO n :R 3 - 1 0115 010 11 S S VRb Syntaxe Assembleur VDIVS.ds VRb VDIVS.ds SRb o ds = {b, b9, h, w} Modes supportés I S 1 VRb I SRb | DS int8 (b) int9 (b9) intl6 (h I int32 (w)
Description
Accomplir une étape itérative d'une division avec signe sans restauration. Cette instruction doit être exécutée autant de fois que la grandeur de donnée (i.e., 8 fois pour les types de données int8, 9 pour int9, 16 pour intl6, et 32 pour int32). L'instruction VDIVI doit être utilisée une fois avant les étapes de division pour produire un reste partiel initial dans l'accumulateur. Le diviseur est un entier à signe à simple précision dans Rb. Une -fois, le bit du quotient est extrait par étape et décalé vers le bit le moins significatif de l'accumulateur. Si le signe du reste partiel dans l'accumulateur est le même que le signe du diviseur dans Rb, Rb est soustrait de l'accumulateur à l'état haut. Sinon, Rb est
ajouté à l'accumulateur à l'état haut.
Le bit de quotient est 1 si le signe du reste partiel résultant (résultat de l'addition, ou de la soustraction) est le même dans
l'accumulateur que le signe du diviseur.
Sinon, le bit de quotient est 0.
L'accumulateur est décalé vers la gauche d'une position d'un bit avec le bit de quotient le remplissant. A la fin des étapes de division, le reste est dans l'accumulateur à l'état haut et le
quotient est dans l'accumulateur à l'état bas.
Le quotient est en forme de complément à un.
Opération VESL DAcalage Elément vers la Gauche de 1 Format e 20 15 10 i 0 RRRR 01,1OOI0011H1 LlS SRc VRd VRa SRb Syntaxe Assembleur VESL.dt SRc, VRd, VRa, SRb o dt = {b, b9, h, w}. Noter que.w et.f
spécifient la même opération.
Modes supportés S S l SRb I DS _ int8 (b) int9 (b9) intl6 (h) int32 {wi
Description
Décaler les éléments dans le registre vectoriel Ra vers la gauche d'une position, en
remplissant à partir du registre scalaire Rb.
L'élément le plus à gauche étant décalé vers l'extérieur est retourné dans le registre scalaire Rc et les autres éléments sont
retournés dans le registre vectoriel Rd.
VRa CE [. IA.-Z 2 AI ISRb SRb Opération VRd[0] = SRb; pour(i=l;i<NumElem-l;i++) VRd[i]=VRa[i-1]; SRc=VRa[NumElem-1] Exception Aucune. Note de programmation Cette instruction n'est pas affectée par le
masque d'éléments.
VESR Décalage Elément vers la Droite de 1 Format 20 1.; Io 5 0 RRRR 0 1 01 10 1 S c SRbR Syntaxe Assembleur VESL.dt SRc, VRd, VRa, SRb o dt = {b, b9, h, w}. Noter que.w et.f
spécifient la même opération.
Modes supportés S X SRb DS int8 (bt lint9 (b9) intl6 (h) int32 (w) |
Description
Décaler les éléments dans le registre vectoriel Ra vers la droite de 1 position, en
remplissant à partir du registre scalaire Rb.
L'élément le plus à droite étant décalé vers l'extérieur et retourné dans le registre scalaire Rc et les autres éléments sont
ramenés dans le registre vectoriel Rd.
SRb VRa B n. Aun21... A2 A1 AI VRd SRe l D...,... 'D2 Dl Do Opération SRc = VRa[0]; pour (i = 0;i<NumElem-2; i++ ) VRd[i] = VRa[i+1]; VRd [NumElem-1] = SRb; Exception Aucune. Note de programmation Cette instruction n'est pas affectée par le
masque d'éléments.
VEXTRT Extraire Un Elément Format RRRM93:5 20 15 10 5 d 0 RRM9 |l 1000 01 SDS MS! SRd VRa SRbIM5 Syntaxe Assembleur VEXTRT.dt SRd,VRa, SRb VEXTRT.dt SRd,VRa,#IMM o dt = {b, b9,w,f}. Noter que.f et.w
spécifient la même opération.
Modes supportés D: S:M | | | S<-S S<-1 DS int8(b) int9 (b9) intl6 (h) int32 (w)
Description
Extraire un élément du registre vectoriel Ra dont l'indice est spécifié par le registre scalaire Rb ou la zone IMM et l'enregistrer
dans le registre scalaire.
Opération indice32 = {SRb % 32 Il IMM<4:0>}; indice64 = {SRb % 64 Il IMM<5:0>}; indice = (VCSR<vec64>)?indice64: indice32; SRd = VRa[index]; Exception Aucune. Note de programmation Cette instruction n'est pas affectée par le masque d'éléments. VEXTSGN2 Extraire Signe de 1fl.- il Format
1 10 5 0
P. R.R0|11 0 1 ISIDS Rd Ra Syntaxe Assembleur VEXTSGN2.dt VRd, VRa VEXTSGN2.dt SRd.SRa
o dt = {b,b9,h,w}.
Modes supportés I s V<-V s<-s DS int8 (b) int9 (b9) intl6 (h) int32 (w)
Description
La valeur du signe du contenu du registre vectoriel/scalaire Ra par éléments est calculée et le résultat est enregistré dans
le registre vectoriel/scalaire Rd.
Opération pour (i=0;i<NumElem&&EMASK[i];i++) { Rd[i] = (Ra[i]<0)?-l:1; } Exception Aucune. FEXTSGN3 Extraire Signe de (1. 0. -1) Format
2 20 15 10 - 0
RRRR 0IIOI Ii11 S DS Rd Ra 1 Syntaxe Assembleur VEXTSGN3.dt VRd,VRa VEXTSGN3.dt SRd,SRa
o dt = {b,b9,h,w}.
Modes supportés I s Iv <-v I s<-s I DS int8 (b) int9 (b9) intl6 (h) int32 (w) I
Description
La valeur du signe du contenu du registre vectoriel/scalaire Ra par élément est calculée et le résultat est enregistré dans
le registre vectoriel/scalaire Rd.
Opération Pour (i=0;i<NumElem&&EMASK[i];i++) { Si(Ra[i]<0) Rd[i] = 1; autrement si(Ra[i]<0) Rd[i] = 1; autrement Rd[i] = 0; } Exception Aucune. VINSRT Insérer Un Elément Format
, 15 I 5 0
I1111 11 I iI iii 1lH RRRM9 Il lu 100000 Dis DS S M9 VRd SRa SRb/LM5 Syntaxe Assembleur VINSRT.dt VRd,SRa, SRb VINSRT.dt VRd,SRa, #IMM o dt = {b,b9,h,w,f}. Noter que.f et.w
spécifient la même opération.
Modes Supportés
1 D:S:M I I V<-S | V<-I I I
DS int8(b) int9 (b9) intl6 (h) int32 (w)
Description
Insérer l'élément dans le registre scalaire Ra dans le registre vectoriel Rd à l'indice spécifié par le registre scalaire Rb ou la
zone IMM.
Opération indice32 = {SRb % 32 Il IMM<4:0>}; indice64 = {SRb % 64 II IMM<5:0>}; indice = (VCSR<vec64>)?indice64: indice32; VRd[index] = SRa; Exception Aucune Note de programmation Cette instruction n'est pas affectée par le
masque d'éléments.
VL Charge Format
25 20 15 10 S 0
I iHIBL CkTr l ii I TI I I REAR f000 0000 Rd SRb SRi 20o15 I0 5 0 REAJI 1 1 100 1 B L OC IMMI 1 |Rd SRb IMM Io!oi [ H, 1i i,i,,i Syntaxe Assembleur VL.lt Rd,SRb, SRi VL.lt Rd,SRb,#IMM VL.lt Rd.SRb+,SRi VL. it Rd, SRb+, #IMM o it = {b, bz9, Bs9, h, w, 4, 8, 16, 32, 64}, Rd = {VRd, VRAd, SRd}.Il faut noter que b et.bs9 spécifient la même opération et que.64 et VRAd ne peuvent être spécifiés ensemble. Utiliser VLOFF pour charge
antémémoire hors circuit.
Description
Charge un registre vectoriel dans la rangée
courante ou alternée d'un registre scalaire.
Opération EA = SRb + {SRi |l sex(IMM<7:0>)}; Si (A==1) SRb = EA: Rd = voir tableau ci-dessous;
LT Opération charge-
bz9 SRd<8:0> = zex BYTE[EA] bz9 SRd<8:0> = zex BYTE[EA] bs9 SRd<158:0> = HALFsex BYTE[EA] h__ SRd<15:;0> - HALF[EA] 4 VRd<9i+ 8:9i> = sex BYTE[EA+i],i=0 à 3 8 VRd<9i+8:9i> = sex BYTE[EA+i],i=0 à 7 16 VRd<9i+8:9i> = sex BYTE[EA+i],i=0 à 15 32 VRd<9i+8:9i> = sex BYTE[EA+i],i=0 à 31 64 VRod<9i+8:9i> = sex BYTE[EA+i],i=0 à 31 VRid<9i+8:9i> = sex BYTE[EA+32+i],i=0 à31 Exception Adresse donnée incorrecte, accès non aligné Note de programmation Cette instruction n'est pas affectée par le
masque d'éléments.
VCLB Charge du Tampon Circulaire Format 25 20 in1, REAR 000IAI 1 ARd SRb SRi
20 15 105 0
REAI 1 01 010 RBLT[ CAIM ' Rd SRb 1 4: M Syntaxe Assembleur VLCB. lt Rd,SRb, SRi VLCB.lt Rd,SRb,#IMM VLCB.lt Rd.SRb+,SRi VLCB.lt Rd,SRb+,#IMM o it = {b, bz9, Bs9, h, w, 4, 8, 16, 32, 64}, Rd = {VRd, VRAd, SRd}.Il faut noter que b et.bs9 spécifient la même opération et que.64 et VRAd ne peuvent être spécifiés ensemble. Utiliser VLCBOFF pour charge
antémémoire hors circuit.
Description
Charge un registre vectoriel ou scalaire du tampon circulaire lié par l'indicateur COMMENCEMENT dans SRb+1 et l'indicateur FIN
dans SRb+2.
L'adresse effective est ajustée si elle est plus grande que l'adresse FIN avant la charge ainsi que l'opération de mise à jour de l'adresse. De plus, les liaisons du tampon circulaire doivent être alignées sur les limites du demi-mot et du mot pour les charges
scalaires.h et.w, respectivement.
Opération EA = SRb + {SRi Il sex(IMM<7:0>)}; COMMENCEMENT = SRb+1; FIN = SRb+2; Grandeur cb = FIN - COMMENCEMENT si (EA >FIN) EA = COMMENCEMENT + (EA - FIN); si (A==i) SRb = EA Rd = voir tableau ci-après; - NId> NIA- Va enb TsuTe TNSWSODNSfWOD < Va jeg uS LN33KDN3fWOD - NI*Z> V. > TJNSWDN3HWOO : puae A,s uo GuRuoo auuoT:ouo; uoTDonaqsuTI enb anod aueaTns UOT:TpUOD Pl aaInsse qTop inuaume Boid aq ÀsUgta, p enbseuz al -jed aa_;le sed 4sau uoTqonzqsuT aqaZ UOTqWlfiVbod ap GqoN gu6TIe uou s.DOoe 'OaIoa:ODUT,guuop Gssa:pV SUOT4daDXS !e O=T.'[T+Zú+ Va:qoanapuPb+!+Zú+.S &(NIA < + + ú + Va c(NIA<T+Z+Vs)]T3LXa xas= <T6:8+T6>PlTjA TE e O=T'[T+Vs:qD anapu-eb-T + V. (NIj<T+Vg)]3LAT xas= <T6:8+T6>PO0A I _ 9'
T E: -- +? 0 =.'[!+Vâ:
qo:rnapuleI-T+Va. (NI<T+V)]L.XS xas = <6:8+T6>PdA zE 9 1 O=T LT+ Vs: qoinepuvab-T+VSZ (Njj<F+Va)] SI S xas = <T6:8+F6>PdA 91'
L O=T'L [T+V
:qonapue6-T+Vf.a(NI.<,+V.)].TX xas = <T6:8+T6>PdA 8-
ú O=T'[T+Vs :qomnapueZ5-T+f+V.(NIa<T+Vg,)].TS xS = <T6:8+T6>PDA t :qnp -+ (_I<,+[vs)] aiuoM = <o: +7>PAS _ M.
[VEI] VH = <O:9I>PUS W'
* [V9],1 Lx xas = <0:8>PUS 6sq' [Vz].JLzx xaz = <0:8>PuS 6zqÀ GbtleqD uoTaWdO TLl VLD Charge Double Format
3011 25 20 1|TCA 5 1I0 | 0
REAR 101001 000d10 I RDB SRL |C il;
205 15 10 0
REM 00 J TC IM M Rd SRb lu Syntaxe Assembleur VLD.lt Rd,SRb, SRi VLD.lt Rd,SRb,#IMM VLD.lt Rd.SRb+,SRi VLD.lt Rd, SRb+,#IMM o it = {b,bz9,Bs9,h,w,4,8,16,32,64}, Rd = {VRd, VRAd, SRd}. Il faut noter que.b et bs9 spécifient la même opération et.64 et
VRAd ne peuvent être spécifiés ensemble.
Utiliser VLODFF pour charge antémémoire hors circuit.
Description
Charge deux registres vectoriels dans la rangée courante ou alternée ou bien de
registres scalaires.
Opération EA = SRb + {SRill sex(IMM<7:0>)}; si (A==1) SRb = EA Rd: Rd + 1 = voir tableau ci-après; LT Opération charge bz9 SRd<8:0> = zex BYTE[EA] SRd+1<8:0> = zex BYTE[EA+1] bs9 SRd<8;0> = zex BYTE[EA] SRd+1<8:0> = zex BYTE[EA+1] h SRd<15:0> = HALF[EA] SRd+ 1<15:0> = HALF[EA+2] SRd+1<31:0> = WORD[EA+4] 4 VRd<9i+8:9i> = sex BYTE[(EA+i],i=0 à 3 VRd+1<9i+8:9i> = sex BYTE[(EA+4+i],i=0 à 3 8 VRd<9i+8:9i> = sex BYTE[(EA+i],i=0 à 7 VRd+1<9i+8:9i> = sex BYTE[(EA+8+ i],i=0 à 7 16 VRd<9i+8:9i> = sex BYTE[(EA+i],i=0 à 15 VRd+1<9i+8:9i> = sex BYTE[(EA+16+i],i=0 à 15 32 VRd<9i+8:9i> = sex BYTE[(EA+i],i=0 à 31 32__ VRd+1<9i+8:9i> = sex BYTE[(EA+32+i],i=0 à 31 64 VRd+<9i+ 8:9i> = sex BYTE[(EA+i],i=O à 31 64 VR1d+1<9i+8:9i> = sex BYTE[(EA+32+ i],i=O à 31 VRld+1<9i+8:9i> = sex BYTE[(EA+6432+i],i=0 à 31 __ _ IVR0d+ 1<9i+8:9i> = sex BYTE[(EA+64+i],i=0 à 31 VRld+l<9i+8:91> = sex BYTE[(EA+ 96+i],i=0 à 31 Exceptions Adresse donnée incorrecte, accès non aligné Note de programmation Cette instruction n'est pas affectée par le masque d'éléments. VLI Charge Immédiate Format RI
, 5,, -, 20 15 0 '
l., I I <lB:s 15li l. s. I Rd.} Syntaxe Assembleur VLI.dt VRd,#IMM VLI.dt SRd,#IMM
o dt = {b,b9,h,w,f}.
Description
Charge une valeur immédiate dans un registre
scalaire ou vectoriel.
Pour la charge d'un registre scalaire un octet, un octet9, un demi- mot ou un mot est chargé selon le type de donnée. Pour l'octet, l'octet9 et le demi-mot comme type de donnée, les octets non affectés (octets9) ne sont pas modifiés. Opération Rd= voir tableau ci-dessous DT Charge scalaire Charge vectorielle i8 SRd<7;0≥IMM<7:0> VRd = 32 éléments int8 i9 SRd<8;0≥IMM<8:0> VRd = 32 éléments int9 i16 SRd<15;0≥IMM<15:0> VRd = 32 éléments intl6 i32 SRd<31;0≥sex IMM<18:0> VRd - 8 éléments int32 f SRd<31≥IMM<18>(signe) VRd = 8 éléments SRd<30:23> =IMM<17:0>(exposant) flottants SRd<22:13≥IMM<9:0>(mantisse) SRd<12:0> =zéros Exception Aucune. VL _ Charge Ouad Format 2."l 1 0 0 R.EAR 110 0 00 100DB LCA Rd SRb SRi 0 [ 20 15 1o0 S ô REAI 0oo 1 00 100 IDIB LT ICIAI Rd |SRb | IMM <7.5> t <4:0> Syntaxe Assembleur VLQ.lt Rd,SRb, SRi VLQ.lt Rd,SRb,#IMM VLQ.lt Rd.SRb+,SRi VLQ.lt Rd,SRb+,#IMM o it = {b,bz9,bs9,h,w,4,8,16,32,64}, Rd = {VRd, VRAd, SRd}.Il faut noter que.b et.bs9 spécifient la même opération et que.64 et
VRAd ne peuvent être spécifiés ensemble.
Utiliser VLQOFF pour charge antémémoire hors circuit.
Description
Charge quatre registres vectoriels dans la rangée courante ou alternée ou bien quatre
registres scalaires.
Opération EA = SRb + {SRili sex(IMM<7:0>)}; si (A==1) SRb = EA Rd: Rd+l: Rd+2: Rd+3 = voir tableau ci-après; LT Opération charge bz9 SRd<8:0> = zex BYTE[EA] SRd+1<8:0> = zex BYTE[EA+1] SRd+2<8:0> = zex BYTE[EA+2] SRd+3<8:0> = zex BYTE[EA+3] bs9 SRd<8;0> = zex BYTE[EA] SRd+1<8:0> = zex BYTE[EA+1] SRd+2<8:0> = zex BYTE[EA+2] SRd+3<8:0> = zex BYTE[EA+3] h SRd<15:0> = HALF[EA] SRd+1<15:0> = sex HALF[EA+2] SRd+ 2<15:0> = sex HALF[EA+4] SRd+3<15:0> = sex HALF[EA+6] SRd+1<31:0> = WORD[EA+4] SRd+2<31:0> = WORD[EA+8] SRd+3<31:0> = WORD[EA+12] 4 VRd<9i+8:9i> = sex BYTE[(EA+i],i=0 à 3 VRd+1<9i+8:9i> = sex BYTE[(EA+4+ i],i=0 à 3 VRd+2<9i+8:9i> = sex BYTE[(EA+8+i],i=0 à 3 VRd+3<9i+8:9i> = sex BYTE[(EA+12+i],i=0 à 3 8 VRd<9i+8:9i> = sex BYTE[(EA+i],i=0 à 7 VRd+1<9i+8:9i> = sex BYTE[(EA+8+i],i=0 à 7 VRd+2<9i+8:9i> = sex BYTE[(EA+ 16+i],i=0 à 7 VRd+3<9i+8:9i> = sex BYTE[(EA+24+i],i=0 à 7 16 VRd<9i+ 8:9i> = sex BYTE[(EA+i],i=0 à 15 VRd+1<9i+8:9i> = sex BYTE[(EA+16+i],i=0 à 15 VRd+2<9i+8:9i> = sex BYTE[(EA+32+i],i=0 à 15 VRd+3<9i+8:9i> = sex BYTE[(EA+48+i],i=0 à 15 32 VRd<9i+8:9i> = sex BYTE[(EA+i],i=0 à 31 VRd+1<9i+8:9i> = sex BYTE[(EA+32+i],i=0 à 31 VRd+2<9i+8:9i> = sex BYTE[(EA+64+i],i=0 à 31 VRd+3<9i+8:9i> = sex BYTE[(EA+96+i],i=0 à 31 64 VROd<9i+8:9i> = sex BYTE[(EA+i],i=0 à 31 VRld<9i+8:9i> = sex BYTE[(EA+ 32+i],i=O à 31 VROd+l<9i+8:9i> = sex BYTE[(EA+64+i],i=0 à 31 VRld+1<9i+ 8:9i> = sex BYTE[(EA+96+i],i=0 à 31 VROd+2<9i+8:9i> = sex BYTE[(EA+128+ i],i=0 à 31 VRld+2<9i+8:9i> = sex BYTE[(EA+160+i],i=0 à 31 VROd+3<9i+ 8:9i> = sex BYTE[(EA+192+i],i=0 à 31 VRld+3<9i+8:9i> = sex BYTE[(EA+224+ i],i=0 à 31 Exception Adresse données incorrecte, accès non aligné Note de programmation Cette instruction n'est pas affectée par le masque d'éléments. VLR Charge Inverse Format REAR 1010|0i H01'W |OIB'ILTICi|_ | 1 Rd | SiRlb |Sp| VLR.lt RddSRb, SRi
302520 $ 0 S 0
1o11 1 I Jl'tH"t""l'"'i'"'lI VLR. it Rd, SRb, SRi VLR.lt Rd,SRb, #IMM VLR.lt Rd.SRb+,SRi VLR.lt Rd,SRb+,#IMM o it = { 4,8,16, 32,64}, Rd={VRd, VRAd}.Il faut noter que.64 et VRAd ne peuvent être spécifiés ensemble. Utiliser VLROFF pour la
charge antémémoire hors circuit.
Description
Charge un registre vectoriel en ordre inverse des éléments. Cette instruction ne supporte
pas un registre de destination scalaire.
Opération EA = SRb + {SRi il sex(IMM<7:0>)}; si (A==1) SRb = EA; Rd:= voir tableau ci-dessous LT Opération charge 4 VRd[31-i]<8;0> = sex BYTE[(EA+i],i=0 à 3 8 VRd[31-i]<8:0> = sex BYTE[(EA+i],i=0 à 7 16 VRd[31-i]<8:0> = sex BYTE[(EA+i],i=0 à 15 32 VRd[31-i]<8:0> = sex BYTE[(EA+i],i=0 à 31 64 VROd[31-i]<8:0> = sex BYTE[(EA+32+i],i=0 à 31 VRld[31-i]<8:0> = sex BYTE[(EA+i],i=0 à 31 Exception
Adresse donnée incorrecte, accès non aligné.
Note de programmation Cette instruction n'est pas affectée par le masque d'éléments. VLSL Décalage Logique A Gauche Format
23 20
RRRM5 0000001DS S Rd SDSIIR SRb/IM5 Syntaxe Assembleur VLSL.dt VRd,VRa,SRb VLSL.dt VRd,VRa,#IMM VLSL.dt SRd, SRa,SRb VLSL.dt SRd.SRa+,#IMM
o dt = {b,b9,h,w}.
Modes supportés D:S:M f V<-V @ S I V<-V @ I S<-S @ S S<-S @ I DS int8(b) int9(b9) intl6(h) int32(w)
Description
Chaque élément du registre vectoriel/scalaire Ra est logiquement décalé d'un bit vers la gauche avec les zéros remplis aux emplacements du bit de moindre poids (LSB), de la quantité de décalage donnée dans le registre scalaire Rb ou la zone IMM et le résultat est enregistré dans le registre
vectoriel/scalaire Rd.
Opération quantité décalage= {SRb % 32 Il IMM <4:0>)}; pour (i=O;1 <NumElem && EMASK [i]; i++){ Rd[i] = Ra[i]"quantité_décalage: } Exception Aucune. Note de programmation Noter que la quantité_décalage est prise en tant que nombre à 5 bits pour SRb ou IMM<4:0>. Pour les types de données octet, octet9 et demi-mot, le programmeur est responsable d'une spécification correcte de la quantité de décalage qui est plus petite ou égale au nombre de bits dans la grandeur de donnée. Si la quantité de décalage est plus grande que la grandeur spécifiée de donnée, les éléments seront complétés par
des zéros.
VLSR Décalage Logique A Droite Format
20 10. 0
RRR/M5 1 0 01 00 IDIS DS i |SR | Ra il, [01 i 1 101'i I' 'i!!óH" I '" I '" ' ' Syntaxe Assembleur VLSR.dt VRd,VRa,SRb VLSR.dt VRd,VRa,#IMM VLSR. it SRd,SRa,SRb VLSR.lt SRd.SRa+,#IMM
o dt = {b,b9,h,w}.
Mode supportés
D:S:M N' V<-V@ S V<-V@ I S<-S @ S S<-S @ I
DS intS(b) int9(b9) intl6(h) int32(w)
Description
Chaque élément de donnée du registre vectoriel/scalaire Ra est logiquement décalé d'un bit vers la droite avec les zéros remplis aux emplacements des bits de poids fort (MSB), de la quantité de bits donnée dans le registre scalaire Rb ou la zone IMM et le résultat est enregistré dans le
registre vectoriel/scalaire Rd.
Opération quantité_décalage= {SRb % 32 IIIMM <4:0>)}; pour (i=0;i <NumElem && EMASK [i]; i++){ Rd[i] = Ra[i]zéro"quantité_décalage; } Exception Aucune Note de programmation Noter que la quantité_décalage est prise en tant que nombre à 5 bits pour SRb ou IMM<4:0>. Pour les types de données octet, octet9 et demi-mot, le programmeur est responsable d'une spécification correcte de la quantité de décalage qui est plus petite que ou égale au nombre de bits de la grandeur de donnée. Si la quantité de décalage est plus grande que la grandeur spécifiée de donnée, les éléments seront complétés par des zéros. VLWS Charge Avec Chevauchement Format
25 20 15 10 5 0
RE-kRi IlLT 1 IR!1i 1 REA&R 000 0111iio 0OB LJC A Rd SRb SR 20 15 I O 10o REAI I j11 Ii 100 IOIBILTICAIkll 0 C Rd SRb I IMM
LJLJ...LJJ..J11 <> <4:0>
Syntaxe Assembleur VLWS.lt Rd,SRb, SRi VLWS.lt Rd,SRb,#IMM VLWS.lt Rd.SRb+,SRi VLWS.lt Rd,SRb+,#IMM o it = { 4,8,16,32}, Rd={VRd, VRAd}.Il faut
noter que le mode.64 n'est pas supporté.
Utiliser VL à la place. Utiliser VLWSOFF pour
charge antémémoire hors circuit.
Description
En partant à l'adresse effective, 32 octets sont chargés de la mémoire au registre vectoriel VRd en utilisant le registre scalaire SRb+l en tant que Registre de
Contrôle de Chevauchement.
LT spécifie la grandeur du bloc, le nombre d'octets consécutifs à charger pour chaque bloc. SRB+l spécifie le chevauchement, le nombre d'octets séparant les débuts de deux
blocs consécutifs.
Le chevauchement doit être égal à ou plus grand que la grandeur du bloc. EA doit être aligné par la grandeur des données. Le chevauchement et la grandeur du bloc doivent être des multiples de la grandeur de la donnée. Opération EA= SRb +{SRi I sex(IMM <7:0>)}; Si (A==l) SRb = EA: Grandeurbloc= {411811161132): Chevauchement = SRb+l<31:0>; pour (i=0;i <VECSIZE/Grandeurbloc;i++) pour (j=0; j<grandeurblock; j++) VRd[i*grandeur_bloc+j]<8:0> = sex BYTE [EA+i*chevauchement+j]; Exception
Adresse donnée incorrecte, accès non aligné.
VMAC MultiPlier Et Accumuler Format RRRM9 1 1 101010 l SD| 1M9 RaI Rb/IM5 Syntaxe Assembleur VMAC.dt VRa,VRb VMAC.dt VRa,SRb VMAC.dt VRa,#IMM VMAC.dt SRa,SRb VMAC.dt SRa+,#IMM
o dt = {b,h,w,f}.
Modes supportés D:S:M | @V<-V V <-V @ S V<-V @ I S<-S @ sI S<-S @ I DS int8 (b) intl6(h) int32(w) Flottant (f)
Description
Multiplier chaque élément de Ra par chaque élément dans Rb pour produire un résultat intermédiaire double précision; ajouter chaque élément double précision du résultat intermédiaire à chaque élément double précision de l'accumulateur vectoriel; enregistrer la somme double précision de
chaque élément dans l'accumulateur vectoriel.
Ra et Rb utilisent le type spécifié de donnée, tandis que VAC utilise le type de donnée double précision, approprié (16, 32 et 64 bits pour int8, intl6 et int32, respectivement). Les portions supérieures de chaque élément double précision sont
enregistrées dans VACH.
Pour le type de donnée flottante, tous les opérandes et les résultats sont de simple précision. Opération pour (i=0;i<NumElem &&EMASK[i];i++) { Aop [i] = {VRa[i] Il SRa}; Bop [i] = {VRb[i] IlI SRb}; si (dt==flottant) VACL[i] = Aop[i] * Bop[i] + VACL[i]; autrement VACH[i]: VACL[i] = Aop[i] * Bop[i] + VACH[i]:VACL[i] } Exception Débordement, opérande point flottant incorrect. Note de programmation Cette instruction ne supporte pas le type de donnée int9, utiliser à la place le type de
donnée intl6.
VMACF Multiplier Et Accumuler Fraction Format 5!o I' I"" i v1 Ra RRRM9 0 0 10 DS S I Ra Rb/IM5
mll 01 ID|S| IS MI'9 i I" I " " | -
Syntaxe Assembleur VMACF.dt VRa,VRb VMACF.dt VRa,SRb VMACF.dt VRa, #IMM VMACF.dt SRa,SRb VMACF.dt SRa,#IMM
o dt = {b,h,w}.
Modes supportés
|D:S:M 11 V<-V @ V I V<-V @ S I V<-V @ I I S<-S @ S 1 S< S @ I
DS int8(b) intl6(h) int32(w)
Description
Multiplier chaque élément de VRa par chaque élément dans Rb pour produire un résultat intermédiaire double précision; décaler le résultat intermédiaire à chaque élément double précision d'un bit vers la gauche; ajouter chaque élément double précision du résultat intermédiaire décalé à chaque élément double précision de l'accumulateur vectoriel; enregistrer la somme double précision de chaque élément dans
l'accumulateur vectoriel.
VRa et Rb utilisent * le type de donnée spécifié, tandis que VAC utilise le type de donnée double précision approprié (16, 32 et 64 bits pour int8, int6 et int32, respectivement). Les portions supérieures de chaque élément double précision sont
enregistrées dans VACH.
Opération pour (i=0;i<NumElem &&EMASK[i];i++){ Bop[i] = {VRb[i] Il SRbIlJ sex(IMM<8:0>)}; VACH[i]:VACL[i] = ((VRa[i]] * Bop[i] <<1) + VACH[i]:VACL[i]; } Exception Débordement. Note de programmation Cette instruction ne supporte pas le type de donnée int9 - utiliser à la place le type de
donnée intl6.
VMACL Multiplier Et Accumuler Valeur basse Format M 20!5 lo $
I IJI IHIHHîIIHHI 1
RRRM9 lil O010 11 DSDS M149 Rd Ra Rb/M| Syntaxe Assembleur VMACL. dt VRd,VRa,VRb VMACL.dt VRd,VRa,SRb VMACL.dt VRd,VRa,#IMM VMACL.dt SRd,SRa,SRb VMACL.dt SRd,SRa,#IMM
o dt = {b,h,w,f}.
Modes supportés D:S:M l V<-V @ V V<-V @ S | V<-V @ I S<-S @ sI S<-S @ I DS it()rint8b intl(h) int32 (w) flottant (f)
Description
Multiplier chaque élément de VRa par chaque élément de Rb pour produire un résultat intermédiaire double précision; ajouter chaque élément double précision du résultat intermédiaire à chaque élément double précision de l'accumulateur vectoriel; enregistrer la somme double précision de chaque élément dans l'accumulateur vectoriel; retourner la portion inférieure au registre
de destination Vrd.
VRa et Rb utilisent le type de donnée spécifié tandis que VAC utilise le type de donnée double précision approprié (16, 32, 64 bits pour int8, intl6 et int32, respectivement). Les portions supérieures de chaque élément double précision sont
enregistrées dans VACH.
Pour le type de donnée flottante, tous les opérandes et résultats sont de simple précision. Opération pour (i=0;i<NumElem &&EMASK[i];i+ +){ Bop [i] = {VRb[i] Il SRb}; si (dt==flottant) VACL[i] = VRa[i] * Bop[i] + VACL[i]; autrement VACH[i]:VACL[i] = VRa[i] * Bop[i] + VACH[i]:VACL[i]; VRd[i] = VACL[i]; Exception Débordement, opérande point flottant incorrect. Note de programmation Cette instruction ne supporte pas le type de donnée int9. Utiliser à la place le type de
donnée intl6.
VMAD Multiplier Et Additionner Format
5 20 15 0 0
RRR.R 0 1 1 0 C1011 iS úDS Rc Rd Ra Rb Syntaxe Assembleur VMAD.dt VRc, VRd, VRa, VRb VMAD.dt SRc,SRd,SRa,SRb
o dt = {b,h,w}.
Modes supportés
S H VR I SR I
DS D int8 (b) intl6(h) int32 (w)
Description
Multiplier chaque élément de Ra par chaque élément dans Rb pour produire un résultat intermédiaire double précision; ajouter chaque élément double précision du résultat intermédiaire à chaque élément de Rc; enregistrer la somme double la précision de chaque élément dans les registres de
destination Rd+l:Rd.
Opération pour (i=0;i<NumElem &&EMASK[i];i++) { Aop [i] = {VRa[i] Il SRa}; Bop [i] = {VRb[i] 1,1 SRb}; Cop [i] = {VRc[i] Il SRc}; Rd+ l[i]:Rd[i] = Aop[i] * Bop[i] + sex_dp (Cop[i]}; } Exception Aucune. VMADL Multiplier Et Ajouter Valeur Basse Format M 52 0l5 o RRRR 010 o01001 SDS Rc Rd RajR Syntaxe Assembleur VMADL.dt VRc,VRd,VRa,VRb VMADL.dt SRc,SRd,SRa,SRb
o dt = {b,h,w,f}.
Modes sup ortés S l VR SR DS int8(b) flottant (f) intl6(h) [ int32(w)
Description
Multiplier chaque élément de Ra avec chaque élément dans Rb pour produire un résultat intermédiaire double précision; ajouter chaque élément double précision du résultat intermédiaire à chaque élément de Rc; retourner la portion inférieure de la somme double précision de chaque élément au
registre de destination Rd.
Pour le type de donnée flottante, tous les opérandes et les résultats sont de simple precision. Opération pour (i=0;i<NumElem &&EMASK[i];i++){ Aop [i] = {VRa[i] Il SRa}; Bop [i] = {VRb[i] Il SRb}; Cop [i] = {VRc[i] IlI SRc}; Si (dt==flottant) Lo[i] = Aop[i] * Bop[i] + Cop[i]; autrement Hi[i]:Lo[i] = Aop[i] * Bop[i] + sex_dp(Cop[i]); Rd[il = Lo[i]; } Exception Débordement, opérande point flottant incorrect. VMAS Multiplier Et Soustraire De L 'Accumulateur Format 30.. ....212, 15!0 5 f) RRRM9 Ii l,11I 101 lH I | I"DS [' I; I À Ra ' Rb/Iv15 Syntaxe Assembleur VMAS.dt VRa,VRb VMAS.dt VRa,SRb VMAS.dt VRa,#IMM VMAS.dt SRa,SRb VMAS.dt SRa,#IMM
o dt = {b,h,w,f}.
Modes supportés
D:S:M V<-V @ V V<-V @ SI V<-V @ I S<-S @ S S<-S @ I
DS int8(b) intl6(h) int32(w) flottant(f)
Description
Multiplier chaque élément de Ra par chaque élément de Rb pour produire un résultat intermédiaire double précision; soustraire chaque élément double précision du résultat intermédiaire du résultat intermédiaire de chaque élément double précision de l'accumulateur vectoriel; enregistrer la somme double précision de chaque élément dans
1 'accumulateur vectoriel.
Ra et Rb utilisent le type de donnée spécifié tandis que VAC utilisa le type de donnée double précision approprié (16, 32, 64 bits
pour int8, intl6 et int32, respectivement).
Les portions supérieures de chaque élément
double précision sont enregistrées dans VACH.
Pour le type de donnée flottante, tous les opérandes et résultats sont de simple précision. Opération pour (i=0;i<NumElem &&EMASK[i];i+ +) { Bop [i] = {VRb[i] Il SRb};
si (dt==flottant) VACL[i] = VACL[i] -
VRa[i] * Bop[i]; autrement VACH[i]:VACL[i] = VACH[i] VACL[i] - VRa[i] * Bop[i]; } Exception Débordement, opérande point flottant incorrect. Note de programmation Cette instruction ne supporte pas le type de donnée int9. Utiliser à la place le type de
donnée intl6.
VMASF Multiplier Et Soustraire De La Fraction D 'Accumulateur Format
4220 1S 10 0
RRRM9 111 001110 S DSH M9 Ra Rb/ 5 Syntaxe Assembleur VMASF. dt VRa,VRb VMASF.dt VRa,SRb VMASF.dt VRa,#IMM VMASF.dt SRa,SRb VMASF.dt SRa,#IMM
o dt = {b,h,w}.
Modes supportés D:S:M | V<-V @ V V<-V @ S V<-V @ I S<-S @ S i S<-S I DS int8(b)>| intl6(h) int32(w)
Description
Multiplier chaque élément de VRa avec chaque élément de Rb pour produire un résultat intermédiaire double précision; décaler le résultat intermédiaire double précision de la valeur d'un bit; soustraire chaque élément double précision du résultat intermédiaire décalé de chaque élément double précision de l'accumulateur vectoriel; enregistrer la somme double précision de chaque élément dans
l'accumulateur vectoriel.
VRa et Rb utilisent le type de donnée spécifié tandis que VAC utilise le type de donnée double précision approprié (16, 32, 64 bits pour int8, intl6 et int32, respectivement). Les portions supérieures de chaque élément double précision sont
enregistrées dans VACH.
Opération pour (i=0;i<NumElem &&EMASK[i];i++) { Bop[i]= {VRb[i] IlI SRb IlI sex(IMM<8:0>};
VACH[i];VACL[i] = VACH[i]: VACL[i] -
VRa[i] * Bop[i]; Exception Débordement Note de programmation Cette instruction ne supporte pas le type de donnée int9. Utiliser à la place le type de
donnée intl6.
VMASL Multiplier Et Soustraire de l'Accumulateur Valeur Basse Format
520 15 10 5 0
RRRM9 1 001111 DS IM9 Rd Ra Rb/IM5 Syntaxe Assembleur VMASL.dt VRd,VRa,VRb VMASL.dt VRd,VRa,SRb VMASL.dt VRd,VRa,#IMM VMASL.dt SRd,SRa,SRb VMASL.dt SRd,SRa,#IMM
o dt = {b,h,w,f}.
Modes supportés
D:S:M IV<-V @ V V<-V @ S | V<-V @ I IS<-S @ SI S<-S @ I
DS int8(b)> intl6 (h) int32 (w) flottant (f)
Description
Multiplier chaque élément de VRa par chaque élément dans Rb pour produire un résultat intermédiaire double précision; soustraire chaque élément double précision du résultat intermédiaire de chaque élément double précision de l'accumulateur vectoriel; enregistrer la somme double précision de chaque élément dans l'accumulateur vectoriel; retourner la portion inférieure au registre
de destination VRd.
VRa et Rb utilisent le type de donnée spécifié tandis que VAC utilise le type de donnée double précision approprié (16, 32, 64 bits pour int8, intl6 et int32, respectivement). Les portions supérieures de chaque élément double précision sont
enregistrées dans VACH.
Pour le type de donnée flottante, tous les opérandes et résultats sont desimple précision. Opération pour (i=0;i<NumElem &&EMASK[i];i++) { Bop [i] = {VRb[i] Il SRb};
si (dt==flottant) VACL[i] = VACL[i] -
VRA[i] * Bop[i]; autrement VACH[i]: VACL[i] = VACH[i]: VACL[i] - VRa[i] * Bop[i]; VRd[i] = VACL[i] } Exception Débordement, opérande point flottant incorrect. Note de programmation Cette instruction ne supporte pas le type de donnée int9. Utiliser à la place le type de
donnée intl6.
VMAXE Maximum Par Paire Et Echange Format
-0 ' 20!0 0
RRiRM5 01 0l 11000 D S S VRd ô 'VRa VRb Syntaxe Assembleur VMAXE.dt VRd,VRb
o dt = {b,b9,h,w,f}.
Modes supportés
ID:S:MI V<-V I
DS |int8(b) int8(b) intl6(h) int32(w) flottant(f)
Description
VRa doit être égal à VRb. Quand VRa est
différent de VRb, le résultat est non défini.
Chaque élément de donnée pair/impair du registre vectoriel Rb est comparé par paires et la plus grande valeur de chaque paire d'éléments de données est enregistrée à l'emplacement pair et la plus petite valeur de chaque paire d'éléments de données est enregistrée à la position impaire du registre
vectoriel Rd.
Opération pour (i=0;i<NumElem &&EMASKli];i+2){ VRd[i] = (VRb[i] > VRb[i+ l]) ? VRb[i]: VRb[i+1]; VRd[i+l] = (VRb[i] > VRb[i+l]) ? VRb[i+ l]: VRb[1]; } Exception Aucune. VMOV Déplacement Format RRRR 0. 1 0 1 10 iiSRd Group Ru Syntaxe Assembleur VMOV.dt Rd,Rb o dt = {b,b9,h,w,f}. Rd et Rb désignent un
nom de registre désigné par l'architecture.
Noter que.w et.f désignent la même opération. Modes supportés 1 DS I int8(b) | int9(b9) intl6(h) int32(w)
Description
Le contenu du registre Rb est déplacé au registre Rd. La zone du groupe spécifie les groupes des registres de source et de destination. La notation des groupes de registre est: VR registre vectoriel rangée courante VRA registre vectoriel autre rangée SR registre scalaire SP registre d'utilité spéciale RASP registre pile adresses retour VAC registre accumulateur vectoriel (voir tableau codage registre VAC ci-dessous) Groupe Groupe Groupe Commentaires <3:0> Source Dest. ___ 0000 réservé
0001 VR VRA
VRA VR
0011 VRA VRA
réservé 0101 réservé
VRA VAC
0111 VAC VRA
1000 réservé
1001 SR VRA
1010 réservé 1011 réservé
1100 SR SP
1101 SP SR __
1110 SR RASR
1111 RASR SR
Noter qu'un registre vectoriel ne peut être déplacé à un registre scalaire par cette instruction. L'instruction
VEXTRT est prévue dans ce but.
Utiliser le tableau suivant pour le codage du registre VAC: R<2:0> Registres Commentaires 000 non défini
001 VACOL
VACOH
011 VACO Spécifier VACOH:VACOL. Si spécifiée comme source, la paire de registres VRd+l:VRd est remise à jour. VRd doit être un registre pair. non défini
101 VACIL
VACIH
111 VACI Spécifier VAC1H:VAClL. Si spécifiée comme source, la paire de registres VRd+1:VRd est remise à jour. VRd doit être un registre pair. tous les non défini autres Opération Rd=Rb Exception Le positionnement d'un bit d'état d'exception dans VCSR ou VISRC provoquera l'exception correspondante. Note de programmation Cette instruction n'est pas affectée par le masque d'éléments. Il faut noter que, comme le concept d'autre rangée n'existe pas en mode VEC64, cette instruction ne peut être utilisée pour passer de ou vers un registre
d'une autre rangée en mode VEC64.
VMUL Multiplier Format 0 OÈ s Ra Rb RRR.R |o lI0 |a X oBi o SD;II I| Syntaxe Assembleur VMUL.dt VRc, VRd, VRa, VRb VMUL.dt SRc,SRd,SRa,SRb
o dt = {b,h,w}.
Modes supportés
S | VR I SR |
DS int8(b) intl6 (h) int32 wI
Description
Multiplier chaque élément de Ra avec chaque élément dans Rb pour produire un résultat intermédiaire double précision; retourner la somme double précision de chaque élément dans
les registres de destination Rc:Rd.
Ra et Rb utilisent le type de donnée spécifiée, tandis que Rc:Rd utilisent le type de donnée double précision approprié (16, 32 et 64 bits pour int8, intl6, int32, respectivement). Les portions supérieures de chaque élément double précision sont
enregistrées dans Rc.
Opération pour (i=0;i<NumElem &&EMASK[i];i++){ Aop [i] = {VRa[i] Il SRa}; Bop [i] = {VRb[i] II SRb}; Hi[i] = Lo[i] = Aop[i]*Bop[i]: Rc[i]=Hi[i] Rd[i]=Lo[i]; } Exception Aucune. Note de programmation Cette instruction ne supporte pas le type de donnée int9, utiliser à la place de type de donnée intl6. Cette instruction ne supporte pas non plus le type de donnée flottante car le résultat étendu n'est pas un type de
donnée supportée.
VMULA Multiplier A Accumulateur Format c0 -- ii-.01. :2t i RRRJ9 til 100000 10 DIS DS1 1.M19 Ra Rbl, | Syntaxe Assembleur VMULA.dt VRa,VRb VMULA.dt VRa,SRb VMULA.dt VRa.#IMM VMULA.dt SRa,SRb VMULA.dt SRa,#IMM
o dt = {b,h,w,f}.
Modes supportés
D:S:M V@ V @ V V @ S V @ I S @ S S @ I
DS int8(b) intl6(h) int32 (w) flottant (f)
Description
Multiplier chaque élément de VRa avec chaque élément dans Rb pour produire un résultat intermédiaire double précision; écrire le
résultat dans l'accumulateur.
Pour le type de donnée flottante tous les opérandes et les résultats sont de simple precision. Opération pour (i=0;i<NumElem &&EMASK[i];i++){ Bop [i] = {VRb[i]IISRb}; si (dt==flottant) VACL[i]=VRa[i]*Bop[i]; autrement VACH[i]:VACL[i]=VRa[i]*Bop[i]; } Exception Aucune. Note de programmation Cette instruction ne supporte pas le type de donnée int9. Utiliser à la place le type de
donnée intl6.
VMULAF Multiplier A La Fraction D'Accumulateur Format
'< 20 1 - S
RRRI.M9 l1 I 0101 00 DIS DS IM9 Ra Rb'III 15 Syntaxe Assembleur VMULAF.dt VRa,VRb VMULAF.dt VRa,SRb VMULAF.dt VRa.#IMM VMULAF.dt SRa, SRb VMULAF.dt SRa,#IMM
o dt = {b,h,w}.
Modes supportés
D:S:MIM V @ V | V @ S V @ I S @ S S @ I
DS int8(b) intl6(h) int32(w)
Description
Multiplier chaque élément de VRa par chaque élément dans Rb pour produire un résultat intermédiaire double précision; décaler le résultat intermédiaire double précision vers la gauche de un bit; écrire le résultat dans
l 'accumulateur.
Opération pour (i=0;i<NumElem &&EMASK[i];i++) { Bop [i] = {{VRb[i]lI. SRbllsex(IMM<8:0>)}; VACH[i]:VACL[i]=(VRa[i]*Bop[i]) << 1; } Exception Aucune. Note de programmation Cette instruction ne supporte pas le type de donnée int9. Utiliser à la place le type de
donnée intl6.
VMULF Multiplier Fraction Format RRR..M9 |X| on; X 8 XM HI1 0 i10 D I HI H RRR-M9 ISv Rd Ri' RbiM5
1111 1000 I11S 1NF 9
Syntaxe Assembleur VMULF.dt VRd,VRa,VRb VMULF.dt VRd,VRa,SRb VMULF.dt VRd,VRa,#IMM VMULF.dt SRd,SRa,SRb VMULF.dt SRd,SRa,#IMM
*o dt = {b,h,w}.
Modes supportés D:S:Mv<-V @ V V<-V S V<-V @ I S<-S @ S S<-S @ I DS int8(b) intl6 (h)int32 (w)
Description
Multiplier chaque élément de VRa par chaque élément dans Rb pour produire un résultat intermédiaire double précision; décaler le résultat intermédiaire double précision vers la gauche de un bit; ramener la portion supérieure du résultat au registre de destination VRd+1 et la portion inférieure au registre de destination VRd. VRd doit être un
registre de numéro pair.
Opération pour (i=0;i<NumElem &&EMASK[i];i++) { Bop[i] = {VRa[i]IISRbllIsex(IMM<8:0>)}; Hiti]:Lo[i]=(VRa[i]*Bop[i])"<1; VRd+1 [i]=Hi[i] VRd[i]=Lo[i]; } Exception Aucune. Note de programmation Cette instruction ne supporte pas le type de donnée int9; utiliser à la place de type de
donnée intl6.
VMULFR Multiplier Fraction Et Arrondir Format
0 ". ...2015 10 ' 0
IRRMI5 I; 'II 9IIiII:I P. ii RRRM9 I 1101 00 D S $ IM9 Rd Ra Rb/IM5 Syntaxe Assembleur VMULFR.dt VRd,VRa,VRb VMULFR.dt VRd,VRa, SRb VMULFR.dt VRd,VRa, #IMM VMULFR.dt SRd,SRa,SRb VMULFR.dt SRd,SRa, #IMM
o dt = {b,h,w}.
Modes supportés D:S:M |V<-V @ V V<-V @ S | V<-V Q I IS<-S @ Sl S<-S @ I DS int8 (b) intl6 (h) int32 (w)
Description
Multiplier chaque élément de VRa avec chaque élément dans Rb pour produire un résultat intermédiaire double précision; décaler le résultat intermédiaire double précision vers la gauche de un bit; arrondir le résultat intermédiaire décalé à la portion supérieure; retourner la portion supérieure au registre
de destination VRd.
Opération pour (i=0;i<NumElem &&EMASK[i];i++){ Bop[i] = {VRb[i]IISRbl lsex(IMM<8:0">)}; Hi[i]:Lo[i]=(VRa[i]*Bop.[i]) "1; Si (Lo[i]<msb≥=1l) Hi[i]+l; VRd[i]=Hi[i]; } Exception Aucune. Note de programmation Cette instruction ne supporte pas le type de donnée int9, utiliser à la place le type de
donnée intl6.
VMULL Multiplier Valeur Basse Format RRRM191 101010 D1 S1DS| I IM91R a IRI 1 Syntaxe Assembleur VMULL.dt VRd, VRa,VRb VMULL.dt VRd,VRa,SRb VMULL.dt VRd,VRa, #IMM VMULL.dt SRd,SRa,SRb VMULL.dt SRd,SRa,#IMM
o dt = {b,h,w,f}.
Modes supportés
|D:S:M 1 V<-V @ V I V<-V @ S I V<-V @ I S<-S Q S I 9<-S @ I
DS int8(b) intl6 (h) int32 (w) flottant (f)
Description
Multiplier chaque élément de VRa avec chaque élément dans Rb pour produire un résultat double précision; retourner la portion inférieure de résultat au registre de
destination VRd.
Pour le type de donnée flottante, tous les opérandes et les résultats sont de simple précision. Opération pour (i=0;i<NumElem &&EMASK[i];i++) { Bop [i] = {VRb[i] Il SRb}; si (dt==flottant) Lo[i]=VRa[i]*Bop[i]; autrement Hi[i]:Lo[i]=VRa[i]*Bop[i]; VRd[i] = Lo[i] } Exception Débordement, opérande point flottant incorrect. Note de programmation Cette instruction ne supporte pas le type de donnée int9, utiliser à la place le type de
donnée intl6.
VNAND NON ET
Format
1 10 0
RRRIM9 1 1 01110 s It Rd. Ra Syntaxe Assembleur VNAND.dt VRd,VRa,VRb VNAND.dt VRd,VRa,SRb VNAND.dt VRd,VRa,#IMM VNAND.dt SRd,SRa,SRb VNAND.dt SRd,SRa,#IMM o dt = {b,b9,h,w}.Il faut noter que. w et.f
spécifient la même opération.
Modes supportés D:S:M IV<-V @ V V<-V @ S V<-V @ I S<-S @ S| S<-S f I DS i lnt8(b) int9(b9 intl6(h) int32(w)
Description
Produire l'opération logique NON ET de chaque bit de chaque élément dans Ra avec le bit correspondant dans l'opérande immédiat/Rb;
retourner le résultat dans Rd.
Opération pour (i=0;i<NumElem &&EMASK[i];i++) { Bop[i] = {VRb[i]IISRbllsex(IMM<8:0>)"}; Rd[i]<k> = -(Ra[i]<k> & Bop[i]<k>), pour k = tous les bits dans l'élément i; } Exception Aucune.
VNOR NON OU
Format 2 'O 15 io. o RRRM9 1 1 0110! S1 M9 Rd Ra Syntaxe Assembleur VNOR.dt VRd,VRa,VRb VNOR.dt VRd,VRa, SRb VNOR.dt VRd,VRa,#IMM VNOR.dt SRd,SRa,SRb VNOR.dt SRd,SRa, #IMM o dt = {b,b9,h,w}.Il faut noter que.w et.f
spécifient la même opération.
Modes supportés D:S:M V<-V @ V V<-V @ St IS I V<-V S<-S @ S S<-S @ I DSI int8 b int9 b9 intl6 (h) int32 (w)
Description
Produire l'opération logique NON OU de chaque bit de chaque élément dans Ra avec le bit correspondant dans l'opérande Rb/Immédiat;
retourner le résultat dans Rd.
Opération pour (i=0;i<NumElem &&EMASK[i];i++){ Bop[i] = {VRb[i]IISRbllsex(IMM<8:0>)}; Rd[i]<k>;(Ra[i]<k>lBop[i]<k≥pour k=tous les bits dans l'élément i; } Exception Aucune.
VOR OU
Format
O S 20 15 10 0
1 1 11 1 l i liii 1111 i1 1 RRRM9 1| olil IDIS DS0 1 Rd Ra Rb/IM5 Syntaxe Assembleur VOR.dt VRd,VRa,VRb VOR.dt VRd, VRa,SRb VOR.dt VRd,VRa,#IMM VOR.dt SRd,SRa,SRb VOR.dt SRd, SRa,#IMM o dt = {b,b9,h,w}.Il faut noter que.w et.f spécifient la même opération Modes supportés
I D:S:M || V<-V @ V V<-V @ S | V<-V @ I S<-S @ S S<-S @ I
DS int8 (b) int9 (b9) intl6(h) int32(w)
Description
Produire le OU logique de chaque bit de chaque élément dans Ra avec le bit correspondant dans l'opérande Rb/Immédiat;
retourner le résultat dans Rd.
Opération pour (i=0;i<NumElem &&EMASK[i];i++) { Bop[i] = {VRb[i]lIISRbllsex(IMM<8:0>)"}; Rd[il]<k>;Ra[i]<k>lBop[i]<k≥pour k= tous les bits dans l'élément i; } Exception Aucune. VORC Complément OU Format 25 20 15 0 o O RRRM9 I 110 11ID 1 DSIS 9 Rd Ra 1 Rb/LM5
1 ' I fEl [ Syntaxe Assembleur -
VORC.dt VRd,VRa,VRb VORC.dt VRd,VRa,SRb VORC.dt VRd,VRa,#IMM VORC.dt SRd,SRa,SRb VORC.dt SRd,SRa,#IMM o dt = {b,b9,h,w}.Il faut noter que.w et.f spécifient la même opération Modes supportés
D:S:M| V<-V @ V V<-V @ S | V<-V @ I S<-S @ S S<-S @ I
DS Il int8(b) int9 (b9) int916 (h) int32(w)
Description
Produire l'opération OU logique de chaque bit de chaque élément dans Ra avec le complément du bit correspondant dans opérande
Rb/Immédiat; retourner le résultat dans Rd.
Opération pour (i=0;i<NumElem &&EMASK[i];i++){ Bop[i] = {VRb[i]IISRbllsex(IMM<8:0>)}; Rd[i]<k>;Ra[i]<k>lBop[i]<k≥pour k=tous les bits dans l'élément i; } Exception Aucune. VPFTCH Pré- extraction Format 3 s:20 o. o FmREAR Iloo loi l 1 |ISi|SRbSRi | 1olo1ol Wo i i 1 ol, i,,i,, i,,i
25 20 I 10 0
iof l o t mTl,,,,,," REMAI010111 'OJI'10' 1 1 IINOIAiM 1 SRb IMM Il III I:1 I S:0I Syntaxe Assembleur VPFTCH.ln SRb,SRi VPFTCH. in SRb,#IMM VPFTCH. in SRb+,SRi VPFTCH. in SRb+, #IMM
o dt = {1,2,4,8}.
Description
Pré-extrait les multiples lignes d'antémémoire de données vectorielles en partant de l'adresse effective. Le nombre des lignes d'antémémoire est spécifié comme suit: LN<l:0≥00: 1 ligne d'antémémoire 64 octets est pré-extraite LN<1:0≥01: 2 lignes d'antémémoire 64 octets sont pré-extraites LN<1:0≥10: 4 lignes d'antémémoire 64 octets sont pré-extraites LN<1:0≥11: 8 lignes d'antémémoire 64 octets sont pré-extraites Si l'adresse effective n'est pas sur une limite à 64 octets, elle est d'abord tronquée
pour être alignée avec la limite à 64 octets.
Opération Exception
Exception adresse donnée incorrecte.
Note de programmation EA<31:0> désigne une adresse d'octet dans la
mémoire locale.
VPFTCHSP Pré-extraction A Zone de Travail Format
20 15 10
REAR S[0 dlSRp b 25 20 s 5
1 3 111I T' 20 M5X ô
REAI 00 110 ell 11 S!Rp 1SIRTb RII Syntaxe Assembleur VPFTCHSP. ln SRp,SRb,SRi VPFTCHSP. ln SRp,SRb,#IMM VPFTCHSP. in SRp, SRb+,SRi VPFTCHSP. ln SRp,SRb+,#IMM o in = {1,2,4,8}. Noter que VPFTCH et
VPFTCHSP ont le même code d'opération.
Description
Transfère des blocs multiples de 64 octets de la mémoire à la zone de travail. L'adresse effective donne l'adresse de départ dans la mémoire et SRp donne l'adresse de départ dans la zone de travail. Le nombre de blocs de 64 octets est spécifié comme suit: LN<l:0≥00: 1 bloc de 64 octets est transféré. LN<1:0≥01: 2 blocs de 64 octets sont transférés LN<l:0≥10: 4 blocs de 64 octets sont transférés LN<1:0≥11: 8 blocs de 64 octets sont transférés. Si l'adresse effective n'est pas sur une limite à 64 octets, elle est d'abord tronquée
pour être alignée avec la limite à 64 octets.
Si l'adresse d'indicateur de zone de travail dans SRp n'est pas sur une limite à 64 octets, elle est également tronquée pour être alignée avec la limite à 64 octets. L'adresse d'indicateur de zone de travail alignée est incrémentée par le nombre d'octets transférés. Opération EA = SRb + {SRillIsex(IMM<7:0)}; Si(A==1) SRb = EA; Numbytes = {64111281125611512}; Memadrs = EA<31:6>:6b'000000; SRp = SRp<31:6>: 6b'000000 pour (i = O; i < Num_bytes; i++) SPAD[SRp++] = MEM[Mem_adrs+i]; Exception
Exception adresse donnée incorrecte.
VROL Rotation à Gauche Format 2s 2' 15 10 5 o RRRM5 0 I 0o 00011 ISDS Rd Ra Rb/IM5 Syntaxe Assembleur VORL.dt VRd,VRa,SRb VORL.dt VRd,VRa, #IMM VORL.dt SRd,SRa,SRb VORL.dt SRd,SRa,#IMM
o dt = {b,b9,h,w}.
Modes supportés D:S:M Il V<-V @ S V<-V @ I S<-S @ S S<-S @ I DS int8 (b) int9 (b9) intl6(h) int32 (w)
Description
Chaque élément de donnée du registre vectoriel/scalaire Ra est tourné vers la gauche de la quantité de bits donnée dans le registre scalaire Rb ou la zone IMM et le résultat est enregistré dans le registre
vectoriel/scalaire Rd.
Opération quantité rotation= {SRb % 321 IIMM<4:0>}; pour (i=0;i<NumElem &&EMASK[i];i++){ Rd[i] = Ra[i] rotation rotation à gauche_quantité; } Exception Aucune. Note de programmation Noter que la quantité_rotation est prise
comme un nombre à 5 bits de SRb ou IMM <4:0>.
Pour les types de données de l'octet de l'octet9, du demi-mot, le programmeur est responsable d'une spécification correcte de la quantité de rotation qui est plus petite que ou égale au nombre de bits dans la grandeur de donnée. Si la quantité de rotation est plus grande que la grandeur de
donnée spécifiée, le résultat est non défini.
Noter que la rotation à gauche de n est équivalente à la rotation à droite de ElemSize-n, o ElemSize désigne le nombre de
bits dans une grandeur donnée de donnée.
VROR Rotation à Droite Format
250 20 15 10 0
RRRM5 0|11|0| 001010 |DISIDISHM Rd I Rb/IM5 Syntaxe Assembleur VROR. dt VRd,VRa,SRb VROR.dt VRd,VRa, #IMM VROR.dt SRd,SRa,SRb VROR. dt SRd,SRa, #IMM
o dt = {b,b9,h,w}.
Modes supportés D:S:M | V<-V @ S V<-V @ i s<-S @ I S<-S @SI DS int8 (b) 1 int9 (b9) intl6(h) int32 (w)
Description
Chaque élément de donnée du registre vectoriel/scalaire Ra est tourné vers la droite de la quantité de bits donnée dans le registre scalaire Rb ou la zone IMM et le résultat est enregistré dans le registre
vectoriel/scalaire Rd.
Opération quantité rotation= {SRb % 3211IMM<4:0>}: pour (i=0;i<NumElem &&EMASK[i];i++); { Rd[i] = Ra[i] rotation rotation à droite_quantité; } Exception Aucune. Note de programmation Noter que la quantité_rotation est prise
comme un nombre à 5 bits de SRb ou IMM <4:0>.
Pour les types de données de l'octet de l'octet9, du demi-mot, le programmeur est responsable d'une spécification correcte de la quantité de rotation qui est plus petite que ou égale au nombre de bits dans la grandeur de donnée. Si la quantité de rotation est plus grande que la grandeur de données spécifiée, le résultat est non défini. Noter que la rotation à droite de n est équivalente à la rotation à gauche de ElemSize-n, o ElemSize désigne le nombre de
bits dans une grandeur donnée de donnée.
VROUND Arrondissement Point Flottant à Entier Format
2 20 15 10 0
RRRM5 olol| 1 Is IRM I 0! S R |b Syntaxe Assembleur VROUND.rm VRd,VRb VROUND.rm SRd,SRb
o rm = {ninf,zero,near,pinf}.
Modes supportés D:S:M v<-v I s<-s I
Description
Le contenu du registre vectoriel/scalaire Rb dans le format de donnée à point flottant est arrondi à l'entier le plus proche à 32 bits et le résultat est enregistré dans le registre vectoriel/scalaire Rd. Le mode
d'arrondissement est défini dans RM.
RM<1:0> |Mode |Siqnification Q00 ninf arrondissement vers - infini 01 zero arrondissement vers zéro near arrondissement vers le pair le plus proche il11 pinf arrondissement vers + infini Opération pour (i=0;i<NumElem: i++){ Rd[i]=convertir à int32 (Rb[i]); } Exception Aucune. Note de programmation Cette instruction n'est pas affectée par le
masque d'élément.
VSATL Saturer à La Limite Inférieure Format M _n I. I0.0
RRRM9 |1 00! 01 SDS LM9 Rid Ra RbLM5I.
Syntaxe Assembleur VSATL.dt VRd,VRa,VRb VSATL.dt VRd,VRa,SRb VSATL. dt VRd,VRa,#IMM VSATL.dt SRd,SRa,SRb VSATL.dt SRd,SRa,#IMM o dt = {b,b9,h,w,f}. Noter que le type de donnée.f n'est pas supporté avec l'immédiat
9 bits.
Modes supportés D:S:M IlV<-V @ V V<-V @ S IV<-V @ I S<-S @ S S<-S @ I DS int8(b) int9 (b9) intl6(h) int32(w) flottant f
Description
Chaque élément de donnée du registre vectoriel/scalaire Ra est vérifié par rapport à sa limite inférieure correspondante dans le registre vectoriel/scalaire Rb ou la zone IMM. Si la valeur de l'élément de donnée est plus petite que la limite inférieure, elle est établie égale à la limite inférieure et le résultat final est enregistré dans le
registre vectoriel/scalaire Rd.
Opération pour (i=0;i<NumElem &&EMASK[i];i++) { Bop[i] = {VRb[i]lISRbllsex(IMM<8:0>)}; Rd[i]=Ra[i]<Bop[i]? Bop[i]:Ra[ii]; } Exception Aucune. VSATU Saturer à La Limite Supérieure Format
220 15 10 5 0
fRRRM9 I 10001 O0DIS Rd Ra | Rib I Syntaxe Assembleur VSATU.dt VRd,VRa,VRb VSATU.dt VRd,VRa,SRb VSATU.dt VRd,VRa,#IMM VSATU.dt SRd, SRa,SRb VSATU.dt SRd,SRa,#IMM o dt = {b,b9,h,w,f}. Noter que le type de donnée.f n'est pas supporté avec l'immédiat
9 bits.
Modes supportés D:S:M V<-V V V<-V @ S V<-V @ I S<-S @ SI S<-S @ I DS int8 (b) int9 (b9) intl6 (h) int32 (w) flottant (f)
Description
Chaque élément de donnée du registre vectoriel/scalaire Ra est vérifié par rapport à sa limite supérieure correspondante dans le registre vectoriel/scalaire Rb ou la zone IMM. Si la valeur de l'élément de donnée est plus petite que la limite supérieure elle est établie égale à la limite supérieure, et le résultat final est enregistré dans le
registre vectoriel/scalaire Rd.
Opération pour (i=0;i<NumElem &&EMASK[i];i++) { Bop[i] = {VRb[i]IISRbllsex(IMM<8.:0>)}; Rd[i]=Ra[i]<Bop[i]? Bop[i]:Ra[i]; } Exception Aucune. VSHFL Brassage Format 25 M. 15s l Io çra i 1 15 10 RRRR jojijjoi 000 00 SDS 1. VIRd VRa Rb Syntaxe Assembleur VSHFL.dt VRc,VRd,VRa,VRb VSHFL.dt VRc,VRd,VRa, SRb o dt = {b,b9,h,w,f}. Noter que.w et.f
spécifient la même opération.
Modes supportés s VRbI SRb I DS int8(b) int9 (b9) int16(h) h int32 w2 w
Description
Le contenu des registres vectoriels Ra est brassé avec Rb et le résultat est enregistré dans les registres vectoriels Rc:Rd comme
montré ci-dessous.
VRa Rb Opération Exception Aucune. Note de Programmation Cette instruction n'utilise pas le masque d'éléments. VSHFLH Brassage Haut Format 1 15 i 1iT1_ RRRR 1O|R|101 1000 JSJDSj | FRd | VRa 'jIT T Syntaxe Assembleur VSHFLH.dt VRd,VRa,VRb VSHFLH.dt VRd,VRa,SRb o dt = (b,b9,h,w,f}. Noter que.w et.f
spécifient la même opération.
Modes supportés
S l VRb SRb.
DS int8 (b) int9 (b9) intl6 (h) îint32 (w)
Description
Le contenu des registres vectoriels Ra est brassé avec Rb et la portion supérieure du résultat est enregistrée dans les registres
vectoriels Rc:Rd comme montré ci-dessous.
VRa Rb VRd IRl1 "1 Opération Exception Aucune. Note de Programmation Cette instruction n'utilise pas le masque d'éléments. VSHFLL Brassage bas Format M 520i 10 j lilt,:o.j 1 51 1 _ i RRRR 01111on0 'idloIS l Rd M' kRb Syntaxe Assembleur VSHFLL.dt VRd, VRa, VRb VSHFLL.dt VRd, VRa, SRb o dt = {b, b9, h, w, f}. Noter que.w et.f
spécifient la même opération.
Modes supportés S VRb SRb DS int8 (b) int9 (b9) intl6 (h) int32 (w)
Description
Le contenu du registre vectoriel Ra est brassé avec Rb et la partie inférieure de résultat est enregistrée dans le registre vectoriel Rd
comme montré ci-dessous.
VRV Rb Opération Exception Aucune. Note de programmation Cette instruction n'utilise pas le masque d'éléments. VST Enregistrement Format
3025 20 10S
REAR |o|oIOHRs J SRb s&J o25 20 15 IO o RRAJ LtI'I BJSTJCH 1 J Rb SRbIIMT J |EAI 1H1 |' j djC i T Syntaxe Assembleur VST.st Rs, SRb, SRi VST.st Rs, SRb, #IMM VST.st Rs, SRb+, SRi VST.st Rs, SRb+, #IMM o st = {b, b9t, h, w, 4, 8, 16, 32, 64}, Rs = {VRs, VRAs, SRs}. Noter que.b et.b9t spécifient la même opération et que.64 et
VRAs ne peuvent être spécifiés ensembles.
Utiliser VSTOFF pour l'enregistrement avec
antémémoire hors circuit.
Description
Enregistre un registre vectoriel ou scalaire.
Opération EA = SRb + {SRt I sex(IMM<7:0>)}; si (A == 1) SRb = EA; MEM[EA] = voir tableau ci-dessous: ST Opération d'enregistrement b BYTE[EA] = SRS<7:0> h HALF[EA] = SRs<15:0> Àw WORD[EA] = SRs<31:0> 4 BYTE[EA+i] = VR8<9i+7:9i>,i = 0 & 3 8 BYTE[EA+i] = VRs<9i+7:9i>,i = 0 à 7 16 BYTE[EA+i] = VRS<9i+7:9i>,i = 0 à 15 32 BYTE[EA+i] = VRs<9i+7:9i>,i = 0 à 31 64 BYTE[EA+i] = VR0s<9i+7:9i>,i = 0 à 31 BYTE[EA+32+i] = VRIs<9i+7:9i>,i = 0 à 31 Exception
Adresse donnée incorrecte, accès non aligné.
Note de programmation Cette instruction n'est pas affectée par le
masque d'éléments.
VSTCB Enregistrement à tampon circulaire Format
25 15 2 5 0
l I HJ I' i i I iIi11 1 -
REAR /01j 1 B 01. ST ICH| |SR, ISRi 1 o 7J 25 0, ,15 Io 0 REAI | Il0 100 ifflN S/11 X' 1 Syntaxe Assembleur VSTCB.st Rs, SRb, SRi VSTCB. st Rs, SRb, #IMM VSTCB.st Rs, SRb+, SRi VSTCB.st Rs, SRb+, #IMM o st = {b, b9t, h, w, 4, 8, 16, 32, 64}, Rs = {VRs, VRAs, SRs}. Noter que. b et.b9t spécifient la même opération et que.64 et
VRAd ne peut être spécifiés ensembles.
Utiliser VSTCBOFF pour le charge antémémoire
hors circuit.
Description
Enregistre un registre vectoriel ou scalaire du tampon circulaire délimité par l'indicateur COMMENCEMENT dans SRb+l et l'indicateur FIN
dans SRb+2.
L'adresse effective est ajustée si elle est plus grande que l'adresse FIN avant l'enregistrement ainsi que l'opération de mise à jour de l'adresse. De plus, les limites du tampon circulaire doivent être alignées sur les limites du demi-mot et du mot pour les
charges scalaires.h et.w, respectivement.
Opération EA = SRb + {SRl Il sex(IMM<7:0>)}; COMMENCEMENT = SRb+l; FIN = SRb+2; grandeurcb = FIN - COMMENCEMENT si (EA>FIN)EA = COMMENCEMENT + (EA + FIN); si (A == 1) SRb = EA; MEM[EA] = voir tableau ci-dessous:
N3SON3WNOD - NI. > NIJ
- Va enb gFSUFE LNZHRoNqzmoo<Y 'aGTp--qsazD LN3NRDN3WXOD - NIA+Z > Va > LN3NaNNWOD : puaeq As uo aURoo auuoTqouo; uoTfoDnisuT a:ao anb:nod aqUeATns uorwpPuoo -e ainsse 4ToP anaueiwbozd aq squauIgaT,p enbsvux azed g:4aje sed qsa,u uoT-onxsuT aa44o uoT:ewweubo:d ap GON gu6TTFe uou s;oe 'laqoeaooui auuop assazpî uoTddaoxa Iú V 0O T '<T6:L+T6>s'IA = [T+ Z+V3:qonaPUe -<+Zú+tf&(NI.<T+ZE+V3)].T <F,6:A+T6>S A = [T+tf. :qo:[nPUaB-T+%f.,(NI.<T+V)]LA 7q. 9 ' <T6: L+T6> 'IA = [T+ï: qo:nepu 6-T+ VaZ (NI.<T+,is)] j.La úE
S O = T
<T6:L+T6>'UA = [ q+va:q nePUej-T+,vs (NIa<T+V,)] aL7.q 3I
L O= T
<T6:L+T6> dA = [+v:qnpu5-+(NI<T+V3)] LX 8V <T6: L+T6>'EA [T+.q:p: - T+V E6 (NI.<T+vE)] 3,rx, <16. L+T6> HA = [FV:d <Ul6FVcNIH<T+ V3) I LL*X 7
<O:lú>S'S = [Ds]GaoM M-
<0:gS>sIS = [VS]IIVH q' <O:L> S = [V.]3L's q uawasTBbauua,p uoTdeado LS OIZ
S96ZS9Z
VSTD Enregistrement Double Format
25 20 15 10 5 ô
REAR lHdd |DB|S. ST i R II i Rs Io SRI M AI 2 5 2 I$ I J0 5 1 0 1 Rb VSTD.st Rs, SRb, SRi VSTD.st Rs, SRb, SRIMM VSTD.st Rs, SRb, SRiMM VSTD.st Rs, SRb+, SR#IMM VSTD.st Rs, SRb+, #IMM o st = {b, b9t, h, w, 4, 8, 16, 32, 64}, Rs = {VRs, VRAs, SRs}. Noter que.b et.b9t spécifient la même opération et que.64 et
VRAs ne peuvent être spécifiés ensemble.
Utiliser VSTDOFF pour enregistrement
antémémoire hors circuit.
Description
Enregistre deux registres vectoriels à partir de la rangée courante ou alternée ou deux
registres scalaires.
Opération EA = SRb + {SRi | sex(IMM<7:0>)}; si (A == 1) SRb = EA; MEM[EA] = voir tableau ci-dessous: ST Opération d'enregistrement b BYTE[EA] = SRs<7:0> BYTE[EA+1] = SR +t<7:0> h HALF[EA] = SRs<15:0>
HALF[EA+2] = SR,+1<15:0>
4 BYTE[EA+i] = VRs<9i+7:9i>,i = 0 à 3 BYTE[EA+4+i] = VR,+1<9i+7:9i>,i = 0 à 3 8 BYTE[EA+i] = VRs<9i+7:9i>,i = 0 à 7 BYTE[EA+8+i] = VRt+1<9i+ 7:9i>,i = 0 à 7 16 BYTE[EA+i] = VRs<9i+7:9i>,i = 0 à 15 BYTE[EA+16+i] = VRit<9i+7:9i>,i = 0 à 15 ST Opération d'enregistrement 32 BYTE[EA+i] = VRs<9i+7:9i>,i = 0 à 31 BYTE[EA+32+i] = VR+,<9i+7:9i>,i = O à 31 64 BYTE[EA+i] = VR0s<9i+7:9i>,i = O à 31 BYTE[EA+32+i] = VRls<9i+7:9i>,i = O à 31 BYTE[EA+64+i] = VR0os+l1<9i+7:9i>,i = O à 31 BYTE[EA+96+il = VR1.+,1<9i+7:9i>,i = O à 31 Exception
Adresse donnée incorrecte, accès non aligné.
Note de programmation Cette instruction n'est pas affectée par le
masque d'éléments. <0: I'C>L+S = [ tI+VY] caOM <0: úI>e+%S = [8+Vs]a(oM <0: Iú>,+"SS = [P+
V3] aHOM <0: 1ú>gS = [YV] Guo4 M
<0: 5I>+HS = [9+VH].IIH
<0: I>Z +S = [9+vaH] vH <O: >e" - [t'+vS)jIvH <O çl,"u [z+v-alaIvH
<0: 5I>T+S =[ +VH].TH
<0: >sHS = [tV].TIH q' <0: L>"+dS = [ú+V3] aLs <O:Lt>7+sS = [Z+V]l3.L q <0: L>[+SHS = [I+Yv] HSixa <0: L>9US = [va].Xt q' quawsTbauua,p UOTeagdo LS : snossap--o neIqvq aToA = [Vg]pqf a = lus (T == V) TG { (<0: L>4I)xas |l TS} + q'S = va UOT,e,do SaTQTVOS SGZqST6aa; Daqnb no equlaeqTe no e4u-eznoa eabuiez -e-[ ap Ia-c4ztd sBSTeTlO1O@A S@lSTBôl al4B alSTBlUS uoTIdT.2Dsaa *MnoaTD SoqT aiT0oue Uu queuleawsfsTauae nod &tOÈISA sGTjTfla * aquJasua s aTJTDGds ai9 queAnad au sYA 3a t9' anb ia uoTeGdo Gweui er.uaT;FoTads 46q- q q- enb xaoN {sUs 'sgVA 'sdA} = s {D9 'ES '91 '8 't 'm 'q '6q 'q} = $s no pqI# '+qs 'sH z *s' OSA TuS '+q/s 'SH qs'*I SA wi# 'qus 'su qs'ÈISA TuS 'qus 'su a S'*úSA inalIquassv axeuAs 0m q; S L 001;oI o 1 1 1 1 11 1É 1% ilEs IsfflQXo T, _' _ _,, _ _.,,? o ogS $ 0X1 1;LLs0l o; '_ ox n peno quewIs U /u&A
96C/C úZ
996ZSEZ
ST Opération d'enregistrement 4 BYTE[EA+i] = VRs<9i+ 7:9i>,i = 0 à 3 BYTE[EA+4+i] = VRs+1<9i+7:9i>,i = 0 à 3 BYTE[EA+8+i] = VRs+2<9i+7:9i>,i = 0 à 3 BYTE[EA+12+i] = VR_+1<9i+7:9i>,i = 0 à 3 8 BYTE[EA+i] = VRs<9i+7:9i>,i = 0 à 7 BYTE[EA+8+i] = VRs+1<9i+7:9i>,i = O à 7 BYTE[EA+16+i] = VRs+2<9i+7:9i>,i = 0 à 7 BYTE[EA+24+i] = VR,+3<9i+ 7:9i>,i = 0 à 7 16 BYTE[EA+i] = VRs<9i+7:9i>,i = 0 à 15 BYTE[EA+16+i] = VRS+1<9i+7:9i>,i = 0 à 15 BYTE[EA+32+i] = VRs+2<9i+7:9i>,i = 0 à 15 BYTE[EA+48+i] = VR,+1<9i+7:9i>,i = 0 à 15 32 BYTE[EA+i] = VRs<9i+7:9i>,i = 0 à 31 BYTE[EA+32+i] = VRs+<9i+7:9i>,i = 0 à 31 BYTE[EA+64+i] = VRs+ 2<9i+7:9i>,i = 0 à 31 BYTE[EA+96+i] = VR_+3<9i+7:9i>,i = 0 à 31 64 BYTE[EA+i] = VR0s<9i+7:9i>,i = 0 à 31 BYTE[EA+32+i] = VRs<9i+7:9i>,i = O à 31 BYTE[EA+64+i] = VRo+l1<9i+7:9i>,i = 0 à 31 BYTE[EA+96+i] = VRls+ l<9i+7:9i>,i = O à 31 BYTE[EA+128+i] = VR0s+2<9i+7:9i>,i = 0 à 31 BYTE[EA+160+i] = VRIs+2<9i+7:9i>,i = 0 à 31 BYTE[EA+192+i] = VR+3<9i+ 7:9i>,i = 0 à 31 BYTE[EA+19224+i] = VRs+3<9i+7:9i>,i = O à 31 i BYTE [EA+224+i] = VRls+3<9i+7: 9i>,i = 0 à 31 Exception
Adresse donnée incorrecte, accès non aligné.
Note de programmation Cette instruction n'est pas affectée par le
masque d'éléments.
VSTR Enregistrement inverse Format REA Àlo 20 15 10 5 REA.I1_1u_ 001 ooLI 'j1171 I REAR JOHO 01 'l 1'0'()O'T SRb S
3025 M
REAI 0 S1Rb IM Syntaxe Assembleur VSTR.st Rs, SRb, SRi VSTR.st Rs, SRb, #IMM VSTR.st Rs, SRb+, SRi VSTR.st Rs, SRb+, #IMM
o st = {4, 8, 16, 32, 64}, Rs = {VRs, VRAs}.
Noter que.64 et VRAs ne peuvent être spécifiés ensemble. Utiliser VSTROFF pour
enregistrement antémémoire hors circuit.
Description
Enregistre un registre vectoriel dans l'ordre d'éléments inverses. Cette instruction ne supporte pas un registre de source de données scalaires. Opération EA = SRb + {SRi l sex(IMM<7:0>)"}; si (A == 1) SRb = EA; MEM[EA] = voir tableau ci-dessous: ST Opération d'enreqistrement 4 BYTE[EA+i] = VRJ[31-i]<7:0>,i = 0 à 3 8 BYTE[EA+i] = VRa[31-i]<7:0>,i = 0 à 7 16 BYTE[EA+i] = VR.[31-i]<7:0>,i = 0 à 15 32 BYTE[EA+i] = VRg[31-i]<7:0>,i = 0 à 31 64 BYTE[EA+32+i] = VRos[31-i]<7:0> ,i = 0 à 31 BYTE[EA+i] = VR1_[31-i]<7:0>,i = 0 à 31 Exception
Adresse donnée incorrecte, accès non aligné.
Note de programmation Cette instruction n'est pas affectée par le
masque d'éléments.
VSTWS Enregistrement avec chevauchement Format REAR EJ1 1 lIX 100 |O|B.ST]CH | iIO [ SRi> 1 Sa l'5 20 10 0 f11 1 1rr1 1 i I I Il 1111 ii I:E.AR II, 0 B10 $T Rb SR REAI " 1"'O IBST1 RS ' I s RI IM'I1 3OM 1c 2O 15 1 0 <4 0 Syntaxe Assembleur VSTWS.st Rs, SRb, SRi VSTWS.st Rs, SRb, #IMM VSTWS.st Rs, SRb+, SRi VSTWS.st Rs, SRb+ , #IMM o st = {8, 16, 32}, Rs = {VRs, VRAs}. Noter que le mode.64 n'est pas supporté - utiliser VST à la place. Utiliser VSTWSOFF pour
enregistrement antémémoire hors circuit.
Description
En partant à l'adresse effective, 32 octets sont enregistrés à partir du registre vectoriel VRs dans la mémoire en utilisant le registre scalaire SRb+l en tant que Registre de
Contrôle de Chevauchement.
ST spécifie grandeur bloc, le nombre d'octets consécutifs enregistrés dans chaque bloc. SRb+j spécifie chevauchement, le nombre d'octets
séparant les débuts de deux blocs consécutifs.
Le chevauchement doit être égal à ou plus grand que la grandeur d'un bloc. EA doit être aligné par la grandeur de donnée. Le chevauchement et la grandeur du bloc doivent
être des multiples de la grandeur de donnée.
Opération EA = SRb + {SR, Il sex(IMM<7:0>)"}; si (A == 1) SRb = EA; Grandeurbloc = {4 Il 8 Il 16 j 32); Chevauchement = SRb+l<31:0>; pour (i = 0;i<VECSIZE/Grandeur bloc;i++) pour (j = 0;j<Grandeur_bloc;j++) BYTE[EA+i*Chevauchement+j] = VRs[i*Grandeurbloc+j]<7:0>; Exception
Adresse donnée incorrecte, accès non aligné.
VSUB Soustraire Format 3o 2s 20 IS 1a5 RRRM9 IIT 1000100] IDS|DSH M9 Rd Ra R b Syntaxe Assembleur VSUB.dt VRd, VRa, VRb VSUB.dt VRd, VRa, SRb VSUB.dt VRd, VRa, #IMM VSUB.dt SRd, SRa, SRb VSUB.dt SRd, SRa, #IMM
o dt = {b, b9, h, w, f}.
Modes supportés FDS:Ms V<-V @ V V<-V @ s V<-V @ I S<-S @ S S<-S @ I DS int8 (b) int9 (b9)lintl6 (h) int32 (w) flottant (f)
Description
Le contenu du registre vectoriel/scalaire Rb est soustrait du contenu du registre vectoriel/scalaire Ra et le résultat est enregistré dans le registre vectoriel/scalaire Rd. Opération pour (i=0; i<NumElem && EMASK[i];i++){ Bop[i] = {Rb[i] Il SRb Il sex(IMM<8:0>)}; Rd[i] = Ra[i]Bop[i]; } Exception Débordement, opérande point flottant incorrect. VSUBS Soustraire et positionner Format
_.3025 20 15 15
RRRM9 1 0101 DS11IS M9) SSRdI 1SI] SRM51 Syntaxe Assembleur VSUBS. dt SRd, SRa, SRb VSUBS.dt SRd, SRa, #IMM
o dt = {b, b9, h, w, f}.
Modes supportés
*D:S:M I I 1 I S<-S @ S S<-S @ I
DS int8 (b) int9 (b9) intl6 (h) int32 (w) flottant (f
Description
SRb est soustrait de SRa; le résultat est enregistré dans SRd et les bits VFLAG dans
VCSR sont positionnés.
Opération Bop[i]={SRb I| sex(IMM<8:0>)O"}; SRd = SRa - Bop; VCSR<lt,eq, gt> = état(SRa - Bop); Exception Débordement, opérande point flottant incorrect. VUNSHFL Débrassage Format 220 is! RRR=1 111 65 h5 ilIS I1 0 5 VIRejVR Syntaxe assembleur VUNSHFL.dt VRc, VRd, VRa, VRb VUNSHFL.dt VRc, VRd, VRa, SRb o dt = {b, b9, h, w, f}. Noter que.w et.f
spécifient la même opération.
Modes supportés S VRb I SRb DS int8 (b) int9 (b9) intl6 (h) int32 (w)
Description
Le contenu du registre vectoriel VRa est débrassé avec Rb dans les registres vectoriels VRc:VRd comme il est montré ci-dessous: VRa Rb Opération Exception Aucune. Note de programmation Cette instruction n'utilise pas le masque d'éléments. VUNSHFLi4 Débrassage valeur haute Format 0 25 2 15 10 5 o RRRR Jo0jijJ'iqhiJ'S DVRd VRa Rb Syntaxe Assembleur VUNSHFLH.dt VRd, VRa, VRb VUNSHFLH.dt VRd, VRa, SRb o dt = {b, b9, h, w, f}. Noter que.w et.f
spécifient la même opération.
Modes su portés S VRb SRb DS int8 (b int9 (b9) intl6 (h) int32 (w)
Description
Le contenu du registre vectoriel VRa est débrassé avec Rb; la portion supérieure du résultat est retournée au registre vectoriel VRd comme il est montré ci-dessous: VRa Rb Opération Exception Aucune. Note de programmation Cette instruction n'utilise pas le masque d'éléments. VUNSHFLL Débrassage valeur basse Format - 2 RRRRt l II20 15 1o 5 o ioI!,,,,MO ioo,, H1 '' ''' 1 Syntaxe Assembleur VUNSHFLL.dt VRd, VRa, VRb VUNSHFLL.dt VRd, VRa, SRb ou dt = {b, b9, h, w, f}. Noter que.w et.f
spécifient la même opération.
Modes supportés S VRb I SRb DS int8 (b) int9 (b9) intl6 (h) int32 (w)
Description
Le contenu du registre vectoriel VRa est débrassé avec Rb; la portion inférieure du résultat est retournée au registre vectoriel VRd comme il est moztré ci-dessous: VRa Rb Opération Exception Aucune. Note de programmation Cette instruction n'utilise pas le masque d'éléments. VWBACK Réécriture Format REoRlolool"Id ' il { l |H"| "SRl
2 15 10 5 0
REAI O 0 1 $Rb S 1 10io IoI 1 0110 r1 HW 1 <4tDjj Syntaxe Assembleur VWBACK.ln SRb, SRi VWBACK.ln SRb, #IMM VWBACK.ln SRb+, SRi VWBACK.ln SRb+, #IMM o in = {1, 2, 4, 8}
Description
La ligne de l'antémémoire dont l'indice est spécifié par EA (en opposition à celle dont l'étiquette correspond à EA) dans l'antémémoire de données vectorielles est mise à jour à la mémoire si elle contient une donnée modifiée. Si plus d'une ligne d'antémémoire est spécifiée, les lignes séquentielles suivantes d'antémémoire sont mises à jour à la mémoire si elles contiennent des données modifiées. Le nombre de lignes dans une mémoire est spécifié comme suit: LN<l:0≥00: 1 ligne antémémoire 64 octets
est écrite.
LN<1:0≥01: 2 lignes antémémoire 64 octets
sont écrites.
LN<l:0≥10: 4 lignes antémémoire 64 octets
sont écrites.
LN<l:0≥11: 8 lignes antémémoire 64 octets
sont écrites.
Si l'adresse effective n'est pas sur une limite de 64 octets, elle est d'abord tronquée
pour être alignée à une limite de 64 octets.
Opération Exception
Exception adresse donnée incorrecte.
Note de programmation EA<31:0> désigne une adresse d'octet dans le
mémoire locale.
VWBACKSP Réécriture de la zone de travail Format
3C 5_ _ 10 5 0
REARI l 0 l'rI il IIILN I S IRLiv VWBACKSP.ln SRp, SRb, SRi
0EA 0 10 LN101 R II
Io0111 '" 1 11 II'H Syntaxe Assembleur VWBACKSP.ln SRp, SRb, SR#IMM VWBACKSP.ln SRp, SRb, SRiMM VWBACKSP.ln SRp, SRb+, #IMM VWBACKSP.ln SRp, SRb+, #IMM o in = {1, 2, 4, 8}. Noter que VWBACK et
VWBACKSP utilisent le même code d'opération.
Description
Transfert des blocs multiples de 64 octets de la zone de travail à la mémoire. L'adresse effective donne l'adresse de départ dans la mémoire et SRp donne l'adresse de départ dans la zone de travail. Le nombre de blocs de 64 octets est spécifié comme suit: LN<l:0≥00: 1 ligne antémémoire 64 octets
est écrite.
LN<l:0≥01: 2 lignes antémémoire 64 octets
sont écrites.
LN<l:0≥10: 4 lignes antémémoire 64 octets
sont écrites.
LN<1:0≥11: 8 lignes antémémoire 64 octets
sont écrites-.
Si l'adresse effective n'est pas sur une limite de 64 octets, elle est d'abord tronquée
pour être alignée à une limite de 64 octets.
Si l'adresse d'indicateur de la zone de travail dans SRp n'est pas sur une limite de 64 octets, elle est également tronquée pour
être alignée sur la limite de 64 octets.
L'adresse de l'indicateur de la zone de travail en alignement est incrémentée par le
nombre d'octets transférés.
Opération EA = SRb + {SRi || sex(IMM<7:0>)}; si (A == 1) SRb = EA; Num_bytes = {64 | 128 Il 256 il 512} Memadrs = EA<31:6>:6b'000000; SRp = SRp<31:6>:6b'000000; pour (i=0;i<Num_bytes;i++) SPAD[SRp++] = MEM[MEM_adrs+i]; Exception
Exception adresse donnée incorrecte.
VXNOR XNOR (NON OU Exclusif Format 01.0L 2ODL I I0I 5 0l11 RRRM9 |1 01 SDsI 001 I D Syntaxe Assembleur VXNOR. dt VRd, VRa, VRb VXNOR.dt VRd, VRa, SRb VXNOR.dt VRd, VRa, #IMM VXNOR.dt SRd, SRa, SRb VXNOR.dt SRd, SRa, #IMM
o dt = {b, b9, h, w}.
Modes supportés D:S:M V<-V @ V V<-V @ S V<-V @ I | S<-S @ S I s<- S @ I DS int8 (b) int9 (b9) intl6 (h) int32 (w)
Description
Le contenu du registre vectoriel/scalaire Ra subit une opération logique NON-OU par rapport au contenu du registre vectoriel scalaire Rb et le résultat est enregistré dans le registre
vectoriel/scalaire Rd.
Opération pour (i=0;i<NumElem && EMASK[i];i++){ Bop[i]={Rb[i] Il SRb sex(IMM<8:0>)}; Rd[i]<k≥(Ra[i]<k>^Bop[i]<k>), pour k=tous les bits dans l'élément i; } Exception Aucune. VXOR XOR (OU exclusif) Format RRRM9 H1 'oi 1' psP i1 1,1 iD,,,M 91 kt RRIN110111 1111S S Rd Ra Syntaxe Assembleur VXOR.dt VRd, VRa, VRb VXOR.dt VRd, VRa, SRb VXOR.dt VRd, VRa, #IMM VXOR.dt SRd, SRa, SRb VXOR.dt SRd, SRa, #IMM
o dt = {b, b9, h, w}.
Modes suportés
D:S:M |V<-V @ V | V<-V @ S V<-V @ I | S<-S @ S S<-S Q I|
DS int8 (b int9 (b9) intl6 (h) int32 (w)
Description
Le contenu du registre vectoriel/scalaire Ra subit une opération logique OU exclusif avec le contenu du registre vectoriel/scalaire Rb et le résultat est enregistré dans le registre
vectoriel/scalaire Rd.
Opération pour (i=0;i<NumElem && EMASK[i];i++){ Bop[i]={VRb[i] Il SRb Il sex(IMM<8:0>)"}; Rd[i]<k≥Ra[i]<k>^Bop [il]<k>, pour k=tous les bits dans l'élément i; } Exception Aucune. VXORALL XOR (OU exclusif} Tous les Eléments Format
302 20 I$ I050
RRRR 101iI 1 10 II1 SRdI1 1 1 1 I 11lVRb Syntaxe Assembleur VXORALL.dt SRd, VRb o dt = {b, b9, h, w}. Noter que.b et.b9 spécifient la même opération Modes supportés DS | int8 (h) int9 (b9) intl6 (h) int32 (w)
Description
Le bit de moindre poids de chaque élément dans VRb subit une opération OU exclusif; le résultat de 1 bit est retourné en tant que bit de moindre poids de SRd. Cette instruction
n'est pas affectée par le masque d'éléments.
Opération Exception Aucune. L'invention n'est pas limitée aux exemples de réalisation représentés et décrits en détail car diverses modifications peuvent y être apportées sans sortir de son cadre.

Claims (8)

REVENDICATIONS
1. Processeur vectoriel, caractérisé en ce qu'il comprend: une première rangée de registres vectoriels (120) o, à chaque registre vectoriel de la première rangée, est assigné un numéro de registre qui est distinct des numéros de registre assignés aux autres registres vectoriels dans la première rangée; une seconde rangée de registres vectoriels (120) o, à chaque registre vectoriel de la seconde rangée est assigné un numéro de registre, qui est distinct des numéros de registre assignés aux autres registres vectoriels dans la seconde rangée mais qui est le même qu'un numéro de registre assigné à un registre vectoriel correspondant dans la première rangée; un registre de contrôle qui comprend une zone de rangée de défaut; et un ensemble de circuits de sélection pour les première et seconde rangées de registres vectoriels, o l'ensemble de circuits de sélection peut fonctionner dans un premier mode pour accéder à un registre vectoriel identifié par une combinaison d'un numéro de registre d'une instruction qui est exécutée par le processeur vectoriel et une valeur de la zone
de rangée de défaut.
2. Processeur vectoriel selon la revendication 1, caractérisé en ce que l'ensemble de circuits de sélection peut fonctionner en second mode pour accéder à un premier registre vectoriel de la première rangée et à un second registre vectoriel de la seconde rangée, o aux premier et second registres sont assignés un numéro de registre d'une instruction qui est exécutée par le processeur vectoriel et la combinaison des premiers et seconds registres est utilisée pour une valeur vectorielle plus grande que celle qui
pourrait être enregistrée dans le premier registre vectoriel.
3. Processeur vectoriel selon la revendication 2, caractérisé en ce que l'ensemble de circuits de sélection peut fonctionner dans un troisième mode pour accéder à un registr- vectoriel identifié par la combinaison d'un numéro de registre et d'une valeur de rangée à partir d'une
instruction qui est exécutée par le processeur vectoriel.
4. Processeur vectoriel selon la revendication 1, caractérisé en ce que l'ensemble de circuits de sélection peut fonctionner dans un deuxième mode pour accéder à un registre vectoriel identifié par une combinaison d'un numéro de registre et d'une valeur de rangée d'une instruction qui
est exécutée par le processeur vectoriel.
5. Processeur vectoriel selon la revendication 4, caractérisé en ce que l'ensemble de circuits de sélection fonctionne en premier mode pour des instructions représentant des opérations logiques accomplies sur des quantités vectorielles et en second mode pour des opérations de charge/enregistrement.
6. Procédé consistant à faire fonctionner un processeur vectoriel, caractérisé en ce qu'il consiste à: assigner des numéros de registre à des registres vectoriels dans une première rangée, o, pour chaque registre vectoriel de la première rangée, le numéro de registre assigné est distinct des numéros de registre assignés aux autres registres vectoriels de la première rangée; assigner des numéros de registre à des registres vectoriels dans une seconde rangée, o, pour chaque registre vectoriel de la seconde rangée, le numéro de registre assigné est distinct des numéros de registre assignés aux autres registres vectoriels de la seconde rangée et est le même qu'un numéro de registre assigné à un registre vectoriel correspondant dans la première rangée; former une instruction qui comprend un numéro de registre; et exécuter l'instruction, o l'exécution de l'instruction comprend l'accès à un registre vectoriel auquel est assigné le numéro de registre inclus dans l'instruction et dans une rangée indiquée par une zone d'un registre de contrôle du
processeur vectoriel.
7. Procédé selon la revendication 6, caractérisé en ce qu'il consiste de plus à: former une seconde instruction qui comprend un numéro de registre; et exécuter la seconde instruction, o l'exécution de la seconde instruction comprend l'accès à un premier registre vectoriel auquel est assigné le numéro de registre dans la première rangée et l'accès à un second registre vectoriel auquel est assigné le numéro de registre dans la seconde rangée.
8. Procédé selon la revendication 7, caractérisé en ce que l'accès aux premier et second registres vectoriels comprend le traitement d'un seul vecteur qui a un premier groupe d'éléments de données enregistré dans le premier registre vectoriel et un second groupe d'éléments de données
enregistré dans le second registre vectoriel.
FR9710436A 1996-08-19 1997-08-18 Traitement de donnees multiples a une seule instruction utilisant des rangees multiples de registres vectoriels Expired - Lifetime FR2752965B1 (fr)

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
US08/697,086 US5838984A (en) 1996-08-19 1996-08-19 Single-instruction-multiple-data processing using multiple banks of vector registers

Publications (2)

Publication Number Publication Date
FR2752965A1 true FR2752965A1 (fr) 1998-03-06
FR2752965B1 FR2752965B1 (fr) 2004-09-24

Family

ID=24799731

Family Applications (1)

Application Number Title Priority Date Filing Date
FR9710436A Expired - Lifetime FR2752965B1 (fr) 1996-08-19 1997-08-18 Traitement de donnees multiples a une seule instruction utilisant des rangees multiples de registres vectoriels

Country Status (7)

Country Link
US (1) US5838984A (fr)
JP (1) JP3983857B2 (fr)
KR (1) KR100236527B1 (fr)
CN (1) CN1117316C (fr)
DE (1) DE19735348B4 (fr)
FR (1) FR2752965B1 (fr)
TW (1) TW345650B (fr)

Families Citing this family (132)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6643765B1 (en) 1995-08-16 2003-11-04 Microunity Systems Engineering, Inc. Programmable processor with group floating point operations
US5961631A (en) * 1997-07-16 1999-10-05 Arm Limited Data processing apparatus and method for pre-fetching an instruction in to an instruction cache
US7197625B1 (en) * 1997-10-09 2007-03-27 Mips Technologies, Inc. Alignment and ordering of vector elements for single instruction multiple data processing
US5864703A (en) 1997-10-09 1999-01-26 Mips Technologies, Inc. Method for providing extended precision in SIMD vector arithmetic operations
US6230259B1 (en) 1997-10-31 2001-05-08 Advanced Micro Devices, Inc. Transparent extended state save
US6157996A (en) * 1997-11-13 2000-12-05 Advanced Micro Devices, Inc. Processor programably configurable to execute enhanced variable byte length instructions including predicated execution, three operand addressing, and increased register space
US6334176B1 (en) * 1998-04-17 2001-12-25 Motorola, Inc. Method and apparatus for generating an alignment control vector
US6282634B1 (en) * 1998-05-27 2001-08-28 Arm Limited Apparatus and method for processing data having a mixed vector/scalar register file
US6862563B1 (en) 1998-10-14 2005-03-01 Arc International Method and apparatus for managing the configuration and functionality of a semiconductor design
US20060168431A1 (en) * 1998-10-14 2006-07-27 Peter Warnes Method and apparatus for jump delay slot control in a pipelined processor
US7308559B2 (en) * 2000-02-29 2007-12-11 International Business Machines Corporation Digital signal processor with cascaded SIMD organization
WO2001069411A2 (fr) 2000-03-10 2001-09-20 Arc International Plc Interface memoire et procede permettant de creer des interfaces entre des entites fonctionnelles
JP3940542B2 (ja) * 2000-03-13 2007-07-04 株式会社ルネサステクノロジ データプロセッサ及びデータ処理システム
JP2001283413A (ja) * 2000-03-29 2001-10-12 Tdk Corp スピンバルブ膜の製造方法
US6857061B1 (en) 2000-04-07 2005-02-15 Nintendo Co., Ltd. Method and apparatus for obtaining a scalar value directly from a vector register
US6877084B1 (en) 2000-08-09 2005-04-05 Advanced Micro Devices, Inc. Central processing unit (CPU) accessing an extended register set in an extended register mode
US6981132B2 (en) 2000-08-09 2005-12-27 Advanced Micro Devices, Inc. Uniform register addressing using prefix byte
US7155601B2 (en) * 2001-02-14 2006-12-26 Intel Corporation Multi-element operand sub-portion shuffle instruction execution
US7599981B2 (en) * 2001-02-21 2009-10-06 Mips Technologies, Inc. Binary polynomial multiplier
US7181484B2 (en) * 2001-02-21 2007-02-20 Mips Technologies, Inc. Extended-precision accumulation of multiplier output
US7162621B2 (en) 2001-02-21 2007-01-09 Mips Technologies, Inc. Virtual instruction expansion based on template and parameter selector information specifying sign-extension or concentration
US7711763B2 (en) 2001-02-21 2010-05-04 Mips Technologies, Inc. Microprocessor instructions for performing polynomial arithmetic operations
US7039060B2 (en) * 2001-03-07 2006-05-02 Mips Tech Inc System and method for extracting fields from packets having fields spread over more than one register
US7127593B2 (en) * 2001-06-11 2006-10-24 Broadcom Corporation Conditional execution with multiple destination stores
US6986025B2 (en) * 2001-06-11 2006-01-10 Broadcom Corporation Conditional execution per lane
US7861071B2 (en) * 2001-06-11 2010-12-28 Broadcom Corporation Conditional branch instruction capable of testing a plurality of indicators in a predicate register
US7624138B2 (en) 2001-10-29 2009-11-24 Intel Corporation Method and apparatus for efficient integer transform
US7685212B2 (en) * 2001-10-29 2010-03-23 Intel Corporation Fast full search motion estimation with SIMD merge instruction
US7631025B2 (en) * 2001-10-29 2009-12-08 Intel Corporation Method and apparatus for rearranging data between multiple registers
US7739319B2 (en) * 2001-10-29 2010-06-15 Intel Corporation Method and apparatus for parallel table lookup using SIMD instructions
US20040054877A1 (en) 2001-10-29 2004-03-18 Macy William W. Method and apparatus for shuffling data
US7725521B2 (en) * 2001-10-29 2010-05-25 Intel Corporation Method and apparatus for computing matrix transformations
US7818356B2 (en) 2001-10-29 2010-10-19 Intel Corporation Bitstream buffer manipulation with a SIMD merge instruction
US20100274988A1 (en) * 2002-02-04 2010-10-28 Mimar Tibet Flexible vector modes of operation for SIMD processor
US20030231660A1 (en) * 2002-06-14 2003-12-18 Bapiraju Vinnakota Bit-manipulation instructions for packet processing
US7793084B1 (en) 2002-07-22 2010-09-07 Mimar Tibet Efficient handling of vector high-level language conditional constructs in a SIMD processor
US6986023B2 (en) * 2002-08-09 2006-01-10 Intel Corporation Conditional execution of coprocessor instruction based on main processor arithmetic flags
WO2004015563A1 (fr) * 2002-08-09 2004-02-19 Intel Corporation Mecanisme de commande a co-processeur multimedia comprenant des instructions d'alignement ou de radiodiffusion
US7392368B2 (en) * 2002-08-09 2008-06-24 Marvell International Ltd. Cross multiply and add instruction and multiply and subtract instruction SIMD execution on real and imaginary components of a plurality of complex data elements
GB2394571B (en) * 2002-10-23 2005-08-10 Motorola Inc Arrangement system and method for vector permutation in single-instruction multiple-data microprocessors
JP2004302647A (ja) * 2003-03-28 2004-10-28 Seiko Epson Corp ベクトルプロセッサおよびレジスタのアドレス指定方法
US20040215924A1 (en) * 2003-04-28 2004-10-28 Collard Jean-Francois C. Analyzing stored data
US7610466B2 (en) * 2003-09-05 2009-10-27 Freescale Semiconductor, Inc. Data processing system using independent memory and register operand size specifiers and method thereof
US7275148B2 (en) * 2003-09-08 2007-09-25 Freescale Semiconductor, Inc. Data processing system using multiple addressing modes for SIMD operations and method thereof
US7315932B2 (en) 2003-09-08 2008-01-01 Moyer William C Data processing system having instruction specifiers for SIMD register operands and method thereof
GB2409064B (en) * 2003-12-09 2006-09-13 Advanced Risc Mach Ltd A data processing apparatus and method for performing in parallel a data processing operation on data elements
GB2409060B (en) * 2003-12-09 2006-08-09 Advanced Risc Mach Ltd Moving data between registers of different register data stores
GB2411974C (en) * 2003-12-09 2009-09-23 Advanced Risc Mach Ltd Data shift operations
GB2409067B (en) * 2003-12-09 2006-12-13 Advanced Risc Mach Ltd Endianess compensation within a SIMD data processing system
GB2411976B (en) * 2003-12-09 2006-07-19 Advanced Risc Mach Ltd A data processing apparatus and method for moving data between registers and memory
GB2409065B (en) * 2003-12-09 2006-10-25 Advanced Risc Mach Ltd Multiplexing operations in SIMD processing
GB2409059B (en) * 2003-12-09 2006-09-27 Advanced Risc Mach Ltd A data processing apparatus and method for moving data between registers and memory
GB2409068A (en) * 2003-12-09 2005-06-15 Advanced Risc Mach Ltd Data element size control within parallel lanes of processing
GB2409066B (en) * 2003-12-09 2006-09-27 Advanced Risc Mach Ltd A data processing apparatus and method for moving data between registers and memory
GB2409062C (en) * 2003-12-09 2007-12-11 Advanced Risc Mach Ltd Aliasing data processing registers
GB2411975B (en) * 2003-12-09 2006-10-04 Advanced Risc Mach Ltd Data processing apparatus and method for performing arithmetic operations in SIMD data processing
GB2409061B (en) * 2003-12-09 2006-09-13 Advanced Risc Mach Ltd Table lookup operation within a data processing system
GB2409063B (en) * 2003-12-09 2006-07-12 Advanced Risc Mach Ltd Vector by scalar operations
GB2411973B (en) * 2003-12-09 2006-09-27 Advanced Risc Mach Ltd Constant generation in SMD processing
GB2410097B (en) * 2004-01-13 2006-11-01 Advanced Risc Mach Ltd A data processing apparatus and method for performing data processing operations on floating point data elements
GB2411978B (en) * 2004-03-10 2007-04-04 Advanced Risc Mach Ltd Inserting bits within a data word
US7873812B1 (en) 2004-04-05 2011-01-18 Tibet MIMAR Method and system for efficient matrix multiplication in a SIMD processor architecture
US7302627B1 (en) * 2004-04-05 2007-11-27 Mimar Tibet Apparatus for efficient LFSR calculation in a SIMD processor
US7493481B1 (en) * 2004-05-17 2009-02-17 Netxen, Inc. Direct hardware processing of internal data structure fields
US9557994B2 (en) 2004-07-13 2017-01-31 Arm Limited Data processing apparatus and method for performing N-way interleaving and de-interleaving operations where N is an odd plural number
US20060070042A1 (en) * 2004-09-24 2006-03-30 Muratori Richard D Automatic clocking in shared-memory co-simulation
US20060179265A1 (en) * 2005-02-08 2006-08-10 Flood Rachel M Systems and methods for executing x-form instructions
US20060218377A1 (en) * 2005-03-24 2006-09-28 Stexar Corporation Instruction with dual-use source providing both an operand value and a control value
US7933405B2 (en) * 2005-04-08 2011-04-26 Icera Inc. Data access and permute unit
US20070038984A1 (en) 2005-08-12 2007-02-15 Gschwind Michael K Methods for generating code for an architecture encoding an extended register specification
US7421566B2 (en) 2005-08-12 2008-09-02 International Business Machines Corporation Implementing instruction set architectures with non-contiguous register file specifiers
US7734897B2 (en) * 2005-12-21 2010-06-08 Arm Limited Allocation of memory access operations to memory access capable pipelines in a superscalar data processing apparatus and method having a plurality of execution threads
US20070283129A1 (en) * 2005-12-28 2007-12-06 Stephan Jourdan Vector length tracking mechanism
US7565514B2 (en) * 2006-04-28 2009-07-21 Freescale Semiconductor, Inc. Parallel condition code generation for SIMD operations
US7958181B2 (en) * 2006-09-21 2011-06-07 Intel Corporation Method and apparatus for performing logical compare operations
US9223751B2 (en) * 2006-09-22 2015-12-29 Intel Corporation Performing rounding operations responsive to an instruction
US8127113B1 (en) 2006-12-01 2012-02-28 Synopsys, Inc. Generating hardware accelerators and processor offloads
JPWO2008087779A1 (ja) * 2007-01-19 2010-05-06 日本電気株式会社 アレイ型プロセッサおよびデータ処理システム
US20080229062A1 (en) * 2007-03-12 2008-09-18 Lorenzo Di Gregorio Method of sharing registers in a processor and processor
US8095735B2 (en) 2008-08-05 2012-01-10 Convey Computer Memory interleave for heterogeneous computing
US8122229B2 (en) * 2007-09-12 2012-02-21 Convey Computer Dispatch mechanism for dispatching instructions from a host processor to a co-processor
US8561037B2 (en) 2007-08-29 2013-10-15 Convey Computer Compiler for generating an executable comprising instructions for a plurality of different instruction sets
US8156307B2 (en) * 2007-08-20 2012-04-10 Convey Computer Multi-processor system having at least one processor that comprises a dynamically reconfigurable instruction set
US9015399B2 (en) 2007-08-20 2015-04-21 Convey Computer Multiple data channel memory module architecture
US9710384B2 (en) 2008-01-04 2017-07-18 Micron Technology, Inc. Microprocessor architecture having alternative memory access paths
CN101377735B (zh) * 2007-08-28 2011-09-28 凌阳科技股份有限公司 于多模处理器中以串行位决定指令长度的装置及方法
US8078836B2 (en) 2007-12-30 2011-12-13 Intel Corporation Vector shuffle instructions operating on multiple lanes each having a plurality of data elements using a common set of per-lane control bits
US8205066B2 (en) * 2008-10-31 2012-06-19 Convey Computer Dynamically configured coprocessor for different extended instruction set personality specific to application program with shared memory storing instructions invisibly dispatched from host processor
US20100115233A1 (en) * 2008-10-31 2010-05-06 Convey Computer Dynamically-selectable vector register partitioning
US8423745B1 (en) 2009-11-16 2013-04-16 Convey Computer Systems and methods for mapping a neighborhood of data to general registers of a processing element
US8434074B2 (en) * 2010-02-24 2013-04-30 Intel Corporation Register allocation with SIMD architecture using write masks
KR20110103256A (ko) * 2010-03-12 2011-09-20 삼성전자주식회사 다중 입출력 오퍼레이션 지원 프로세서 및 그 방법
US20120185670A1 (en) * 2011-01-14 2012-07-19 Toll Bret L Scalar integer instructions capable of execution with three registers
US9128701B2 (en) * 2011-04-07 2015-09-08 Via Technologies, Inc. Generating constant for microinstructions from modified immediate field during instruction translation
KR20120134549A (ko) 2011-06-02 2012-12-12 삼성전자주식회사 Ｓｉｍｄ 프로세서를 이용한 병렬 연산 처리 장치 및 방법
GB2508312B (en) 2011-09-26 2020-04-22 Intel Corp Instruction and logic to provide vector load-op/store-op with stride functionality
KR101783312B1 (ko) 2011-11-15 2017-10-10 삼성전자주식회사 클러스터 간의 통신으로 인한 오버헤드를 최소화하는 장치 및 방법
CN103946797B (zh) * 2011-12-06 2017-07-04 英特尔公司 用于转换矢量指令的系统、装置和方法
CN104011645B (zh) * 2011-12-22 2018-06-26 英特尔公司 用于产生其中在连续位置中的整数相差恒定整数跨度且最小整数从零偏移整数偏移量的整数序列的处理器、方法、系统和含有指令的介质
US9678751B2 (en) 2011-12-23 2017-06-13 Intel Corporation Systems, apparatuses, and methods for performing a horizontal partial sum in response to a single instruction
WO2013095614A1 (fr) * 2011-12-23 2013-06-27 Intel Corporation Instruction de super multiplication addition (super madd)
US9792115B2 (en) 2011-12-23 2017-10-17 Intel Corporation Super multiply add (super MADD) instructions with three scalar terms
WO2013100991A1 (fr) 2011-12-28 2013-07-04 Intel Corporation Systèmes, appareils et procédés permettant de mettre en oeuvre un codage différentiel sur des éléments de données condensées
CN104040482B (zh) * 2011-12-28 2018-02-16 英特尔公司 用于在打包数据元素上执行增量解码的系统、装置和方法
US9864602B2 (en) 2011-12-30 2018-01-09 Intel Corporation Packed rotate processors, methods, systems, and instructions
US10289412B2 (en) * 2012-02-09 2019-05-14 Qualcomm Incorporated Floating point constant generation instruction
WO2013180712A1 (fr) * 2012-05-30 2013-12-05 Intel Corporation Exponentiation modulaire à base vectorielle et scalaire
US10430190B2 (en) 2012-06-07 2019-10-01 Micron Technology, Inc. Systems and methods for selectively controlling multithreaded execution of executable code segments
CN102819692A (zh) * 2012-08-10 2012-12-12 上海交通大学 基于fpga的rna二级结构预测装置、系统及其实现方法
CN102930008B (zh) * 2012-10-29 2015-10-07 无锡江南计算技术研究所 向量查表方法
US9639371B2 (en) * 2013-01-29 2017-05-02 Advanced Micro Devices, Inc. Solution to divergent branches in a SIMD core using hardware pointers
CN104375803B (zh) * 2013-08-13 2017-10-24 华为技术有限公司 一种数据处理的方法及装置
CN104461939A (zh) * 2014-12-16 2015-03-25 清华大学 扩展处理器寄存器堆容量的方法
US10296489B2 (en) * 2014-12-27 2019-05-21 Intel Corporation Method and apparatus for performing a vector bit shuffle
US10296334B2 (en) * 2014-12-27 2019-05-21 Intel Corporation Method and apparatus for performing a vector bit gather
US10503502B2 (en) * 2015-09-25 2019-12-10 Intel Corporation Data element rearrangement, processors, methods, systems, and instructions
GB2543303B (en) * 2015-10-14 2017-12-27 Advanced Risc Mach Ltd Vector data transfer instruction
US9733899B2 (en) * 2015-11-12 2017-08-15 Arm Limited Lane position information for processing of vector
US20170177350A1 (en) * 2015-12-18 2017-06-22 Intel Corporation Instructions and Logic for Set-Multiple-Vector-Elements Operations
US10152321B2 (en) * 2015-12-18 2018-12-11 Intel Corporation Instructions and logic for blend and permute operation sequences
CN107315568B (zh) * 2016-04-26 2020-08-07 中科寒武纪科技股份有限公司 一种用于执行向量逻辑运算的装置
CN111176608A (zh) * 2016-04-26 2020-05-19 中科寒武纪科技股份有限公司 一种用于执行向量比较运算的装置和方法
CN108009976A (zh) * 2016-10-27 2018-05-08 超威半导体公司 用于图形处理单元(gpu)计算的超级单指令多数据(超级simd)
US10216479B2 (en) * 2016-12-06 2019-02-26 Arm Limited Apparatus and method for performing arithmetic operations to accumulate floating-point numbers
CN111742525B (zh) * 2018-02-19 2022-02-25 华为技术有限公司 多云vpc路由和注册
JP7296574B2 (ja) * 2019-03-04 2023-06-23 パナソニックＩｐマネジメント株式会社 プロセッサ及びプロセッサの制御方法
US11132198B2 (en) 2019-08-29 2021-09-28 International Business Machines Corporation Instruction handling for accumulation of register results in a microprocessor
CN110727412B (zh) * 2019-09-14 2022-01-07 无锡江南计算技术研究所 一种基于掩码的混合浮点乘法低功耗控制方法及装置
US11551148B2 (en) * 2020-04-29 2023-01-10 Marvell Asia Pte Ltd System and method for INT9 quantization
CN112230995B (zh) * 2020-10-13 2024-04-09 广东省新一代通信与网络创新研究院 一种指令的生成方法、装置以及电子设备
CN112328511B (zh) * 2021-01-04 2021-05-04 统信软件技术有限公司 一种数据处理方法、计算设备及可读存储介质
CN115794671B (zh) * 2023-02-07 2023-04-14 成都申威科技有限责任公司 一种兼容向量数据的访存系统及方法

Citations (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
WO1993001543A1 (fr) * 1991-07-08 1993-01-21 S-Mos Systems, Inc. Architecture de microprocesseur risc mettant en ×uvre divers ensembles de registres types
EP0543366A2 (fr) * 1991-11-20 1993-05-26 Hitachi, Ltd. Procédé et dispositif pour le traitement de données
US5226142A (en) * 1990-11-21 1993-07-06 Ross Technology, Inc. High performance register file with overlapping windows
EP0622732A1 (fr) * 1993-04-27 1994-11-02 Kabushiki Kaisha Toshiba Microprocesseur
US5392411A (en) * 1992-02-03 1995-02-21 Matsushita Electric Industrial Co., Ltd. Dual-array register file with overlapping window registers
WO1995032466A1 (fr) * 1994-05-19 1995-11-30 Vlsi Technology, Inc. Schema flexible d'affectation d'un registre

Family Cites Families (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPS59160267A (ja) * 1983-03-02 1984-09-10 Hitachi Ltd ベクトル処理装置
US4791555A (en) * 1983-10-24 1988-12-13 International Business Machines Corporation Vector processing unit
JPH0648486B2 (ja) * 1986-10-08 1994-06-22 日本電気株式会社 ベクトルデ−タ処理装置
JP2679994B2 (ja) * 1987-08-14 1997-11-19 株式会社日立製作所 ベクトル処理装置
JP2941817B2 (ja) * 1988-09-14 1999-08-30 株式会社日立製作所 ベクトル処理装置
JPH06274528A (ja) * 1993-03-18 1994-09-30 Fujitsu Ltd ベクトル演算処理装置
US5669013A (en) * 1993-10-05 1997-09-16 Fujitsu Limited System for transferring M elements X times and transferring N elements one time for an array that is X*M+N long responsive to vector type instructions

Patent Citations (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5226142A (en) * 1990-11-21 1993-07-06 Ross Technology, Inc. High performance register file with overlapping windows
WO1993001543A1 (fr) * 1991-07-08 1993-01-21 S-Mos Systems, Inc. Architecture de microprocesseur risc mettant en ×uvre divers ensembles de registres types
EP0543366A2 (fr) * 1991-11-20 1993-05-26 Hitachi, Ltd. Procédé et dispositif pour le traitement de données
US5392411A (en) * 1992-02-03 1995-02-21 Matsushita Electric Industrial Co., Ltd. Dual-array register file with overlapping window registers
EP0622732A1 (fr) * 1993-04-27 1994-11-02 Kabushiki Kaisha Toshiba Microprocesseur
WO1995032466A1 (fr) * 1994-05-19 1995-11-30 Vlsi Technology, Inc. Schema flexible d'affectation d'un registre

Also Published As

Publication number Publication date
JP3983857B2 (ja) 2007-09-26
CN1174353A (zh) 1998-02-25
DE19735348A1 (de) 1998-03-12
KR100236527B1 (ko) 1999-12-15
US5838984A (en) 1998-11-17
KR19980018072A (ko) 1998-06-05
FR2752965B1 (fr) 2004-09-24
TW345650B (en) 1998-11-21
DE19735348B4 (de) 2006-10-05
CN1117316C (zh) 2003-08-06
JPH10116268A (ja) 1998-05-06

Similar Documents

Publication Publication Date Title
FR2752965A1 (fr) Traitement de donnees multiples a une seule instruction utilisant des rangees multiples de registres vectoriels
FR2752630A1 (fr) Traitement de donnees multiples a une seule instruction dans un processeur de signaux multisupport
US6366998B1 (en) Reconfigurable functional units for implementing a hybrid VLIW-SIMD programming model
US8335812B2 (en) Methods and apparatus for efficient complex long multiplication and covariance matrix implementation
US7010668B2 (en) Methods and apparatus to support conditional execution in a VLIW-based array processor with subword execution
TWI329803B (en) Multi-level cache having overlapping congruence groups of associativity sets in different cache levels
US20030061473A1 (en) Methods and apparatus to dynamically reconfigure the instruction pipeline of an indirect very long instruction word scalable processor
CA2758366C (fr) Systeme, dispositif et methode pour les permutations a la volee des memoires vectorielles pour executer des operations intra- vectorielles
EP2261814A2 (fr) Processeur multifilière á traitement efficace pour des applications de dispositif de convergence
FR2598835A1 (fr) Cache de blocs de donnees empiles sur une puce de microprocesseur
JPH03138759A (ja) 信号プロセツサ
JP2001520775A (ja) 算術プロセッサ
US20110296431A1 (en) Method and apparatus for efficient helper thread state initialization using inter-thread register copy
US8977835B2 (en) Reversing processing order in half-pumped SIMD execution units to achieve K cycle issue-to-issue latency
FR2752629A1 (fr) Traitement de donnees multiples a une seule instruction avec operations scalaires/vectorielles combinees
US5473557A (en) Complex arithmetic processor and method
FR2678400A1 (fr) Processeur de protocole destine a l&#39;execution d&#39;un ensemble d&#39;instructions en un nombre reduit d&#39;operation.
EP0435718A1 (fr) Processeur à plusieurs unités microprogrammées avec mécanisme d&#39;exécution anticipée des instructions
JP2001525966A (ja) 命令発行速度を加速するプロセッサ・コントローラ
US6654870B1 (en) Methods and apparatus for establishing port priority functions in a VLIW processor
JP3534987B2 (ja) 情報処理装置
EP0082903B1 (fr) Unité de commande pouvant être connectée à deux mémoires de vitesses différentes
TW200302982A (en) Context execution in a pipelined computer processor
Le US 8,949,575 Β2

Legal Events

Date Code Title Description
PLFP Fee payment

Year of fee payment: 20