FR2752629A1 - Traitement de donnees multiples a une seule instruction avec operations scalaires/vectorielles combinees - Google Patents

Traitement de donnees multiples a une seule instruction avec operations scalaires/vectorielles combinees Download PDF

Info

Publication number
FR2752629A1
FR2752629A1 FR9710440A FR9710440A FR2752629A1 FR 2752629 A1 FR2752629 A1 FR 2752629A1 FR 9710440 A FR9710440 A FR 9710440A FR 9710440 A FR9710440 A FR 9710440A FR 2752629 A1 FR2752629 A1 FR 2752629A1
Authority
FR
France
Prior art keywords
register
vector
data
scalar
instruction
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
FR9710440A
Other languages
English (en)
Other versions
FR2752629B1 (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 FR2752629A1 publication Critical patent/FR2752629A1/fr
Application granted granted Critical
Publication of FR2752629B1 publication Critical patent/FR2752629B1/fr
Anticipated expiration legal-status Critical
Expired - Fee Related legal-status Critical Current

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F13/00—Interconnection of, or transfer of information or other signals between, memories, input/output devices or central processing units
    • 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
    • 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
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F17/00—Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G06F17/10—Complex mathematical operations
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F17/00—Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G06F17/10—Complex mathematical operations
    • G06F17/16—Matrix or vector computation, e.g. matrix-matrix or matrix-vector multiplication, matrix factorization
    • 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
    • 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/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
    • G06F9/30038—Instructions to perform operations on packed data, e.g. vector, tile or matrix operations using a mask
    • 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/38—Concurrent instruction execution, e.g. pipeline or look ahead
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
    • G06T1/00—General purpose image data processing
    • G06T1/20—Processor architectures; Processor configuration, e.g. pipelining
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04N—PICTORIAL COMMUNICATION, e.g. TELEVISION
    • H04N7/00—Television systems
    • H04N7/24—Systems for the transmission of television signals using pulse code modulation

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • Software Systems (AREA)
  • General Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • Mathematical Physics (AREA)
  • Computer Hardware Design (AREA)
  • Data Mining & Analysis (AREA)
  • Mathematical Optimization (AREA)
  • Mathematical Analysis (AREA)
  • Computational Mathematics (AREA)
  • Pure & Applied Mathematics (AREA)
  • Databases & Information Systems (AREA)
  • Algebra (AREA)
  • Computing Systems (AREA)
  • Signal Processing (AREA)
  • Multimedia (AREA)
  • Complex Calculations (AREA)
  • Advance Control (AREA)
  • Executing Machine-Instructions (AREA)

Abstract

L'invention concerne un processeur vectoriel. Selon l'invention, il comporte des registres scalaires pour les valeurs scalaires et un registre vectoriel pour des vecteurs comprenant des éléments de données multiples. Les opérations exécutées par le processeur vectoriel (120) traitent deux opérandes vectoriels ou plus pour déterminer une quantité vectorielle, en combinant un opérande scalaire et un opérande vectoriel pour déterminer une quantité vectorielle et en combinant deux opérandes scalaires ou plus pour déterminer une quantité scalaire. Les registres scalaires facilitent également la manipulation d'éléments individuels de données dans un registre vectoriel. L'invention s'applique notamment au traitement des 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 "; Demande de brevet U.S. No. INCONNU7, dossier du
mandataire No. M-4369 intitulé "Single-Instruction-
Multiple-Data Processing Using Multiple Banks of Vector Registers". 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 0010G 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 Interpretation l____ _ donnée int8 8 bits 8 bits complément à 2 entre -128 l_____ _ (octet) et 127 int9 9 bits 9 bits complément à 2 entre -256 l______ (octet 9) et 255 intl6 16 bits 16 bits complément à 2 entre (demi-mots) -32 768 et 32 767 int32 32 bits 32 bits complément à 2 entre l_____ _ (mot) - 2147483648 et 2147483647 flottement 32 bits 32 bits format précision unique l_____ _ (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 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 VP IDLE 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 VPRUN 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 maître 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 VPIDLE.
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 VP_IDLE et signale une demande d'interruption par une ligne directe au processeur 110. Le processeur vectoriel 120 reste à l'état VPIDLE 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 VP IDLE.
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 VPIDLE 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 contr1ô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" VD1CBR, 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 l'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 VPRUN. 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 VP _IDEL 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 VP IDLE. 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 reqistre 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 registre 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
0x00000000 Remise Etat Initial ARM7 0x00000004 Exception Instruction Non Définie ARM7 0x00000004 Exception Processeur Vectoriel Non Disponible 0x00000008 Interruption Logiciel ARM7 Ox0000000C Exception Seule Etape ARM7 OxOOOOOOOC Exception Point de Rupture Adresse Instruction ARM7 0x00000010 Exception Point de Rupture Adresse Donnée ARM7 OxO0000010 Exception Point de Rupture Adresse Donnée Incorrecte ARM7 Ox00000018 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
I I III I I IIII I i I I II I I I I I j I Cond 1 1!0IPIUINIWILJ Rn C Rn i CP#, décalage
j I I! I II I I..
I I1II I I
Les zones dans le format CDP 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 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 Reqistre 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 i5 10 5 0 I1 I I I Ill lllIll l t l l l l l Cond 11110 I PUINIWLI n CRn C décalage 1 I I I! i I I I I I,,, i Les zones aans 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. 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 charge/enregistrement. Rn Registre de base. CRn Registre source/destination coprocesseur. CP# Numéro coprocesseur. Les numéros suivants de coprocesseur sont couramment utilisés: 1111-antémémoire données ARM7 _______ 10111-registres é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
I I iII I III II I I I I1111 1 I I I 1 lCond 1llîllIQI OPc ILl CRn 1 Rd I CP? I C? 111 CRm
I I I II 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 signifie 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
L D C| I X i I I I I I I || I |,,II II I I T STC -Cond [1-l201 Ui0 Wi0PRn Opc 1 1n décalage I Ill l I T I, Syntaxe Assembleur STC{cond} pl5, 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
i'] I" 1]tII t i III I Ii I I I I t'f I I iI I
111 Il I I I t i l l.111111 IIIII 11111.
CDP ICond 111111101 00011 I I 0111 lo 0 I lII I II I I I II I
I I I1 1 I [
Syntaxe Assembleur CDP{cond} p7, 1, cO, cO, co INTVP{cond} o cond = {eq, ne, cs, cc, mi, pli, vs, vc, hi, ls, ge, lt, gt, le, al, 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 i^ 25 20 15 10 5 0 D ll l l l l,, ,,, -;r};T MCR l ' PI Rd I oi l OR I I I i j ii j i I I i I i I t I I r I IPRdIIj, E J 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, is, ge, it, gt, le, al, nv}, Rd = {rO,..r15}, P={0, 1}, ER = {0,..15} et RNAME se rapporte à la mnémonique du registrespé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>, comme 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 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
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.
nassaDoozd np aleTOGds 9FT TnP SaaqST5az SaT znod Sl nealqle ne eaigz aS snossep-ToD aeauom qsa iaTZooDaA znassaooid np saqsTfaz sap aTqde-Todo; le -saAaasga quos <Z::ú>uuo anb T!Use 9:L sI!q saU Àsaaqsiba sap sqaasu-ei sal inod ioTZOqDGA znassaoozd np GlqsTal ap ozuilnu np UOTqPqDGJJPl inod ú *ZC *úUOTIOGS V 91 laGIGl as '<oú> WUD: <O:I>U-dD iaTzoZoaA jnassaooid np aG!IeDOs/elUT!Ods 91TIiin,p aisTbea np asspd LgW- ap PU as/Tab aG Àa TA ISe puo3 TS anb aeanoexa qsG,u uoTqonrasuI avaD uoTdTizDsaG
* (SDA
no OdS "'aT) aanqoaqTqoae,I aed aeT;Toeds alsT6ai np enbTuomeuw QI V aloddt es SWVNU qe { I.o'''o}=wzo {SIo..0O})=U-1,{gi.. '0T}=pU '{AU 'le 'aI '1f5 ' ab 'SI 'lq 'OA 'SA 'd 'TI 'OZ 'so 'au 'ba} = puoo no ZxvNup { PuQO} JlAU OUffNl'P1 {puoo}gA4 o0urdo.uio'pu'I'Ld {pUOo}D%5 analquiassaxequXS &-jj j j j I j j j
II1 I I I 11111 I
I z Izz p II I I. I l 0 z 1 0 I1z l I I lI l ) j' TjI 111 jO p j' U s iw 1 j 010 i 1 Ol'jl'jl'jpuoDi w0W iI i I I Ii' i I i i I i I I I I I I IAa] 4leuliol TalTODaA lnssaooid np l9sspd aAiN CRM<3:0> CRn<1:0≥00 CRn<l:0≥01 CRn<l:0≥10 CRn<l:0≥111
0000 SRO SR16 SPO0 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 RASRll
1100 SR12 SR28 SPO RASR12
1101 SR13 SR29 SPO0 RASR13
1110 SR14 SR30 SPO0 RASR14
1111 SR15 SR31 SPO0 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 5 0 5 0
MCR iCond 111H.i01 l10 ll IPI Rd I 01o11 ERI I l 'I l I I f! I t 1, f ' ' '' tI I 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, it, 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 - 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 UERll PER1l
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.
S IESV 3OdS I 91ESStlt __________ 0d5s Ous Gild5 OUI úIHSVU 0cOs Oú6S IS O 011 ú IdS Ou a cs 6 ZUS uu TOITE zI$SY_ odS 8ZuS ZTIS - 0011 IIHtSV Ods L ZUS I1 Ius OIHSV o0s 9zus 0OIS 0101 6USVM oas szuS 6US 1001 8USV: 0OdS zuS 8uS 0001 LuS% 0 ciS úZUS LUS 1110 9US 'a 0 S ZZUS 9us 0t110 _ S____ osIS 10ESsus 1010 __S____ OdS 0S 0S t'S 0010 _ SIe_ 0S 61HS _S _1100 zS U o0s 81IS ZuS 0100 __S_ _ 0dS LIUS lus 1000 oUsVU ' o0s 91ES oES 0000 111=<0:l>uaD 01=<O:T>UUD 10=<0: I>UD 00=<0:I>uuD <0: >w9I Àsnossap- To a.auoul sa IeTzOloeA anasseoozd np sGasT6ba sep aFTqdeiBodoi ie seaAas5a quos <E::>uaI anb TsuT1 S:L sq7q Saq <o: E>ur$: <0: I>UUD IaTloqoaA znassaood np G=?jPos/GygDTds gTiTqn,p Gais!6ai npassed LtNV GP PU GsasTBGl aG aSTpA isa puoD Is enb asanoaxe sa,u uoTqonarsuT aaD UoTqdT20saa (SDA no oas ''aT) flnDaMsTqI,I.d aoT3FToeds orsaianp anbTuowaum -E i aioddL as aNvm a { Io-'''oo})=wD { i o' '0o})=u=0 '{gi.'' '0o}=pu '{AU '1T 'a- '-B 'jI eB 'SI 'Tq 'DoA 'SA 'Id '7l 'oD 'so 'eu 'bal} = puoo no NVNf*'PU {pUOD} anaU 0 urD * U * pu ' I Ld {puoD}s D anaIquess s exQquAs wuO Pu OUD I11 010 Iol!iîI Puo:I ww ] i[ iiIIl I
ii I I! III I,I I I [I ' I It I -
0 S 0I S Q SZ OE
-4eewao,q TaTlOqDaA anassaDooa ?aesspa aAJW 6z9zG/zz t7go 69g9gg Exception Processeur vectoriel indisponible PFTCH Pré-extraction Format
25 20 15 10 5
o0
LDC 7 I 1 IIII I I
STC ICond 1l1[10PJUJ0JWI17 Rn | 0010 L 1111 décalage 7
" I I 77 I 7
Syntaxe Assembleur LDC{cond} p15, 2, <Adresse> PFTCH{cond} <Adresse> o cond = { eq, he, es, 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
o0 --I I I I Il I l l I I I I I I I I I I II I I itl I I I I I I I I I I I I 1 CDP Cond JlJ11Oij0 0000 1 0111 1 0J I I! l _ I _ l
II I I I I
Syntaxe Assembleur CDP{cond} p7, 0 Co, 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
o i i i i tII I I I I I II i i i I I M R C I t I i X i | I i I l |
I II I
MCR ICond I1!1110 000 i11 101 Rd I 011 i IliER * Ir I I,
I I
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, ai, 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 PER1 PVR Registre 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.
O 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é-
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 ______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
_ I___ 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'enregistrement ne soit exécutée.
Bit Mnémonique Description
O 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
UER0 VPSTATE Drapeau Etat Processeur Vectoriel. Bit , quand il est établi, indique que le processeur vectoriel est à l'état VP_RUN, exécutant des instructions. Si il est effacé, cela indique que le processeur vectoriel est à l'état VPIDLE 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 Registre Remise à l'état initial
CTR 0
PVR TBD
VIMSK 0
AIABR AIABR<O≥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 LargeurGrandeur (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ôle 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≥VR2i<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 VAClH, 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.
D neaIqel ne sgaauow quos snld ap s;cq Z ae GLTZads a-FT-Frn,p saSTBaT qdas-xTa auTnoT-snos ap ino4ea ap q laddep suo!onzsuT sa% ied SSTTsTFn 1uos sF - a aUaIUT Zno4al ap sassaeipe,p aiTd aun quamoo; ' IUSVU ? 0OSVU saladde 'aleTOeds qyIyRnp saGZsi6Tb aZ/aS 'a/oulaul Pl suep quGaWaGoaGp sa=ISTeau0 no aJiowe0u PT Zed quGaZWDGZTp saBxPTpe a1qa luaAnDd au Tnb aieToads 9aTITqn,p sGST.56G úú eX IIÀ *UGmUIaATDadsai aoxq a-r;a 0ouI-TuIaGa-'(qaqDoo,a 6.aoo anod 91 no ZE '9 anb puei6 Tssne ar;a qnad squwauaa sap aiqmou al 9 o t9DoA apow ua,nb asITIIn 4sa,u 'IIDVA:H1DVA axeTd Pq Sl'- 8=T inod <0:1ú>[8 -Y]%IIVA:<0:1ú>[$-!]HIO'A a L'0=F znod <O:IE> []T0IovA:<0:1ú>[E]H0oVA <O:ú9>[E]DVA $o0 Iú' 91=T inod [91- 7T]rIVA :<0: l>[91-T]HIDVA LaS '0=T anod <O:gl>[T1JODVA:<0:SI> [T]H0O$A <O:lú>[FTIVA qou-Twac 9'ZúE=F anoct <O:L>[ZE-!]IloiA :<O:L> [ZE-T]HIDVA a TE'' 0=T anod <O: L> [ T]00VA:<0: L> [ T]HODA <0:9I> []D3VA a;Do ú9--ZE=T inod <0:8>[ú-T!]rIOVA :<0:8>[Z-T]HIDVA;a Tú''0=T nod <0:8>[F] 0yA <8>[ET]HODA <0: L > [ F]DVA 6 a0DO quaWal a DVA am2o08nbTbo5 anAznapueag Iato;,aA nael nDDv n eol: E- nealqpl
Tableau C.4: Registres d'Utilité Spéciale.
Numéro Mnémonique Description
SP0 VCSR Reqistre Vectoriel Contrôle et Etat SPA VPC Compteur Proqramme Vectoriel SP2 VEPC Compteur Programme Exception Vectoriel SP3 VISCR Reqistre Source Interruption Vectoriel SP4 VIINS Registre Instruction Interruption Vectoriel SP5 VCR1 Registre Compte Vectoriel 1 SP6 VCR2 Registre Compte Vectoriel 2 SP7 VCR3 Registre Compte Vectoriel 3 SP8 VGMR0 Reqistre Masque Global Vectoriel 0 SP9 VGMR1 Reqistre Masque Global Vectoriel 1 SP10i VOR0O 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 ____Vectoriel SP14 VMMR0 Reqistre Masque Déplacement Vectoriel 0 SP15 V>MR1 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 VP _IDLE. 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 Registres 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 ReQistre 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 VOR1 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. O 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 VMMRQ 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 VR.d<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, VGMRl<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 SR0 tous les autre Etat Remise l'tat initial 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 registre 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 Registre 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 signe) 16 bits 16 bits enregistrer 16 bits (enregistrer 16 bits sans signe ou en complément à deux) 32 bits 32 bits enregistrer 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 à 0 à 7. Si tous les bits dans un groupe de quatre dans VGMR0 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 0xOO000018 Exception Seule Etape Processeur Vectoriel 0x00000018 Exception Débordement Pile Adresses Retour ___ _ Processeur Vectoriel 0x00000018 Exception Sous-débordement Pile Adresses Retour Processeur Vectoriel Ox00000018 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 0xOO000018 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éarranqer 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 B)
VCOR OU Complément - (-A | B) VORC Complément OU - (A I - B)
VNOR NON-OU - - (A | 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écalage Loqique à Gauche VLSR Décalage 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écalage 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écalaqe 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, int16 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 Siqne de (-1, 0, 1) VEXTSGN2 Extraction Signe de (-1, 1) VEXTSGN3 Extraction Siqne 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 movenne de deux Eléments Adiacents 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écalage Elément à Gauche de 1 VESR Décalaqe 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ébrassage à 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 Enregistrement VSTD Enregistrement Double VSTQ Enregistrement Quad VSTCB Enregistrement à Tampon Circulaire VSTR Enregistrement Ordre Elément Inverse VTSWS Enregistrement 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 Charge 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] = O. 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 | 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 Siqnification 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 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 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 registre destination/source SRb <4:0> Numéro registre base scalaire SRi <4:0> Numéro registre 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 demi-mot i 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 Mnmonique 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 <0> est établi. Tableau E.16: Opérations Charge 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 O 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érieurs dans 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 9infé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.h Enregistrer grandeur demi-mot dans 16 bits
1 10 non défini -
1 il 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 <O> est effacé.
Tableau E.18: opérations d'Enregistrement Vectoriel
REAR en mode VEC32.
D:ST Mnémonique Siqnification 0 00.4 Enregistrer 4 octets du registre dans la mémoire. Tous les neuvièmes bits des 4 octets 9 dans
le reqistre sont ignorés.
0 01.8 Enregistrer 8 octets du registre dans la mémoire. Tous les neuvièmes bits des 8 octets 9 dans
le reqistre sont iqnoré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.
0 11i.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 <0> 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
registre 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 iqnorés.
1 0 00 non défini 1 0 01 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 Siqnification 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
codaqe 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 registre 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.
Tableau E.21: Format RRRM5 Zone Signification Op<4:0> Code opération 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. S Registre Rb scalaire. Quand il est établi
indique que Rb<4:0> est un registre scalaire.
Quand il est effacé, Rb<4:0> est un registre vectoriel. DS<l: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) M Modificateur pour les bits D:S. Voir le Tableau
de codage de D:S:M ci-dessous.
Rd<4:0> Numéro registre destination D. Ra<4:0> Numéro reqistre source A. Rb<4:0> ou Numéro registre source B sur un immédiat de
IM5<4:0> 5 bits, déterminé par le codage D:S:M.
L'immédiat de 5 bits est interprété comme un
nombre sans siqne.
Les bits 19:15 sont réservés et doivent être des zéros pour assurer la compatibilité avec des extensions futures dans l'architecture. Tous les opérandes de registre vectoriel se rapportent à la rangée courante (qui peut être soit la rangée 0, soit la rangée 1), à moins qu'autre chose ne soit indiqué. Le Tableau E.22 donne la liste des codages D:S:M quand DS<l:0>
est 00, 01 ou 10.
Tableau E.22: codages D:S:M de RRRM5 pour DS qui n'est pas éqal à 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 à 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 ____ 000... a(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<l: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 reqistre destination D Rd<4:0> Numéro registre 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 0 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 Signification 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<l:0> pour être 11.
DS<l: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 charqé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> w mot (32 bits) Rd<31:0>:= Imm<18> étendu au signe 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.
Tableau E.28: Format RRRM9 Zone Siqnification Opc<5:0> Code opération 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. S Registre scalaire Rb. Quand il est établi, Rd<4:0> est un registre scalaire. Quand il est effacé, Rd<4:0> désigne un registre vectoriel 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) M Modificateur pour les bits D:S. Voir le Tableau
de codage D:S:M ci-dessous.
Rd<4:0> Numéro reqistre destination.
Ra<4:0> Numéro registre source A. Rd<4:0> ou Numéro registre source B ou immédiat à 5 bits,
IM5<4:0O> déterminé par le codage D:S:M.
IM9<3:0> Avec IM5<4:0>, produit un immédiat à 9 bits,
déterminé par le codage D:S:M.
Les bits 19:15 sont réservés quand le codage D:S:M ne spécifie pas un opérande immédiat et doivent être des zéros
* pour assurer une future compatibilité.
Tous les opérandes de registre vectoriel se rapportent à la rangée courante (qui pourrait être soit la rangée O ou la rangée 1) à moins qu'autre chose ne soit indiqué. Les codages D:S:M sont identiques à ceux montrés aux Tableaux E.22 et E.23 pour le format RRRM5, à l'exception que les valeurs immédiates extraites de la zone immédiate dépendent
du codage DS<1:0>, comme le montre le Tableau E.29.
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 | 010 I 011 | 110 | 111 l
DS 00 01 10 11
5. Pour les formats RRRM5 et RRRM9, les codages suivants sont utilisés pour les types de données flottantes: D:S:M 001 100 n/a 101 n/a
DS 11
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 : c]o $ RRRM5 10 110001 DS S |Rd Ra Rb 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 V<-V V V<-V @ 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;1<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
5 20 '. 10 ô O
RRRR 0 1 0 01 00 S DS 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 supportes
S 1 VR SR
DS | int8 (b) int9 (b9) int16 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] I| 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]; } VADACL Addition et accumulation valeur basse Format 25 20 0 i o ri I M | d|Ra Rb IM5 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 su pportés
D:S:M V<-V @ V | V<-V @ S | V<-V @ I S<S @ S S<-S @ I
I DS int8 (b) int9 (b9) intl6 (h) int32 (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] Il 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 )0 25 20:3)0 $ 0Hi RRRM9 1 1 0000 00 DS DS 119 Rd Ra Rb/I5| 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 D:S:M V<-V @ V t V<-V @ S I V<-V @ I | S<-S @ S} S<-S @ IT DS int8 (B) int9 (b9) intl6 (h) int32 (w) 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
S 20 ' 15 10 ' O
RRRM5 010 10100 DS S Rd Ra 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 o B - -=2... A, A1 A0 DI,-,D..-1... D2 Dl Do, Opération pour (i=0;i<NumElem -1;i++){ Rd[i]=Ra[i]+Ra[i+1]; } Rd[NumElem-1]=Ra[NumElem-1]+{VRb[0] Il 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 'O 15 10 5 0
RRR.M9 1 1 011000 D|S DS 9 RJ RHa. Rb/lM.' | 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 suDportés 1 D:S:M V<-V @ V | V<-V @ S i V<-V @ I | S<-S @ S | S<- S @ I DS int8 (b) int9 (b9) intl6 (h) int32 2w I
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++){ Bopti]={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 rt 2 _:.t IQ _ o RRRM9 1 111000 1S1Q Rd Ra b/IM 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 suPportés D:S:M V<-V @ V V<-VI< S T <- s I I DS int8 (b) int9 (b9) intl6 (h) int32 (w) f
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 Ij 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 ' 5 C
RRRR 0111111 10 11100 IDS 1il11 111 Mi1iiii
RRJR 0 1 0 0110 RIDS
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 i DS int8 (b) int9 (b9) intl6 (h) int32 (w)
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=0) ou vers la droite à une position de un bit avec extension de signe (si R=l). 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"l; autrement VACOH[i]:VACOL[i]= VACOH[i]:VACOL[i] "1; Exception Débordement. VASL Décalage Arithmétique â Gauche Format 2 iD0 RERRU5 i I Il bi DIS'sS | Rd Ra SRbIM5I
01011 0101
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 supportés D:S:M V<-V @ S | V<-V @ I S<-S @ S IS<-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écalaae Arithmétique à Droite Format
32 20 15 10
Ioioi "," pl ' "il"'tITTi'"' I' RRR|M5 TOI | 01Y lDSH I S Rd I Ra SRb/IM5 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 supportés D:S:M | V<-V @ S | V<-V @ I S<-S @ S| S<-S @ I DS l int8 (b) 1 int9 (b9) intl6 (h)i 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
20 1 5!0 5 0
RRRM5 1 1 1O iDS1DSS M I Rd | Ra 1 Rb 1 Syntaxe Assembleur VASS3.dt VRd, VRa, VRb VASS3.dt VRd, VRa, SRb VASS3.dt SRd, SRa, SRb o dt = {b, b9, h, w} Modes suportés
D:S:M V<-V @ VIV<-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 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 Soustraetion Format 25 2I0 15 I 5 o II DSDS Rd Ra tRbfM5 RRRM9 001000 Ds 9 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 H V<-V @ V | V<-V @ S I V<-V @ I | S<-S @ S | S<-S @ I
DS H 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=0;i<NumElem && EMASK[i];i++){ Bop[i]={VRb[i] Il SRb I| sex(IMM<8:0>)} Rd[i]= 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 W RRRM5 |11f 001 SSDJS IDSk T 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++){ Bopti]={VRb[i] Il SRb Il sex(IMM<8:0>)} Rd[i]=(Ra[i]+Bop[i]//2; } Exception Aucune. VAVGH Moyenne deux Eléments Adjacents Format RRRM5 Jo1 , 1 1l oi RI SRDST| I I a I i 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
D:S:M V<-V @ V V<-V @ S
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 dedonnée flottante, le mode d'arrondissement est
spécifié dans VCSR<RMODE>.
Rb Ra IBo 0 iiS.. A-) AIA
IDU-1 D..2D2 D.
Opération pour (i=0;i<NumElem -1;i++) { Rd[i]=(Ra[i]+Rafi+l])//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 RRRM5 ic1| 1 D 'id VRa HTli ilib 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) 1int9 (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
(Dnl) est non défini.
Ra
1 A..,1. 1A2 1 AI A0
Rb\ Ba-1 D D1 D Opération 1 Dg,. 1DO2.2... |A Dl Dol Opération pour (i=O;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 O 15 10 5 0
REAR 1E11 I i 11| Fck lAI SRb Si| REIj.25 YO 15 10 5 0 REAI 10|0|1| 01 110 | FC |AI7m5m |SRb Imm|
0 0 1 11[ 1 <7:5> <4:0>
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.
VCAND ET Complément Format _ 30 25 20 10 o RRRM9 1I 1111 00 D SDSS IM9 Rd Ra Rb/'M5 Syntaxe Assembleur VCAND.dt VRd, VRa, VRb VCAND.dt VRd, VRa, SRb VCAND.dt VRd, VRa, #IMM VCAND.dt SRd, SRa, SRb VCAND.dt SRd, SRa, #IMM o dt = {b, b9, h, w}. Noter que.w et .f
spécifient la même opération.
Modes suportés D:S:MM V<-V @ V V<-v @ S v<-v @ I S<-S @ S S S<- S @ I DS!int8 (b) int9 (b9) intl6 (h) int32 (w)
Description
Complément ET logique des opérandes Ra et Rb/immédiats et retour du 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. VCBARR Barrière Conditionnelle Format 25 20 i 10 5 0 C l l1 0100o. I" I ' I | 11 ' i ii i | 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> Siqnification 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
5 1 0 10
CT 101 000 Cond dage 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 == VCSRESO,GT,EQ,LT]) I (Cond == un)) VPC = VPC + sex(offset<22:0>*4); autrement VPC = VPC + 4; Exception
Adresse instruction incorrecte.
VCBRI Branchement Conditionnel Indirect Format
5 20 1 I 0
CT IO C icond! ' 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]) | (Cond == un)) VPC = SRb<31:2> :b'00 autrement VPC = VPC + 4; Exception
Adresse instruction incorrecte.
VCCS Commutateur Contexte Conditionnel Format
3 " 20 15 10 $S 0- X
C o 11101O 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>+l; VPC=VPC + sex(décalage<22:0>*4); } } autrement VPC=VPC+4 Exception
Débordement pile adresses retour.
VCHGCR Registre Contrôle Changement Format
0 20 10 5
CT 1'1 10011 | Mo de C1 I" i I I I I I 1 t'"1Iiit I IIII Syntaxe Assembleur VCHGCR Mode
Description
Cette instruction change le mode de
fonctionnement du processeur vectoriel.
Chaque bit en Mode spécifie ce gui 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 c-r C1o1, d111 I ICODEIIT77 lfoI oii jo o Syntaxe Assembleur VCINT.cond #ICODE 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[SO,GT,EQ,LT]) I (Cond == un)) VISRC<vip≥ 1; VIINS = [VCINT.cond #ICODE instruction];
VEPC =VPC;
si (VIMSK<vie> == 1)interruption signal ARM7;
VPSTATE = VP IDLE
} autrement VPC = VPC + 4; Exception
Interruption VCINT.
VCJOIN Jonction Conditionnelle avec Tâche ARM7 Format
15 0 S
CT 1 l o, 1 0 Condt|i C d1 vaa <. ge 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[SO, GT,EQ,LT]) I (Cond == un)) VISRC<vjp≥ - 1; VIINS = [VCJOIN.cond #Décalage instruction];
VEPC = VPC;
si (VIMSK<vje> == 1)interruption signal ARM7;
VPSTATE = VPIDLE
) autrement VPC = VPC + 4; Exception
Interruption VCJOIN.
VCJSR Saut Conditionnel à Sous-Routine Format CT|l|oOl018 loIl 1 11 1 1 5 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
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 de retour.
VCJSRI Saut Conditionnel à Sous-Routine Indirect Format "l 20) 15 105 CT 1 0 I1 dll Cl 1j - l 1 1001 1 Clonid _ _. I 1 1SRb 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]) | (Cond == un)){ si (VSP<4:0> 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 = SRb<31:2>:b'00; } }autrement VPC = VPC + 4ç Exception
Débordement pile adresses de retour.
VCMOV Déplacement Conditionnel Format
022 1 10 5 0
fl!9 C t Rb/1M5 RRRM9* 111i1 o lSo oo D1s1Ds M9 I RdJ CoIDi RMW 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 | 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<l:0≥00 ID<l: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; l<NumElem;i++) Rd[i]={Rb[i] Il 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 Format RRRjM9ae oI1 '01t0k001 IDS H $| Rdi Con' d ID RbIM5 Syntaxe Assembleur VCMOVM.dt Rd, Rb, cond VCMOVM.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é par l'opérande
immédiat à 9 bits.
Modes suDportés D:S:M V<-V I V<- 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]) | (Cond == un)) pour (i=0; l<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 Masque Format RRRM9UI" I01MO 11010 DS Cod 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 I 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=l) 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;l<NumElem;i++){ Bop[i]={Rb[i] |l 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 |0|1|1|0| 10ô 00 5d IRL RRRR,,MI I sk1 1'"'11 I" I' '" t Syntaxe Assembleur VCNTLZ. dt VRd, VRb VCNTLZ.dt SRd, SRb
o dt = {b; b9, h, w}.
Modes supportés S V<-VS<-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;1<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 20 1_ Io $ Iii ai 1 11h /15 RRRM9 1 II 1lI l S1 DS H 9 Rd Ra Rb/M5 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 @ L 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;l<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 3C'. Hf2S 20 15 10 5 ' O I _ I I I I I I I I'1 I I I I I I 1 1 1 1i I I i i i i I I I1 Clr 00 Condl 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
2 15 10 5 0
IllllT1 i_ lll i_-Rd_ | Rb Syntaxe Assembleur VCVTB9. md VRd, VRb VCVTB9.md SRd, SRb o md = {bb9, b9h, hb9} Modes supportés I s I' V<-V I s<-s I L MDI 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<1:0≥=0){ //bb9 pour conversion d'octet à octet 9 VRd = VRb; VRd<9i+8≥VRb<9i+7>,i=0 à 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 I II 10 MI 0i PRRRM5 011I0 01011 il1SI I'1H Rd Ra SRb/LM5 Syntaxe Assembleur VCVTFF VRd, VRa, SRb VCVTFF VRd, VRa, #IMM VCVTFF SRd, SRa, SRb VCVTFF SRd, SRa, #IMM Modes supportés D:S:M Iv <- V, S V <- V, Ils <- S, s S <- S, Il
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;1<NumElem;i++){ Rd[i]=convertir au format <32-grandeur_Y.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 RRKMe 5 15 10, o RRRM5 0i 1o| 10o Ill i}1 Rd Rbi Syntaxe Assembleur VCVTIF VRd, VRb VCVTIF VRd, SRb VCVTIF SRd, SRb Modes supportés
D:S:M 1 V <- V 1 V <- 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;l<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.
VDiCBR Décrément VCR1 et Branchement Conditionnel Format r30 '5 20 15 1o 0
1114T [-î îî11111511M011111 II
CT 10001 Cond aae 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 Décrément VCR2 et Branchement Conditionnel Format 302e 20 1 I I IIi'T- IiIoil12 l1 I II 11 1' CT1 i |01 ' |ConI I I I l Syntaxe Assembleur VD2CBR.cond #Décalage
o cond = {un, it, 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]) I (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
2 20 15 10 5 0
CT _ O001111 IConid |î dage 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]) I (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 s25 20 l 10 $ o R. RRMS llol IoI DISIdDjSidH' J. IRd1 Ra J SRb/[IMW 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 su-portés [ D:S:M T V<-V @ Sir V<-V @ I |s<-S e S |S<-S@If DS int8 (b) int9 (b9 intl6 (h) int32 (w)
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. Cette instruction utilise le mode tronqué (arrondissement vers zéro) en tant que mode d'arrondissement. Opération N = {SRb % 32 |I 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
R.RR_52 1 0
In RRRM5 lo|l|o| t [IS [i t |] I [ I] I I i] RJR.M5S 11o Rd0 Ra!S1 RdI Syntaxe Assembleur VDIV2N.f VRd, VRa, SRb VDIV2N.f VRd, VRa, #IMM VDIV2N.f SRd, SRa, SRb VDIV2N.f SRd, SRa, #IMM Modes supportés
D:S:M | V<-V @ S V<-V @ I | S<-S @ S S<-S @ I
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.
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
0 M 2 " 10 - 0
RRRR 1I 11O010 S DS I I
Syntaxe Assembleur VDIVI.ds VRb VDIVI.ds SRb o ds = {b, b9, h, w} Modes supportés S VRb SRb 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] |I 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 Incomplète Format RRRR1|20 i II | I 0 Syntaxe Assembleur VDIVS.ds VRb VDIVS.ds SRb o ds = {b, b9, h, w} Modes supportés S N VRb I SRb I DS | int8 (b) lint9 (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 Décalage Elément vers la Gauche de 1 Format :n 2 10 5 0 RRPRR ZI 0011 Ill1DSI SRc VRd s R[ 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 i I SRb DS int8 (b) int9 (b9) intl6 (h) int32 w7 |
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.
VPRa SRb & |AZ... |A2 A1 o A0 SRc VR C 1 -l | D.-2 I** D2 Do] Opération VRd[0] = SRb; pour (i=l;i<NumElem-1;i++) VRd[i]=VRa[i-l]; 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 3o 20!5 lo.O o RRRR 0 II 0 11 DSSRc VRd V Ra b 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 I SRb DS int8 (b int9 (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 | AA.. 1 An.2... A2 A1 AI VRd.D., | Dn2... D2 Dl Do SRcc Opération SRc = VRa[O]; 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
2! 10 $
RRRM9 X0001XDS MSRd | a 1SRbi.|5 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 I D:S:M I I 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 (1.- 1i Format 2.5 15 0 | 0i
RRR.R 01101(1 101 10 IS1DR5R
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 I DS int8(b) int9(b9) 1intl6(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)?-1:1; } Exception Aucune. VEXTSGN3 Extraire Signe de (1. 0. -1) Format
32 0 O 200-
1 11111 11 II I iI lIN 111i11 R.RRR.01111101 $0d il. Rd Ra Syntaxe Assembleur VEXTSGN3.dt VRd,VRa VEXTSGN3.dt SRd,SRa
o dt = {b,b9,h,w}.
Modes supportés - s IV<-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é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 10. 0
RRRM9 i 100000 DSSH IM9 |VRd SRa SRb/M1 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
[ D:S:M _ _ V<-S _ V<-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 Il 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
" 20 15 10 5 0
LiI I I I I I i RL î REAR 10001 CI Rd SRb SiÀ Syntaxe Assembleur VL.lt Rd,SRb, SRi VL.lt Rd,SRb,#IMM VL. lt Rd.SRb+,SRi VL.lt Rd,SRb+,#IMM o lt = {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 Il 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] bs9 SRd<8:0> = sex 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 RE3R 90j 0[ dCA SRb | SIi 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, Sbz9, Bs9, h, w, 4, 8, 16, 32, 64}, Rd = {VRd, VRAd, SRd}.I1 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+l 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+l; 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; - NIA> NI.- V annb TSuTV INSM3ONZDN3N0 < V. IGJo ug
NSK.DNSHNOD - NIJZ> V. > NSN3DONZNNOD
: puaq s uo euRwOD auuoTjouo; UOTfonlSUTI enb anod aUeATnS UOTqTPUOD el zaanssie -ToP inauwu6boid al squawUalg,p enbs-w al asd Daoa;;e sed 4sa,u uoTonflsuT $;Do uoTquenuiibozd ap aqom -guBTIU uou sGoDe 'a oaaoDUT aGauuop ossGIpV
SUOT daox.
Iú. O=T'[T+ZE+V.:qoanaPueb+T+Ze+Va c(NI4 <T + ZE + V. &(NI.<T+Z++V,)]. 3SX xas= <T6:8+T6>PIIA Iú. O=T'[T+V.:qD anapuva6-T + Va (NI.<T+V. )]aLÀX xas= <T6:8+T6>POA A9' le 0 =OT 'T++V: qoanapuB-Tl+YVa &(NI.<T+ VS)H]SLX xas = <6:8+T6>PdA 3E' Sli ? O=T'[T+va: qoanapue;6-T+fc (NI.<T+,g)] SX xas = <T6:8+T6>PdA 91' L e O=T' [T+Va :qoanapue6- T+'.&(NI.<T+)],XE xas = <T6:8+T6>PdA 8'
ú ? O=T'[T+vs.
:qoanapue6-T+,fae(NI.<T+V.)] XE xs = <T6:8+T6>PdA _' [vi.] aoM = <O:Iú> PuS M. [V.].'IVH = <O: I>Pus -' [VI]ZLAS xas = <0:8>PuS 6sq [vs]Lsg xaz = <0:8>PS 6zq abaqo UOqeTaao l ri SSI VLD Charge Double Format
'5 'O 0 1 5 10 17 0
REAR 1010 0! 00010BLCA Rd SRb SRi
' 20 15 10 0
REAM 10 01( o0[0o FB|LT DIAMI IRd SRb IMM 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 + {SRilI sex(IMM<7:0>)"}; si (A==l) 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+ l<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+l<9i+8:9i> = sex BYTE[(EA+4+i],i=0 à 3 8 VRd<9i+8:9i> = sex BYTE[(EA+i],i=0 à 7 VRd+l<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=O à 31 VRd+l<9i+8:9i> = sex BYTE[(EA+32+i],i=0 à 31 64 VROd<9i+8:9i> = sex BYTE[(EA+i],i=0 à 31 VRld+1<9i+8:9i> = sex BYTE[(EA+32+i],i=0 à 31 VROd+1<9i+8:9i> = sex BYTE[(EA+64+i],i=0 à 31 VRld+l<9i+8:9i> = 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 20 I0 lO' i 0I||ltjI825 1 1 I IMM' FD |' Rd IM 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 8 SRd<7;0≥IMM<7:0> VRd = 32 lments int8 i8 SRd<7;0≥IMM<7:0> VRd = 32 éléments int8 i9 SRd<8;0≥IMM<8:O> 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. VLQ Charge Ouad Format
D 20 15 10 5 0
I ii S 1 1111 | F100 F|B|LT Rd SRb Syntaxe Assembleur VLQ.l t 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+ {SRiI sex(IMM<7:0>)}; si (A==l) 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=O à 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=0 à 31 VROd+l<9i+8:9i> = sex BYTE[(EA+64+i],i=0 à 31 VRld+l<9i+ 8:9i> = sex BYTE[(EA+96+i],i=0 à 31 VROd+2<9i+8:9i> = sex BYTE[(EA+128+ i],i=0 à 31 VRId+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
25 20 15 10 5 0
I I F.. i I I_.
Syntaxe Assembleur VLR.lt RdSRb, SRiSP VLR.lt Rd,SRb,#IMM 101(101 0,,o,, -,!+
2 0 1 I
REAI 010 0 Rd SRb kt Syntaxe Assembleur VLR.lt Rd.SRb+,SRi VLR.lt Rd,SRb+,#IMM VLR.lit Rd. SRb+, SRi VLR.lit Rd, SRb+, #IMM o it = { 4,8,16,32,64}, Rd={VRd, VRAd}.I1 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=O à 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 20 t 5 0 RRRM5 10 00001 DS RSa RdI bSR/IlI5 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 I 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 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=0;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écalaae Logique A Droite Format ojil "' RPRlM50 00 D Rd Ra RRRMS 11 l j D|SDS |Rd Ra |Rb/lM5 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}.
Modes supportés | D:S:M s | V<-V @ S V<-V @ I S<-S @ S S<- S @ I |DS int8(b) 1 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 $ 0
I II l I!I I 'i 1 1 "Ii f R.EkR 00ojo bi0 011' JOB LIjC Rd SRb Ski
20 015) 5
REAI 0 1 O1l0 OIB LT CIC AIMMRd SRb I MM jJJJJJj)j <7i>,, <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+i 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 II sex(IMM <7:0>)}; Si (A==l) SRb = EA: Grandeurbloc = {411811161132): Chevauchement = SRb+1<31:0>; pour (i=0;i <VECSIZE/Grandeur bloc;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
25 _0 15 10 0
RRRM9 1 101 0 10D 9 D IRbIM5a 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<-V @ S V<-V @ I I S<-S @ S S<-S @ I
DS I 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] Il 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
20 15 10 0
RM9 3 tll OIlI FIS|D I 119 1 |I I II It c| E RRRM9 1'l' 0010 10 tDs IM9 Ra Rb/IM5 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 I V<-V @ V V<-V @ S V<-V @ I IS<-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 à 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] II SRbll 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
2.20 O!5 5 0
RRRM9 1 DS M9 Rd Ra Rb 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 V<-V @ V V<-V @ S I V<-V @ I I S<-S @ S S<-S @ I
DS Iint8(b) intl6(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 ' 20 15 o S I lJ Ss T 11il 5 12 it RRRR 011 S01DS Rc R 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 VR SR
DS 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] 1I 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[il]}; } Exception Aucune. VMADL Multiplier Et Ajouter Valeur Basse Format to 5 20! RRRR 1011,|0o 010 0, S S Rc 0 R Syntaxe Assembleur VMADL.dt VRc,VRd,VRa,VRb VMADL. dt SRc,SRd,SRa,SRb
o dt = {b,h,w,f}.
Modes supportés IS I VR I SR I DS int8(b) flottant (f) int16 (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 précision. Opération pour (i=0;i<NumElem &&EMASK[i];i++){ Aop [i] = {VRafi] Il SRa}; Bop [i] = {VRb[i] Il SRb}; Cop [i] = {VRc[i] Il 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[i] = Lo[i]; } Exception Débordement, opérande point flottant incorrect. VMAS Multiplier Et Soustraire De L'Accumulateur Format 25 205. i o lii I iII I ii ji RRRM9 Il 1101110 SI DSH 1M. b151 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 IV<-V @ V V<-V @ S I V<-V @ I 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
l'accumulateur vectoriel.
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, 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
25 20 15 I 1
RRRM9 i1 t001110 RS DS M9 Ra I Rb/IM5 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 I V<-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 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] Il SRb IlI sex(IMM<8:0>};
VACH[i];VACL[i] = VACH[i]: VACL[i] -
VRa[i] * Bop[i]; Exception 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
25 20 15 >0 S
RRI I Il Il ID] 119I I t i I 1111 RRRM9 i ool 11 |D|S DSt 1{9} |; I I{ { {b 1 I { 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,V<-V @ V V<-V @ S V<-V @ I S<-S @ S S<-S @ I
DS l 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 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]; 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 3D DS i! I RRR.M5 |0|1|0 11000 IDIS}DSé | VRd VRa VRb Syntaxe Assembleur VMAXE. dt VRd,VRb
o dt = {b,b9,h,w,f}.
Modes supportés
D:S:MII V<-V I I I 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 &&EMASK[i];i+2) { VRd[i] = (VRb[i] > VRb[i+ l]) ? VRb[i]: VRb[i+l]; VRd[i+l] = (VRb[i] > VRb[i+l]) ? VRb[i+ l]: VRb[1]; Exception Aucune. VMOV Déplacement Format i is l 0 CcO3: R.,RR.01IIJ0110 00i OD R 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 L DS I int8(b) | int9(b9) 1 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 VAClH:VAClL. Si spécifiée comme source, la paire de registres VRd+l: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 RRR.R |01lOlio 01000 -SbSi R i Rd R! V
IS'IDS R,
Syntaxe Assembleur VMUL.dt VRc,VRd,VRa,VRb VMUL.dt SRc,SRd,SRa,SRb
o dt = {b,h,w}.
Modes supportés
S || VR SR |
DS int8(b) 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; 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] Il 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 i l [ t9|i ll l.i,,S, I!-i lj 000010 I Ra Rb/ilS i RRRI,19 1. 1 000010 DIS DS rl 119.R Rt1N 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@ V V @ I I S @ S I 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 précision. Opération pour (i=0;i<NumElem &&EMASK[i];i++ ) { Bop [i] = {VRb[i]I SRb}; 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 f1 C RRR9 1 0101 D Ra R O, 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:MI 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]l.ISRbllsex(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 RRR9 r o 1 Rd RDaash 's|l R|lD 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:M V<-V @ V I 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]IISRblisex(IMM<8:0>)}; Hi[i]:Lo[i]=(VRa[i]*Bop[i])"<1; VRd+l [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".20 15 10 ' 0
RRRM9 il ' 01 00 DSDH IM9Rd '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 @ SI V<-V @ I S<-S @ S S<-S @ I
DS int8<bntntl6 (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] IISRbI Isex(IMM<8:0>)}; Hi[i]:Lo[i]=(VRa[i]*Bop.[i]j)"1; Si (Lo[i]<msb≥=1) Hi[i]+1; 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 '' '0 15 10 o LERRR9 |1|1| 010101 |D1SIDSD 1Mt9| Rd Ra Rb/1M5 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 V<-V @ V V<-V @ S V<-V I I S<-S @ S S<-S @ I
DS nl 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.
* aunonv UOT daoxa { T uatugI,19T suQp slTq sel sno = anod '(<:!> [T]dos q <X>[]eu)_ = <X>[F]PU À{(<0:8>NNI)xas Iq'jS II[T]qlJa} = [F]doq }(++T:[T]HSkSH3 UIwWSfnN>TF!O=T) anod uoTeaSdo pU suep qeqlnsga, el Tauznoja C'q/eTPgURUT GpuU29do, I suVp Juepuodsazaoo MTq GT o0Al -e supp quau.,i enbpqo ap FTq anbeqo p m3 NON nbTb6oT uOTqvaWdosT aTfnpo.a uoTdTIOSGa I- - I (m) ZEuT I (q) 9IuT I (6q) 6uT I (q) 84uT I Sa I ) S->S S 0 S->S I 0 A->A S 0 A->A A 0 A->A || Z s a: s:roddns sapoN * UOTIaodO G1UUI 'e uaTJTDGds - m- aenb aaou Inv; II'{m'q'6q'q} = 4p no NfI#' euS'PuS qP' ONNA Ms'eS 'PS,P' ON-'NA qI4s ''eus 'pAs 'P 'GNVNA NNI# ' eA 'PEA 1P GNVNA FS ' eA 'PEA P' GNVNA o uwxP aiSI O analqUassV axpquXS 6 NON uNi
VNOR NON OU
Format
25 1 10 -0
RRRM9 111 o 11 s M9 d Ra R b/IM5i 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 @ S | V<-V Q I S<-S Q S S<-S @ I
DS 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 RRRRM9 I 1 0110 si1Sds f Ra RaI 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 D:S:M V<-V @ V V<-V S V<-V Q 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]IISRblIsex(IMM<8:0>)"}; Rd[i]<k>;Ra[i]<k>lBop[i]<k≥pour k= tous les bits dans l'élément i; } Exception Aucune. VORC Comnrlément OU Format
25 20 1] 10 O
1H11 L 'J TiIIIIH I RRRM9 11 1110m i IDS 1M Rd Ra Rb/IM5 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 11 V<-V v V IV<-V @ S T V<-V v I I S<- S @ S S<-S @ I DS int8 (b) int9 (b9) intl6 (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]{ISRbIsex(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 1 o 2 0 I 0 REAR 101oo[J' 1 J IN' " i I " IRb |o|o|o|;,sd | | ||O|A| i |SRb |SRi r 20 15 10 0 REAI 0 0!I| SRb O[IMM| Syntaxe Assembleur VPFTCH. in SRb,SRi VPFTCH. in SRb,#IMM VPFTCH. in SRb+,SRi VPFTCH. in SRb+,#IMM
ou 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<1: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
REA 0 1 00110 | LN|F t "|ISS 1 | | b L; SI RI 1-
20 15 10
REARI I EdI 110SIRI SRb IRI Syntaxe Assembleur VPFTCHSP.ln SRp,SRb,SRi VPFTCHSP.ln SRp,SRb,#IMM VPFTCHSP. in SRp,SRb+ ,SRi VPFTCHSP. in 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<l: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<l: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 + {SRilsex(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 c 0 5,0 5 0 II RRRM5 I I1 oi 11 0 i I I 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 | | 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 IMM<4:0>}; pour (i=0;i<NumElem &&EMASK[i];i++){ Rd[i] = Ra[i] rotationrotation à 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 20 15 Io. 0 ioilI R RRRM5 o11 000 10 DS1DS Rd Ra 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 l V<-V @ S V<-V @ I S<-S @ S I 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 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[il 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
20 17 0 0
RRRM5 I 01 11010 DSRM I Rd Rb.
1 si H Syntaxe Assembleur VROUND.rm VRd,VRb VROUND.rm SRd,SRb
o rm = {ninf,zero,near,pinf}.
Modes supportés D:S:M Ii V<-V S<-S
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 Signification 00 ninf arrondissement vers - infini 01 zero arrondissement vers zéro near arrondissement vers le pair le plus proche 11 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 * 20 1. 10 s 0 _ _ IIIH i_" I I 1 1 iI 1 I I" I I
RRRM9 _ _001101 ISiD LM9 Rd Ra Rb/IM.
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 IV<-V @ V V<-V @ S V<-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]jIISRbllsex(IMM<8:0>)}; Rd[i]=Ra[i]<Bop[i]? Bop[i]:Ra[i]; } Exception Aucune. VSATU Saturer à La Limite Supérieure Format i5 20 1$ Io O RRRM9 1111l 0 0110|0 D 'm91 Rd p1 R | Syntaxe Assembleur VSATU.dt VRdi 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 tD:S:M IV<-V @ V V<-V @ S V<-V @ I S<-S s S<-S s I l 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]tISRbilsex(IMM<8:0>)}; Rd[i]=Ra[i]<Bop[i]? Bop[i]:Ra[i]; Exception Aucune. VSHFL Brassage Format 25 20 is!O 0 RRRR lO 0 Y00S S VRc VRd VRa Rb fi'l i 1"1 IS' [" 1' '] ' "1 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 VRb SRb I DS int8b) int9(b9) int6h) int32 (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 VRd Opération Exception Aucune. Note de Programmation Cette instruction n'utilise pas le masque d'éléments. VSHFLH Brassage Haut Format R.oRRR DIoClI 100 00 IsIis| X|I VRd VRa Rb Syntaxe Assembleur VSHFLH.dt VRd,VRa,VRb VSHFLH.dt VRd, VRa,SRb o dt = {b,b9,h,w,fJ. Noter que.w et.f
spécifient la même opération.
Modes supportés S Il 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 VRb Opération Exception Aucune. Note de Programmation Cette instruction n'utilise pas le masque d'éléments. VSHFLL Brassage bas Format
M0 25 20 5 10 5 O
RRRR 1oIIJ101 OO li ISI DS | V'I Pao 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 lb9) 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.
VRa Rb I l, U ' E VRd I..t I I Opération Exception Aucune. Note de programmation Cette instruction n'utilise pas le masque d'éléments. VST Enregistrement Format 3O 2 2015o5o REAR o00 I00BJSICH Rs SRb' SRi 3015 20 i n Rffd 010] il 1 1 1 [-F1I REAI | l S'T IC |. SR mml 1 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 + {SR, 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> 4 BYTE[EA+i] = VRs<9i+7:9i>,i = 0 à 3 8 BYTE[EA+i] = VR.<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, ,20 15 10 5 0
REAR 1 O l 1 1 0'i + IBS'T JC|1 |R SRb | S; 25 20 15 Io5 0 REAI T D-1m SRL' 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+1 et 1' 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: ST Opération d'enregistrement b BYTE[EA] = SRs<7: 0> h HALF[EA] = SRs<15:0> 4 BYTE[ (EA+i>FIN)?EA+i-grandeurcb:EA+i] = VRs<9i+ 7:9i>, i= 0 à 3 8 BYTE [ (EA+i>FIN)?EA+i-grandeurcb:EA+i] = VRs<9i+7:9i>, i = 0 à 7 1 BYTE [ (EA+i>FIN) ?EA+i-grandeurcb:EA+i] = VRs<9i+7: 9i>, i = 0 à 15 32 BYTE[ (EA+i>FIN) ?EA+i-grandeurcb:EA+i] = VRs<9i+7: 9i>, i = 0 à 31 64 BYTE[ (EA+i>FIN) ?EA+i-grandeurcb:EA+i] = VRos<9i+7:9i>, i = 0 à 31 BYTE [ (EA+32+i>FIN)?EA+32+i-grandeurcb: 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.
Le programmeur doit assurer la condition suivante pour que cette instruction fonctionne comme on s'y attend:
COMMENCEMENT < EA < 2*FIN - COMMENCEMENT
C'est-à-dire, EA>COMMENCEMENT ainsi que EA -
FIN < FIN - COMMENCEMENT.
VSTD Enregistrement Double Format
25 20 15 10 S 0
25 20 15 la $ iEAR.ojojoj icIoY 1DJBJSTJCJ 1 J I I.f I L RIEAIn0-01- 10||1 |D|B|ST i M b SRj Syntaxe Assembleur VSTD.st Rs, SRb, SRi VSTD.st Rs, SRb, #IMM VSTD.st Rs, SRb+, SRi 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) SR, = EA; MEM[EA] = voir tableau ci-dessous: ST Opération d'enreqistrement b BYTE[EA] = SR,<7:0> BYTE[EA+1] = SRt]<7:0> h HALF[EA] = SRs<15:0> HALF[EA+2] = SRt1<15:0> 4 BYTE[EA+i] = VRs<9i+7:9i> ,i = O à 3 BYTE[EA+4+i] = VRt1<9i+7:9i>,i = 0 à 3 8 BYTE[EA+i] = VRs<9i+ 7:9i>,i = 0 à 7 BYTE[EA+8+i] = VR:+1<9i+7:9i>,i = 0 à 7 16 BYTE[EA+i] = VRs<9i+7:9i>,i = 0 à 15 BYTE[EA+16+i] = VRt+1<9i+7:9i>,i = 0 à 15 ST Opération d'enregistrement 32 BYTE[EA+i] = VRs<9i+7:9i>,i = O à 31 BYTE[EA+32+i] = VR+1<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 = 0 à 31 BYTE[EA+64+i] = VR0Os+l<9i+7:9i>,i = O à 31 _ BYTE[EA+96+i] = VR1l1<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ú>t> S = [ZT+Vs]c'aOM <0: g>t+gS = [8+W]rG]aaoM <0:1ú>'+ tS = [+ .:] a'O oM <0: e>,+s = [+v a] aIM M <0O: IE>+IS = [+as]cro MH <0: 91> +5S = [ t+Vz] AaIvH
<0: Gl>Ius = [V,.aZ 'H q-
"' <0:51> * =ES= [Y'S].L
<O0: L>1-+ Us-[ ú+vzi] 'S;; <o: L>,+Sts: [ z+,:a] a..xa <O:L> +s S = [I+ V.l]zix <0: L>sES = [v.] Z.LKa q' ummaw;slgua,P uolTwa.aDdoS : snossap- TD nalqe iT.oA = [Ev]wHw va = %S (T == V) Ts
{ (<O:L>I)XaS 11 US} + qUs = v. uoT ;ado ÀSTlTg1oDS ailsTbal azenb no agu:aI1e no afueunoo eaBuw:z wI
ap:-+r-4d sI S =o:%o;aa sa:[+sTBa: a:z nb aais-4a:u.n uoT.dT.Dsaa À Tno:To SOtoq:JTOUtWuGuu sanod SSOOLSA ZGSTTTqn *-alqusue saT;Tods az:e quaAnad au sV'A 4a t9 anb qa uoT3g:2do Gu Mt e[ 4uT;TTDgds $6q' a q' nb:z qoN {sus 'sTdA 'sgdA} = su {t9 'ZE '91 '8 ' 'M 'q '46q 'q} = Is tno NNI# '+qcs 'su qS'OLSA TUS '+qus 'sU qs'OISA WI# 'qqs 'sE ' s'ÈISA TUS 'qUs 'sUI qs'O. SA nasquiassV ex"quAs !II il 1 II >& 'ç S Ic IaI I oo I, w, a a,, y o pulnozi@QSéU S ú1Z S ol;I o; ' ogtiio pp e"t0. uewe;z:lx.a3...T 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 = O à 3 BYTE[EA+8+i] = VR,+2<9i+7:9i>,i = 0 à 3 BYTE[EA+12+i] = VR,+t<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 = 0 à 7 BYTE[EA+16+i] = VRs+2<9i+7:9i>,i = 0 à 7 BYTE[EA+24+i] VR,+,<9i+7:9i>,i 0 à 7 16 BYTE[EA+i] = VR,<9i+7:9i>,i = 0 à 15 BYTE[EA+16+i] = VRS+l<9i+7:9i>,i = 0 à 15 BYTE[EA+32+i] = VRs+2<9i+7:9i>,i = 0 à 15 BYTE[EA+48+i] = VR+_<9i+ 7:9i>,i = 0 à 15 32 BYTE[EA+i] = VRs<9i+7:9i>,i = 0 à 31 BYTE[EA+32+i] = VR$+1<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] = VRoS<9i+7:9i>,i = O à 31 BYTE[EA+32+i] = VRls<9i+7:9i>,i = 0 à 31 BYTE[EA+64+i] = VRos+ 1<9i+7:9i>,i = 0 à 31 BYTE[EA+96+i] = VRls+l<9i+7:9i>,i = 0 à 31 BYTE[EA+ 128+i] = VRos+2<9i+7:9i>,i = 0 à 31 BYTE[EA+160+i] = VRls+2<9i+7:9i>,i = 0 à 31 BYTE[EA+192+i] = VRos+3<9i+7:9i>,i = 0 à 31 _ BYTE[EA+224+i] = VR1.+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 REAR pIoI<o ll 0)OBSY. Rs j SRbs SR j REAII I I T OllI I t1 1 SIR 41 [+ in )+1' I t'l"tcH, 7 i 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 | sex(IMM<7:0>)}; si (A == 1) SRb = EA; MEM[EA] = voir tableau ci-dessous: ST Opération d'enregistrement 4 BYTE[EA+i] = VR,[31-i]<7:0>,i = 0 à 3 8 BYTE[EA+i] = VR[31-i]<7:0>,i = 0 à 7 16 BYTE[EA+i] = VR,[31-i]<7:0>,i = 0 à 15 32 BYTE[EA+i] = VR_[31-i]<7:0>,i = 0 à 31 64 BYTE[EA+32+i] = VRos[31-i]<7:0> ,i = 0 à 31 BYTE[EA+i] = VR,.[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
'I. 20 I 1
REAR 0| ll '11 1110 1ST j SRb S It I I sIf11 ". I $. 1t i Io I I III 1X 11| * REoI I//117' STC SRb IM 1010111BI,+1 i' 111l 111111 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+1 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+, 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, sex(IMM<7:0>)}; si (A == 1) SRb = EA; Grandeurbloc = {4 I 8 Il 16 Il 32); Chevauchement = SRb+l<31:0>; pour (i = 0;i<VECSIZE/Grandeurbloc;i++) pour (j = 0;j<Grandeurbloc;j++) BYTE[EA+ i*Chevauchement+j] = VRs [i*Grandeur_bloc+j]<7:0>; Exception
Adresse donnée incorrecte, accès non aligné.
VSUB Soustraire Format 25 20 15 10 S p iiRRRM9III I |1 | I I i I I I I I I 1 11111 RRRM9 000100 DSIDSMI IM9 Rd Ra IRa'I 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
D:S:M V<-V @ VI 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 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 : _ _2520 15 10 5R l RRRM9 I 010100 l SIDSH IM9 SRd I,, ,'"l r' H."I"I' _ 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 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 Il sex(IMM<8:0>)}; SRd = SRa - Bop; VCSR<lt,eq,gt> = état(SRa - Bop); Exception Débordement, opérande point flottant incorrect. s;luGugT,p enbseul e sud aSTTTIn,u uoTqonasuT aao uoTqunWeZbOZd ap e4ON aunDnv uoT daDox uoTez ado
I I I I '" I I I I '" IIA
qll : snossap-To aeiuoui sa IT aumooD pA:oUA sTaTzoqoeA sasT6z sal suep qc DoAv gssezqgp qsa MUA TITOO4DA GZqST6az np nuaquoo aq UOTqdTZOSeC (M) Z-UT 1 (T) 9l'U4T (6q) 6qu-F (q) 8;UT saI saOdd ns sapow uoTqeZado uUI UIl V us;Topds la M- enb 2;oON {; 'M ' 6q q} = p tio qcS 'HA 'PUA 'OUA IP'* HSNfLA qHA 'MUA 'PUA 'ODA qP'UIHSNOA inalquImasss exeuAs i J&I. 10000 _ e sseqg;a I&HSNQA OZZ 6Z9ZSEZ oz VUNSHFL14 Débrassaae valeur haute Format 20 lS 10 5 0 1IIIIIi II IIITI RRRR | 0|1 0 i01 S Ds VRd VRa 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 suportés S s VRb I SRb IDS int8 (b) int9 (b9)1 intl6 (h) lint32 (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 Rh Opération Exception Aucune. Note de programmation Cette instruction n'utilise pas le masque d'éléments. VUNSHFLL Débrassage valeur basse Format t 20w 15 lo 5 o RRRR 0 1 0 I011 SS VRd Syntaxe Assembleur VUNSHFLL.dt VRd, VRa, VRb VUNSHFLL.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 VRa est débrassé avec Rb; la portion inférieure du résultat est retournée au registre vectoriel VRd comme il est mortré ci-dessous: VRa Rb
!-,.. t!r e...I J"-
Opération Exception Aucune. Note de programmation Cette instruction n'utilise pas le masque d'éléments. VWBACK Réécriture Format
25 20 15 10 5
1 1 1 11 1lld 11ILlll1 1' IRf idpi Iolojl II i, 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<1: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<1: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 r r30 rr r 20 15 10 5 0 REARli I I IIJ' ISR I 41 I '^'
O > 2 1 10 50
1 1 1 I I J lmr REM0I1toll "i'd I I I'1 I'H I' I I' I {r ' Syntaxe Assembleur VWBACKSP.ln SRp, SRb, SRi VWBACKSP.ln SRp, SRb, #IMM VWBACKSP.ln SRp, SRb+, SRi 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<1: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<1: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.
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 I MIII MMM MII I I I J t111 RRRM9 0101 MS DSM 1 | Rd RajRb/M51 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 su portés D:S:M V<-V @ V | V<-V @ S | V<-V @ I 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 exclusifl Format '5 20 15 10o o RRRM9 1 1 0 llRd Ra SRIM5 H. I'""bt 'H"'49I,,,, 1 ' 1' '1' 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 Q V I V<-V Q S V<-V @ I S- @SS<-S@ SI I
DS lint8 (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] 1] SRb Il 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. VXORALL XOR (OU exclusif) Tous les Eléments Format
30......5 2015 10 0
RRRR to1j1 1O 111 X 0 1DSI [ iSRd |Rb 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 suoDorté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 (9)

REVENDICATIONS
1. Processeur, caractérisé en ce qu'il comprend: un registre scalaire adapté à enregistrer une seule valeur scalaire un registre vectoriel adapté à enregistrer un certain nombre d'éléments de données; et un ensemble de circuits de traitement couplé au registre scalaire et au registre vectoriel, o, en réponse à une seule instruction, l'ensemble de circuits de traitement accomplit des opérations multiples en parallèle, chacune des opérations combinant l'un des éléments de données du registre vectoriel à la valeur scalaire du registre scalaire.
2. Procédé de fonctionnement d'un circuit de traitement pour exécuter une instruction, caractérisé en ce qu'il comprend: la lecture, depuis un registre, d'éléments de données qui forment des composants d'une valeur vectorielle; et l'accomplissement d'opérations en parallèle qui combinent une valeur scalaire à chacun des éléments de
données pour générer un résultat vectoriel.
3. Procédé selon la revendication 2, caractérisé en ce que l'accomplissement des opérations en parallèle consiste à multiplier la valeur scalaire par chacun des éléments de données pour générer un résultat de donnée vectorielle.
4. Procédé selon la revendication 2, caractérisé en ce que l'accomplissement des opérations en parallèle consiste à ajouter la valeur scalaire à chacun des éléments
de données pour générer un résultat de donnée vectorielle.
5. Procédé selon la revendication 2, caractérisé en ce qu'il consiste de plus à lire la valeur scalaire d'un second registre pour une combinaison avec les éléments de données, o le second registre est adapté à l'enregistrement
d'une certaine valeur scalaire.
6. Procédé selon la revendication 2, caractérisé en ce qu'il comprend de plus l'extraction, de l'instruction, de la valeur scalaire pour une combinaison avec les éléments de données.
7. Procédé de fonctionnement d'un processeur, caractérisé en ce qu'il consiste à: prévoir des registres scalaires et des registres vectoriels dans le processeur, o chaque registre scalaire est adapté à l'enregistrement d'une seule valeur scalaire et chaque registre vectoriel est adapté à l'enregistrement d'un certain nombre de d'éléments de données qui forment les composants d'un vecteur; assigner, à chaque registre scalaire, un numéro de registre qui est distinct des numéros de registre assignés aux autres registres scalaires; assigner, à chaque registre vectoriel, un numéro de registre qui est distinct des numéros de registre assignés aux autres registres vectoriels, o au moins certains numéros de registre assignés aux registres vectoriels sont égaux aux numéros de registre assignés aux registres scalaires; former une instruction qui comprend un premier opérande et un second opérande, o le premier opérande est le numéro de registre identifiant un registre scalaire et le second opérande est un numéro de registre identifiant un registre vectoriel; et exécuter l'instruction en déplaçant les données entre le registre scalaire identifié par le premier opérande et un élément de donnée dans le registre vectoriel identifié
par le deuxième opérande.
8. Procédé selon la revendication 7, caractérisé en ce que l'instruction formée comprend de plus un troisième opérande identifiant un élément de donnée dans un vecteur; et l'exécution de l'instruction déplace la donnée entre le registre scalaire identifié par le premier opérande et l'élément de données identifié par le troisième opérande dans le registre vectoriel identifié par le deuxième opérande.
9. Procédé selon la revendication 7, caractérisé en ce que l'instruction formée comprend de plus un troisième opérande identifiant un second registre scalaire; et l'exécution de l'instruction déplace la donnée entre le registre scalaire identifié par le premier opérande et un élément de donnée qui est dans le registre vectoriel, identifié par le deuxième opérande et identifié par une
valeur enregistrée dans le second registre scalaire.
FR9710440A 1996-08-19 1997-08-18 Traitement de donnees multiples a une seule instruction avec operations scalaires/vectorielles combinees Expired - Fee Related FR2752629B1 (fr)

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
US69958596A 1996-08-19 1996-08-19

Publications (2)

Publication Number Publication Date
FR2752629A1 true FR2752629A1 (fr) 1998-02-27
FR2752629B1 FR2752629B1 (fr) 2005-08-26

Family

ID=24809983

Family Applications (1)

Application Number Title Priority Date Filing Date
FR9710440A Expired - Fee Related FR2752629B1 (fr) 1996-08-19 1997-08-18 Traitement de donnees multiples a une seule instruction avec operations scalaires/vectorielles combinees

Country Status (6)

Country Link
JP (1) JPH10143494A (fr)
KR (1) KR100267089B1 (fr)
CN (1) CN1152300C (fr)
DE (1) DE19735349B4 (fr)
FR (1) FR2752629B1 (fr)
TW (1) TW346595B (fr)

Families Citing this family (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN103002276B (zh) * 2011-03-31 2017-10-03 Vixs系统公司 多格式视频解码器及解码方法
US20140082333A1 (en) * 2011-12-22 2014-03-20 Elmoustapha Ould-Ahmed-Vall Systems, apparatuses, and methods for performing an absolute difference calculation between corresponding packed data elements of two vector registers
CN104011664B (zh) * 2011-12-23 2016-12-28 英特尔公司 使用三个标量项的超级乘加(超级madd)指令
CN102750133B (zh) * 2012-06-20 2014-07-30 中国电子科技集团公司第五十八研究所 支持simd的32位三发射的数字信号处理器
KR102179385B1 (ko) 2013-11-29 2020-11-16 삼성전자주식회사 명령어를 실행하는 방법 및 프로세서, 명령어를 부호화하는 방법 및 장치 및 기록매체
GB2543303B (en) * 2015-10-14 2017-12-27 Advanced Risc Mach Ltd Vector data transfer instruction
US10108581B1 (en) * 2017-04-03 2018-10-23 Google Llc Vector reduction processor
US11893393B2 (en) 2017-07-24 2024-02-06 Tesla, Inc. Computational array microprocessor system with hardware arbiter managing memory requests
US11409692B2 (en) * 2017-07-24 2022-08-09 Tesla, Inc. Vector computational unit
CN114116513B (zh) * 2021-12-03 2022-07-29 中国人民解放军战略支援部队信息工程大学 多指令集架构向risc-v指令集架构的寄存器映射方法及装置

Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP0395348A2 (fr) * 1989-04-28 1990-10-31 Apple Computer, Inc. Méthode et dispositif de calcul multijauge
US5081573A (en) * 1984-12-03 1992-01-14 Floating Point Systems, Inc. Parallel processing system
EP0681236A1 (fr) * 1994-05-05 1995-11-08 Rockwell International Corporation Chemin de données de vecteur d'espace

Family Cites Families (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPH04336378A (ja) * 1991-05-14 1992-11-24 Nec Corp 情報処理装置
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 (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5081573A (en) * 1984-12-03 1992-01-14 Floating Point Systems, Inc. Parallel processing system
EP0395348A2 (fr) * 1989-04-28 1990-10-31 Apple Computer, Inc. Méthode et dispositif de calcul multijauge
EP0681236A1 (fr) * 1994-05-05 1995-11-08 Rockwell International Corporation Chemin de données de vecteur d'espace

Non-Patent Citations (2)

* Cited by examiner, † Cited by third party
Title
DILEEP BHANKARKAR ET AL: "VAX VECTOR ARCHITECTURE", PROCEEDINGS OF THE ANNUAL INTERNATIONAL SYMPOSIUM ON COMPUTER ARCHITECTURE. SEATTLE, MAY 28 - 31, 1990, LOS ALAMITOS, IEEE COMP. SOC. PRESS, US, vol. SYMP. 17, 28 May 1990 (1990-05-28), pages 204 - 215, XP000144782, ISBN: 0-8186-2047-1 *
WEBERPALS H: "ARCHITECTURAL APPROACH TO THE IBM 3090E VECTOR PERFORMANCE", PARALLEL COMPUTING, ELSEVIER PUBLISHERS, AMSTERDAM, NL, vol. 13, no. 1, 1990, pages 47 - 59, XP000103375, ISSN: 0167-8191 *

Also Published As

Publication number Publication date
KR100267089B1 (ko) 2000-11-01
FR2752629B1 (fr) 2005-08-26
KR19980018065A (ko) 1998-06-05
JPH10143494A (ja) 1998-05-29
CN1188275A (zh) 1998-07-22
CN1152300C (zh) 2004-06-02
DE19735349A1 (de) 1998-04-02
DE19735349B4 (de) 2006-12-14
TW346595B (en) 1998-12-01

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
US6925553B2 (en) Staggering execution of a single packed data instruction using the same circuit
RU2137184C1 (ru) Отображение с помощью мультинаборов команд
US6380942B1 (en) Packetized command interface to a graphics processor
US5996057A (en) Data processing system and method of permutation with replication within a vector register file
US6775766B2 (en) Methods and apparatus to dynamically reconfigure the instruction pipeline of an indirect very long instruction word scalable processor
US6334176B1 (en) Method and apparatus for generating an alignment control vector
RU2636675C2 (ru) Команды, процессоры, способы и системы доступа множественных регистров к памяти
US6401190B1 (en) Parallel computing units having special registers storing large bit widths
TWI329803B (en) Multi-level cache having overlapping congruence groups of associativity sets in different cache levels
FR2752466A1 (fr) Dispositif processeur integre de signaux numeriques
JP2000509528A (ja) データ処理マネージメントシステム
US4562538A (en) Microprocessor having decision pointer to process restore position
KR20200068564A (ko) Ssd들 상에서의 가속된 데이터 처리를 위한 시스템 및 방법
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
EP1365318A2 (fr) Microprocesseur avec module de matrice à manipulation de données
JP4078243B2 (ja) 繰返しブロック命令を入れ子ループに沿ってゼロ・サイクル・オーバヘッドで実行する方法及び装置
US20030033503A1 (en) Single instruction having opcode and stack control field
JP2001525966A (ja) 命令発行速度を加速するプロセッサ・コントローラ
US6654870B1 (en) Methods and apparatus for establishing port priority functions in a VLIW processor
KR100267092B1 (ko) 멀티미디어신호프로세서의단일명령다중데이터처리
TWI470541B (zh) 用於滑動視窗資料收集之設備及方法
US11210091B2 (en) Method and apparatus for processing data splicing instruction

Legal Events

Date Code Title Description
ST Notification of lapse

Effective date: 20100430