KR19980018065A - 스칼라/벡터 연산이 조합된 단일 명령 복수 데이터 처리 - Google Patents

스칼라/벡터 연산이 조합된 단일 명령 복수 데이터 처리 Download PDF

Info

Publication number
KR19980018065A
KR19980018065A KR1019970012609A KR19970012609A KR19980018065A KR 19980018065 A KR19980018065 A KR 19980018065A KR 1019970012609 A KR1019970012609 A KR 1019970012609A KR 19970012609 A KR19970012609 A KR 19970012609A KR 19980018065 A KR19980018065 A KR 19980018065A
Authority
KR
South Korea
Prior art keywords
register
vector
scalar
data
srb
Prior art date
Application number
KR1019970012609A
Other languages
English (en)
Other versions
KR100267089B1 (ko
Inventor
에이. 모하메드 모아타즈
박 헌철
누옌 르
Original Assignee
윤종용
삼성전자 주식회사
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 윤종용, 삼성전자 주식회사 filed Critical 윤종용
Publication of KR19980018065A publication Critical patent/KR19980018065A/ko
Application granted granted Critical
Publication of KR100267089B1 publication Critical patent/KR100267089B1/ko

Links

Classifications

    • 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
    • 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
    • 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)
  • General Physics & Mathematics (AREA)
  • Software Systems (AREA)
  • General Engineering & Computer Science (AREA)
  • Computer Hardware Design (AREA)
  • Mathematical Physics (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

벡터 프로세서는 스칼라 값을 위한 스칼라 레지스터와 다수의 데이타 엘리먼트를 포함하는 벡터를 위한 벡터 레지스터 모두를 구비한다. 상기 벡터 프로세서에 의해 실행된 연산은 벡터 양을 결정하기 위해 두개 이상의 벡터 오퍼런드를 처리하고, 벡터 양을 결정하기 위해 스칼라 오퍼런드와 벡터 오퍼런드를 결함하고, 스칼라 양을 결정하기 위해 두개 이상의 스칼라 오퍼런드를 결합한다. 상기 스칼라 레지스터는 또한 벡터 레지스터 내의 개별적인 데이타 엘리먼트의 곱셈을 용이하게 한다.

Description

스칼라/벡터 연산이 조합된 단일 명령 복수 데이타 처리
본 발명은 디지탈 신호 프로세서에 관한 것으로, 특히 비디오 및 오디오 인코딩 및 디코딩과 같은 멀티미디어 기능을 위해 명령마다 복수 데이타 엘리먼트의 병렬 처리를 위한 프로세서에 관한 것이다.
실시간 비디오 인코딩 및 디코딩과 같은 멀티미디어 어플리케이션을 위한 프로그래머블 디지탈 신호 프로세서(DSP)는 제한된 시간내에 처리되어야만 하는 많은 양의 데이타를 위해 상당한 처리력을 필요로 한다. 디지탈 신호 프로세서를 위한 몇 가지 아키텍춰가 알려져 있다. 대부분의 마이크로프로세서에 사용되는 것과 같은 범용 아키텍춰는 전형적으로 실시간 인코딩 또는 디코딩하는 충분한 연산력을 갖는 DSP를 제공하기 위해 고주파수를 필요로 한다. 이는 DSP의 값을 비싸게 한다.
매우 긴 명령 워드(VLIW) 프로세서는 비교적 간단한 작업과 같이 서로 달리 수행하는 많은 기능 유닛을 갖는 DSP이다. VLIW DSP를 위한 단일 명령은 128 바이트보다 길 수 있고, 개별적인 기능 유닛들이 병렬로 실행하는 개별적인 부품을 갖는다. VLIW DSP는 많은 기능 유닛들이 병렬로 수행할 수 있기 때문에 높은 연산력을 갖는다. VLIW DSP는 또한 각각의 기능 유닛이 비교적 작고 간단하기 때문에 비교적 값이 싸다. VLIW DSP의 문제점은 입력/출력 제어의 처리에서의 비효율성, 호스트 컴퓨터와의 통신, 및 VLIW DSP의 기능 유닛 상에서 병렬 실행에 적합하지 않는 다른 기능들이다. 부수적으로, VLIW 소프트웨어는 종래의 소프트웨어와는 다르며, 프로그램 툴과 VLIW 소프트웨어 아키텍춰에 익숙하지 않은 프로그래머가 부족하기 때문에 개발하기가 어려울 수 있다.
적당한 가격과, 높은 연산력, 및 익숙한 프로그래밍 환경을 제공하는 DSP가 멀티미디어 어플리케이션에 요구된다.
본 발명의 특징에 따르면, 멀티미디어 디지탈 신호 프로세서(DSP)는 높은 처리력을 제공하기 위해 벡터 데이타(즉, 오퍼런드마다 복수 데이타 엘리먼트)를 조작하는 벡터 프로세서를 구비한다. 상기 프로세서는 RISC형 명령어 세트를 갖는 단일 명령 복수 데이타 아키텍춰를 이용한다. 프로그래머는 그들 대부분이 익숙한 범용 프로세서의 프로그래밍 환경에 익숙하기 때문에 벡터 프로세서의 프로그래밍 환경에 쉽게 적응할 수 있다.
DSP는 범용 벡터 레지스터 세트를 구비한다. 각 벡터 레지스터는 고정된 크기를 갖지만, 사용자가 선택할 수 있는 크기의 개별적인 데이타 엘리먼트로 파티션 되어 있다. 따라서, 벡터 레지스터에 저장된 데이타 엘리먼트의 수는 엘리먼트에 대해 선택된 크기에 따른다. 예를 들어, 32 바이트 레지스터는 32개의 8 비트 데이타 엘리먼트, 16개의 16 비트 데이타 엘리먼트, 또는 8개의 32 비트 데이타 엘리먼트로 나누어질 수 있다. 데이타 크기 및 유형의 선택은 벡터 레지스터와 연관된 데이타를 처리하는 명령에 의해 이루어지고, 명령을 위한 실행 데이타 경로는 명령에 의해 지시된 데이타 크기에 따르는 다수의 병렬 연산을 수행한다.
벡터 프로세서를 위한 명령은 오퍼런드로서 벡터 레지스터 또는 스칼라 레지스터를 가질 수 있고, 연산력이 높도록 병렬인 벡터 레지스터의 복수 데이타 엘리먼트를 조작한다. 본 발명에 따른 벡터 프로세서를 위한 예시적인 명령은 : 코프로세서 인터페이스 연산; 흐름 제어 연산; 로드/저장 연산; 및 논리/산술 연산을 포함한다. 상기 논리/산술 연산은 결과로 나타나는 데이타 벡터의 데이타 엘리먼트를 생성하기 위해 한 벡터 레지스터로부터의 데이타 엘리먼트를 하나 이상의 다른 벡터 레지스터로부터의 대응하는 데이타 엘리먼트와 결합하는 연산을 포함한다. 다른 논리/산술 연산은 하나 이상의 벡터 레지스터로부터의 여러 데이타 엘리먼트를 합성하거나 또는 벡터 레지스터로부터의 데이타 엘리먼트와 스칼라 양을 합성한다.
벡터 프로세서 아키텍춰의 확장은 각각 스칼라 데이타 엘리먼트를 포함하는 스칼라 레지스터를 더한다. 스칼라 및 벡터 레지스터의 조합은 벡터의 각 데이타 엘리먼트를 스칼라 값과 병렬로 결합하는 연산을 포함하도록 설정된 벡터 프로세서의 명령의 확장을 용이하게 한다. 예를 들어, 하나의 명령은 벡터의 데이타 엘리먼트에 스칼라 값을 곱한다. 스칼라 레지스터는 또한 벡터 레지스터로부터 추출되거나 또는 그것에 저장될 단일 데이타 엘리먼트를 저장하기 위한 장소를 제공한다. 상기 스칼라 레지스터는 또한 벡터 프로세서와 스칼라 레지스터만을 제공하는 아키텍춰를 갖는 코프로세서 간의 정보의 전달과, 로드/저장 연산을 위한 효율적인 어드레스의 계산이 용이하다.
본 발명의 다른 특징에 따르면, 벡터 프로세서의 벡터 레지스터는 뱅크로 구성되어 있다. 각 뱅크는 현재의(current) 뱅크로 선택되는 한편, 다른 뱅크는 대체(alternative) 뱅크이다. 벡터 프로세서의 제어 레지스터에 있는 현재의 뱅크 비트는 현재의 뱅크를 가리킨다. 벡터 레지스터를 식별하는데 필요한 비트수를 줄이기 위해, 일부 명령은 레지스터 번호만을 제공하여 현재의 뱅크에서 벡터 레지스터를 식별한다. 로드/저장 명령은 어느 한 뱅크로부터 벡터 레지스터를 식별하기 위한 부수적인 비트를 갖는다. 따라서, 로드/저장 연산은 현재의 뱅크에 있는 데이타의 조작 동안 대체 뱅크로 데이타를 훼치할 수 있다. 이는 화상 처리 및 그래픽 프로시져를 위한 소프트웨어 파이프라인을 용이하게 하고, 논리/산술 연산이 대체 레지스터 뱅크를 액세스하는 로드/저장 연산과는 다른 순서로 수행될 수 있기 때문에 데이타를 훼치할 때 프로세서 지연을 감소시킨다. 다른 명령에서, 대체 뱅크는 현재의 뱅크로부터의 벡터 레지스터와 대체 뱅크로부터의 대응하는 벡터 레지스터를 포함하는 이중 크기(double-size) 벡터 레지스터의 사용을 가능하게 한다. 이"
벡터 프로세서는 또한 또한 쿼드(quad), 셔플, 언셔플, 페어-와이즈 최대 및 교환(pair-wise maximum and exchange), 및 새춰레이트와 같은 신규한 명령을 구현한다. 이들 명령들은 비디오 인코딩 및 디코딩과 같은 멀티미디어 기능에 공통인 연산을 수행하고, 다른 명령어 세트가 동일한 기능을 수행하는데 필요할 두개 이상의 명령을 대신한다. 따라서, 벡터 프로세서 명령어 세트는 멀티미디어 어플리케이션에서 프로그램의 효율성과 속도를 향상시킨다.
도1은 본 발명의 실시예에 따른 멀티미디어 프로세서의 블럭도.
도2는 도1의 멀티미디어 프로세서를 위한 벡터 프로세서의 블럭도.
도3은 도2의 벡터 프로세서를 위한 명령 훼치부의 블럭도.
도4는 도2의 벡터 프로세서를 위한 명령 훼치부의 블럭도.
도5a, 5b, 5c는 도2의 벡터 프로세서의 레지스터-대-레지스터 명령, 로드 명령, 및 저장 명령에 대한 실행 파이프라인의 스테이지를 도시하는 도면.
도6a는 도2의 벡터 프로세서를 위한 실행 데이타 경로의 블럭도.
도6b는 도6a의 실행 데이타 경로에 대한 레지스터 화일의 블럭도.
도6c는 도6a의 실행 데이타 경로에 대한 병렬 프로세싱 논리부의 블럭도.
도7은 도2의 벡터 프로세서에 대한 로드/저장부의 블럭도.
도8은 본 발명의 실시예에 따른 벡터 프로세서의 명령 세트에 대한 포맷도.
* 도면의 주요부분에 대한 부호의 설명 *
100 : 멀티미디어 신호 프로세서(MSP)
105 : 코어 프로세싱
110 : 범용 프로세서
120 : 벡터 프로세서
130 : 캐쉬 서브시스템
140, 150 : 시스템 버스
142 : 시스템 타이머
146 : 비트 스트림 프로세서
148 : 인터럽트 콘트롤러
152 : 디바이스 인터페이스
156 : 국부 버스 인터페이스
158 : 메모리 콘트롤러
162, 192 : 명령어 캐쉬
164, 194 : 데이타 캐쉬
180 : 캐쉬 제어부
220 : 디코더
230 : 스케쥴러
310 : 주 명령어 버퍼
312 : 보조 명령어 버퍼
340, 342, 344 : 레지스터
350 : 가산기
420 : 제어 파이프
421 내지 427 : 실행 레지스터
514, 515 : 실행 스테이지
610 : 레지스터 화일
612, 614, 616, 618 : 선택회로
620, 626 : 곱셈기
630 : 산술 논리부
640 : 누산기
도1은 본 발명의 실시예에 따른 멀티미디어 신호 프로세서(MSP)(100)의 블럭도를 도시한다. 멀티미디어 프로세서(100)는 범용 프로세서(110)와 벡터 프로세서(120)를 포함하는 프로세싱 코어(105)를 구비한다. 프로세싱 코어(105)는 SRAM(160 및 190), ROM(170), 및 캐쉬 제어부(180)를 포함하는 캐쉬 서브시스템(103)을 통해 멀티미디어 프로세서(100)의 나머지 부분에 접속된다. 캐쉬 제어부(180)는 프로세서(110)를 위해 명령어 캐쉬(162)와 데이타 캐쉬(164)로서 SRAM(160)을 컨피그할 수 있고, 벡터 프로세서(120)를 위해 명령어 캐쉬(192)와 데이타 캐쉬(194)로서 SRAM(190)를 컨피그할 수 있다.
온-칩 ROM(170)은 프로세서(110)를 위해 데이타와 명령어를 포함하고 역시 캐쉬로서 컴피그될 수 있다. 예식적인 실시예에서, ROM(170)은 : 리셋 및 초기화 프로시져; 자기-시험 진단 프로시져; 인터럽트 및 예외 핸들러; 및 사운드블러스트 에뮬레이션을 위한 서브루틴; V. 34 모뎀 신호 프로세싱을 위한 서브루틴; 일반적인 텔레포니 기능; 1-D 및 3-D 그래픽스 서브루틴 라이브러리; 및 MPEG-1, MPEG-2, H. 261, H. 263, G. 728 및 G. 723과 같은 오디오 및 비디오 표준을 위한 서브루틴 라이브러리를 포함한다.
캐쉬 서브시스템(130)은 프로세서(110 및 120)에 접속되어 두개의 시스템 버스(140과 150)으로 향하고, 프로세서(110 및 120)를 위한 캐쉬 및 스위칭 스테이션 모두로서 동작하고, 디바이스 버스(140 및 150)에 결합되어 있다. 시스템 버스(150)는 높은 클럭 주파수로 동작하고, 외부 국부 메모리를 위한 인터페이스, 호스트 컴퓨터의 국부 버스, 직접 메모리 액세스, 및 다양한 아날로그 대 디지탈 및 디지탈 대 아날로그 변환기를 각각 제공하는 메모리 콘트롤러(158), 국부 버스 인터페이스(156), DAM 콘트롤러(154), 및 디바이스 인터페이스(152)에 접속된다. 버스(140)에 접속되어 있는 것은 시스템 타이머(142), UART(유니버셜 비동기 수신기 트랜시버)(144), 비트스트림 프로세서(146), 및 인터럽트 콘트롤러(148)이다. 멀티 미디어 신호 프로세서에서 멀티프로세서 연산 및 비디오 데이타를 처리하기 위한 방법 및 장치라는 발명의 명칭을 갖는 본 발명에 참조로 일체화된 특허출원은 프로세서(110 및 120)가 캐쉬 서브시스템(130) 및 버스(140 및 150)를 액세스하는 예시적인 디바이스 및 캐쉬 서브시스템(130)의 동작을 보다 상세히 설명한다.
프로세서(110 및 120)는 개별적인 프로그램 스래드를 실행하고 그들에 할당된 특정 작업의 효율적인 실행을 위해 구조적으로 다르다. 프로세서(110)는 주로 실시간 연산 시스템의 실행과 같은 제어 기능 및 많은 각각의 연산을 필요로 하지 않는 유사한 기능을 위한 것이다. 따라서, 프로세서(110)는 고도의 연산력을 필요로 하지 않으며, 종래의 범용 프로세서 아키텍춰를 이용하여 구현될 수 있다. 벡터 프로세서(120)는 대부분 멀티미디어 프로세싱에 공통인 데이타 블럭에 대한 반복적인 연산을 포함하는 숫자 크러싱(number crushing)을 수행한다. 고도의 연산력과 비교적 간단한 프로그래밍을 위해, 벡터 프로세서(120)는 SIMD(Single Instruction Multimedia Data) 아키텍춰를 가지며, 예시적인 실시예에서, 벡터 프로세서(120)에서 대부분의 경로는 벡터 데이타 조작을 지원하기 위해 288 또는 576 비트 폭이다. 부수적으로, 벡터 프로세서(120)를 위한 명령어 세트는 특히 멀티미디어 문제에 적합한 명령어를 포함한다.
예시적인 실시예에서, 프로세서(110)는 40 MHz에서 동작하는 32 비트 RISC 프로세서이고, ARM 7 표준에 의해 정의된 바와 같이 레지스터 세트를 포함하는 ARM 7 프로세서의 아키텍춰에 맞는다. ARM 7 RISC 프로세서를 위해 설정된 아키텍춰 및 명령어는 ARM 7 DM 데이타 쉬트, 문서번호 : Advance RUSC Machines Ltd. 로부터 입수할 수 있는 ARM DDI 0010G에 설명되어 있다. 상기 ARM 7 DM 데이타 쉬트는 이하 그 전문이 본 발명의 참조로 일체화되어 있다. 부록 A 는 예시적인 실시예에서 ARM 7 명령어의 확장을 설명한다.
벡터 프로세서(120)는 벡터 및 스칼라 양 모두를 조작한다. 예시적인 실시예에서, 벡터 데이타 프로세서(120)는 80 MHz에서 동작하는 파이프라인된 RISC 엔진으로 구성된다. 벡터 프로세서(120)의 레지스터는 32 비트 스칼라 레지스터, 32 비트 특수 목적 레지스터, 288 비트 벡터 레지스터의 두 뱅크, 및 이중 크기(즉, 576 비트)의 두개의 벡터 누산 레지스터를 구비한다. 부록 C는 벡터 프로세서(120)의 예시적인 실시예를 위한 레지스터 세트를 설명한다. 예시적인 실시예에서, 프로세서(120)는 0에서 31까지의 범위에 이르는 5 비트 레지스터 번호들에 의해 명령어에 식별된다. 또한 32 벡터 레지스터의 두개 뱅크로 구성된 64개 288 비트 벡터 레지스터가 존재한다. 각각의 벡터 레지스터는 1 비트 뱅크 번호(0 또는 1) 및 0 에서 31까지의 범위에 이르는 5 비트 벡터 레지스터 번호로서 식별될 수 있다. 대부분의 명령어는 벡터 프로세서(120)의 제어 레지스터 VCSR에 저장된 디폴트 뱅크 비트 CBANK로 가리켜진 현재의 뱅크에 있는 벡터 레지스터를 액세스한다. 두번째 제어 비트 VEC 4는 디폴트로 레지스터 번호가 각 뱅크로부터의 레지스터를 포함하는 이중 크기 벡터 레지스터를 식별하는 "
각각의 벡터 레지스터는 프로그램가능한 크기의 데이타 엘리먼트로 파티션될 수 있다. 표1은 288 비트 벡터 레지스터내의 데이타 엘리먼트를 지원하는 데이타 유형을 도시한다.
[표 1]
부록 D는 본 발명의 예시적인 실시예에서 지원되는 크기와 유형의 자세한 설명을 제공한다.
int 9 데이타형의 경우, 9 비트 바이트가 288 비트 벡터 레지스터에 순차적으로 팩되지만, 다른 데이타형의 경우 288 비트 벡터 레시즈터의 매 9번째가 비트가 사용되지 않는다. 288 비트 벡터 레지스터는 328 비트 또는 9 비트 정수 데이타 엘리먼트, 16개의 16 비트 정수 데이타 엘리먼트, 또는 8개의 32 비트 정수 또는 부동 소수점 엘리먼트를 보유할 수 있다. 부수적으로, 두개의 벡터 레지스터가 이중 크기 벡터의 데이타 엘리먼트에 조합될 수 있다. 본 발명의 예시적인 실시예에서, 제어 비트 VEC 64를 제어 및 상태 레지스터 VSCR에 세팅함으로서 이중 크기(576 비트)가 벡터 레지스터의 디폴트 크기인 모드 VEC 64에 위치시킨다.
또한 멀티미디어 프로세서(100)는 프로세서(110 및 120) 모두에 액세스할 수 있는 32 비트 확장 레지스터(115)의 세트를 수용한다. 부록 B는 본 발명의 예시적인 실시예에서 확장 레지스터 세트 및 그 기능을 설명한다. 벡터 프로세서(120)의 확장 레지스터 및 스칼라 및 특수 목적 레지스터는 몇몇 환경에서 프로세서(110)에 액세스할 수 있다. 두개의 특수 사용자 확장 레지스터는 두개의 판독포트를 가짐으로서 프로세서(110 및 120)가 레지스터를 동시에 판독할 수 있다. 다른 확장 레지스터는 동시에 액세스될 수 없다.
벡터 프로세서(120)는 벡터 프로세서(120)가 실행중 또는 아이들인지를 가리키는 두개의 선택적인 상태 VP_RUN 및 VP_IDLE를 갖는다. 프로세서(110)는 벡터 프로세서(120)가 상태 VP_IDLE에 있을 때 벡터 프로세서(120)의 스칼라 또는 특수 목적 레지스터를 판독 또는 기록할 수 있지만, 벡터 프로세서(120)가 상태 VP_RUN에 있는 동안 벡터 프로세서(120)의 레지스터를 판독 또는 기록하는 프로세서(110)의 결과는 정의되어 있지 않다.
프로세서(110)를 위한 ARM 7 명령어 세트의 확장은 벡터 프로세서(120)의 확장 레지스터 및 스칼라 또는 특수 목적 레지스터를 액세스하는 명령어를 포함한다. 명령어 MFER 및 MFEP는 확장 레지스터 및 벡터 프로세서(120)의 스칼라 또는 특수 목적 레지스터에서 프로세서(110)의 범용 레지스터로 각각 데이타를 이동시킨다. 명령어 MTER 및 MTEP는 각각 프로세서(110)의 범용 레지스터에서 확장 레지스터 및 벡터 프로세서(120)의 및 스칼라 또는 특수 목적 레지스터로 데이타를 이동시킨다. TESTSET 명령어는 확장 레지스터를 판독하고 모두 확장 레지스터의 비트 30을 1로 세트시킨다. 명령어 TESTSET는 프로세서(110)가 나온 결과를 판독(또는 사용)한 프로세서(120)에 시그날하기 위해 비트 30를 세트시킴으로서 사용자/생산자 동기화를 용이하게 한다. STARTVP와 INTVP를 위한 다른 명령어는 벡터 프로세서(120)의 동작 상태를 제어한다.
프로세서(110)는 벡터 프로세서(120)의 동작을 제어하기 위해 마스터 프로세서로서 동작한다. 프로세서(110 와 120)간의 제어의 비동기 분할을 사용함으로서 프로세서(110 및 120)의 동기화 문제를 간단하게 한다. 프로세서(110)는 벡터 프로세서(120)가 상태 VP_IDLE에 있는 동안 벡터 프로세서(120)를 위한 프로그램 카운터에 명령어 어드레스를 기록함으로서 벡터 프로세서(120)를 초기화시킨다. 다음에 프로세서(110)는 벡터 프로세서(120)를 상태 VP_RUN으로 바꾸는 STARTVP 명령어를 실행한다. 상태 VP_RUN에서, 벡터 프로세서(120)는 캐쉬 서브시스템(130)을 통해 명령어를 훼치하고 자신의 프로그램의 실행을 계속하면서 프로세서(110)와 병렬로 그와 같은 명령어를 실행한다. 시작되면, 벡터 프로세서(120)는 예외를 만날때까지 실행을 계속하고, 적당한 조건이 충족되면 VCJOIN 또는 VCINT 명령어를 실행하거나 또는 프로세서(120)에 의해 인터럽트된다. 벡터 프로세서(120)는 벡터 프로세서(120)가 상태 VP_IDLE에 재진입할 때 그 결과는 확장 레지스터에 기록하고, 그 결과를 프로세서(110 및 120)의 공유 어드레스 공간에 기록하거나 또는 그 결과를 프로세서(110)가 액세스하는 스칼라 "
벡터 프로세서(120)는 그 자신의 예외를 처리하지 않는다. 예외를 유발하는 명령어를 실행하면, 벡터 프로세서(120)는 상태 VP_IDLE에 진입하고 직접 라인을 통해 인터럽트 요구를 프로세서(110)에 시그날한다. 벡터 프로세서(120)는 프로세서(110)가 다른 STARTVP 명령어를 실행할 때까지 상태 VP_IDLE에 남는다. 프로세서(110)는 예외의 성질을 판단하기 위해 벡터 프로세서(120)의 레지스터 VISRC를 판독하고, 벡터 프로세서(120)를 다시 초기화시킴으로서 가능한 한 예외를 처리한 다음, 필요하다면 예외를 재시작하기 위해 벡터 프로세서(120)를 다이렉트할 책임이 있다.
프로세서(110)에 의해 실행된 INTVP 명령어는 벡터 프로세서(120)로 하여금 아이들 상태 VP_IDLE로 진입하게 한다. 예를 들어, 명령어 INTVP는 비디오 디코딩과 같은 하나의 작업에서 사운드 카드 에뮬레이션과 같은 다른 작업으로 벡터 프로세서를 전환시키는 멀티태스킹 시스템에 사용될 수 있다.
벡터 프로세서 명령어 VCINT 및 VCJOIN은 명령어에 의해 가리켜진 조건이 충족되었다면, 벡터 프로세서(120)에 의한 실행을 중지하고, 벡터 프로세서(120)를 상태 VP_IDLE에 놓으며 이와 같은 요구가 마스크될 때까지 인터럽트 요구를 프로세서(110)에 발행하는 흐름 제어 명령어이다. 벡터 프로세서(120)의 프로그램 카운터(특수 목적 레지스터)는 VCINT 또는 VCJOIN 명령어이후 명령어 어드레스를 가리킨다. 프로세서(110)는 벡터 프로세서(120)의 인터럽트 소스 레지스터 VISRC를 점검하여 VCINT 또는 VCJOIN 명령어가 인터럽트 요구를 유발하였는지를 결정한다.
벡터 프로세서(102)가 보다 큰 데이타 버스를 가지고 그 레지스터를 저장 및 복구하는데 보다 효율적이기 때문에, 벡터 프로세서(120)에 의해 실행된 소프트웨어는 구문 전환 동안 레지스터를 저장 및 복구하여야 한다. 상기 일체로 된 특허 출원 발명의 명칭 마이크로프로세서에서 효율적인 구문 저장 및 복구는 구문 전환을 위한 예시적인 시스템을 설명한다.
도2는 도1의 벡터 프로세서(120)의 예시적인 실시예의 주요 기능 블럭도이다. 벡터 프로세서(120)는 명령어 훼치부(IFU)(210), 디코더(220), 스케쥴러(230), 실행 데이타 경로(240), 및 로드/저장부(LSU)(250)를 구비한다. IFU(210)는 명령어를 훼치하고 분기와 같은 흐름 제어 명령어를 처리한다. 명령어 디코더(220)는 IFU(210)로부터 도달 순서로 사이클 마다 하나의 명령어를 디코드하고, 명령어로부터 디코드된 필드 값을 스케쥴러(230)의 FIFO에 기록한다. 스케쥴러(230)는 연산의 실행 스테이지에 필요하다면 실행 제어 레지스터로 발행된 필드 값을 선택한다. 발행 선택은 실행 데이타 경로(240) 또는 로드/저장부(250)와 같은 프로세싱 자원의 의존성과 이용가능성에 따른다. 실행 데이타 경로(240)는 벡터 또는 스칼라 데이타를 조작하는 논리/산술 명령어를 실행한다. 로드/저장부(25)는 벡터 프로세서(120)의 어드레스 공간을 액세서하는 로드/저장 명령어를 실행한다.
도3은 주 명령어 버퍼(310)와 보조 명령어 버퍼(312)로 나누어지는 명령어 버퍼를 포함하는 IFU(210)의 실시예에 대한 블럭도를 도시한다. 주 버퍼(310)는 현재의 프로그램 카운트에 대응하는 명령어를 포함하는 8개의 연속하는 명령어를 수용한다. 보조 버퍼(312)는 버퍼(310)의 명령어를 즉시 따라가는 8개의 명령어를 수용한다. IFU(210)는 또한 버퍼(310 또는 312)의 다른 흐름 제어 명령어의 목표를 포함하는 8개의 연속하는 명령어를 수용하는 분기 목표 버퍼(314)를 포함한다. 예시적인 실시예에서, 벡터 프로세서(120)는 각 명령어가 32 비트 길이인 RISC형 명령어 세트를 사용하고, 버퍼(310, 312, 및 314)는 8×32 비트 버퍼로 256 비트 명령어 버스를 통해 캐쉬 서브시스템(130)에 접속된다. IFU(210)는 캐쉬 서브시스템(130)에서 임의의 버퍼(310, 312, 또는 314)로 단일 클럭 사이클로 8개의 명령어를 로드할 수 있다. 레지스터(340, 342 및 344)는 각각 버퍼(310, 312 및 314)에 로드된 명령어에 대한 베이스 어드레스를 가리킨다.
멀티플렉서(332)는 주 명령어 버퍼(310)로부터 현재으 명령어를 선택한다. 만일 현재의 명령가 흐름 제어 명령어가 아니고 명령어 레지스터(330)에 저장된 명령어가 실행의 디코드 스테이지로 진행하면, 현재의 명령어는 명령어 레지스터(330)에 저장되고, 프로그램 카운트는 증가된다. 프로그램 카운트를 증가시켜 버퍼(310)의 마지막 명령어를 선택한 후, 다음 세트의 8명령어가 버퍼(310)에 로드 된다. 만일 버퍼(312)가 소정의 8명령어를 포함하면, 버퍼(312) 및 레지스터(342)의 내용은 즉시 버퍼(310) 및 레지스터(340)로 이동되고, 8개 이상의 명령어가 캐쉬 시스템(130)으로부터 보조 버퍼(312)로 프리훼치된다. 가산기(350)는 레지스터(342)에 있는 베이스 어드레스로부터 다음 명령어 세트의 어드레스와 멀티플렉서(352)에 의해 선택된 오프셋을 결정한다. 가산기(350)로부터 결과로 나타나는 어드레스가 레지스터(342)가 레지스터(340)로 이동하거나 이동한 후 레지스터(342)로 저장된다. 산출된 어드레스는 또한 8개 명령어를 위한 요구로서 캐쉬 서브시스템(130)으로 전달된다. 만일 캐쉬 제어 시스템(130)에 대한 이전의 호출이 버퍼(310)가 요구한 버퍼(312)로 다음 8명령어를 제공하"
만일 현재의 명령어가 흐름 제어 명령어이면, IFU(210)에 흐름 제어 명령어에 대한 조건을 평가하고 흐름 제어 명령어의 뒤에 오는 프로그램 카운트를 갱신함으로서 명령어를 처리한다. 조건을 바꿀 수 있는 이전 명령어가 완료되지 않았기 때문에 만일 조건이 결정되지 않으면 IFU(210)는 보류된다. 만일 분기가 취해지지 않으면, 프로그램 카운터는 증가되고 다음 명령어가 상술된 바와 같이 선택된다. 만일 분기가 취해지고 분기 목표 버퍼(314)가 분기의 목표를 포함하고 있으면, 버퍼(314) 및 레지스터(344)의 내용이 버퍼(310) 및 레지스터(340)로 이동되어, IFU(210)는 캐쉬 서브시스템(130)으로부터 명령어를 대기하지 않고 디코더(220)에 계속 제공할 수 있다.
분기 목표 버퍼(314)에 대한 명령어를 프리훼치하기 위해, 스캐너(320)는 버퍼(310 및 312)를 스캔하여 현재의 프로그램 카운트의 뒤에 오는 다음 흐름 제어 명령어를 찾는다. 만일 흐름 제어 명령어가 버퍼(310 또는 312)에서 발견되면, 스캐너(320)는 명령어를 수용하고 있는 버퍼(310 또는 312)의 베이스 어드레스로부터 흐름 제어 명령어의 목표 어드레스를 포함하는 8개의 명령어의 정렬된 세트로 오프셋을 결정한다. 멀티플렉서(352 및 354)는 흐름 제어 명령어로부터의 오프셋과 레지스터(340 또는 342)로부터의 베이스 어드레스를 버퍼(314)에 대해 새로운 베이스 어드레스를 생성하는 가산기(350)로 공급한다. 새로운 베이스 어드레스는 다음에 분기 목표 버퍼(314)에 대해 8명령어를 공급하는 캐쉬 서브시스템(130)으로 전달된다.
감소 및 조건 분기 명령어 VDICBR, VD2CBR 및 VD3CBR 및 변경 제어 레지스터 명령어 VCHGCR와 같은 흐름 제어 명령어를 취급하는데 있어, IFU(210)는 프로그램 카운트 이외에 레지스터 값을 바꿀 수 있다. IFU(210)가 흐름 제어 명령어가 아닌 명령어를 발견하면, 해당 명령어는 그곳에서 명령어 레지스터(330)에서 디코더(220)로 전달한다.
디코더(220)는 도4에 도시된 바촤 같이 스케쥴러(230)의 FIFO 버퍼(410)이 필드에 제어 값을 기록함으로서 명령어를 디코드한다. FIFO 버퍼(410)는 네 행의 플립-플롭을 수용할 수 있는데, 이들 각각은 한 명령어의 실행을 제어하기 위한 5필드의 정보를 수용할 수 있다. 행 0 내지 3은 가장 오래된 것에서 가장 최근의 명령어에 대한 정보를 각각 보유하고, FIFO 버퍼(410)의 정보는, 명령어가 완료됨에 따라 오래된 정보가 제거될 때 보다 낮은 행으로 쉬프트 다운한다. 스케쥴러(230)는 실행 레지스터(421 내지 427)를 수용하고 있는 제어 파이프(420)로 로드될 명령어의 필요한 필드를 선택함으로서 실행 스테이지에 명령어를 발행한다. 대부분의 명령어는 순서에 어긋난 발행 및 실행으로 스케쥴될 수 있다. 특히, 로드/저장 연산과 논리/산술 연산의 순서는 로드/저장 연산 및 논리/산술 연산 간에 오퍼런드 종속성이 존재하지 않는 한 임의적이다. FIFO 버퍼(410)의 필그 값의 비교는 임의의 오퍼런드 종속성이 존재하는 지를 가리킨다.
도5a는 벡터 프로세서(120)의 어드레스 공간을 액세스하지 않고의 레지스터-대-레지스터 연산을 수행하는 명령어에 대한 6개의 스테이지 실행 파이프라인을 도시한다. 명령어 훼치 스테이지(511)에서, IFU(210)는 상술된 바와 같이 명령어를 훼치한다. 훼치 스테이지는 IFU(210)가 파이프라인 지연, 미해결 분기 조건, 또는 프리훼치된 명령어를 제공하는 캐쉬 서브시스템(130)에서의 지연에 의해 보류되지 않는 한, 한 클럭 사이클을 필요로 한다. 디코드 스테이지(512)에서, 디코더(220)는 IFU(210)로부터 명령어를 디코드하고, 스케쥴러(230)에 명령어에 대한 정보를 기록한다. 디코드 스테이지(512)는 또한 FIFO(410)의 어떠한 행도 새로운 연산에 사용할 수 없는 한 한 클럭 사이클을 필요로 한다. 연산은 FIFO(410)에서 첫번째 사이클 동안 제어 파이프(420)로 발생될 수 있지만, 보다 오래된 연산의 발행에 의해 지연될 수 있다.
실행 데이타 경로(240)는 레지스터-대-레지스터 연산을 수행하고 로드/저장 연산을 위해 데이타 및 어드레스를 공급한다. 도6a는 실행 데이타 경로(240)의 실시예의 블럭도를 도시하고, 실행 스테이지(514, 515 및 516)와 결합하여 서술된다. 실행 레지스터(421)는 판독 스테이지(514) 동안 클럭 사이클에서 판독된 레지스터 화일(610)에 두개의 레지스터를 식별하는 신호들을 제공한다. 도6b는 레지스터 화일(610)의 블럭도를 도시한다. 레지스터 화일(610)는 두개의 판독 및 두개의 기록을 각 클럭 사이클마다 수용하기 위해 두개의 판독 및 두개의 기록 포트를 갖는다. 각각의 포트는 선택 회로(612, 614, 616 및 618) 및 288 비트 데이타 버스(613, 615, 617 및 619)를 포함한다. 회로(612, 614, 616 및 618)과 같은 선택 회로는 기술 분야에 공지되어 있고, 디코더(220)가 전형적으로 명령어로부터 추출되는 5 비트 레지스터 번호로부터 유도하는 어드레스 신호 WRADDR1, WRADDR2, RDADDR1 또는 RDADDR2, 명령어 또는 제어 상태 레지스터 VCSR로부터의 뱅크 비트, 및 레지스터가 벡터 레지스터 또는 스칼라 레지스터 인지를 가리키는 명령어 구문을 이용한다. 데이타 판독은 멀티플렉서(656)를 "
실행 스테이지(515) 동안, 곱셈기(620), 산술 논리부(630) 및 누산기(640)는 레지스터 화일(610)로부터 이전에 판독된 데이타를 처리한다. 실행 스테이지(515)는 소정의 데이타를 판독하는데 다수의 사이클이 필요하다면 판독 스테이지(514)를 오버랩할 수 있다. 실행 스테이지(515)의 기간은 처리된 데이타 엘리먼트의 유헝(정수 또는 부동 소수점) 및 양(판독 사이클의 수)에 의존한다. 실행 레지스터(422, 423 및 425)로부터의 신호는 실행 스테이지 동안 수행된 첫번째 연산 동안 산술 논리부(630), 누산기(640) 및 곱셈기(620)로의 입력 데이타를 제어한다. 실행 레지스터(432, 433 및 435)로부터의 신호는 샐행 스테이지(515) 동안 수행된 두번째 연산을 제어한다.
도6c는 곱셈기(620) 및 ALU(630)의 실시예에 대한 블럭도이다. 곱셈기(620)는 8개의 독립적인 36×36 비트 곱셈기(626)를 포함하는 정수 곱셈기이다. 각각의 곱셈기(626)는 제어 회로에 의해 함께 접속된 4개의 9×9 비트 곱셈기를 포함한다. 8 비트 및 9 비트 데이타 엘리먼트 크기의 경우, 스케쥴러(230)로부터의 제어 신호는 각 곱셈기(626)가 네개의 곱셈을 수행하도록 상호 4개의 9×9 비트 곱셈기로부터 분리시키고, 곱셈기(620)는 사이클 동안 32개의 독립적인 곱셈을 수행한다. 16 비트 데이타 엘리먼트의 경우, 제어 회로는 함께 동작하는 9×9 비트 곱셈기의 쌍들을 연결하고, 곱셈기(620)는 16개의 병렬 곱셈을 수행한다. 32 비트 정수 데이타 엘리먼트 유형의 경우, 8개의 곱셈기(626)는 클럭 사이클 마다 8개의 병렬 곱셈을 수행한다. 곱셈의 결과는 9 비트 데이타 엘리먼트 크기에 대해 576 비트 결과를 그리고 다른 데이타 크기에 대해서는 512 비트를 제공한다.
ALU(630)는 두 클럭 사이클 동안 곱셈기(620)로부터 결과로 나타나는 576 비트 또는 512 비트 결과를 처리할 수 있다. ALU(630) 8개의 독립적인 36 비트 ALU(636)를포함한다. 각각의 ALU(636)는 부동 소수점 덧셈 및 곱셈을 위해 32×32 비트 부동 소수점부를 포함한다. 부수적인 회로는 정수 쉬프트, 산술 및 논리 함수를 실행한다. 정수 조작의 경우, 각각의 ALU(636)는 독립적인 8 비트 및 9 비트 조작을 수행할 수 있고 16 비트 및 32 비트 정수 데이타 엘리먼트에 대해 두개 또는 네개 세트로 함께 링크될 수 있는 네개의 부를 포함한다.
누산기(640)는 결과를 누산하고 중간 결과에서 보다 높은 정확도를 위해 두개의 576 비트 레지스터를 포함한다.
기록 스테이지(516) 동안, 실행 스테이지로부터의 결과는 레지스터 화일(610)에 저장된다. 두개의 레지스터는 단일 클럭 사이클 동안 기록될 수 있고, 입력 곱셈기(602 및 605)는 기록될 두개의 데이타 값을 선택한다. 연산을 위한 기록 스테이지(516)기간은 연산의 결과로서 기록될 데이타의 양과 레지스터 화일(610)에 기록함으로서 로드 명령어를 완료할 수 있는 LSU(250)으로부터의 완료에 따른다. 실행 레지스터(426 및 427)로부터의 신호는 논리부(630), 누산기(640) 및 곱셈기(620)로부터의 데이타가 기록되는 레지스터를 선택한다.
도5b는 로드 명령의 실행을 위한 실행 파이프라인(520)을 도시한다. 실행 파이프라인(520)을 위한 명령어 훼치 스테이지(511), 디코드 스테이지(512) 및 발생 스테이지(513)는 레지스터-대-레지스터 연산에 대해 서술된 것과 동일하다. 판독 스테이지(514)는 또한 실행 데이타 경로(240)가 레지스터 화일(610)로부터의 데이타를 사용하여 캐쉬 서브시스템(130)에의 호출을 위한 어드레스를 결정한다는 것을 제와하고 상술된 것과 동일하다. 어드레스 스테이지(525)에서, 멀티플렉서(652, 654 및 656)는 실행 스테이지(526 및 527)를 위해 로드/저장부(250)에 제공되는 어드레스를 선택한다. 로드 연산을 위한 정보는 스테이지(526 및 527) 동안 FIFO(410)에 유지되는 반면에 로드/저장부(250)는 연산을 취급한다.
도7은 로드/저장부(250)의 실시예를 도시한다. 스테이지(256) 동안, 스테이지(525)에서 결정된 어드레스로부터의 데이타를 위해 캐쉬 서브시스템(130)에 대해 호출된다. 예시적인 실시예는 프로세서(110 및 120)를 포함하는 다수의 디바이스들이 캐쉬 시스템(130)을 통해 국부 어드레스 공간을 액세스할 수 있는 트랜잭션에 근거한 호출을 이용한다. 요청된 데이타는 캐쉬 서브시스템(130)을 호출한 후 몇 사이클 동안 이용할 수 없지만, 로드/저장부(250)는 다른 호출이 계류하는 동안 캐쉬 서브시스템을 호출할 수 있다. 따라서, 로드/저장부(250)는 보류되지 않는다. 요청된 데이타를 제공하기 위해 캐쉬 서브시스켐(130)에 필요한 클럭 사이클의 수는 데이타 캐쉬(194)를 히트 또는 미스하였는 가에 따른다.
드라이브 스테이지(527)에서, 캐쉬 서브시스템(130)은 로드/저장부(250)에 대해 데이타 신호를 어써트한다. 캐쉬 서브시스템(130)은 로드/저장부(250)에 사이클마다 데이타의 256 비트(32 바이트)를 제공할 수 있다. 바이트 정렬기(710)는 288 비트 값을 제공하기 위해 대응하는 9 비트 저장 장소에 각각의 32 바이트를 정렬시킨다. 288 비트 포맷은 때때로 9 비트 데이타 엘리먼트를 사용하는 MPEG 엔코딩 및 디코딩과 같은 멀티미디어 어플레케이션에 용이하다. 288 비트 값은 판독 데이타 버퍼(720)에 기록된다. 기록 스테이지(528)의 경우, 스케쥴러(230)는 데이타 버퍼(720)로부터의 288 비트 양을 레지스터 화일(610)에 기록하기 위해 FIFO 버퍼(410)에서 실행 레지스터(426 또는 427)로 필드(4)를 운반한다.
도5c는 저장 명령어의 실행을 위한 실행 파이프라인(530)을 도시한다. 실행 파이프라인(530)을 위한 명령어 훼치 스테이지(511), 디코드 스테이지(512) 및 발생 스테이지(513)는 상술된 바와 동일하다. 판독 스테이지(514)는 또한 판독 스테이지가 저장될 데이타 및 어드레스 산출을 위한 데이타를 판독한다는 점을 제외하고 상술된 바와 같다. 저장될 데이타는 로드/저장부(250)의 데이타 버퍼(730)에 기록된다. 멀티플렉서(740)는 9 비트 바이트를 제공하기 위한 포맷인 데이타를 8 비트 바이트를 갖는 종래의 포맷으로 변환한다. 버퍼(730)로부터의 변환된 데이타 및 어드레스 산출 스테이지(525)로부터의 연관된 어드레스는 SRAM 스테이지(536) 동안 캐쉬 서브시스템(130)에 병렬로 보내진다.
벡터 프로세서(120)의 예시적인 실시예에서, 각 명려엉는 32 비트 길이이고, 도8에 도시된 9개의 포맷중 한 포맷을 가지며 REAR, REAI, RRRM5, RRRR, RI, CT, RRRM9, RRRM9* 및 RRRM9**의 표식을 갖는다. 부록 E는 벡터 프로세서(120)를 위한 명령어 세트를 설명한다.
효율적인 어드레스를 결정할 때 스칼라 레지스터를 이용하는 일부 로드, 저장 및 캐쉬 연산은 REAR 포맷을 갖는다. REAR 포맷 명령은 000b인 비트 29--31에 의해 식별되고, 스칼라 레지스터를 위한 두개의 레지스터 번호 SRb 및 SRi 및 비트 D에 의존하는 스칼라 또는 벡터일 수 있는 레지스터의 레지스터 번호 Rn으로 식별되는 3개의 오퍼런드를 갖는다. 뱅크 배트 B는 레지스터 Rn에 대한 뱅크를 식별하거나 또는 디폴트 벡터 레지스터 크기가 이중 크기이면 벡터 레지스터 Rn이 이중 크기 벡터 레지스터인 지를 가리킨다. 오피코드 필드 Opc는 오퍼런드에 대해 수행된 연산을 식별하고, 필드 TT는 로드 또는 저장으로서 전송 유형을 식별한다. 전형적인 REAR 포맷 명령은 스칼라 레지스터 SRb 및 SRi의 내용을 더함으로서 결정된 어드레스로부터 레지스터 Rn을 로드하는 명령어 VL이다. 만일 비트 A가 세트되면 산출된 어드레스는 스칼라 레지스터 SRb에 저장된다.
REAI 포맷 명령은 필드 IMM으로부터의 8 비트 중간 값이 스칼라 레지스터 SRi의 내용 대신에 사용된다는 것을 제외하고 REAR 명령과 동일하다. REAR 및 REAI 포맷은 데이타 엘리먼트 크기 필드를 가지고 있지 않다.
RRRM 5 포맷은 두개의 소스 오퍼런드와 하나의 목적지 오퍼런드를 갖는 명령어를 위한 것이다. 이들 명령은 세개의 레지스터 오퍼런드 또는 두개의 레지스터 오퍼런드중 어느 하나와 5 비트 중간 값을 갖는다. 부록 E에 도시된 바와 같이 필드 D, S 및 M의 엔코딩은 첫번째 소스 오퍼런드 Ra가 스칼라 또는 벡터 레지스터 인지; 두번째 소스 오퍼런드 Rb/IM 5가 스칼라 레지스터, 벡터 레지스터, 또는 5 비트 중간 값인지; 그리고 목적지 레지스터 Rd가 스칼라 또는 벡터 레지스터인지를 판단한다.
RRRR 포맷은 네개의 레지스터 오퍼런드를 갖는 명령어를 위한 것이다. 레지스터 번호 Ra 및 Rb는 소스 레지스터를 가리킨다. 레지스터 번호 Rd는 목적지 레지스터를 가리키고, 레지스터 번호 Rc는 필드 Opc에 따라 소스 또는 목적지 레지스터중 어느 하나를 가리킨다. 모든 오퍼런드는 비트 S가 레지스터 Rb를 가리키도록 세트되어 있지 않는 한 벡터 레지스터이다. 필드 DS는 벡터 레지스터를 위한 데이타 엘리먼트 크기를 가리킨다. 필드 Opc는 32 비트 데이타 엘리먼트를 위한 데이타 유형을 선택한다.
RI 포맷 명령은 중간 값을 레지스터로 로드한다. 필드 IMM은 18 비트까지의 중간 값을 수용한다. 레지스터 번호 Rd는 현재의 뱅크에 있는 벡터 레지스터 또는 비트 D에 따른 스칼라 레지스터중 어느 하나인 목적지 레지스터를 가리킨다. 필드 DS 및 F는 각각 데이타 엘리먼트 크기와 유형을 가리킨다. 32 비트 정수 데이타 엘리먼트의 경우, 18 비트 중간 값은 레지스터 Rd로 로드되기 전에 확장된 부호이다. 부동 소수점 데이타 엘리먼트의 경우, 비트 18, 비트 17 내지 10 및 비트 9 내지 0은 각각 32 비트 부동 소수점 값의 부호, 지수 및 가수를 가리킨다.
CT 포맷은 흐름 제어 명령어를 위한 것이고 오피 코드 필드 Opc, 조건 필드 Cond, 및 32 비트 중간 값 IMM을 포함한다. 조건 필드에 의해 가리켜진 조건이 참일 때 분기가 취해진다. 가능한 조건은 항상, 보다 적은, 같은, 적거나 같은, -이상인, 같지 않은, -이상이거나 같은, 및 오버플로우이다. 상태 및 제어 레지스터 VCSR에 있는 비트 GT, EQ, LT 및 SO는 조건을 평가하는데 사용된다.
포맷 RRRM9는 3개의 레지스터 오퍼런드 또는 두개의 레지스터 오퍼런드중 어느 하나와 9 비트 중간 값을 제공한다. 비트 D, S 및 M의 조합은 어떤 오퍼런드가 벡터 레지스터, 스칼라 레지스터, 또는 9 비트 중간 값인 지를 가리킨다. 필드 DS는 데이타 엘리먼트 크기를 가리킨다. RRRM9* 및 RRRM9** 포맷은 RRRM9 포맷의 특수한 경우이고 오피 코드 필드 Opc에 의해 식별된다. RRRM9* 포맷은 소스 레지스터 번호 Ra를 조건 코드 Cond 및 ID 필드로 교체한다. RRRM9* 포맷은 중간 값의 최상위 비트를 조건 코드 Cond 및 비트 K로 교체한다. RRRM9* 및 RRRM9**의 부가적인 설명은 조건 이동 명령 VCMOV, 엘리먼트 마스크를 갖는 조건 이동 CMOVM과 관련하여 부록 E에 제시되어 있고 마스크 CMPV 명령과 비교하고 그것을 세트시킨다.
비록 본 발명이 특정 실시예를 참조로 서술되었지만, 본 설명은 만지 본 출원의 예일 뿐이면 한정하는 것으로 간주되어서는 않된다. 개시된 실시예의 다양한 변형과 조합은 다음의 특허 청구 범위 영역으로서 한정된 바와 같이 본 발명의 영역내에서 포괄된다.
부록 A
예시적인 실시예에서, 프로세서(110)는 ARM7 프로세서용 표준과 호환하는 범용 프로세서이다. ARM7 내의 레지스터의 설명을 위한 ARM 아키텍춰 문서 또는 ARM7 데이타 쉬트(1994년 12월 발행된 문서 번호 ARM DDI 0020C)를 참조한다.
백터 프로세서(120)와 인터렉트하기 위해 프로세서(110)는 벡터 프로세서를 시작하고 정지시키며; 동기화를 위한 것을 포함하여 벡터 프로세서 상태를 태스트 하고; 벡터 프로세서(120)에 있는 스칼라/특수 목적 레지스터로부터의 데이타를 프로세서(110)의 범용 레지스터로 전송하고; 및 범용 레지스터로부터의 데이타를 벡터 프로세서 스칼라/특수 목적 레지스터로 전송한다. 범용 레지스터와 벡터 프로세서 벡터 레지스터 간에 직접적인 전송 수단은 존재하지 않는다. 이와 같은 전송은 중간으로서 메모리를 필요로 한다.
표 A1은 벡터 프로세서 명령어를 위한 ARM7 명령어 세트로의 확장을 설명한다.
표 A2는 결함이 있는 명령을 실행하기 전에 검출되어 보고된 ARM7 예외를 열거한다. 예외 벡터 어드레스가 16 진수 주석으로 제시되어 있다.
다음은 ARM7 명령어 세트로의 확장 구문을 설명한다. 명명법 설명과 명령어 표맷을 위해서는 ARM 아키텍춰 문서 또는 ARM7 데이타 쉬트(1994년 12월 발행된 문서번호 ARM DDI 0020C)를 참조한다.
ARM 아키텍춰 코프로세서 인터페이스를 위해 세개의 명령어를 제공한다 :
1. 코프로세서 데이타 연산(CDP)
2 코프로세서 데이타 전송(LDC, STC)
3. 코프로세서 레지스터 전송(MRC, MCR)
MSP 아키텍춰 확장은 세가지 모든 형식을 이용한다.
코프로세서 데이타 연산 포맷(CDP)는 ARM7로 다시 통신할 필요가 없는 연산에 상요된다.
CDP 포맷
CDP 포맷에 있는 필드는 다음과 같은 규약을 갖는다 ;
코프로세서 데이타 전송 포맷(LDC, STC)은 벡터 프로세서의 레지스터의 서브셋을 직접 메모리로 로드하거나 저장하는데 사용된다. ARM7 프로세서는 워드 프로세서를 공급하는 것을 담당하고, 벡터 프로세서는 데이타를 공급하거나 또는 수락하고 전송된 워드 수를 제어한다. 상세한 설명을 위해서는 ARM7 데이타 쉬트를 참조한다.
LDC, STC 포맷
포맷에 있는 필드는 다음과 같은 규약을 갖는다 :
코프로세서 레지스터 전송 포맷(MRC, MCR)은 ARM7나 벡터 프로세서 간에 직접 정보를 통신하는데 사용된다. 이 포맷은 ARM7 레지스터와 벡터 프로세서 스칼라 또는 특수 목적 레지스터 간을 이동시키는데 사용된다.
MRC, MCR 포맷
포맷에 있는 필드는 다음 규약을 갖는다 :
(확장 ARM 명령어 설명)
확장 ARM 명령어는 알파벳 순서로 설명된다.
CACHE Cache 연산
포맷
어셈블러 구문
STC{cond} p15, cOpc, Address
CACHE{cond} Opc, Address
여기서 cond = {eq, he, cc, mi, pl, vs, vc, hi, Is, ge, It, gt, le, ai, nv} 및 Opc = {0, 1, 3}. LDC/STC 포맷의 CRn 필드가 Opc를 명시하는데 사용되기 때문에, 오피코드의 십진 표현은 첫번째 구문에서 글자 'c'가 선행하여야 한다(즉, 0 대신에 c 0 를 사용한다.)는 것에 유의한다. 어드레스 모드 구문에 대해서는 ARM7 데이타 쉬트를 참조한다.
설명
이 명령어는 Cond가 참일 때에만 실행된다. Opc3:0는 다음 연산을 명시한다:
연산
EA가 어떻게 산출되는 지에 대해서는 ARM7 데이타 쉬트를 참조한다.
예외
ARM7 보호 위반
INTVP 인터럽트 벡터 프로세서
포맷
어셈블러 구문
CDP{cond} p7, 1, c0, c0, co
INTVP{cond}
여기서 cond={eq, ne, cs, cc, mi, pl, vs, vc, hi, ls, ge, It, gt, le, al, ns}
설명
이 명령은 Cond가 참일 때 실행된다. 이 명령은 벡터 프로세서에게 중지하도록 시그날한다. ARM7은 벡터 프로세서가 중지할 때를 대기하지 않고 다음 명령을 계속 실행한다.
MFER 비지-대기 루프는 만일 벡터 프로세서가 이 명령이 실행된 후 정지되었는 지를 확인하는데 사용된다. 이 명령은 만일 벡터 프로세서가 이미 VP_IDLE 상태에 있다면 어떠한 영향도 없다.
비트 19:12, 7:15 및 3:0이 할당된다.
예외
이용가능하지 않은 벡터 프로세서
MFER 확장 레지스터로부터 이동
포맷
어셈블러 구문
MRC{cond} p7, 2, Rd, cp, 0
MFER{cond} Rd, RNAME
여기서 cond={eq, he, cs, cc, mi, pl, rs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd={r0...r15}, P={0, 1}, ER={0,...15} 및 RNAME은 아키텍춰하게 명시된 레지스터니모닉(즉, PERO 또는 CSR)을 가리킨다.
설명
본 명령은 Cond가 참일 때에만 실행된다. ARM7 레지스터 Rd는 이하의 표에 도시된 바와 같이, P:ER3:0로 명시된 확장 ER 레지스터로부터 이동된다. 확장 레지스터 설명에 대해서는 1.2절을 참조한다.
비트 19:17 및 7:5는 예약되어 있다.
설명
사용자 모드에 있는 동안 PERx를 액세스하려고 시도하는 것은 보호 위반.
MFVP 벡터 프로세서로부터의 이동
포맷
어셈블러 구문
MRC{cond} p7. 1. Rd. Crn. Crm. 0
MFER{cond} Rd. RNAME
여기서 cond={eq, ne, cs, cc, mi, pl, vs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd={r0...r15}, CRn={c0...c15}, CRm={c0...c15} 및 RNAME은 아키텍춰하게 명시된 레지스터 니모닉(즉, SP0 또는 VSR)을 가리킨다.
설명
본 명령은 Cond가 참일 때에만 실행된다. ARM7 레지스터 Rd는 벡터 프로세서의 스칼라/특수 목적 레지스터 CRn1:0 : CRm3:0으로부터 이동된다. 레지스터 전송을 위한 벡터 프로세서 레지스터 번호 할당에 대해서는 3.2.3절을 참조한다.
CRn3:2는 물론 비트 7.5는 예약되어 있다.
벡터 프로세서 레지스터 맵은 이하의 표에 도시된다. 벡터 프로세서 특수 목적 레지스터(SP0-SP15)에 대해서는 표 15를 참조한다.
SR0은 항상 제로의 32비트로서 판독되고 그것에 대한 기록은 무시된다.
설명
벡터 프로세서는 이용할 수 없음.
MTER 확장 레지스터로의 이동
포맷
어셈블러 구문
MRC{cond} p7, 2, Rd, cp, cER, 0
MFER{cond} Rd, RNAME
여기서 cond={eq, he, cs, cc, mi, pl, rs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd={r0...r15}, P={0, 1}, ER={0...15} 및 RNAME은 아키텍춰하게 명시된 레지스터 니모닉(즉, PERO 또는 CSR)을 가리킨다.
설명
본 명령은 Cond가 참일 때에만 실행된다. ARM7 레지스터 Rd는 이하의 표에 도시된 바와 같이 P:ER3:0으로 명시된 확장 레지스터 ER로부터 이동된다.
비트 19:17 및 7:5는 예약되어 있다.
설명
사용자 모드에 있는 동안 PERx를 액세스하려고 시도하는 것은 보호 위반.
MTVP 벡터 프로세서로부터의 이동
포맷
어셈블러 구문
MRC{cond} p7. 1. Rd. Crn. Crm. 0
MFVP{cond} Rd. RNAME
여기서 cond={eq, ne, cs, cc, mi, pl, vs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd={r0...r15}, CRn={c0...c15}, CRm={c0...c15} 및 RNAME은 아키텍춰하게 명시된 레지스터 니모닉(즉, SP0 또는 VCS)을 가리킨다.
설명
본 명령은 Cond가 참일 때에만 실행된다. ARM7 레지스터 Rd는 벡터 프로세서의 스칼라/특수 목적 레지스터 CRn1:0 : CRm3:0로부터 이동된다.
CRn3:2는 물론 비트 7.5는 예약되어 있다.
벡터 프로세서 레지스터 맵이 이하의 표에 도시되어 있다.
예외
벡터 프로세서는 이용할 수 없음.
PFTCH 프리훼치
포맷
어셈블러 구문
LDC{cond} p15, 2, Address
PFTCH{cond} Address
여기서 cond={eq, he, cs, cc, mi, pl, rs, vc, hi, ls, ge, lt, gt, le, al, nv}. 어드레스 모드 구문에 대해서는 ARM7 데이타 쉬트를 참조한다.
설명
본 명령은 Cond가 참일 때에만 실행된다. EA에 의해서 명시된 캐쉬 라인은 ARM7 데이타 캐쉬로 프리훼치된다.
연산
EA가 어떻게 계산되는지에 대해서는 ARM7 데이타 쉬트를 참조한다.
예외 : 없음.
STARTVP 시작 벡터 프로세서
포맷
어셈블러 구문
LDP{cond} p7, 0, c0, c0
STARTVP{cond}
여기서 cond={eq, he, cs, cc, mi, pl, vs, vc, hi, ls, ge, it, gt, le, al, nv}.
설명
본 명령은 Cond가 참일 때에만 실행된다. 이 명령은 벡터 프로세서에게 시그날 하여 실행을 시작할 수 있게 하고 VISRCvjp와 VISRCvip를 자동적으로 클리어한다. ARM7은 벡터 프로세서가 실행을 시작할 때까지 대기하지 않고 다음 명령을 계속 실행한다.
벡터 프로세서의 상태는 이 명령이 실행되기 전에 소정 상태로 초기화되어야 한다. 이 명령은 벡터 프로세서가 이미 VP_RUN 상태에 있으면 아무런 영향도 미치지 않는다.
비트 19:12, 7:5 및 3:0은 예약되어 있다.
예외
벡터 프로세서는 이용할 수 없다.
TESTSET 테스트와 세트
포맷
어셈블러 구문
MRC{cond} p7, 0, Rd, c0, cER, 0
TESTSET{cond} Rd, RNAME
여기서 cond={eq, he, cs, cc, mi, pl, rs, re, hi, ls, ge, lt, gt, le, al, nv}, Rd={r0...r15}, ER={0...15} 그리고 RNAME은 아키텍춰하게 명시된 레지스터 니모닉(즉, UER1 또는 VASYNC)를 가리킨다.
설명
본 명령은 Cond가 참일 때에만 실행된다. 이 명령은 UERx의 내용을 RD로 반환하고, UERx30를 1로 세트시킨다. 만일 ARM7 레지스터 15가 목적지 레지스터로 명시되어 있으면, 짧은 비지웨이트(busywait) 루프가 구현될 수 있도록 UERx30은 CPSR의 Z비트에서 반환된다.
예외 : 없음
부록 B
멀티미디어 프로세서(100)의 아키텍춰는 프로세서(110)가 MFER과 MTER 명령어로서 액서스하는 확장 레지스터를 정의한다. 상기 확장 레지스터는 전용 확장 레지스터와 사용자 확장 레지스터를 포함한다.
상기 전용 확장 레지스터는 대부분 멀티미디어 신호 프로세서의 동작을 제어하는데 사용된다. 이들은 표 B1에 도시되어 있다.
[표 B1]
전용 확장 레지스터.
제어 레지스터는 MSP(100)의 동작을 제어한다. CTR에 있는 모든 비트는 리셋시 클리어된다. 레지스터 정의가 표 B2에 도시되어 있다.
[표 B2]
CTR 정의.
상태 레지스터는 MSP(100)의 상태를 가리킨다. 필드 STR에 있는 모든 비트는 리셋시 클리어된다. 레지스터 정의가 표 B3에 도시되어 있다.
[표 B3]
STR 정의.
프로세서 버젼 레지스터는 프로세서들의 멀티미디어 신호 프로세서 군의 특수한 프로세서의 특수 버젼을 식별한다.
벡터 프로세서 인터럽트 마스크 레지스터 VIMSK는 프로세서(110)로의 벡터 프로세서 예외의 보고를 제거한다. VIMSK에 있는 각 비트는, VISRC 레지스터에 있는 대응하는 비트와 함께 세트될 때 예외를 인에블시켜 ARM7을 인터럽트시킨다. 벡터 프로세서 예외가 검출되는 방법에는 영향을 미치지 않지만, 예외가 ARM7을 인터럽트시켜야 하는 지에 대해서만 영향을 미친다. VIMSK에 있는 모든 비트는 리셋시 클리어한
*다. 레지스터 정의가 표 B4에 도시되어 있다.
[표 B4]
ARM7 명령어 어드레스 브레이크포인터 레지스터는 ARM7 프로그램을 디버스하는데 도움이 된다. 레지스터 정의가 표 B5에 도시되어 있다.
[표 B5]
ARM7 데이타 어드레스 브레이크포인터 레지스터는 ARM7 프로그램을 디버그하는데 도움이 된다. 레지스터 정의가 표 B6에 도시되어 있다.
[표 B6]
스크래치 패드 레지스터는 캐쉬 서브시스템(130)에 있는 SRAM을 이용하여 형성된 스크래치 패드의 어드레스와 크기를 컨피그한다. 레지스터 정의가 표 B7에 도시되어 있다.
[표 B7]
SPREG
사용자 확장 레지스터는 대부분 프로세서(110 및 120)의 동기화에 사용된다. 사용자 확장 레지스터는 비트 30으로 맵핑된 단지 하나의 비트만을 갖도록 현재 정의되어 있고, 예를 들어 MFER R15, UERx와 같은 명령은 비트 값을 Z 플래그로 반환한다. 비트 UERx31 및 UERx29:0는 항상 제로로 판독된다. 사용자 확장 레지스터가 표 B8에 설명되어 있다.
[표 B8]
확장 레지스터.
표 B9는 파우어-온 리셋시 확장 레지스터의 상태를 도시한다.
[표 B9]
확장 레지스터 파우어-온 상태
부록 C
벡터 프로세서(120)의 아키텍춰 상태는 : 32개의 32비트 스칼라 레지스터 ; 32개의 288 비트 벡터 레지스터의 2 뱅크 ; 한쌍의 576 비트 벡터 누산 레지스터 ; 한 세트의 32 비트 특수 목적 레지스터를 구비한다. 스칼라, 벡터 및 누산기 레지스터는 범용 목적 프로그래밍을 위해 의도되었고, 다른 많은 데이타 형을 지원한다.
다음 주석은 이와 같은 그리고 후속하는 절에 사용된다 : VR은 벡터 레지스터를 가리킨다 ; VRi는 i번째 벡터 레지스터(제로 오프셋)를 가리킨다 ; VR[i]는 벡터 레지스터 VR에서 i번째 데이타 엘리먼트를 가리킨다 ; VRa:b는 벡터 레지스터 VR에서 비트 a 내지 b를 가리킨다 ; 그리고 VR[i]a:b는 벡터 레지스터 VR에서 i번째 데이타 엘리먼트의 a 내지 b를 가리킨다.
벡터 아키텍춰는 하나의 벡터 레지스터내에 다수의 엘리먼트를 위한 데이타 형 및 크기의 부가된 치수를 갖는다. 벡터 레지스터가 고정된 크기이므로, 그것이 수용할 수 있는 데이타 엘리먼트의 수는 엘리먼트의 크기에 따른다. MSP 아키텍춰는 표 C1에 도시된 바와 같이 다섯개의 엘리먼트 크기를 갖는다.
[표 C1]
데이타 엘리먼트 크기
MSP 아키텍춰는 명령에 있는 명시된 데이타 형과 크기에 따라 벡터 데이타를 해석한다. 현재 2의 보수(정수) 포맷이 대부분의 아키텍춰 명령의 바이트, 바이트 9, 하프워드 및 워드 엘리먼트 크기에 지원된다. 게다가, 대부분의 아키텍춰 명령을 위한 워드 엘리먼트로서 IEEE 754 단일 정확도 포맷이 지원된다.
프로그래머는 명령어 시퀀스가 의미있는 결과를 내는 한 임의의 소정 방법으로 데이타를 자유로이 해석할 수 있다. 예를 들어, 프로그래머는 바이트 9 크기를 사용하여 8 비트 부호없는 숫자를 저장할 수 있고, 똑같이 바이트 크기 데이타 엘리먼트에 8 비트 부호없는 숫자를 자유로이 저장할 수 있고 프로그래머가 거짓 오버플로우 결과를 취급할 수 있는 한 제공된 2의 보수 아키텍춰 명령을 사용하여 자유로이 그들을 연산할 수 있다.
SR0 내지 SR31이라고 하는 32 스칼라 레지스터가 존재한다. 스칼라 레지스터는 32 비트 폭이고, 정의된 크기중 어느 한 크기의 한 데이타 엘리먼트를 수용할 수 있다. 스칼라 레지스터 SR0는 레지스터 SR0이 항상 제로의 32 비트로서 판독되고 레지스터 SR0에의 기록이 무시된다는 점에서 특수하다. 바이트, 바이트 9 및 하프워드 데이타 형은 최상위 비트가 정의되지 않은 값을 갖는 스칼라 레지스터의 최하위 비트에 저장된다.
레지스터가 데이타 형 표시기를 가지지 않기 때문에, 프로그래머는 각 명령에 사용되고 있는 레지스터의 데이타 형을 알아야만 한다. 이는 32 비트 레지스터가 32 비트 값을 수용하는 것으로 간주되는 다른 아키텍춰와는 다르다. MSP 아키텍춰는 데이타 형 A의 결과가 데이타 형 A에 대해 정된 비트 만을 정확히 수정하는 것을 명시한다. 예를 들어, 바이트 9 가산의 결과는 32 비트 목적지 스칼라 레지스터의 하위 9 비트만을 수정한다. 상위 23 비트의 값은 명령어에 대해 달리 지시되지 않는 한 정의되어 있지 않다.
64 벡터 레지스터는 각각 32 레지스터를 갖는 2 뱅크로 조직된다. 뱅크 0은 첫번째 32 레지스터를 수용하고, 뱅크 1은 두번째 32 레지스터를 수용한다. 두개의 뱅크는 하나의 뱅크가 현재의 뱅크로 세트되고 다른 뱅크가 대체 뱅크로 세트되는 방식으로 사용된다. 모든 벡터 명령은 대체 뱅크에 있는 벡터 레지스터를 액서스할 수 있는 명령들을 로드/저장 및 레지스터가 이동시키는 것을 제외하고, 디폴트로서 현재의 뱅크에 있는 레지스터를 사용한다. 벡터 제어 및 상태 레지스터 VCSR에 있는 CBANK 비트는 뱅크 0 또는 뱅크 1을 현재의 뱅크로 세트시키는데 사용된다(다른 뱅크는 대체 뱅크가 된다.). 현재의 뱅크에 있는 벡터 레지스터는 VR0 내지 VR31이라고 불리우고, 대체 뱅크에 있는 벡터 레지스터는 VRA0 내지 VRA31라고 불리운다.
선택적으로, 두개의 뱅크는 576 비트의 32 이중 크기 벡터 레지스터를 각각 제공하도록 개념적으로 합병될 수 있다. 제어 레지스터 VCSR에 있는 VEC64 비트는 이와 같은 모드를 명시한다. VEC64 모드에서, 어떠한 현재 및 대체 뱅크는 존재하지 않으며, 벡터 레지스터 번호는 두개의 뱅크로부터 대응하는 288 비트 벡터 레지스터 쌍을 지칭한다. 즉,
VRi576:0=VR1i287:0 : VR0i287:0
여기서, VR0및 VR1i는 뱅크 1 및 뱅크 0 각각에 레지스터 번호 VRi를 갖는 벡터 레지스터를 지칭한다. 이중 크기 벡터 레지스터는 VR0 내지 VR31로 불리운다.
벡터 레지스터는 표 C2에 도시된 바와 같이 바이트, 바이트 9, 하프워드 또는 워드 크기의 다수 엘리먼트를 수용할 수 있다.
[표 C2]
벡터 레지스터당 엘리먼트의 수
한 벡터 레지스터내의 엘리먼트 크기의 혼합은 지원되지 않는다. 바이트 9 엘리먼트 크기를 제외하고, 단지 288 비트의 256 만이 사용된다. 특히, 매 9번째 비트는 사용되지 않는다. 바이트, 하프워드 및 워드 크기에 있는 사용되지 않는 32 비트는 예약되고, 프로그래머는 그들 값에 대해 어떠한 가정도 해서는 안된다.
벡터 누산 레지스터는 목적지 레지스터에 있는 결과보다 정확도가 높은 중간결과를 위한 기억장치를 제공하도록 의도된다. 벡터 누산 레지스터는 VAC1H, VAC1L, VAC0H 및 VAC0L 이라고 하는 네개의 288 비트 레지스터로 구성된다. VAC0H : VAC0L 쌍은 디폴트로서 세개의 명령어에 의해 사용된다. VEC64 모에서만, VAC1H : VAC1L 쌍이 64 바이트 9 벡터 연산을 에뮬레이트하는 데 사용된다. 뱅크 1이 VEC32 모드에서 현재의 뱅크로 세트되더라도, VAC0H : VAC0L 쌍이 사용된다.
소스 벡터 레지스터에서와 같이 동일한 수의 엘리먼트를 갖는 확장된 정확도 결과를 내기 위해, 표 C3에 도시된 바와 같이 레지스터 쌍에 걸쳐 확장된 정확도 엘리먼트가 절약된다.
[표 C3]
벡터 누산기 포맷
VAC1H 및 VAC1L 쌍은 엘리먼트의 수가 바이트 9(및 바이트), 하프워드, 및 워드 각각에 대해 64, 32, 또는 16인 VEC64 모드에서만 사용된다.
메모리로부터 직접 로드되거나 또는 메모리에 직접 저장될 수 없는 33 특수 목
*[표C4]
특수 목적 레지스터가 존재한다. RASR0 내지 RASR15라고 불리우는 16개의 특수 목적 레지스터는 내부의 반환 어드레스 스택을 형성하고 서브루틴 호출 및 반환 명령에 의해 사용도니다. 17개의 32 비트 특수 목적 레지스터가 표C4에 도시되어 있다.
[표 C4]
특수 목적 레지스터.
벡터 제어 및 상태 레지스터 VCSR 정의가 표 C5에 도시되어 있다.
[표 C5]
VCSR 정의.
벡터 프로그램 카운터 레지스터 VPC는 벡터 프로서서(120)에 의해 실행될 다음 명령의 어드레스이다. ARM7 프로세서(110)는 벡터 프로세서(120)의 연산을 시작하기 위해 STARTVP 명령을 발생하기 전에 레지스터 VPC를 로드하여야 한다.
벡터 예외 프로그램 카운터 VEPC는 가장 최근의 예외를 유발할 가능성이 있는 명령어의 어드레서를 명시한다. MSP 100은 정확한 예외 즉, 가장 가능성이 있는 용어를 지원하지 않는다.
벡터 인터럽트 소스 레지스터 VISRC는 ARM7 프로세서(110)에 대한 인터럽트 소스를 가리킨다. 예외(들)의 검출시 적당한 비트(들)가 하드웨어에 의해 세트된다. 소프트웨어는 벡터 프로세서(120)가 실행을 재개할 수 있기 전에 레지스터 VISRC를 클리어하여야 한다. 레지스터 VISRC에 설정된 임의의 비트는 벡터 프로세서(120)로 하여금 상태 VP_IDLE에 진입하게 한다. 만일 대응하는 인터럽트 인에이블 비트가 VIMSK로 세트되어 있으면, 프로세서(110)에 대한 인터럽트가 시그날된다. 표 C6은 레지스터 VISRC의 내용을 정의한다.
[표 C6]
VISRC 정의.
벡터 인터럽트 명령어 레지스터 VIINS는 VCINT 또는 VCJOIN 명령이 ARM7 프로세서(110)를 인터럽트하기 위해 실행될 때 VCINT 또는 VCJOIN 명령으로서 갱신된다.
벡터 카운터 레지스터 VCR1, VCR2 및 VCR3는 감소 및 분기 명령 VD1CBR, VD2CBR2 및 VD3CBR이고, 실행될 루프 카운트로서 초기화된다. 명령어 VD1CBR이 실행될 때, 레지스터 VCR1은 1만큼 감소된다. 만일 카운트 값이 제로가 아니고 명령어에 명시된 조건이 VFLAG와 일치하면, 이때 분기가 취해진다. 만일 그렇지 않으면, 분기는 취해지지 않는다. 레지스터 VCR1은 어느 경우에나 1만큼 감소된다. 레지스터 VCR2 및 VCR3 도 이와 동일하게 사용된다.
벡터 전역 마스크 레지스터 VGMR0는, VEC32에서 영향을 미칠 목적지 벡터 레지스터의 엘리먼트와, VEC64 모드에서 VR287:0내에 있는 엘리먼트를 가리킨다. VGMR0의 각 비트는 벡터 목적지 레지스터의 9 비트의 갱신을 제어한다. 특히, VGMR0i는 VEC32 모드의 VRd9i+8:9i와 VEC64모드의 VR0d9i+8:9i의 갱신을 제어한다. VR0d는 VE64 모드에서 뱅크 0의 목적지 레지스터를 가리키고, VRd는 VEC32 모드에서 뱅크 0 또는 1 중 어느 하나일 수 있는 현재의 뱅크에 있는 목적지 레지스터를 가리킨다. 벡터 전역 마스크 레지스터 VGMR0는 VCMOVM명령을 제외하고 모든 명령의 실행에 사용된다.
벡터 전역 마스크 레지스터 VGMR1은 VEC64 모드에서 영향을 받는 VR575:288내의 엘리먼트를 가리킨다. VGMR1의 각 비트는 뱅크 1에서 벡터 목적지 레지스터에 있는 9 비트의 갱신을 제어한다. 특히, VGMR1i는 VR1d9i+8:9i의 갱신을 제어한다. 레지스터 VGMR1i는 VR1d9i+8:9i의 갱신을 제어한다. 레지스터 VGNR1은 VEC32 모드에서 사용되지 않지만, VEC64 모드에서 VCMOVM 명령을 제외하고 VEC32 명령에 사용되지 않는다.
벡터 오버플로우 레지스터 VOR0은 VEC 32 모드에 있는 엘리먼트와 벡터 산술연산후 오버플로우 결과를 수용하고 있는 VEC 64 모드에 있는 VR287:0내의 엘리먼트를 가리킨다. 이 레지스터는 스칼라 산술 연산에 의해 수정되지 않는다. 세트되는 비트 VOR0i는 바이트 또는 바이트 9 의 i번째 엘리먼트, 하프워드의 (i idiv 2)번째 엘리먼트, 또는 워드 데이타형 연산의 (i idiv 4)번째 엘리먼트가 오버플로우 결과를 포함하고 있다는 것을 가리킨다. 예를 들어, 비트 1 및 비트 3은 각각 첫번째 하프워드 및 워드 엘먼트의 오버플로우를 가리키도록 세트될 것이다. VOR0에 있는 비트들의 이와 같은 맵핑은 VGMR0 또는 VGMR1에 있는 비트의 맵핑과는 다르다.
벡터 오버플로우 레지스터 VOR1은 벡터 산술 연산후 오버플로우 결과를 포함하고 있는 VEC64 모드에서 VR575:288내의 엘리먼트를 가지는데 사용된다. 레지스터 VOR1은 VEC32 모드에서 사용되지도 않고 스칼라 산술 연산에 의해 수정되지도 않는다. 세트되고 있는 비트 VOR1i은 바이트 또는 바이트 9의 i번째 엘리먼트, 하프워드의 (i idiv 2)번째 엘리먼트, 또는 오버플로우 결과를 포함하고 있는 워드 데이타형 연산의 (i idiv 4)번째 엘리먼트를 가리킨다. 예를 들어, 비트 1 및 비트 3은 VR575:288에서 각각 첫번째 하프워드 및 워드 엘리먼트의 오버플로우를 가리키도록 세트될 것이다. VOR1에 있는 비트들의 맵핑은 VGMR0 또는 VGMR1에 있는 비트들의 맵핑과는 다르다.
벡터 명령 어드레스 브레이크포인트 레지스터 VIABR은 벡터 프로그램을 디버그하는데 도움이 된다. 레지스터 정의가 표 C7에 도시되어 있다.
[표 C7]
VIABR 정의.
벡터 데이타 어드레스 브레이크포인트 레지스터 VDABR은 벡터 프로그램을 디버그하는데 도움이 된다. 이 레지스터 정의가 표 C8에 도시되어 있다.
[표 C8]
VDABR 정의.
벡터 이동 마스크 레지스터 VMMR0는 모든 명령에 대해 VSCRSMM=1일 때는 물론 모든 경우에 VCMOVM 명령에 의해 사용된다. 레지스터 VMMR0는 VEC32 모드에서 영향을 받을 목적지 벡터 레지스터의 엘리먼트와 VEC64 모드에서 VR287:0내의 엘리먼트를 가리킨다. VMMR0의 각 비트는 벡터 목적지 레지스터의 9 비트의 갱신을 제어한다. 특히, VMMR0i는 VEC32 모드에서 VRd9i+8:9i과 VEC64 모드에서 VR0d9i+8:9i의 갱신을 제어한다. VR0d는 VEC64에서 뱅크 0의 목적지 레지스터를 가리키고, VRd는 VEC32 모드에서 뱅크 0 또는 1중 어느 하나일 수 있는 현재의 뱅크에서 목적지 레지스터를 가리킨다.
벡터 이동 마스크 레지스터 VMMR1는 모든 명령에 대해 VSCRSMM=1일 때는 물론 모든 경우에 VCMOVM 명령에 의해 사용된다. 레지스터 VMMR1는 VEC64 모드에서 영향을 받을 VR575:288내의 엘리먼트를 가리킨다. VMMR1의 각 비트는 뱅크 1에서 벡터 목적지 레지스터의 9 비트의 갱신을 제어한다. 특히, VMMR1i는 VR1d9i+8:9i의 갱신을 제어한다. 레지스터 VGMR1은 VEC32 모드에서 사용되지 않는다.
벡터 및 ARM7 동기화 레지스터 VASYNC는 프로세서(110 및 120)간의 동기화의 생산자/소비자를 제공한다. 현재, 단지 비트 30만이 정의되어 있다. ARM7 프로세서는 벡터 프로세서(120)가 상태 VP_RUN 또는 VP_IDLE에 있는 동안 명령어 MFER, MTER 및 TESTSET를 사용하여 레지스터 VASYNC를 액세스할 수 있다. 레지스터 VASYNC는 이들 명령들이 첫번째 16 벡터 프로세서의 특수 목적 레지스터를 벗어나 액세스할 수 없기 때문에 TVP 또는 MFVP 명령을 통해 ARM7 프로세서에 액세스할 수 없다. 벡터 프로세서는 VMOV 명령을 통해 레지스터 VASYNC를 액세스할 수 있다.
표 C9는 파우어-온 리셋시 벡터 프로세서의 상태를 도시한다.
[표 C9]
파우어-온 리셋시 벡터 프로세서
특수 목적 레지스터는 벡터 프로세서가 명령을 실행할 수 있기 전에 ARM7 프로세서(110)에 의해 초기화된다.
부록 D
각 명령은 소스 및 목적지 오퍼런드의 데이타 형을 암시하거나 또는 명시한다. 일부 명령은 한 가지 이상의 데이타 형과 동등하게 적용되는 시맨틱스를 갖는다. 일부 명령은 소스에 대한 하나의 데이타 형을 취하는 시맨틱스를 가지며, 그 결과에 대해 다른 데이타 형을 설명한다. 본 부록은 예시적인 실시예에 의해 지원되는 데이타 형을 설명한다. 본 장의 표 1은 지원되는 데이타 형 int8, int9, int16, int32 및 부동 데이타를 설명한다. 부호없는 정수 포맷은 지원되지 않고 부호없는 정수 값은 먼저 사용되기 전에 2의 보수 포맷으로 변환되어야 한다. 프로그래머는 오버플로우가 적절히 처리되는 한 부호없는 정수 또는 그가 선택한 임의의 다른 포맷으로서 산술 명령을 자유로이 사용한다. 아키텍춰는 2의 보수 정수 및 32 비트 부동 소수점 데이타 형만의 오버플로우를 정의한다. 아키텍춰는 부호없는 오버플로우에 필요한 8, 9, 16 또는 32 비트 연산의 캐리 아웃을 검출할 수 없다.
표 D1은 로드 연산에 의해 지원되는 데이타 크기를 도시한다.
[표 D1]
로드 연산에 의해 지원되는 데이타 크기.
아키텍춰는 데이타 형 경계일 메모리 어드레스 정렬을 명시한다. 즉, 바이트의 경우, 어떠한 정렬 조건도 존재하지 않는다. 하프워드의 경우, 정렬 조건은 하프워드 경계이다. 워드의 경우, 정렬 조건은 워드 경계이다.
표 D2는 저장 연산에 의해 지원되는 데이타 크기를 도시한다.
[표 D2]
저장 연산에 의해 지원되는 데이타 크기.
스칼라이거나 또는 벡터이거나 하나 이상의 dam형이 레지스터에 맵핑되기 때문에, 일부 데이타 형에 대해 정의된 결과를 갖지 않는, 목적지 레지스터에 비트가 존재할 수 있다. 사실, 벡터 목적지 레지스터에 대한 바이트 9 데이타 크기 연산과 스칼라 목적지 레지스터에 대한 워드 데이타 크기 연산을 위한 이외에, 그 값이 연산에 의해 정의되지 않은 목적지 레지스터에 비트가 존재한다. 이들 비트들의 경우, 아키텍춰는 그들 값이 정의될 것을 지정한다. 표 D3은 각각의 데이타 크기에 대해 정의되지 않은 비트들을 도시한다.
[표 D3]
데이타 크기에 대해 정의되지 않은 비트.
프로그래밍시 프로그래머는 항상 소스 및 목적지 레지스터 또는 메모리의 데이타 형을 알고 있어야 한다. 한 엘리먼트 크기에서 다른 것으로 데이타 형 변환은 잠재적으로 벡터 레지스터에 저장되는 수가 다른 엘리먼트로 되는 결과가 된다. 예를 들어, 하프워드에서 워드 데이타 형으로 벡터 레지스터의 변환은 동일한 수의 변환된 엘리먼트를 저장하기 위해 두개의 벡터 레지스터를 필요로 한다. 역으로, 벡터 레지스터에서 사용자가 정의한 포맷을 가질 수 있는 워드 데이타 형에서 하프 포맷으로의 변환은 벡터 레지스터의 1/2에 동일한 수의 엘리먼트 그리고 다른 절반에 나머지 비트들을 발생시킨다. 어느 경우건, 데이타 형 변환은 소스 엘리먼트와는 다른 크기인 변환된 엘리먼트의 배열에 아키텍춰의 문제를 야기한다.
원칙적으로, MSP 아키텍춰는 엘리먼트의 수를 묵시적으로 변환시키는 연산을 결과로서 제공한다. 아키텍춰는 프로그래머가 목적지 레지스터에 있는 엘리먼트의 수를 바꾼 결과를 알고 있어야만 한다고 본다. 아키텍춰는 하나의 데이타 형에서 동일한 크기의 다른 데이타 형으로 변환하는 연산만을 제공하고, 프로그래머로 하여금 하나의 데이타 형에서 크기가 다른 데이타 형으로 변환할 때 데이타 크기의 차이를 조정할 것으로 요구한다.
부록 E에 서술된 것과 같이 VSHFLL 및 VUNSHFLL와 같은 특수한 명령은 하나의 데이타 크기를 갖는 하나의 벡터에서 다른 데이타 크기를 갖는 다른 벡터로의 변환을 단순히 한다. 예를 들면 벡터 VRa에서 보다 작은 엘리먼트 크기, int8에서 보다 큰 엘리먼트 예를 들면 int 16으로의 2의 보수 데이타 형을 변환하는 것에 관련된 기본적인 스텝은 다음과 같다 :
1. 바이트 데이타 형을 이용하여 다른 벡터 VRb를 갖는 VRa에 있는 엘리먼트를 두개의 벡터 VRc: VRd로 셔플한다. VRa에 있는 엘리먼트는 이중 크기 레지스터 VRc: VRd에 있는 int 16 데이타 엘리먼트의 하위 바이트로 이동되고, 그 값이 무관한 VRb의 엘리먼트가 VRc: VRd의 상위 바이트로 이동된다. 이 연산은 바이트에서 하프워드로 각 엘리먼트의 크기를 배가시키면서, VRa의 엘리먼트 절반을 VRc로, 다른 절반을 VRd로 효율적으로 이동시킨다.
2. VRc에 있는 엘리먼트를 부호 확장하기 위해 8 비트 산술 쉬프트시킴.
예를 들면 벡터 VRa에 있는 보다 큰 엘리먼트의 크기, int16에서 예를 들면 보다 작은 크기, int 6로 2의 보수 데이타 형을 변환하는 것에 관련된 기본 스텝은 다음과 같다 :
1. int16 데이타 형에 있는 각 엘리먼트가 바이트 크기로 표현가능한 지를 점검한다. 만일 필요하다면, 양쪽 모두에 엘리먼트를 포화시켜 보다 작은 크기에 끼워 맞춘다.
2. VRa의 엘리먼트를 다른 VRb로서 두개의 벡터 VRc: VRd속에 언셔플한다. VRa및 VRb에 있는 각 엘리먼트의 상위 절반은 VRc로 이동되고 하위 절반은 VRd로 이동된다. 이는 VRd의 하위 절반에 있는 VRa의 모든 엘리먼트의 하부 절반을 효율적으로 수집한다.
3. 특수 명령이 다음과 같은 데이타 형 변환에 제공된다 : 단일 정확도 부동 소수점에 대해 int32 ; 고정 소수점에 대해 단일 정확도 부동 소수점(X, Y 주석) ; int32에 대해 단일 정확도 부동 소수점 ; int9 에 대해 int8 ; int16에 대해 int9 ; 및 int9에 대해 int16.
벡터 프로그래밍에 유연성을 제공하기 위해, 대부분의 벡터 명령은 엘리먼트 마스크를 사용하여 벡터내의 선택된 엘리먼트에 대해서만 연산한다. 벡터 전역 마스크 레지스터 VGMR0 및 VGMR1는 벡터 명령에 의해 목적지 레지스터 및 벡터 누산기에서 수정된 엘리먼트를 식별한다. 바이트 및 바이트 9 데이타 크기 연산의 경우, VGMR0(또는 VGMR1)에 있는 32 비트 각각은 연산될 엘리먼트를 식별한다. 세트되고 있는 비트 VGMR0i는 여기서 i가 0에서 31까지인 바이트 크기의 엘리먼트 i가 영향을 받게 될 것이라는 것을 가리킨다. 하프워드 데이타 크기 연산의 경우, VGMR0(또는 VGMR1)에 있는 32 비트의 각 쌍은 연산될 엘리먼트를 식별한다. 세트되고 있는 비트들 VGMR02i:2i+1는 여기서 i가 0에서 15까지인 엘리먼트 i가 영향을 받을 것이라는 것을 가리킨다. 만일, VGMR0에 있는 쌍의 한 비트만이 하프워드 데이타 크기 연산을 위해 세트되면, 대응하는 바이트에 있는 비트만이 수정된다. 워드 데이타 크기 연산의 경우, VGMR0(또는 VGMR1)에 있는 네개 비트의 각 세트는 연산될 엘리먼트를 식별한다. 세트되고 있는 비트들 VGMR04i:4i+3는 여기서 i가 0에서 7까지인 엘리"
VGMR0 및 VGMR1는 VCMPM 명령을 사용하여 벡터 레지스터를 벡터 또는 스칼라 레지스터 또는 중간값과 비교함으로서 세트될 수 있다. 이 명령은 지정된 데이타 크기에 따라 마스크를 적절히 세트시킨다. 스칼라 레지스터가 하나의 데이타 엘리먼트만을 수용하도록 정의되어 있기 때문에, 스칼라 연산(즉, 목적지 레지스터가 스칼라인)은 엘리먼트 마스크에 의해 영향을 받지 않는다.
벡터 프로그래밍에서의 유연성을 위해, 대부분의 MSP 명령은 세가지 형태의 벡터 및 스칼라 연산을 지원한다. 이들은 다음과 같다 :
1. 벡터 = 벡터 op 벡터
2. 벡터 = 벡터 op 스칼라
3. 스칼라 = 스칼라 op 스칼라
스칼라 레지스터가 B 오퍼런드로서 명시된 2의 경우, 스칼라 레지스터에 있는 하나의 엘리먼트는 벡터 A 오퍼런드 내의 엘리먼트의 수와 일치할 필요가 있는 수만큼 복제된다. 복제된 엘리먼트는 지정된 스칼라 오퍼런드에 있는 엘리먼트와 동일한 값이다. 스칼라 오퍼런드는 중간 오프런드 형태로 스칼라 레지스터 또는 명령으로부터 올 수 있다. 중간 오퍼런드의 경우, 만일 지정된 데이타 형이 중간 필드 크기로서 이용할 수 있는 것 보다 큰 데이타 크기를 이용한다면 적당하게 부호 확장된다.
많은 멀티미디어 어플리케이션에서, 소스, 중간 및 결과의 정밀도에 대해 많은 관심이 모아져야만 한다. 또한, 정수 곱셈 명령은 두개의 벡터 레지스터에 저장될 수 있는 이중 정밀도 중간 결과를 만든다.
MSP 아키텍춰는 현재 8, 9, 16 및 32 비트 엘리먼트를 위한 2의 보수 정수 포맷과 32 비트 엘리먼트를 위한 IEEE 754 단일 정확도 포맷을 지원한다. 오버플로우는 명시된 데이타 형으로서 표현할 수 있는 가장 양의 또는 가장 음의 값을 벗어난 결과로 정의된다. 오버플로우가 발생할 때, 목적지 레지스터에 기록된 값은 무효 숫자가 아니다. 언더플로우는 부동 소수점 연산에 대해서만 정의되어 있다.
달리 정의하지 않는 한, 모든 부동 소수점 연산은 VCSRRMODE에 명시된 네개의 라운딩 모드중 하나를 이용한다. 일부 명령은 라운드 어웨이 프럼 제로(round away from zero)(라운드 이븐(round even)) 라운딩 모드라고 알려진 것을 이용한다.
포화(saturation)는 많은 멀티미디어 어플리케이션에 있어서 중요한 기능이다. MSP 아키텍춰는 네가지 모든 정수 및 부동 소수점 연산에서의 포화를 지원한다. 레지스터 VCSR에 있는 비트 ISAT는 정수 포화 모드를 명시한다. 고속 IEEE 모드로도 알려진 부동 소수점 포화 모드는 VCSR에서 FSAT로 명시되어 있다. 포화모드가 인에블되면, 가장 양의 또는 음의 값을 벗어난 결과가 가장 양의 또는 가장 음의 값으로 각각 세트된다. 이 경우 오버플로우는 발생할 수 없고, 오버플로우 비트는 세트될 수 없다.
표 D4는 결함이 있는 명령이 실행되기 전에 검출되어 보고되는 정확한 예외를 열거한다.
[표 D4]
정확한 예외.
표 D5는 결함이 있는 명령 이외의 차후의 프로그램에 있는 몇가지 명령을 실행한 후 검출되어 보고된 부정확한 예외를 열거한다.
[표 D5]
부정확한 예외.
부록 E
벡터 프로세서를 위해 세트된 명령은 표 E1에 도시된 바와 같이 11개로 분류할 수 있다.
[표 E1]
벡터 명령 분류 요약.
표 E2는 흐름 제어 명령을 열거한다.
[표 E2]
흐름 제어 명령.
논리적 분류는 부울린 데이타 형을 지원하고, 엘리먼트 마스크에 의해 영향을 받는다. 표 E3은 흐름 제어 명령을 열거한다.
[표 E3]
논리적 명령.
쉬프트/회전 분류 명령은 int8, int9, int16 및 int32 데이타 형(부동 데이타 형 없음)에 대해 연산하고, 엘리먼트 마스크에 의해 영향을 받는다. 표 E4는 쉬프트/회전 분류 명령을 열거한다.
[표 E4]
쉬프트 회전 분류
산술 분류 명령은 일반적으로, int8, int9, int16, int32 부동 데이타 형을 지원하고, 엘리먼트 마스크에 의해 영향을 받는다. 지원되지 않는 데이타 형에 대한 특정한 제한에 대해서는, 이하의 각 명령에 대한 상세한 설명을 참조한다. VCMPV 명령은 엘리먼트 마스크에 대해 연산을 하기 때문에 엘리먼트 마스크에 의해 영향을 받지 않는다. 표 E5는 산술 분류 명령을 열거한다.
[표 E5]
산술 분류.
MPEG 명령은 MPEG 엔코딩 및 디코딩에 특별히 적합한 명령어의 분류이지만, 다양한 방법을 사용될 수 있다. MPEG 명령은 int8, int9, int16 및 INT32 데이타 형을 지원하고, 엘리먼트 마스크에 의해 영향을 받는다. 표 E6은 MPEG 명령을 열거한다.
[표 E6]
MPEG 분류.
각각의 데이타 형 변환 명령은 특정 데이타 형을 지원하고, 아키텍춰가 레지스터에 있는 하나 이상의 데이타 형을 지원하지 않기 때문에 엘리먼트 마스크에 의해 영향을 받지 않는다. 표 E7은 데이타 형 변환 명령을 열거한다.
[표 E7]
데이타 형 변환 분류.
명령의 엘리먼트간 산술 분류는 int8, int9, int16, int32 및 부동 데이타 형을 지원한다. 표 E8은 엘리먼트간 산술 분류를 열거한다.
[표 E8]
엘리먼트간 산술 분류.
명령의 엘리먼트간 이동 분류는 바이트, 바이트9, 하프워드 및 워드 데이타 크기를 지원한다. 표 E9는 명령의 엘리먼트간 이동 분류를 열거한다.
[표 E9]
엘리먼트간 이동 분류.
로드/저장 명령은 바이트, 하프워드 및 워드 데이타 크기 이외에 특수한 바이트 9 관련 데이타 크기 연산을 지원하고, 엘리먼트 마스크에 의한 영향을 받지 않는다. 표 E10은 로드/저장 분류에 있는 명령들을 열거한다.
[표 E10]
로드/저장 분류.
대부분의 레지스터 이동 명령은 int8, int9, int16, int32 및 부동 데이타형을 지원하고, 엘리먼트 마스크에 의한 영향을 받지 않는다. VCMOVM 명령만이 엘리먼트 마스크에 의한 영향을 받는다. 표 E11은 명령의 레지스터 이동 분류를 열거한다.
[표 E11]
레지스터 이동 분류.
표 E12 는 캐쉬 서브시스템(130)을 제어하는 캐쉬 연산 분류에 있는 명령을 열거한다.
[표 E12]
캐쉬 연산 분류.
명령어 설명 명명
명령어 세트의 명세를 간단히 하기 위해, 부록 전반에 걸쳐 특수한 용어가 사용된다. 예를 들어, 명령어 오퍼런드는 달리 정의되지 않는 한, 바이트, 바이트 9, 하프워드 또는 워드 크기의 부호가 있는 2의 보수 정수이다. 레지스터라는 용어는 범용(스칼라 또는 벡터) 레지스터를 가리키는데 사용된다. 다른 종류의 레지스터는 명시적으로 설명되어 있다. 어셈블리 언어 구문에서, 첨자 b, b9, h 및 w는 데이타 크기(바이트, 바이트 9, 하프우드 및 워드) 및 정수 데이타 형(int8, int9, int16 및 int32) 모두를 지칭한다. 또한, 명령어 오퍼런드, 연산, 및 어셈블리 언어 구문을 설명하는데 사용된 용어와 기호는 다음과 같다 :
Rd : 목적지 레지스터 (벡터, 스칼라 또는 특수 목적용)
Ra, Rb : 소스 레지스터 a 및 b (벡터 또는 스칼라)
Rs : 데이타 소스 레지스터 저장 (벡터 또는 스칼라)
S : 32 비트 스칼라 또는 특수 목적 레지스터
VR : 현재의 뱅크 벡터 레지스터
VRA : 대체 뱅크 벡터 레지스터
VR0: 뱅크 0 벡터 레지스터
VR1: 뱅크 1 벡터 레지스터
VRd : 벡터 목적지 레지스터 (VRA가 명시되어 있지 않는 한 현재의 뱅크에 대한 디폴트)
VRa, VRb : 벡터 소스 레지스터 a 및 b
VRc : 벡터 소스 또는 목적지 레지스터 c
VRs : 벡터 저장 데이타 소스 레지스터
VAC0H : 벡터 누산기 레지스터 0 하이
VAC0L : 벡터 누산기 레지스터 0 로우
VAC1H : 벡터 누산기 레지스터 1 하이
VAC1H : 벡터 누산기 레지스터 1 로우
SRd : 스칼라 목적지 레지스터
SRa, SRb : 스칼라 소스 레지스터 a 및 b
SRb+ : 유효 어드레스로 베이스 레지스터의 갱신
SRs : 스칼라 저장 데이타 소스 레지스터
SP : 특수 목적 레지스터
VR[i] : 벡터 레지스터 VR에 있는 i번째 엘리먼트
VR[i]a:b : 벡터 레지스터 VR에 있는 i번째 엘리먼트의 비트 a 내지 b
VR[i]msb : 벡터 레지스터 VR에 있는 i번째 엘리먼트의 최상위 비트
EA : 메모리 액세스를 위한 유효 어드레스
MEN : 메모리
BYTE[EA] : EA에 의해 어드레스되는 메모리의 한 바이트
HALF[EA] : EA에 의해 어드레스되는 메모리의 하프워드. 비트 15:8는 EA+1에 의해 어드레스 된다.
WORD[EA] : EA에 의해 어드레스되는 메모리의 워드. 비트31:24는 EA+3에 의해 어드레스 된다.
NumElem : 소정의 데이타 형에 대한 엘리먼트의 수를 가리킨다. 이는 VEC32 모드에서 바이트 및 바이트 9, 하프워드, 또는 워드 데이타 크기 각각에 대해 32, 16, 8 이다. 이는 VEC64 모드에서 바이트 및 바이트 9, 하프워드, 또는 워드 데이타 크기 각각에 대해 64, 32 또는 16이다. 스칼라 연산의 경우, NumElem은 0이다.
EMASK[i] : i번째 엘리먼트에 대한 엘리먼트 마스크를 가리킨다. 이는 바이트 및 바이트 9, 하프워드 또는 워드 데이타 크기에 대해 각각 VGMR0/1,~VGMR0/1, VMMR0/1,~VMMR0/1를 표현한다. 스칼라 연산의 경우, 엘리먼트 마스크는 EMASK[i]=0일 지라도 세트되는 것으로 가정한다.
MMASK[i] : i번째 엘리먼트에 대한 엘리먼트 마스크를 지칭한다. 이는 바이트 및 바이트 9, 하프워드 또는 워드 데이타 크기에 대해 각각 VMMR0 또는 VMMR1에 있는 1, 2, 또는 4 비트를 표현한다.
VCSR : 벡터 제어 및 상태 레지스터
VCSRx : VCSR에 있는 비트 또는 비트들을 가리킨다. x는 필드명이다.
VPC : 벡터 레지스터 크기는 VEC32에서는 32이고 VEC64에서는 64이다.
SPAD : 스크래치 패드
C 프로그래밍 구조는 연산의 제어 흐름을 설명하느데 사용된다. 예외는 다음과 같다 :
= 할당
: 연결
{x y}는 x 또는 y 사이의 선택을 가리킨다. (논리적이 아님 또는)
sex 지정된 데이타 크기로의 부호 확장
sex_dp 지정된 데이타 크기의 이중 정확도로 부호 확장
sign 부호 확장된 (산술) 우측 쉬프트
zex 지정된 데이타 크기로의 제로 확장
zero 제로 확장된 (논리적) 우측 쉬프트
좌측 쉬프트 (제로 필 인(fill in))
trnc7 선두 7 비트 (하프워드로부터)를 트렁케이트
trnc1 선두 1 비트 (바이트 9로부터)를 트렁케이트
% 모듈로 연산자
expression식의 절대값
/ 나눔(부동 데이타 형의 경우, 네개의 IEEE 라운딩 모드중 하나를 이용한다.)
// 나눔(라운드 어웨이 프럼 제로 라운딩 모드를 이용한다.)
saturate() 정수 데이타 형의 경우, 오버플로우를 생성하는 대신에 가장 음의 또는 가장 양의 값까지 포화. 부동 데이타 형의 경우, 포화는 양의 무한대, 음의 제로, 양의 제로, 또는 음의 무한대까지일 수 있다.
전반적인 명령어 포맷은 도 8 에 도시되어 있고 이하 서술된다.
REAR 포맷은 로드, 저장 및 캐쉬 연산 명령에 의해 사용되고, REAR 포맷에 있는 필드는 표 E13 에 제시된 바와 같이 다음 의미를 갖는다.
[표 E13]
REAR 포맷.
비트 17 : 15는 예약되어 있고, 아키텍춰에서 차후 확장과 호환하기 위해 제로이어야 한다. B : D 및 TT 필드의 일부 엔코딩은 정의되지 않는다.
프로그래머는 이와 같은 엔코딩이 이용될 때 아키텍춰가 예상되는 결과를 지정하지 않기 때문에 이들 엔코딩을 사용해서는 안된다. 표 E14는 VEC32 및 VEC64 모드 모두에서 지원되는(LT로서 TT 필드에서 인코드됨) 스칼라 로드 연산을 도시한다.
[표 E14]
VEC32 및 VEC64 모드에서의 REAR 로드 Ops
표 E15 는 비트 VCSR0이 클리어할 때 VEC32 모드에서 (LT로서 TT 필드에서 엔코드됨) 지원되는 벡터 로드 연산을 도시한다.
[표 E15]
VEC32 모드에서의 REAR 로드 Ops.
B 비트는 현재의 또는 대체 뱅크를 가리키는데 사용된다.
표 E16 은 VCSR0 비트가 클리어일 때 VEC64 모드에서 (LT로서 TT 필드에서 엔코드됨) 지원되는 벡터 로드 연산을 도시한다.
[표 E16]
VEC64 모드에서의 REAR 로드 Ops.
B 비트는 현재 및 대체 뱅크의 개념이 VEC64 모드에 존재하지 않기 때문에 64 바이트 벡터 연산을 가리키는데 사용된다.
표 E17 은 VEC32 및 VEC64 모드 모두에서 (ST로서 TT 필드에서 엔코드됨) 지원되는 스칼라 저장 연산을 열거한다.
[표 E17]
REAR 스칼라 저장 연산.
표 E18 은 VCSR0 비트가 클리어일 때 VEC32 모드에서 (ST로서 TT 필드에서 엔코드됨) 지원되는 벡터 저장 연산을 열거한다.
[표 E18]
VEC32 모드에서의 REAR 벡터 저장 연산.
표 E19 은 VCSR0 비트가 세트될 때 VEC64 모드에서 (ST로서 TT 필드에서 엔코드됨) 지원되는 벡터 저장 연산을 열거한다.
[표 E19]
VEC32 모드에서의 REAR 벡터 저장 연산.
B 비트는 현재 및 대체 뱅크의 개념이 VEC64 모드에 존재하지 않기 때문에 64 바이트 벡터 연산을 가리키는데 사용된다.
REAI 포맷은 로드, 저장 및 캐쉬 연산 명령에 의해 사용된다. 표 E20 은 REAI 포맷에 있는 필드는 필드의 의미를 도시한다.
[표 E. 20]
REAI 포맷.
REAR 및 REAI 포맷은 전달형에 대해 동일한 엔코딩을 이용한다. 추가적인 엔코딩에 대해서는 REAR 포맷을 참조한다.
RRRM5 포맷은 3개의 레지스터 또는 두개의 레지스터 및 5 비트 중간 오퍼런드를 제공한다. 표 E21 은 RRRM5 포맷에 대한 필드를 가리킨다.
[표 E21]
RRRM5 포맷.
비트 19 : 15는 예약되어 있고, 아키덱춰에서의 추후 확장과 호환하도록 제로이어야 한다.
모든 벡터 레지스터 오퍼런드는 달리 정의되지 않는 한 현재의 뱅크(이는 뱅크 0 또는 뱅크 1중 어느 하나일 수 있다.)를 참조한다. 표 E22 는 DS1:0이 00, 01 또는 10일 때 D:S:M 엔코딩을 열거한다.
[표 E22]
DS가 11과 같지 않을 때 RRRM5 D:S:M 엔코딩.
DS1:0이 11일 때, D:S:M 엔코딩은 다음과 같은 의미를 갖는다.
[표 E23]
DS이 11일 때, RRRM5 D:S:M 엔코딩.
RRRR 포맷은 네개의 레지스터 오퍼런드를 제공한다.
표 E24 는 RRRR 포맷의 필드를 도시한다.
[표 E24]
RRRR 포맷.
모든 벡터 레지스터 오퍼런드는 달리 정의되지 않는 한 현재의 뱅크(이는 뱅크 0 또는 뱅크 1중 어느 하나일 수 있다)를 참조한다.
RI 포맷은 로드 중간 임시 명령에 의해 사용된다. 표 E25 는 RI 포맷의 필드를 가리킨다.
[표 E25]
RI 포맷.
F:DS1:0 필드의 임의의 엔코딩은 정의되어 있지 않다. 프로그래머는 아키텍춰가 이와 같은 엔코딩이 사용되면 예상되는 결과를 명시하지 않기 때문에 이들 엔코딩을 사용해서는 안된다. Rd로 로드되는 값은 표 E26 에 도시된 바와 같이 데이타 형에 따른다.
[표 E26]
CT 포맷은 표 E27 에 도시된 필드를 포함한다.
[표 E27]
CT 포맷.
분기 조건은 VCSR[GT:EQ:LT] 필드를 이용한다. 오버플로우 조건은 세트되면 GT, EQ 및 LT 비트에 선행하는 VCSR[SO] 비트를 이용한다. VCCS와 VCBARR은 상술된 것과는 달리 Cond2:0 필드를 해석한다. 세부사항에 대해서는 그들 명령 설명을 참조한다.
RRRM9 포맷은 3개의 레지스터 또는 두개의 레지스터 및 9 비트 중간 오퍼런드를 명시한다. 표 E28 은 RRRM9 포맷의 필드를 가리킨다.
[표 E28]
RRRM9 포맷.
비트 19 : 15는 D : S : M 엔코딩이 중간 오퍼런드를 명시하지 않을 때 예약되고, 차후의 호환성을 보장하기 위해 제로이어야 한다.
모든 벡터 레지스터 오퍼런드는 달리 정의되지 않는 한 현재의 뱅크(이는 뱅크 0 또는 뱅크 1중 어느 하나일 수 있다.)를 참조한다. D : S : M 엔코딩은 중간 필드로부터 추출된 중간 값이 표 E29 에 도시된 바와 같이 DS1:0 엔코딩에 따른다는 것을 제외하고 RRRM5 포맷에 대한 표 E22 와 표 E23 에 도시된 것과 동일하다.
[표 E29]
RRRM9 포맷의 중간값.
중간 포맷은 부동 데이타 형과는 사용할 수 없다.
다음에서, MSP 벡터 명령은 알파벳 순서로 나타난다. 주:
1. 명령은 달리 정의되지 않는 한 엘리먼트 마스크에 의해 영향을 받는다. CT 포맷 명령은 엘리먼트 마스크에 의해 영향을 받지 않는다. 로드, 저장 및 캐쉬 명령으로 구성되는 REAR 및 REAI 포맷 명령도 역시 엘리먼트 마스크에 의해 영향을 받지 않는다.
2. 9 비트 중간 오퍼런드는 부동 데이타 형과 사용할 수 없다.
3. 연산 설명에서, 벡터 형식만이 제시된다. 스칼라 연산의 경우, 오로지 하나만을 가정하면 0번째 엘리먼트가 정의된다.
4. RRRM5 및 RRRM9 포맷의 경우, 다음 엔코딩이 정수 데이타 형(b, b9, h, w)에 사용된다.
5. RRRM5 및 RRRM9 포맷의 경우, 다음 엔코딩이 부동 데이타 형에 사용된다.
6. 오버플로우를 유발하는 모든 명령에 대해, VCSRISAT 비트가 세트될 때 int8, int9, int16, int32 최대 또는 최소 한계값까지의 포화가 적용된다. 따라서, 부동 소수점 결과는 VCSRFSAT 비트가 세트될 때 -무한대, -제로, +제로 또는 +무한대까지 포화된다.
7. 구문으로 보아, .n은 바이트 9 데이타 크기를 가리키기 위해 .b9 대신에 사용될 수 있다.
8. 모든 명령에 대해, 목적지 레지스터 또는 벡터 누산기로 반환된 부동 소수점 결과는 IEEE 754 단일 정확도 포맷이다. 부동 소수점 결과는 누산기의 하부에 기록되고 상부는 수정되지 않는다.
VAAS3 덧셈 및 (-1, 0, 1)의 부호 덧셈
포맷
어셈블러 구문
VAAS3.dtVRd, VRa, VRb
VAAS3.dtVRd, VRa, SRb
VAAS3.dtSRd, SRa, SRb
where dt = {b, b9, h, w}
여기서 dt = {b, b9, h, w}
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 내용이 Rb에 더해져 중간 결과를 내고, 다음이 이 중간 결과는 Ra의 부호와 더해지며; 최종적인 결과는 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for(j =0 ; i NumElem EMASK[i] ; i++) {
if (Ra[i] 0)extsgn3 = 1 ;
else if (Ra[i] 0)extsgn3 = -1 ;
elseextsgn3 = 0 ;
Rd[i] = Ra[i] + Rb[i] + extsgn3 ;
}
예외
오버플로우.
VADAC 덧셈 및 누산
포맷
어셈블러 구문
VADAC.dtVRc, VRd, VRa, VRb
VADAC.dtSRc, SRd, SRa, SRb
여기서 dt = {b, b9, h, w}
지원되는 모드
설명
Ra 및 Rb 오퍼런드의 각 엘리먼트를 벡터 누산기의 각 이중 정확도 엘리먼트와 더하고, 각 엘리먼트의 이중 정확도 합을 벡터 누산기와 목적지 레지스터 Rc 및 Rd 모두에 저장한다. Ra 및 Rb는 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(int8, int9, int16 및 int32 각각에 대해 16, 18, 32 및 64 비트)을 이용한다. 각각의 이중 크기 정확도 엘리먼트의 상부는 VACH와 Rc에 저장되고, Rc에 있는 그 결과는 정의되지 않는다.
연산
for (i =0 ; i NumElem EMASK[i] ; i++) {
Aop[i] = {VRa[i]∥SRa} ;
Bop[i] = {VRb[i]∥SRb} ;
VACH[i] : VACL[i] = sex(Aop[i]+Bop[i])+VACH[i]:VACL[i] ;
Rc[i] = VACH[i] ;
Rd[i] = VACL[i] ;
}
VADACL 덧셈 및 로우 누산
포맷
어셈블러 구문
VADACL.dtVRd, VRa, VRb
VADACL.dtVRd, VRa, SRb
VADACL.dtVRd, VRa, #IMM
VADACL.dtSRd, SRa, SRb
VADACL.dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w}
지원되는 모드
설명
Ra 및 Rb/중간 오퍼런드의 각 엘리먼트를 벡터 누산기의 각각의 확장된정확도 엘리먼트와 더하고, 확장된 정확도 합계를 벡터 누산기에 저장하고, 그 하위 정확도를 목적지 레지스터 Rd로 반환한다. Ra 및 Rb/중간은 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(itn8, int9, int16 및 int32 각각에 대해 16, 18, 32 및 64 비트)을 이용한다. 각각의 확장된 정확도 엘리먼트의 상부는 VACH에 저장된다.
연산
for (i =0 ; i NumElem EMASK[i] ; i++) {
Bop[i] = {VRb[i]∥SRb∥sex(IMM8:0)} ;
VACH[i] : VACL[i] = sex(Ra[i]+Bop[i])+VACH[i]:VACL[i] ;
Rd[i] = VACL[i] ;
}
VADD 덧셈
포맷
어셈블러 구문
VADD.dtVRd, VRa, VRb
VADD.dtVRd, VRa, SRb
VADD.dtVRd, VRa, #IMM
VADD.dtSRd, SRa, SRb
VADD.dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w, f}
지원되는 모드
설명
Ra 및 Rb/중간 오퍼런드를 더하고 그 합계를 목적지 레지스터 Rd로 반환한다.
연산
for (i =0 ; i NumElem EMASK[i] ; i++) {
Bop[i] = {VRb[i]∥SRb∥sex(IMM8:0)} ;
Rd[i] = Ra[i]+Bop[i] ;
}
예외
오버플로우, 부동 소수점 무효 오퍼런드
[VADDH인접하는 두개의 엘리먼트 덧셈]
포맷
어셈블러 구문
VADDH.dtVRd, VRa, VRb
VADDH.dtVRd, VRa, SRb
여기서 dt = {b, b9, h, w, f}
지원되는 모드
설명
연산
for (i = 0 ; i NumElem - 1 ; i++) {
Rd[i] = Ra[i] + Ra[i+1] ;
}
Rd[NumElem - 1] = Ra[NumElem - 1] + {VRb[0]SRb} ;
예외
오버플로우, 부동 소수점 무효 오퍼런드
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향을 받지 않는다.
[VANDAND]
포맷
어셈블러 구문
VAND.dtVRd, VRa, VRb
VAND.dtVRd, VRa, SRb
VAND.dtVRd, VRa, #IMM
VAND.dtSRd, SRa, SRb
VAND.dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
지원되는 모드
설명
Ra 및 Rb/중간 오퍼런드를 논리적으로 AND하고, 그 결과를 목적지 레지스터 Rd로 반환한다.
연산
for (i = 0 ; i NumElem EMASK[i] ; i++) {
Bop[i] = {VRb[i]SRbsex(IMM8:0)} ;
Rd[i]k = Ra[i]k Bop[i]k, k = for all bits in element i ;
}
예외
없음.
[VANDCAND 보수]
포맷
어셈블러 구문
VANDC.dtVRd, VRa, VRb
VANDC.dtVRd, VRa, SRb
VANDC.dtVRd, VRa, #IMM
VANDC.dtSRd, SRa, SRb
VANDC.dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
지원되는 모드
설명
Ra 및 Rb/중간 오퍼런드의 보수를 논리적으로 더하고, 그 결과를 목적지 레지스터 Rd에 반환한다.
연산
for (i = 0 ; 1 NumElem EMASK[i] ; i++) {
Bop[i] = {VRb[i]SRbsex(IMM8:0)} ;
Rd[i]k = Ra[i]k ~Bop[i]k, k = for all bits in element i ;
}
예외
없음.
[VASA산술 쉬프트 누산기]
포맷
어셈블러 구문
VASAL.dt
VASAR.dt
여기서 dt = {b, b9, h, w}이고, R은 좌측 또는 우측의 쉬프트 방향을 지칭한다.
지원되는 모드
설명
벡터 누산기 레지스터의 각 데이타 엘리먼트는 제로가 우측(만일 R=0이면)에서부터 채우며 1비츠 위치만큼 쉬프트되거나 또는 부호 확장(만일 R=1이면)으로 1비트 위치만큼 우로 쉬프트된다. 그 결과는 벡터 누산기에 저장된다.
연산
for (i = 0 ; 1 NumElem EMASK[i] ; i++) {
if (R 〓 1)
VAC0H[i]:VAC0L[i] = VAC0H[i]:VAC0L[i] sign 1 ;
else
VAC0H[i]:VAC0L[i] = VAC0H[i]:VAC0L[i] 1 ;
}
예외
오버플로우.
[VASL좌측 산술 쉬프트]
포맷
어셈블러 구문
VASL.dtVRd, VRa, SRb
VASL.dtVRd, VRa, #IMM
VASL.dtSRd, SRa, SRb
VASL.dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w}.
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 각 데이타 엘리먼트는 스칼라 레지스터 Rb 또는 IMM 필드에 주어진 쉬프트 양만큼 제로가 우측에서부터 채우며 1비트 좌로 쉬프트되고, 그 결과는 그 부호에 따라 최대 양 또는 최대 음의 값까지 포화된다. 상기 쉬프트 양은 부호없는 정수가 되도록 정의된다.
연산
shift_amount = {SRb % 32IMM4:0} ;
for (i = 0 ; i NumElem EMASK[i] ; i++) {
Rd[i] = saturate(Ra[i] shift_amount) ;
}
예외
없음.
프로그래밍 주석
shift_amount는 SRb 또는 IMM4:0으로부터 5 비트 숫자로서 취해진다. 바이트, 하프워드 데이타 형인 경우, 프로그래머는 데이타 크기에 있어 비트의 숫자보다 적거나 같은 쉬프트 양을 정확히 명시할 책임이 있다. 만일 쉬프트 양이 지정된 데이타 크기보다 크면, 엘리먼트는 제로로 채워질 것이다.
[VASR우측 산술 쉬프트]
포맷
어셈블러 구문
VASR.dtVRd, VRa, SRb
VASR.dtVRd, VRa, #IMM
VASR.dtSRd, SRa, SRb
VASR.dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w}.
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 각 데이타 엘리먼트는 스칼라 레지스터 Rb 또는 IMM 필드의 최하위 비트에 주어진 쉬프트 양만큼 스최상위 비트 위치에서 부호가 확장되어 우로 산술적을 쉬프트되고, 그 결과는 벡터/스칼라 레지스터 Rd에 저장된다. 쉬프트 양은 부호없는 정수가 되도록 정의된다.
연산
shift_amount = {SRb % 32IMM4:0} ;
for (i = 0 ; i NumElem EMASK[i] ; i++) {
Rd[i] = Ra[i] sign shift_amount ;
}
예외
없음.
프로그래밍 주석
shift_amount는 SRb 또는 IMM4:0으로부터 5 비트 숫자로서 취해진다. 바이트, 바이트9, 하프워드 데이타 형인 경우, 프로그래머는 데이타 크기에 있어 비트의 숫자보다 적거나 같은 쉬프트 양을 정확히 명시할 책임이 있다. 만일 쉬프트 양이 지정된 데이타 크기보다 크면, 엘리먼트는 보호 비트로 채워질 것이다.
포맷
어셈블러 구문
VASS3.dtVRd, VRa, VRb
VASS3.dtVRd, VRa, SRb
VASS3.dtSRd, SRa, SRb
여기서 dt = {b, b9, h, w}.
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 내용이 Rb에 더해져 중간 결과를 내고, 다음에 Ra의 부호가 상기 중간 결과로부터 감산되고, 최종 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for (i = 0 ; i NumElem EMASK[i] ; i++) {
if (Ra[i] 0)extsgn3 = 1 ;
else if (Ra[i] 0)extsgn3 = -1 ;
elseextsgn3 = 0 ;
Rd[i] = Ra[i] + Rb[i] - extsgn3 ;
}
예외
오버플로우.
[VASUB뺄셈 절대값]
포맷
어셈블러 구문
VASUB.dtVRd, VRa, VRb
VASUB.dtVRd, VRa, SRb
VASUB.dtVRd, VRa, #IMM
VASUB.dtSRd, SRa, SRb
VASUB.dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w, f}.
지원되는 모드
설명
벡터/스칼라 레지스터 Rb 또는 IMM 필드의 내용이 벡터/스칼라 레지스터 Ra의 내용으로부터 감산되고 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for (i = 0 ; i NumElem EMASK[i] ; i++) {
Bop[i] = {Rb[i]SRbsex(IMM8:0)} ;
Rd[i] = │Ra[i] - Bop[i]│;
}
예외
오버플로우.
[VAVG두 엘리먼트의 평균]
포맷
어셈블러 구문
VAVG.dtVRd, VRa, VRb
VAVG.dtVRd, VRa, SRb
VAVG.dtSRd, SRa, SRb
여기서 dt = {b, b9, h, w, f}. VAVGT를 이용하여 정수 데이타 형에 대한 트렁케이트(truncate) 라운딩 모드를 지정한다.
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 내용이 벡터/스칼라 레지스터 Rb의 내용에 더해져 중간 결과를 내고, 상기 중간 결과를 2로 나누고, 최종 결과가 벡터/스칼라 레지스터 Rd에 저장된다. 정수 데이타 형의 경우, 라운딩 모드는 만일 T=1이면 트렁케이트하고, 만일 T=0(디폴트)이면 제로로부터 라운트 어웨이된다. 부동 데이타 형의 경우, 라운딩 모드는 VCSRRMODE에 지정되어 있다.
연산
for (i = 0 ; i NumElem EMASK[i] ; i++) {
Bop[i] = {Rb[i]SRbsex(IMM8:0)} ;
Rd[i] = (Ra[i] + Bop[i])2;
}
예외
없음.
[VAVGH인접하는 두개의 엘리먼트의 평균]
포맷
어셈블러 구문
VAVGH.dtVRd, VRa, VRb
VAVGH.dtVRd, VRa, SRb
여기서 dt = {b, b9, h, w, f}. VAVGHT를 이용하여 정수 데이타 형에 대한 트렁케이트(truncate)라운딩 모도를 지정한다.
지원되는 모드
설명
각 엘리먼트에 대해, 엘리먼트의 인접하는 두개의 쌍을 평균한다. 정수 데이타 형의 경우, 라운딩 모드는 만일 T=1이면 트렁케이트하고, 만일 T=0(디폴트)이면 제로로부터 라운트 어웨이된다. 부동 데이타 형의 경우, 라운딩 모드는 VCSRRMODE에 지정되어 있다.
연산
for (i = 0 ; i NumElem -1 ; i++) {
Rd[i] = (Ra[i] + Ra[i+1])2;
}
Rd[NumElem-1] = (Ra[NumElem-1] + {VRb[0]SRb})2;
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향을 받지 않는다.
[VAVGQQuad 평균]
포맷
어셈블러 구문
VAVGQ.dtVRd, VRa, VRb
여기서 dt = {b, b9, h, w}. VAVGQT를 이용하여 정수 데이타 형에 대한 트렁케이트(truncate) 라운딩 모드를 지정한다.
지원되는 모드
설명
이 명령은 VEC64 모드에 지원되지 않는다.
이하의 도면에 도시된 바와 같이, T(트렁케이트를 위해 1, 제로에서 라운드 어웨이를 위해 0, 디폴트)에서 지정된 라운딩 모드를 사용하여 네개의 엘리먼트의 평균을 산출한다. 최좌측 엘리먼트(Dn-1)는 정의되어 있지 않다.
연산
for (i = 0 ; i NumElem-1 ; i++) {
Rd[i] = (Ra[i] + Rb[i] + Ra[i+1] + Rb[i+1])4;
}
예외
없음.
[VCACHE캐쉬 연산]
포맷
어셈블러 구문
VCACHE.fcSRb, SRi
VCACHE.fcSRb, #IMM
VCACHE.fcSRb+, SRi
VCACHE.fcSRb+, #IMM
여기서 fc = {0, 1}.
설명
이 명령은 벡터 데이타 캐쉬의 소프트웨어 관리를 위해 제공된다. 상기 데이타 캐쉬의 일부 또는 전부가 스크래치 패드로 컨피그될 때, 이 명령은 스크래치 패드에 영향을 주지 않는다.
다음 선택이 지원된다.
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향을 받지 않는다.
[VCAND보수 AND]
포맷
어셈블러 구문
VCAND.dtVRd, VRa, VRb
VCAND.dtVRd, VRa, SRb
VCAND.dtVRd, VRa, #IMM
VCAND.dtSRd, SRa, SRb
VCAND.dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w}. .w과 .f는 동일한 연산을 지정한다는 것에 유의한다.
지원되는 모드
설명
Ra 및 Rb/중간 오퍼런드의 보수를 논리적으로 AND하고, 그 결과를 목적지 레지스터 Rd로 반환한다.
연산
for (i = 0 ; i NumElem EMASK[i] ; i++) {
Bop[i] = {VRb[i]SRbsex(IMM8:0)} ;
Rd[i]k = ~Ra[i]k Bop[i]k, k = for all bits in element i ;
}
예외
없음.
[VCBARR조건 베리어]
포맷
어셈블러 구문
VCBARR.cond
여기서 cond = {0, -7}. 각각의 조건은 나중에 니모닉으로 주어질 것이다.
설명
조건이 유효한 한, 명령 및 차후의 모든 명령(나중에 프로그램 순서로 나타나는 명령)을 정체시킨다. Cond2:0 필드는 CT 포맷에서 다른 조건 명령과는 달리 해석된다.
다음 조건이 현재 정의되어 있다. :
연산
while (Cond 〓 true)
stall all later instructoins ;
예외
없음.
프로그래밍 주석
이 명령은 명령 실행을 강제로 일련화시키기 위해 소프트웨어에 제공된다. 이 명령은 부정확한 실행을 강제로 정확히 보고하도록 하는데 사용될 수 있다. 예를 들면, 만일 이 명령이 예외를 유발할 수 있는 산술 명령 즉후에 사용되면, 이 예외는 프로그램 카운터가 이 명령을 어드레스하는 것으로 보고될 것이다.
[VCBR조건 분기]
포맷
어셈블러 구문
VCBR.cond#Offset
여기서 cond = {un, lt, eq, le, gt, ne, ge, ov}.
설명
만일 Cond이 참이면 분기한다. 이는 지연된 분기가 아니다.
연산
If ( (Cond 〓 VCSR[SO,GT,EQ,LT])│(Cond 〓 un) )
VPC = VPC + sex(Offset22:0 * 4);
else VPC = VPC + 4;
예외
무효 명령 어드레스.
[VCBRI조건 분기 인다이렉트]
포맷
어셈블러 구문
VCBRI.condSRb
여기서 cond = {un, lt, eq, le, gt, ne, ge, ov}.
설명
만일 Cond이 참이면 분기한다. 이는 지연된 분기가 아니다.
연산
If ( (Cond 〓 VCSR[SO,GT,EQ,LT])│(Cond 〓 un) )
VPC = SRb31:2 : b'00 ;
else VPC = VPC + 4;
예외
무효 명령 어드레스.
[VCCS조건 콘택스트 스위치]
포맷
어셈블러 구문
VCCS #Offset
설명
만일 VIMSKcse가 참이면 콘택스트 스위치 서브루틴으로 점프한다. 이는 지연된 분기가 아니다.
만일 VIMSKcse가 참이면, VPC+4(반환 어드레스)가 반환 어드레스 스택에 저장된다. 그렇지 않으면, 실행은 VPC+4로 계속된다.
연산
If (VIMSKcse 〓 1) {
if (VSP4 15) {
VISRCRASO = 1 ;
signal ARM7 with RASO exception ;
VP_STATE = VP_IDLE ;
} else {
RSTACK[VSP3:0] = VPC + 4 ;
VSP4:0 = VSP4:0 + 1 ;
VPC = VPC + sex(Offset22:0 * 4) ;
}
}else VPC = VPC + 4;
예외
반환 어드레스 스택 오버플로우.
[VCHGCR제어 레지스터 변경]
포맷
어셈블러 구문
VCHGCR 모드
설명
이 명령은 벡터 프로세서의 동작 모드를 바꾼다.
모드에 있는 각 비트는 다음을 지정한다:
연산
예외
없음.
프로그래밍 주석
이 명령은 VMOV 명령으로 가능하기 보다는 보다 효율적인 방법으로 VCSR에 있는 제어 비트를 바꾸기 위해 하드웨어에 제공된다.
VCINT 조건 인터럽트 ARM7
포맷
어셈블러 구문
VCINT.cond#ICODE
여기서 cond = {un, lt, eq, le, gt, ne, ge, ov},
설명
만일 Cond이 참이면 실행을 중지하고 만일 인에이블 되면 ARM7을 인터럽트한다.
연산
If((Cond==VCSR[SO,GT,EQ,LT])|(Cond==un)) {
VISRCvip= l;
VIINS=[VCINT.cond#ICODE instruction];
VEPC=VPC;
if(VIMSKvie==1)signal ARM7 interrupt;
VP_STATE=VP_IDLE;
}
else VPC=VPC+4;
예외
VCINT 인터럽트.
VCJOIN ARM7 태스크와 조건 결합
포맷
어셈블러 구문
VCJOIN.cond#Offset
여기서 cond = {un, lt, eq, le, gt, ne, ge, ov}.
설명
만일 Cond이 참이면 실행을 중지하고 만일 인에이블 되면 ARM7을 인터럽트한다.
연산
If((Cond==VCSR[SO,GT,EQ,LT])|(Cond==un)) {
VISRCvjp= -1;
VIINS=[VCJOIN.cond#Offset instruction];
VEPC=VPC;
if(VIMSKvje==1)signal ARM7 interrupt;
VP_STATE=VP_IDLE;
}
else VPC=VPC+4;
예외
VCJOIN 인터럽트.
VCJSR 서브루틴으로 조건 점프
포맷
어셈블러 구분
VCJSR.cond#Offset
여기서 cond = {un, lt, eq, le, gt, ne, ge, ov}.
설명
만일 Cond이 참이면 서브루틴으로 점프한다. 이는 지연된 분기가 아니다.
만일 Cond가 참이면 VPC+4(반환 어드레스)가 반환 어드레스 스택에 저장된다. 만일 그렇지 않으면, 실행은 VPC+4로서 계속된다.
연산
If((Cond==VCSR[SO,GT,EQ,LT])|(Cond==un)) {
if(VSP415 ) {
VISRCRASO=1;
signal ARM7 with RASO exception;
VP_STATE=VP_IDLE;
} else {
RSTACK[VSP3:0]=VPC+4;
VSP4:0=VSP4:0+1;
VPC=VPC+sex(Offset22:0*4);
}
} else VPC=VPC+4;
예외
반환 어드레스 스택 오버플로우.
VCJSRI 서브루틴 인다이렉트로 조건 점프
포맷
어셈블러 구문
VCJSRI.cond SRb
여기서 cond={un, lt, eq, le, gt, ne, ge, ov}.
설명
만일 Cond이 참이면 서브루틴으로 인다이렉트 점프한다. 이는 지연된 분기가 아니다.
만일 Cond가 참이면 VPC+4(반환 어드레스)가 반환 어드레스 스택에 저장된다. 만일 그렇지 않으면, 실행은 VPC+4로서 계속된다.
연산
If((Cond==VCSR[SO,GT,EQ,LT])|(Cond==un)) {
if(VSP4:015) {
VOISRCRASO=1;
signal ARM7 with RASO exception;
VP_STATE=VP_IDLE;
} else {
RSTACK[VSP3:0]=VPC+4;
VSP4:0=VSP4:0+1;
VPC=SRb31:2:b'00;
}
} else VPC=VPC+4;
예외
반환 어드레스 스택 어버플로우.
VCMOV 조건 이동
포맷
어셈블러 구문
VCMOV.dt Rd.Rb.cond
VCMOV.dt Rd.#IMM.cond
여기서 dt = {b, b9, h, w, f), cond={un, lt, eq, le, gt, ne, ge, ov}. . f 데이타 형이 9 비트 중간 오퍼런드와 함께 지원되지 않는다는 것을 제외하고, .f와 .w는 동일한 연산을 지정하고 있다는 것에 유의한다.
지원되는 모드
설명
만일 Cond이 참이면 레지스터 Rb의 내용이 레지스터 Rd로 이동된다. ID1:0는 소스 및 목적지 레지스터를 부가적으로 명시한다;
VR 현재의 뱅크 벡터 레지스터
SR 스칼라 레지스터
SY 동기화 레지스터
VAC 벡터 누산기 레지스터(VAC 레지스터 엔코딩에 대해서는 VMOV 설명을 참조한다.)
연산
If((Cond==VCSR[SOV.GT.EQ.LT])|(Cond==un))
for(i=0;iNumElem;i++)
Rd[i]={Rb[i]||SRb||sex(IMM8:0)};
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다. VCMOVM은 엘리먼트 마스크에 의한 영향을 받는다.
벡터 누산기에 있는 확장된 부동 소수점 정확도 표현은 8 엘리먼트에 대해 576 비트를 사용한다. 따라서, 누산기에 관계된 벡터 레지스터 이동은 .b9 데이타 크기를 명시하여야 한다.
VCMOVM 엘리먼트 마스크와 조건 이동
포맷
어셈블러 구문
VCMOVM.dt Rd.Rb.cond
VCMOVM.dt Rd,#IMM.cond
여기서 dt = {b, b9, h, w, f}, cond={un, lt, eq, le, gt, ne, ge, ov}. .f 데이타 형이 9비트 중간 오퍼런드와 함께 지원되지 않는다는 것을 제외하고, .f와 .w는 동일한 연산을 지정하고 있다는 것에 유의한다.
지원되는 모드
설명
만일 Cond이 참이면 레지스터 Rb의 내용이 레지스터 Rd로 이동된다. ID1:0는 소스 및 목적지 레지스터를 부가적으로 명시한다:
VR 현재의 뱅크 벡터 레지스터
SR 스칼라 레지스터
VAC 벡터 누산기 레지스터(VAC 레지스터 엔코딩에 대해서는 VMOV 설명을 참조한다.)
연산
If((Cond==VCSR[SO,GT,EQ,LT])|(Cond==un))
for(i=0;iNumElem MMASK[i];i++)
Rd[i]={Rb[i]||SRb||sex(IMM8:0)};
예외
없음.
프로그래밍 주석
이 명령은 VMMR 엘리먼트 마스크에 의한 영향을 받는다-VCMOV은 엘리먼트 마스크에 의해 영향받지 않는다.
벡터 누산기에 있는 확장된 부동 소수점 정확도 표현은 8 엘리먼트에 대해 모든 576 비트를 사용한다. 따라서, 누산기에 관계된 벡터 레지스터 이동은 .b9 데이타 크기를 명시하여야 한다.
VCMPV 마스크의 비교 및 세트
포맷
어셈블러 구문
VCMPV.dt VRa,VRb, cond, mask
VCMPV.dt VRa, SRb, cond, mask
여기서 dt = {b, b9, h, w, f}, cond={lt, eq, le, gt, ne, ge}, 마스크={VGMR, VMMR}. 만일 어떠한 마스크도 지정되어 있지 않으면, VGMR이 가정된다.
지원되는 모드
설명
벡터 레지스터 VRa 및 VRb의 내용이 (VRa[i]-VRb[i]를 수행함으로서 엘리먼트 와이즈 비교되고, (만일 K=0이면) VGMR 또는 (만일 K=1이면) VMMR 레지스터에 있는 대응하는 비트 #i가 비교의 결과가 VCMPV 명령의 Cond 필드와 일치되면 세트된다. 예를 들면, 만일 Cond 필드가 (LT)보다 작으면, VGMR[i] 또는 VMMR[i] 비트가 만일 VRa[i]VRb[i]이면 세트될 것이다.
연산
for(i=0;iNumElem;i++) {
Bop[i]={Rb[i]||SRb||sex(IMM8:0)};
relationship[i]=Ra[i]?Bop[i];
if(K==1)
MMASK[i]=(relationship[i]==Cond)?True:False;
else
EMASK[i]=(relationship[i]==Cond)?True:False;
}
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VCNTLZ 선두 제로의 카운트
포맷
어셈블러 구문
VCNTLZ.dt VRd, VRb
VCNTLZ.dt SRd, SRb
여기서 dt = {b, b9, h, w}.
지원되는 모드
설명
Rb에 있는 각 엘리먼트에 대해, 선두 제로의 수를 카운트하고, Rd에 있는 카운트를 반환한다.
연산
for(i=0;iNumElem EMASK[i};i++) {
Rd[i]=number of leading zeroes (Rb[i]);
}
예외
없음.
프로그래밍 주석
만일 엘리먼트에 있는 모든 비트가 제로이면, 이때 그 결과는 엘리먼트 크기(바이트, 바이트9, 하프워드 또는 워드 각각에 대해 8, 9, 16 또는 32)와 같다.
선두 제로들의 카운트는(만일 VCMPR 명령이 후에 사용되면) 엘리먼트 위치의 인덱스과 반전관계를 갖는다. 엘리먼트 위치로 변환하기 위해, 소정의 데이타 형에 대해 NumElem으로 부터 VCNTLZ의 결과를 감산한다.
VCOR OR의 보수
포맷
어셈블러 구문
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
여기서 dt = {b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
지원되는 모드
설명
Ra 및 Rb/중간 오퍼런드의 보수를 논리적으로 OR하고 그 결과를 목적지 레지스터 Rd로 변환한다.
연산
for(i=0;iNumElem EMASK[i};i++) {
Bop[i]={VRb[i]||SRb||sex(IMM8:0)};
Rd[i]k=-Ra[i]k|Bop[i]k, k=for all bits in element i;
}
예외
없음.
VCRSR 서브루틴으로부터 조건 반환
포맷
어셈블러 구문
VCRSR.cond
여기서 cond = {un, lt, eq, le, gt, ne, ge, ov},
설명
만일 Cond가 참이면, 반환 어드레스 스택에 저장된 반환 어드레스로부터 실행이 계속된다. 만일 그렇지 않으면, VPC+4로서 실행을 계속한다.
연산
If((Cond==VCSR[SO,GT,EQ,LT])|(Cond==un)) {
if(VSP4:0==0) {
VISRCRASU=1;
signal RAM7 with RASU exception;
VP_STATE=VP_IDLE;
} else {
VSP4:0=VSP4:0-1;
VPC=SRTACK[VSP3:0];
VPC1:0=b'00;
}
} else VPC=VPC+4;
예외
무효 명령 어드레스. 어드레스 스택 오버플로우 반환
VCVTB9 바이트9 데이타 형의 변환
포맷
어셈블러 구문
VCVTB9.md VRd, VRb
VCVTB9.md SRd, SRb
여기서 md = {bb9, b9h, hb9}.
지원되는 모드
설명
Rb에 있는 각 엘리먼트는 바이트에서 바이트9(bb9), 바이트9에서 하프워드(b9h) 또는 하프워드에서 바이트9(hb9)로 변환된다.
연산
if(md1:0==0) { //bb9 for byte to byte9 conversion
VRd=VRb;
VRd9i+8=VRb9i+7i=0 to 31 (or 63 in VEC64 mode) }
else if (md1:0==2) { //b9h for byte9 to halfword conversion
VRd=VRb;
VRd18i+16:18i+9=VRb18i+8, i=0 to 15 (or 31 in VEC64 mode)}
else if (md1:0==3) //hb9 for halfword to byte9 conversion
VRd18i+8==VRb18i+9, i=0 to 15 (or 31 inVEC64 mode)
else VRd=undefined;
예외
없음.
프로그래밍 주석
b9h 모드와 함께 이 명령을 사용하기 전에, 프로그래머는 셔플 연산으로 벡터 레지스터에 있는 감소된 엘리먼트 수를 조정할 필요가 있다. hb9 모드와 함께 이 명령을 사용한 후, 프로그래머는 셔플 연산으로 목적지 벡터 레지스터에 있는 증가된 엘리먼트 수를 조정할 필요가 있다. 이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VCVTFF 부동 소수점을 고정 소수점으로 변환하기
포맷
어셈블러 구문
VCVTFF VRd, VRa, SRb
VCVTFF VRd, VRa, #IMM
VCVTFF SRd, SRa, SRb
VCVTFF SRd, SRa, #IMM
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 내용이 32 비트 부동 소수점에서 포맷 X. Y의 고정 소수점 실수로 변환되는데, 여기서 Y의 폭은 Rb(모둘로 32) 또는 IMM 필드에 의해 지정되고, X의 폭은 (32-Y의 폭)에 의해 지정된다. X는 정수 부분을 지칭하고, Y는 분수 부분을 지칭한다. 그 결과는 벡터/스칼라 레지스터 Rb에 저장된다.
연산
Y_size={SRb % 32 ||IMM4:0};
for(i=0;iNumElem;i++) {
Rd[i}=convert to 32-Y_size.Y_size format (Ra[i});
}
예외
오버플로우.
프로그래밍 주석
이 명령은 워드 데이타 크기만을 지원한다. 이 명령은 아키텍춰가 레지스터내의 복수 데이타 형을 지원하지 않기 때문에 엘리먼트 마스크를 사용하지 않는다. 이 명령은 정수 데이타 형에 대해 제로 라운딩 모드로부터 라운드 어웨이를 사용한다.
VCVTIF정수에서 부동 소수점으로의 변환
포맷
어셈블러 구문
VCVTIFVRd. VRb
VCVTIFVRd. SRb
VCVTIFSRd. SRb
지원되는 모드
설명
벡터/스칼라 레지스터 Rb의 내용이 int32에서 부동 데이타 형으로 변환되고 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for (i=0;iNumElem;i++){
Rd[i] = convert to floating point format (Rb[i]);
}
예외
없음.
프로그래밍 주석
이 명령은 워드 데이타 크기만 지원한다. 이 명령은 아키텍춰가 레지스터내의 복수 데이타 형을 지원하지 않기 때문에 엘리먼트 마스크를 사용하지 않는다.
VD1CBR VCR1의 감소 및 조건 분기
포맷
어셈블러 구문
VD1CBR.cond #Offset
여기서 cond={un, lt, eq, gt, ne, ge, ov}
설명
VCR1을 감소하고 만일 Cond가 참이면 분기한다. 이는 지연된 분기가 아니다.
연산
VCR1=VCR1-1;
If((VCR10)((Cond==VCSR[SO,GT,EQ,LT])}(Cond==un)))
VPC=VPC+sex(Offset22:0*4);
else VPC=VPC+4;
예외
무효 명령 어드레스.
프로그래밍 주석
VCR1은 분기 조건이 점검되기 전에 감소된다는 것에 유의한다. VCR1이 0일 때 이 명령의 실행은 루프 카운트를 232-1로 효과적으로 세트시킨다.
VD2CBRVCR2의 감소 및 조건 분기
포맷
어셈블러 구문
VD2CBR.cond #Offset
여기서 cond={un, lt, eq, gt, ne, ge, ov}
설명
VCR2을 감소하고 만일 Cond가 참이면 분기한다. 이는 지연된 분기가 아니다.
연산
VCR2=VCR2-1;
If((VCR20)((Cond==VCSR[SO,GT,EQ,LT])｜(Cond==un)))
VPC=VPC+sex(Offset22:0*4);
else VPC=VPC+4;
예외
무효 명령 어드레스.
프로그래밍 주석
VCR2는 분기 조건이 점검되기 전에 감소된다는 것에 유의한다. VCR2이 0일 때 이 명령의 실행은 루프 카운터를 232-1로 효과적으로 세트시킨다.
VD3CBRVCR3의 감소 및 조건 분기
포맷
어셈블러 구문
VD3CBR.cond #Offset
여기서 cond={un, lt, eq, gt, ne, ge, ov}
설명
VCR3을 감소하고 만일 Cond가 참이면 분기한다. 이는 지연된 분기가 아니다.
연산
VCR3=VCR3-1;
If((VCR30)((Cond==VCSR[SO,GT,EQ,LT])｜(Cond==un)))
VPC=VPC+sex(Offset22:0*4);
else VPC=VPC+4;
예외
무효 명령 어드레스.
프로그래밍 주석
VCR3는 분기 조건이 점검되기 전에 감소된다는 것에 유의한다. VCR3이 0일 때 이 명령의 실행은 루프 카운터를 232-1로 효과적으로 세트시킨다.
VDIV2N2n로 나누기
포맷
어셈블러 구문
VDIV2N.dt VRd, VRa, SRb
VDIV2N.dt VRd, VRa, #IMM
VDIV2N.dt SRd, SRa, SRb
VDIV2N.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w}
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 내용을 여기서 n이 스칼라 레지스터 Ra 또는 IMM의 양의 정수 내용인 2n으로 나누고, 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다. 이 명령은 라운딩 모드로서 트렁케이트(라운드 투워드 제로)를 사용한다.
연산
N={SRb % 32 ∥ IMM4:0};
for(i=0;iNumElem EMASK[i];i++){
Rd[i]=Ra[i]/2N;
}
예외
없음.
프로그래밍 주석
N은 SRb 또는 IMM4:0로부터 5 비트로서 취해진다. 바이트, 바이트9, 하프워드 데이타 형의 경우, 프로그래머는 데이타 크기에 있는 정확도보다 적거나 같은 N의 값을 정확하게 명시할 책임이 있다. 만일 명시된 데이타 크기의 정확도 보다 크면, 엘리먼트가 부호 비트에 채워질 것이다. 이 명령은 라운드 투워드 제로 라운딩 모드를 이용한다.
VDIV2N.F2n부동으로 나누기
포맷
어셈블러 구문
VDIV2N.f VRd, VRa, SRb
VDIV2N.f VRd, VRa, #IMM
VDIV2N.f SRd, SRa, SRb
VDIV2N.f SRd, SRa, #IMM
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 내용을 여기서 n이 스칼라 레지스터 Rb 또는 IMM의 양의 정수 내용인 2n으로 나누고, 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
N={SRb % 32 ∥ IMM4:0};
for(i=0;iNumElem EMASK[i];i++){
Rd[i]=Ra[i]/2N;
}
예외
없음.
프로그래밍 주석
N은 SRb 또는 IMM4:0로부터 5 비트 수로서 취해진다는 것에 유의한다.
VDIV초기화 나누기-불완전
포맷
어셈블러 구문
VDIVI.dsVRb
VDIVI.dsSRb
여기서 ds={b, b9, h, w}
지원되는 모드
설명
비복원 부호가 있는 정수 나눗셈의 초기 단계를 수행한다. 피젯수는 누산기에 있는 이중 정확도 부호가 있는 정수이다. 만일 젯수가 단일 정확도이면, 이중 정확도로 부호가 확장되어 VACOH 및 VACOL에 저장되어야 한다. 젯수는 Rb에 있는 단일 정확도의 부호가 있는 정수이다.
만일 피젯수의 부호가 젯수의 부호와 동일하면, Rb가 누산기 하이로부터 감산된다. 만일 그렇지 않으면, Rb가 누산기 하이에 가산된다.
연산
for(i=0;iNumElemEMASK[i];i++){
Bop[i]={VRb[i]∥SRb}
if(VACOH[i]msb==Bop[i]msb)
VACOH[i]=VACOH[i]-Bop[i];
else
VACOH[i]=VACOH[i]+Bop[i];
}
예외
없음.
프로그래밍 주석
프로그래머는 나눗셈 단계이전에 제로 케이스로 오버플로우 또는 나눗셈을 검출할 책임이 있다.
VDIVS나눗셈 단계-불완전
포맷
어셈블러 구문
VDIVS.dsVRb
VDIVS.dsSRb
여기서 ds={b, b9, h, w}
지원되는 모드
설명
비복원 부호가 있는 나눗셈의 하나의 순환 단계를 수행한다. 이 명령은 데이타 크기(즉, int9 데이타 형에 대해 int8에 대해 8번, int9에 대해 9번, int16에 대해 16 및 int32에 대해 32)만큼 실행되어야 한다. VDIVI 명령은 누산기에서 초기의 부분 나머지를 만드는 나눗셈 단계 이전에 사용되어야 한다.
젯수는 Rb에 있는 부호가 있는 단일 정확도 정수이다. 일단 지수 비트가 단계마다 추출되면 누산기의 최하위 비트로 쉬프트된다.
누산기에 있는 부분 나머지의 부호가 Rb에 있는 젯수의 부호와 동일하면, Rb가 누산기 하이로부터 감산된다. 그렇지 않으면, Rb는 누산기 하이에 더해진다.
만일 누산기에 있는 결과로 나타나는 부분 나머지(덧셈 또는 뺄셈의 결과)가 젯수의 부호와 동일하면, 지수 비트는 1이다. 그렇지 않으면, 지수 비트는 0이다. 누산기는 지수 비트를 채우도록 한 비트 위치만큼 좌로 쉬프트 된다.
나눗셈 단계의 결과에서, 나머지는 누산기 하이에 있고 지수는 누산기 로우에 있다. 지수는 1의 보수 형태이다.
연산
VESL1만큼 좌로 엘리먼트 쉬프트
포맷
어셈블러 구문
VESL.dtSRc, VRd, VRa, SRb
여기서 dt={b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
지원되는 모드
설명
벡터 레지스터 Ra에 있는 엘리먼트를 1위치 만큼 좌로 쉬프트하여, 스칼라 레지스터 Rb로부터 채운다. 쉬프트 아웃되는 최좌측 엘리먼트는 스칼라 레지스터 Rc에 반환되고 다른 엘리먼트는 벡터 레지스터 Rd에 반환된다.
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VESR1만큼 우로 엘리먼트 쉬프트
포맷
어셈블러 구문
VESL.dtSRc, VRd, VRa, SRb
여기서 dt={b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
지원되는 모드
설명
벡터 레지스터 Ra에 있는 엘리먼트를 1위치 만큼 우로 쉬프트하여, 스칼라 레지스터 Rb로부터 채운다. 쉬프트 아웃되는 최우측 엘리먼트는 스칼라 레지스터 Rc에 반환되고 다른 엘리먼트는 벡터 레지스터 Rd에 반환된다.
연산
SRc=VRa[0];
for(i=0;iNumElem-2;i++)
VRd[i]=VRa[i+1];
VRd[NumElem-1]=SRb;
예외
없음.
프로그래밍 주석.
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VEXRT한 엘리먼트의 추출
포맷
어셈블러 구문
VEXTRT.dtSRd, VRa, SRb
VEXTRT.dtSRd. VRa, #IMM
여기서 dt={b, b9, h, w}. .f와 .w는 동일한 연산을 명시하고 있다는 것에 유의한다.
지원되는 모드
설명
그 인덱스가 스칼라 레지스터 Rb 또는 IMM 필드로서 명시된 Ra 벡터 레지스터로부터 엘리먼트를 추출하고 그것을 스칼라 레지스터 Rd에 저장한다.
연산
index32={SRb % 32 ∥IMM4:0};
index64={SRb % 64 ∥IMM5:0};
index=(VCSRvec64) ?index64:index32;
SRd=VRa[index];
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VEXTSGN2(1, -1)의 부호를 추출
포맷
어셈블러 구문
VEXTSGN2.dtVRd, VRa
VEXTSGN2.dtSRd, SRa
여기서 dt={b, b9, h, w}.
지원되는 모드
설명
벡터/스칼라 레지스터 Ra 엘리먼트와이즈의 내용의 부호값이 계산되고 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for{i=0;iNumElem EMASK[i];i++){
Rd[i]=(Ra[i]0)?-1:1;
}
예외
없음.
VEXTSGN3(1, 0, -1)의 부호 추출
포맷
어셈블러 구문
VEXTSGN3.dt VRd. VRa
VEXTSGN3.dt SRd. SRa
여기서 dt={b, b9, h, w}.
지원되는 모드
설명
벡터/스칼라 레지스터 Ra 엘리먼트와이즈의 내용의 부호값이 계산되고 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for{i=0;iNumElem EMASK[i];i++){
if(Ra[i]0)Rd[i]=1;
else if(Ra[i]0)Rd[i]=-1;
elseRd[i]=0;
}
예외
없음.
VINSRT한 엘리먼트의 삽입
포맷
어셈블러 구문
VINSRT.dtVRd, SRa, SRb
VINSRT.dtVRd, SRa, #IMM
여기서 dt={b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
지원되는 모드
설명
스칼라 레지스터 Rb 또는 IMM 필드로 명시된 인덱스에서 스칼라 레지스터 Ra에 있는 엘리먼트를 벡터 레지스터 Rd에 삽입한다.
연산
index32={SRb % 32 ∥IMM4:0};
index64={SRb % 64 ∥IMM5:0};
index=(VCSRvec64) ?index64:index32;
VRd[index]=SRa;
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VL로드
포맷
어셈블러 구문
VL.ltRd, SRb, SRi
VL.ltRd, SRb, #IMM
VL.ltRd, SRb+, SRi
VL.ltRd, SRb+, #IMM
여기서 lt={b, bz9, ds9, h, w, 4, 8, 16, 32, 64}, Rd={VRd, VRAd, SRd}. .b와 .ds9는 동일한 연산을 명시하고 .64와 VRAd는 함께 명시될 수 없다는 것에 유의한다. 캐쉬-오프 로드를 위해 VLOFF를 사용한다.
설명
현재 또는 대체 뱅크에 있는 벡터 레지스터 또는 스칼라 레지스터를 로드한다.
연산
EA=SRb+{SRi∥sex(IMM7:0)};
if(A==1) SRb=EA;
Rd=see table below;
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VLCB 순환 버퍼로부터 로드
포맷
어셈블러 구문
VLCB.lt Rd, SRb, SRi
VLCB.lt Rd, SRb, #IMM
VLCB.lt Rd, SRb+, SRi
VLCB.lt Rd, SRb+, #IMM
여기서, lt={b, bz9, ds9, h, w, 4, 8, 16, 32, 64}, Rd={VRd, VRAd, SRd}. .b와 .ds9는 동일한 연산을 명시하고 .64와 VRAd는 함께 명시될 수 없다는 것에 유의한다. 캐쉬-오프 로드를 위해 VLCBOFF를 사용한다.
설명
SRb+1에 있는 BEGIN 포인터와 SRb+2에 있는 END 포인터로 가리켜진 순환 버퍼로부터 벡터 레지스터 또는 스칼라 레지스터를 로드한다.
만일 어드레스 갱신 연산은 물론 로드 이전에 END 어드레스 보다 크면 유효 어드레스가 조정된다. 또한, 순환 버퍼 바운드는 각각 .h 및 .w 스칼라 레지스터에 대해 하프워드 및 워드 경계상에서 정렬되어야 한다.
연산 EA=SRb+{SRi∥sex(IMM7:0)};
BEGIN=SRb+1;
END=SRb+2;
cbsize=END-BEGIN;
if(EAEND)EA=BEGIN+(EA-END):
if(A=1)SRb=EA;
Rd=see table below;
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
프로그래머는 다음 조건을 확실히 하여야 예상된대로 작동한다.
BEGINEA2*END-BEGIN
즉, EA-ENDEND-BEGIN은 물론 EABEGIN
VLD 이중 로드
포맷
어셈블러 구문
VLD.lt Rd, SRb, SRi
VLD.lt Rd, SRb, #IMM
VLD.lt Rd, SRb+, SRi
VLD.lt Rd, SRb+, #IMM
여기서, lt={b, bz9, ds9, h, w, 4, 8, 16, 32, 64}, Rd={VRd, VRAd, SRd}. .b와 .ds9는 동일한 연산을 명시하고 .64와 VRAd는 함께 명시될 수 없다는 것에 유의한다. 캐쉬-오프 로드를 위해 VLDOFF를 사용한다.
설명
현재 또는 대체 뱅크에 있는 두개의 벡터 레지스터 또는 두개의 스칼라 레지스터를 로드한다.
연산
EA=SRb+{SRi∥sex(IMM7:0)};
if(A=1)SRb=EA;
Rd:Rd+1=see table below;
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VL1 중간 로드
포맷
어셈블러 구문
VLI.dt VRd, #IMM
VLI.dt SRd, #IMM
여기서, dt={b, b9, h, w, f}
설명
중간값을 스칼라 또는 벡터 레지스터로 로드한다.
스칼라 레지스터 로드의 경우, 바이트, 바이트9, 하프워드 또는 워드는 데이타 형에 따라 로드된다. 바이트, 바이트9 및 하프워드 데이타 형의 경우, 영향받지 않는 바이트(바이트9)는 수정되지 않는다.
연산 Rd=이하의 표를 참조한다:
예외
없음.
VLQ Quad 로드
포맷
어셈블러 구문
VLQ.lt Rd, SRb, SRi
VLQ.lt Rd, SRb, #IMM
VLQ.lt Rd, SRb+, SRi
VLQ.lt Rd, SRb+, #IMM
여기서, lt={b, bz9, ds9, h, w, 4, 8, 16, 32, 64}, Rd={VRd, VRAd, SRd}. .b와 .ds9는 동일한 연산을 명시하고 .64와 VRAd는 함께 명시될 수 없다는 것에 유의한다. 캐쉬-오프 로드를 위해 VLQOFF를 사용한다.
설명
현재 또는 대체 뱅크에 있는 네개의 벡터 레지스터 또는 네개의 스칼라 레지스터를 로드한다.
연산 EA=SRb+{SRi∥sex(IMM7:0)};
if(A=1) SRb=EA;;
Rd:Rd+1:Rd+2:Rd+3=see table below;
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VLR 반전 로드
포맷
어셈블러 구문
VLR.lt Rd, SRb, SRi
VLR.lt Rd, SRb, #IMM
VLR.lt Rd, SRb+, SRi
VLR.lt Rd, SRb+, #IMM
여기서, lt={4, 8, 16, 32, 64}, Rd={VRd, VRAd}. 64와 VRAd는 함께 명시될 수 없다는 것에 유의한다. 캐쉬-오프 로드를 위해 VLROFF를 사용한다.
설명
역 엘리먼트 순으로 벡터 레지스터를 로드한다. 이 명령은 스칼라 목적지 레지스터를 지원하지 않는다.
연산 EA=SRb+{SRi∥sex(IMM7:0)};
if(A=1)SRb=EA;
Rd=see table below;
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
★
VLSL 논리적 좌측 쉬프트
포맷
어셈블러 구문
VLSL. dtVRd, VRa, SRb
VLSL. dtVRd, VRa, #IMM
VLSL. dtSRd, SRa, SRb
VLSL. dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w}
지원되는 모드
설명
벡터/스칼라 레지스터 Ra에 있는 각 엘리먼트의 스칼라 레지스터 Rb 또는 IMM 필드에 주어진 쉬프트 양만큼 제로의 최하위 비트(LSB) 위치에 채워지면서 논리적으로 좌로 비트 쉬프트되고, 그 결과는 벡터/스칼라 레지스터 Rd에 저장된다.
연산
shift_amount = (SRb%32∥IMM＜4:0＞};
for(i = 0:i ＜ NumElemEMASK[i] ; i++) {
Rd[i] = Ra[i]≪shift_amount;
}
예외
없음.
프로그래밍 주석
shift_amount은 SRb 또는 IMM＜4:0＞로부터 5비트 숫자로서 취해진다는 것에 유의한다. 바이트, 바이트9, 하프워드 데이타 형의 경우, 프로그래머는 데이타 크기에 있는 비트의 수보다 적거나 또는 같은 쉬프트 양을 정확하게 명시할 책임이 있다. 만일 쉬프트 양이 명시된 데이타 크기보다 크면, 엘리먼트는 제로로 채워질 것이다.
VLSR 논리적 우측 쉬프트
포맷
어셈블러 구문
VLSR. dtVRd, VRa, SRb
VLSR. dtVRd, VRa, #IMM
VLSR. dtSRd, SRa, SRb
VLSR. dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w}
지원되는 모드
설명
벡터/스칼라 레지스터 Ra에 있는 각 엘리먼트의 스칼라 레지스터 Rb 또는 IMM 필드에 주어진 쉬프트 양만큼 제로의 최하위 비트(MSB) 장소에 채워지면서 논리적으로 우로 비트 쉬프트되고, 그 결과는 벡터/스칼라 레지스터 Rd에 저장된다.
연산
shift_amount = (SRb%32∥IMM＜4:0＞};
for(i = 0:i ＜ NumElemEMASK[i] ; i++) {
Rd[i] = Ra[i]zero≫shift_amount;
}
예외
없음.
프로그래밍 주석
shift_amount은 SRb 또는 IMM＜4:0＞로부터 5비트 숫자로서 취해진다는 것에 유의한다. 바이트, 바이트9, 하프워드 데이타 형의 경우, 프로그래머는 데이타 크기에 있는 비트의 수보다 적거나 또는 같은 쉬프트 양을 정확하게 명시할 책임이 있다. 만일 쉬프트 양이 명시된 데이타 크기보다 크면, 엘리먼트는 제로로 채워질 것이다.
VLWS 스트라이드로 로드
포맷
어셈블러 구문
VLWS. ltRd, SRb, SRi
VLWS. ltRd, SRb, #IMM
VLWS. ltRd, SRb+, SRi
VLWS. ltRd, SRb+, #IMM
여기서 lt = {4, 8, 16, 32}, Rd={VRd, VRAd}, 64 모드는 지원되지 않는다 - 대신에 VL을 사용한다. 캐쉬-오프 로드를 위해 VLWSOFF를 사용한다.
설명
유요 어드레스에서 시작하여, 스칼라 레지스터 SRb+1를 스트라이드 제어 레지스터로서 이용하여 32 바이트가 메모리에서 벡터 레지스터 VRd로 로드된다.
LT는 블럭 크기, 각 블럭에 대해 로드할 연속적인 바이트의 수를 명시한다.
SRb+1는 스트라이드(stride), 두개의 연속하는 블럭의 시작을 분리하는 바이트의 수를 명시한다.
스트라이드는 블럭 크기와 같거나 커야 한다. EA는 데이타 크기가 정렬되어야 한다. 스트라이드와 블럭 크기는 복수의 데이타 크기이어야 한다.
연산
EA = SRb+{SRi∥ sex(IMM＜7:0＞)};
if(A = 1) SRb= EA;
Block_size = (4∥8∥16∥32);
Stride = SRb+1＜31:0＞;
for(i=0:i＜VECSIZE/Block_size;i++)
for(i=0:i＜Block_size;j++)
VRd[i*Block_size+j]＜8:0＞=sex BYTE[EA+i*Stride+j];
예외
무효 데이타 어드레스. 정렬되지 않은 액세스.
VMAC 곱셈과 누산
포맷
어셈블러 구문
VMAC. dtVRa, VRb
VMAC. dtVRa, SRb
VMAC. dtVRa, #IMM
VMAC. dtSRa, SRb
VMAC. dtSRa, #IMM
여기서 dt = {b, h, w, f}
지원되는 모드
설명
이중 정확도 중간 결과를 내기 위해 Ra의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 상기 중간 결과의 각 이중 정확도 엘리먼트를 벡터 누산기의 각 이중 정확도 엘리먼트에 더하고; 각 엘리먼트의 이중 정확도 합계를 상기 벡터 누산기에 저장한다.
Ra와, Rb는 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(int8, int16 및 int 32 각각에 대해 16, 32, 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 VACH에 저장된다.
부동 데이타 형의 경우, 모든 오퍼런드와 결과는 단일 정확도 형이다.
연산
for(i=0:i＜NumElemEMASK[i];i++){
Aop[i]={VRa[i]∥SRa};
Bop[i]={VRb[i]∥SRb};
if(dt=float) VACL[i]=Aop[i]*Bop[i]+VACL[i];
else VACH[i]:VACL[i]=Aop[i]*Bop[i]+VACH[i]:VACL[i];
}
예외
오버플로우, 부동 소수점 무효 오퍼런드.
프로그래밍 주석
이 명령은 int9 데이터 형을 지원하지 않는다 - 대신에 int16 데이타 형을 지원한다.
VMACF 분수의 곱셈과 누산
포맷
어셈블러 구문
VMACF. dtVRa, VRb
VMACF. dtVRa, SRb
VMACF. dtVRa, #IMM
VMACF. dtSRa, SRb
VMACF. dtSRa, #IMM
여기서 dt = {b, h, w}
지원되는 모드
설명
이중 정확도 중간 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 상기 중간 결과를 좌로 1비트 쉬프트 하고; 쉬프트된 중간 결과의 각 이중 정확도 엘리먼트를 벡터 누산기의 각 이중 정확도 엘리먼트에 더하고; 각 엘리먼트의 이중 정확도 합계를 상기 벡터 누산기에 저장한다.
VRa와, Rb는 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(int8, int16 및 int 32 각각에 대해 16, 32, 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 VACH에 저장된다.
연산
for(i=0:i＜NumElemEMASK[i];i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM＜8:0＞)};
VACH[i]:VACL[i]=((VRa[i]*Bop[i]≪1)+VACH[i]:VACL[i];
}
예외
오버플로우.
프로그래밍 주석
이 명령은 int9 데이터 형을 지원하지 않는다 - 대신에 int16 데이타 형을 지원한다.
VMACL 로우의 곱셈과 누산
포맷
어셈블러 구문
VMACL. dtVRd, VRa, VRb
VMACL. dtVRd, VRa, SRb
VMACL. dtVRd, VRa, #IMM
VMACL. dtSRd, SRa, SRb
VMACL. dtSRd, SRa, #IMM
여기서 dt = {b, h, w, f}
지원되는 모드
설명
이중 정확도 중간 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 상기 중간 결과의 각 이중 정확도 엘리먼트를 벡터 누산기의 각 이중 정확도 엘리먼트에 더하고; 각 엘리먼트의 이중 정확도 합계를 상기 벡터 누산기에 저장하고; 그 하부를 목적지 레지스터 VRd에 저장한다.
VRa와, Rb는 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(int8, int16 및 int 32 각각에 대해 16, 32, 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 VACH에 저장된다.
부동 데이타 형의 경우, 모든 오퍼런드와 결과는 단일 정확도 형이다.
연산
for(i=0:i＜NumElemEMASK[i];i++){
Bop[i]={VRb[i]∥SRb};
if(dt=float) VACL[i]=VRa[i]*Bop[i]+VACL[i];
else VACH[i]:VACL[i]=VRa[i]*Bop[i]+VACH[i]:VACL[i];
}
예외
오버플로우, 부동 소수점 무효 오퍼런드.
프로그래밍 주석
이 명령은 int9 데이터 형을 지원하지 않는다 - 대신에 int16 데이타 형을 지원한다.
VMAD 곱셈과 덧셈
포맷
어셈블러 구문
VMAD.dt VRc, VRd, VRa, VRb
VMAD.dt SRc, SRd, SRa, SRb
여기서 dt={b, h, w}.
지원되는 모드
설명
이중 정확도 중간 결과를 내기 위해 Ra의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 상기 중간 결과의 각 이중 정확도 엘리먼트를 Rc의 각 엘리먼트에 더하고; 각 엘리먼트의 이중 정확도 합계를 상기 목적지 레지스터 Rd+1:Rd에 저장한다.
연산
for(i=0;iNumElem EMASK[i]; i++){
Aop[i]={VRa[i] || SRa};
Bop[i]={VRb[i] || SRb};
Cop[i]={VRc[i] || SRc};
Rd+l[i]:Rd[i]=Aop[i]*Bop[i]+sex_dp(Cop[i]);
}
예외
없음.
VMAD L 로우의 곱셈과 덧셈
포맷
어셈블러 구문
VMADL.dt VRc, VRd, VRa, VRb
VMADL.dt SRc, SRd, SRa, SRb
여기서 dt={b, h, w, f}.
지원되는 모드
설명
이중 정확도 중간 결과를 내기 위해 Ra의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 상기 중간 결과의 각 이중 정확도 엘리먼트를 Rc의 각 엘리먼트에 더하고; 각 엘리먼트의 이중 정확도 합계를 상기 목적지 레지스터 Rd에 저장한다.
부동 데이타 형의 경우, 모든 오퍼런드와 결과는 단일 정확도 유형이다.
연산 for(i=0;iNumElem EMASK[i]; i++){
Aop[i]={VRa[i] || SRa};
Bop[i]={VRb[i] || SRb};
Cop[i]={VRc[i] || SRc};
if(dt==float)Lo[i]=Aop[i]*Bop[i]+Cop[i]
else Hi[i]:Lo[i]=Aop[i]*Bop[i]+sex_dp)Cop[i]);
Rd[i]=Lo[i];
}
예외
오버플로우, 부동 소수점 무효 오퍼런드.
VMAS 누산기로부터의 곱셈과 뺄셈
포맷
어셀블러 구문
VMAS.dt VRa, VRb
VMAS.dt VRa, SRb
VMAS.dt VRa, #IMM
VMAS.dt SRa, SRb
VMAS.dt SRa, #IMM
여기서 dt={b, h, w, f}.
지원되는 모드
설명
이중 정확도 중간 결과를 내기 위해 Ra의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 벡터 누산기의 각 이중 정확도 엘리먼트로부터 상기 중간 결과의 각 이중 정확도 엘리먼트를 빼고; 각 엘리먼트의 이중 정확도 합계를 상기 벡터 누산기에 저장한다.
Ra와 Rb는 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(int8, int16 및 int32 각각에 대해 16, 32 및 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 VACH에 저장된다.
부동 데이타 형의 경우, 모든 오퍼런드와 결과는 단일 정확도 형이다.
연산
for(i=0;iNumElem EMASK[i];i++){
Bop[i]={VRb[i] || SRb};
if(dt==float) VACL[i]=VACL[i]-VRa[i]*Bop[i];
else VACH[i]:VACL[i]=VACH[i]:VACL[i]-VRa[i]*Bop[i];
}
예외
오버플로우, 부동 소수점 무효 오퍼런드.
프로그래밍 주석
이 명령은 int9에 데이타 형을 지원하지 않는다-대신에 int16 데이타 형을 이용한다.
VMASF 누산기 분수로부터의 곱셈과 뺄셈
포맷
어셈블러 구문
VMASF.dt VRa, VRb
VMASF.dt VRa, SRb
VMASF.dt VRa, #IMM
VMASF.dt SRa, SRb
VMASF.dt SRa, #IMM
여기서 dt={b, h, w}.
지원되는 모드
설명
이중 정확도 중간 결과는 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 이중 정확도 중간 결과를 우로 1만큼 쉬프트 하고; 벡터 누산기의 각 이중 정확도 엘리먼트로부터 상기 쉬프트된 중간 결과의 각 이중 정확도 엘리먼트를 빼고; 각 엘리먼트의 이중 정확도 합계를 상기 벡터 누산기에 저장한다.
VRa와 Rb는 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(int8, int16 및 int32 각각에 대해 16, 32 및 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 VACH에 저장된다.
연산
for(i=0;iNumElem EMASK[i];i++){
Bop[i]={VRb[i] || SRb || sex(IMM8:0)};
VACH[i]:VACL[i]=VACH[i]:VACL[i]-VRa[i]*Bop[i];
}
예외
오버플로우.
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다- 대신에 int16 데이타 형을 이용한다.
VMASL 누산기 로우로부터의 곱셈과 뺄셈
포맷
어셈블러 구문
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
여기서 dt={b, h, w, f}.
지원되는 모드
설명
이중 정확도 중간 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 벡터 누산기의 각 이중 정확도 엘리먼트로부터 상기 중간 결과의 각 이중 정확도 엘리먼트를 빼고; 각 엘리먼트의 이중 정확도 합계를 상기 벡터 누산기에 저장하고; 그 하부를 목적지 레지스터 VRd로 반환한다.
VRa와 Rb는 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(int8, int16 및 int32 각각에 대해 16, 32 및 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 VACH에 저장된다.
부동 데이타 형의 경우, 모든 오퍼런드와 겨로가는 단일 정확도 형이다.
연산
for(i=0;iNumElem EMASK[i];i++){
Bop[i]={VRb[i] || SRb};
if(dt==float) VRCl[i] =VACL[i]-VRA[i]*Bop[i];
else VACH[i]:VACL[i]=VACH[i]:VACL[i]-VRa[i]*Bop[i];
VRd[i]=VACL[i];
}
예외
오버플로우, 부동 소수점 무효 오퍼런드.
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다-대신에 int16 데이타 형을 이용한다.
VMAXE 페어와이즈 최대 및 교환
포맷
어셈블러 구문
VMAXE.dt VRd.VRb
여기서 dt={b, b9, h, w, f}.
지원되는 모드
설명
VRa는 VRb와 같다. VRa가 VRb와 다르면, 그 결과는 정의되지 않는다.
벡터 레지스터 VRb의 각 홀수/짝수 데이타 엘리먼트가 쌍으로 비교되고 각 데이타 엘리먼트 쌍의 큰 값이 짝수 장소에 저장되고 각 데이타 엘리먼트 쌍의 작은 값이 벡터 레지스터 Rd의 홀수 장소에 저장된다.
연산
for(i=0;iNumElem EMASK[i];i+2){
VRd[i]=(VRb[i] VRb[i+1]) ? VRb[i]:VRb[i+1];
VRd[i+1]=(VRb[i]VRb[i+1])? VRb[i+1]*VRb[i];
}
예외
없음
VMOV 이동
포맷
어셈블러 구문
VMOV.dt Rd.Rb
여기서 dt=[b, b9, h, w, f}, Rd와 Rb는 아키텍춰적으로 지정된 레지스터 명을 지칭한다. .w와 .f는 동일한 연산을 지정한다는 것에 유의한다.
지원되는 모드
설명
레지스터 Rb의 내용이 레지스터 Rd로 이동된다.
그룹 필드는 소스 및 목적지 레지스터 그룹을 명시한다. 레지스터 그룹 주석은 다음과 같다 :
VR 현재의 뱅크 벡터 레지스터
VRA 대체 뱅크 벡터 레지스터
SR 스칼라 레지스터
RASR 반환 어드레스 스택 레지스터
VAC 벡터 누산기 레지스터(이하의 VAC 레지스터 엔코딩을 참조한다.)
벡터 레지스터는 이 명령으로서 스칼라 레지스터로 이동될 수 없다는 것에 유의한다. VEXTRT 명령이 상기 목적을 위해 제공된다.
VAC 레지스터 엔코딩을 위해 다음 표를 사용한다:
연산
Rd=Rb
예외
예외 상태를 VCSR 또는 VISRC에 세트함으로서 대응하는 예외를 초래할 것이다.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다. 대체 뱅크 개념은 VEC64모드에 존재하지 않기 때문에, 이 명령은 VEC64 모드에 있는 대체 뱅크로부터 또는 에 이동하는데 사용될 수 없다.
VMUL 곱셈
포맷
어셈블러 구문
VMUL.dt VRc,VRd, VRa, VRb
VMUL.dt SRc, SRd, SRa, SRb
여기서 dt={b, h, w}.
지원되는 모드
설명
이중 정확도 결과를 내기 위해 Ra의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 각 엘리먼트의 이중 정확도 합계를 상기 목적지 레지스터 Rc:Rd로 반환한다.
Ra와 Rb는 지정된 데이타 형을 사용하는데 반해, Rc:Rd는 적당한 이중 정확도 데이타 형(int8, int16 및 int32 각각에 대해 16, 32 및 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 Rc에 저장된다.
연산
for(i=0;iNumElem EMASK[i];i++){
Aop[i]={VRa[i] || SRa};
Bop[i]={VRb[i] || SRb};
Hi[i]:Lo[i]+Aop[i]*Bop[i];
Rc[i]=Hi[i];
Rd[i]=Hi[i];
}
예외
없음
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다-대신에 int16 데이타 형을 사용한다. 이 명령은 또한 확장된 결과가 지원된 데이타 형이 아니기 때문에 부동 데이타 형을 지원하지 않는다.
VMULA 누산기에 대한 곱셈
포맷
어셈블러 구문
VMULA.dt VRa, VRb
VMULA.dt VRa, SRb
VMULA.dt VRa, #IMM
VMULA.dt SRa, SRb
VMULA.dt SRa, #IMM
여기서 dt={b, h, w, f}.
지원되는 모드
설명
이중 정확도 결과는 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 그 결과를 누산기에 기록한다.
부동 데이타 형의 경우, 모든 오퍼런드와 결과는 단일 정확도 유형이다.
연산
for(i=0;iNumElem EMASK[i];i++){
Bop[i]={VRb[i] || SRb};
if(dt==float) VACL[i] =VRa[i]*Bop[i];
else VACH[i]:VACL[i]=VRa[i]*Bop[i];
}
예외
없음
프로그래밍 주석
이 명령은 int9 데이타 형을 지우너하지 않는다- 대신에 int16 데이타 형을 사용한다.
VMULF 누산기 분수에 대한 곱셈
포맷
어셈블러 구문
VMULAF.dt VRa, VRb
VMULAF.dt VRa, SRb
VMULAF.dt VRa, #IMM
VMULAF.dt SRa, SRb
VMULAF.dt SRa, #IMM
여기서 dt={b, h, w}.
지원되는 모드
설명
이중 정확도 중간 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 상기 이중 정확도 중간 결과를 좌로 1 비트 쉬프트 하고; 그 결과를 누산기에 기록한다.
연산
for(i=0;iNumElem EMASK[i];i++){
Bop[i]={VRb[i] || SRb || sex(IMM8:0)};
VACH[i]:VACL[i]=(VRa[i]*Bop[i])1;
}
예외
없음
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다-대신에 int16 데이타 형을 사용한다.
(VMULF 분수 곱셈)
포맷
어셈블러 구문
VMULF.dtVRd, VRa, VRb
VMULF.dtVRd, VRa, SRb
VMULF.dtVRd, VRa, #IMM
VMULF.dtSRd, SRa, SRb
VMULF.dtSRd, SRa, #IMM
여기서 dt={b, h, w}.
지원되는 모드
설명
이중 정확한 중간 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 상기 이중 정확도 중간 결과를 좌로 1비트 쉬프트하고; 그 결과의 상부를 목적지 레지스터 VRd+1 및 목적지 레지스터 VRd로 반환한다. VRd는 짝수 번호의 레지스터이어야 한다.
연산
for(i=0;iNumElem EMASK[i] ; i++)(
Bop[i]=(VRb[i]∥SRb∥sex(IMM8:0));
Hi[i]:Lo[i]=(VRa[i]*Bop[i])1 ;
VRd+1[i]=Hi[i];
VRd[i]=Lo[i];
예외
없음
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다-대신에 int16 데이타 형을 사용한다.
(VMULFR 분수 곱셈 및 라운드)
포맷
어셈블러 구문
VMULFR.dtVRd, VRa, VRb
VMULFR.dtVRd, VRa, SRb
VMULFR.dtVRd, VRa, #IMM
VMULFR.dtSRd, SRa, SRb
VMULFR.dtSRd, SRa, #IMM
여기서 dt=(b, h, w).
지원되는 모드
설명
이중 정확도 중간 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 상기 이중 정확도 중간 결과를 좌로 1비트 쉬프트하고; 상기 쉬프트된 중간 결과를 상부로 라운드하고; 그 상부를 목적지 레지스터 VRd로 반환한다.
연산
for(i=0;iNumElem EMASK[i] ; i++){
Bop[i]=(VRb[i]∥SRb∥sex(IMM8:0)};
Hi[i]:Lo[i]=(VRa[i]*Bop[i])1 ;
if(LO[i]msb==1)Hi[i]=Hi[i];
VRd[i]=Hi[i];
예외
없음
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다-대신에 int16 데이타 형을 사용한다.
(VMULL 로우 곱셈)
포맷
어셈블러 구문
VMULL.dtVRd, VRa, VRb
VMULL.dtVRd, VRa, SRb
VMULL.dtVRd, VRa, #IMM
VMULL.dtSRd, SRa, SRb
VMULL.dtSRd, SRa, #IMM
여기서 dt=(b, h, w, f).
지원되는 모드
설명
이중 정확도 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고; 그 결과의 상부를 목적지 레지스터 VRd로 반환한다.
부동 데이타 형의 경우, 모든 오퍼런드와 결과는 단일 정확도 유형이다.
연산
for(i=0;iNumElem EMASK[i] ; i++)[
Bop[i]=(VRb[i]∥SRb) ;
if(dt==float)Lo[i]=VRa[i]*Bop[i] ;
else Hi[i]:Lo[i]=VRa[i]*Bop[i] ;
VRd[i]=Lo[i];
예외
오버플로우, 부동 소수점 무효 오퍼런드.
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다-대신에 int16 데이타 형을 사용한다.
(VMULF NAND)
포맷
어셈블러 구문
VNAND.dtVRd, VRa, VRb
VNAND.dtVRd, VRa, SRb
VNAND.dtVRd, VRa, #IMM
VNAND.dtSRd, SRa, SRb
VNAND.dtSRd, SRa, #IMM
여기서 dt=(b, b9, h, w). .w와 .f는 동일한 연산을 명시한다.
지원되는 모드
설명
Ra에 있는 각 엘리먼트의 각 비트를 Rb/중간 오퍼런드에 있는 대응하는 비트와 논리적 NAND하고; 그 결과를 Rd에 반환한다.
연산
for(i=0;iNumElem EMASK[i] ; i++){
Bop[i]=(VRb[i]∥SRb∥sex(IMM8:0)};
Rd[i]k=-(Ra[i]k Bop[i]k), for k=all bits in element i;
)
예외
없음.
(VNOR NOR)
포맷
어셈블러 구문
VNOR.dtVRd, VRa, VRb
VNOR.dtVRd, VRa, SRb
VNOR.dtVRd, VRa, #IMM
VNOR.dtSRd, SRa, SRb
VNOR.dtSRd, SRa, #IMM
여기서 dt=(b, b9, h, w). .w와 .f는 동일한 연산을 명시한다.
지원되는 모드
설명
Ra에 있는 각 엘리먼트의 각 비트를 Rb/중간 오퍼런드에 있는 대응하는 비트와 논리적으로 NOR하고; 그 결과를 Rd에 반환한다.
연산
for(i=0;iNumElem EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM8:0)};
Rd[i]k=-(Ra[i]k|Bop[i]k), for k=all bits in element i;
}
예외
없음.
(VOR OR)
포맷
어셈블러 구문
VOR.dtVRd, VRa, VRb
VOR.dtVRd, VRa, SRb
VOR.dtVRd, VRa, #IMM
VOR.dtSRd, SRa, SRb
VOR.dtSRd, SRa, #IMM
여기서 dt=(b, b9, h, w). .w와 .f는 동일한 연산을 명시한다.
지원되는 모드
설명
Ra에 있는 각 엘리먼트의 각 비트를 Rb/중간 오퍼런드에 있는 대응하는 비트와 논리적으로 OR하고; 그 결과를 Rd에 반환한다.
연산
for(i=0;iNumElem EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM8:0)};
Rd[i]k=Ra[i]k|Bop[i]k), for k=all bits in element i;
}
예외
없음.
(VORC OR보수)
포맷
어셈블러 구문
VORC.dtVRd, VRa, VRb
VORC.dtVRd, VRa, SRb
VORC.dtVRd, VRa, #IMM
VORC.dtSRd, SRa, SRb
VORC.dtSRd, SRa, #IMM
여기서 dt=(b, b9, h, w). .w와 .f는 동일한 연산을 명시한다.
지원되는 모드
설명
Ra에 있는 각 엘리먼트의 각 비트를 Rb/중간 오퍼런드에 있는 대응하는 비트와 논리적으로 OR하고; 그 결과를 Rd에 반환한다.
연산
for(i=0;iNumElem EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM8:0)};
Rd[i]k=-(Ra[i]k|-Bop[i]k), for k=all bits in element i;
}
예외
없음.
(VPFTCH 프리훼치)
포맷
어셈블러 구문
VPFTCH.InSRb, SRi
VPFTCH.InSRb, #IMM
VPFTCH.InSRb+, SRi
VPFTCH.InSRb+, #IMM
여기서 In=(1, 2, 4, 8).
설명
유효 어드레스에서 시작하는 복수의 벡터 데이타 캐쉬 라인을 프리훼치한다. 캐쉬 라인의 수는 다음과 같이 지정된다:
LN1:000: 1 64 바이트 캐쉬 라인이 프리훼치된다.
LN1:001: 2 64 바이트 캐쉬 라인이 프리훼치된다.
LN1:010: 4 64 바이트 캐쉬 라인이 프리훼치된다.
LN1:011: 8 64 바이트 캐쉬 라인이 프리훼치된다.
연산
예외
무효 데이타 어드레스 예외.
프로그래밍 주석
EA31:0는 국부 메모리에 있는 바이트 어드레스를 지칭한다.
(VPFTCHSP 스크래치 패드에 대한 프리훼치)
포맷
어셈블러 구문
VPFTCHSP.InSRp, SRb, SRi
VPFTCHSP.InSRp, SRb, #IMM
VPFTCHSP.InSRp, SRb+, SRi
VPFTCHSP.InSRp, SRb+, #IMM
여기서 In=(1, 2, 4, 8). VPFTCH와 VPFTCHSP는 동일한 오피코드를 갖는다.
설명
메모리에서 스크래치 패드로 복수의 64 바이트 블럭을 전송한다. 유효 어드레스는 메모리에서 시작 어드레스를 제공하고 SRp는 스크래치 패드에 시작 어드레스를 제공한다. 64바이트 블럭의 수는 다음과 같이 명시된다:
LN1:000: 1 64 바이트 블럭이 전송된다.
LN1:001: 2 64 바이트 블럭이 전송된다.
LN1:010: 4 64 바이트 블럭이 전송된다.
LN1:011: 8 64 바이트 블럭이 전송된다.
만일 유효 어드레스가 64 바이트 경계 상에 있지 않으면, 먼저 64 바이트 경계로 정렬되도록 트렁케이트된다. 만일 SRp에 있는 스크래치 패드 포인터 어드레스가 64바이트 경계 상에 있지 않으면, 이 또한 64 바이트 경계로 정렬되도록 트렁케이트된다. 상기 정렬된 스크래치 패드 포인터 어드레스는 전송된 바이트의 수 만큼 증가된다.
연산
EA=SRb+{SRi∥sex(IMM7:0)};
if(A==1)SRb=EA;
Num_bytes=(64∥128∥256∥512);
Mem_adrs=EA31:6:6b'000000;
SRp=SRp31:6:6b'000000;
for(i=0; iNum_bytes;i++)
SPAD[SRp++]=MEM[Mem_adrs+i];
예외
무효 데이타 어드레스 예외.
(VROL 좌로 회전)
포맷
어셈블러 구문
VROL.dtVRd, VRa, SRb
VROL.dtVRd, VRa, #IMM
VROL.dtSRd, SRa, SRb
VROL.dtSRd, SRa, #IMM
여기서 dt=(b, b9, h, w).
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 각 데이타 엘리먼트는 스칼라 레지스터 Rb 또는 IMM 필드에 주어진 비트 양만큼 좌로 회전되고, 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
rotate_amount=(SRb % 32∥IMM4:0);
for(i=0:iNumElem EMASK[i]; i++)(
Rd[i]=Ra[i]rotate_left rotate_amount;
)
예외
없음.
프로그래밍 주석
rotate_amount는 SRb 또는 IMM4:0으로부터 5 비트 숫자로서 취해진다. 바이트, 바이트9, 하프워드 데이타 형인 경우, 프로그래머는 데이타 크기에 있어 비트의 숫자보다 적거나 같은 회전 양을 정확히 명시할 책임이 있다. 만일 회전 양이 지정된 데이타 크기보다 크면, 결과는 정의되지 않는다.
좌로 n 회전은 우로, ElemSize-n회전과 같다. 여기서, ElemSize는 소정의 데이타 크기에서 비트들의 수를 지칭한다.
(VROP 우로 회전)
포맷
어셈블러 구문
VROR.dtVRd, VRa, SRb
VROR.dtVRd, VRa, #IMM
VROR.dtSRd, SRa, SRb
VROR.dtSRd, SRa, #IMM
여기서 dt=(b, b9, h, w).
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 각 데이타 엘리먼트는 스칼라 레지스터 Rb 또는 IMM 필드에 주어진 비트 양만큼 우로 회전되고, 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
rotate_amount=(SRb % 32∥IMM4:0);
for(i=0:iNumElem EMASK[i]; i++)(
Rd[i]=Ra[i]rotate_left rotate_amount;
)
예외
없음.
프로그래밍 주석
rotate_amount는 SRb 또는 IMM4:0으로부터 5 비트 숫자로서 취해진다. 바이트, 바이트9, 하프워드 데이타 형인 경우, 프로그래머는 데이타 크기에 있어 비트의 숫자보다 적거나 같은 회전 양을 정확히 명시할 책임이 있다. 만일 회전 양이 지정된 데이타 크기보다 크면, 결과는 정의되지 않는다.
좌로 n 회전은 우로, ElemSize-n회전과 같다. 여기서, ElemSize는 소정의 데이타 크기에서 비트들의 수를 지칭한다.
(VROUND 부동 소수점에서 정수로 라운드)
포맷
어셈블러 구문
VROUND.rm VRd, VRb
VROUND.rm SRd, SRb
여기서 rm={ninf, zero, near, pinf}.
지원되는 모드
설명
부동 소수점 데이타 포맷에 있는 벡터/스칼라 레지스터 Rb의 내용은 가장 가까운 32 비트 정수(워드)로 라운드되고, 그 결과는 벡터/스칼라 레지스터 Rd에 저장된다. 라운딩 모드는 RM에 정의되어 있다.
연산
for (:=0;iNumElem;i++)(
Rd[i]=Convert to int32(Rb[i]);
)
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
(VSATl 보다 하위의 라운드까지 포화)
포맷
어셈블러 구분
VSATL.dtVRd, VRa, VRb
VSATL.dtVRd, VRa, SRb
VSATL.dtVRd, VRa, #IMM
VSATL.dtSRd, SRa, SRb
VSATL.dtSRd, SRa, #IMM
여기서 dt={b, b9, h, w}. .f 데이타 형은 9비트 중간과 함께 지원되지 않는다는 것에 유의한다.
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 각 데이타 엘리먼트는 벡터/스칼라 레지스터 Rb 또는 IMM 필드에 있는 그것의 대응하는 하위 한계에 대해 점검된다. 만일 데이타 엘리먼트의 값이 상기 하위 한계보다 작으면, 하위 한계와 같도록 세트되고, 최종 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for(i=0;iNumElem EMASK[i];i++)(
Bop[i]=(VRb[i]∥SRb∥sex(IMM8:0));
Rd[i]=(Ra[i]Bop[i])?Bop[i]:Ra[i];
)
예외
없음.
(VSATU 보다 상위의 라운드까지 포화)
포맷
어셈블러 구분
VSATU.dtVRd, VRa, VRb
VSATU.dtVRd, VRa, SRb
VSATU.dtVRd, VRa, #IMM
VSATU.dtSRd, SRa, SRb
VSATU.dtSRd, SRa, #IMM
여기서 dt={b, b9, h, w. f}. .f 데이타 형은 9비트 중간과 함께 지원되지 않는다는 것에 유의한다.
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 각 데이타 엘리먼트는 벡터/스칼라 레지스터 Rb 또는 IMM 필드에 있는 그것의 대응하는 상위 한계에 대해 점검된다. 만일 데이타 엘리먼트의 값이 상기 상위 한계보다 크면, 상위 한계와 같도록 세트되고, 최종 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for(i=0;iNumElem EMASK[i];i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM8:0)};
Rd[i]=(Ra[i]Bop[i])?Bop[i]:Ra[i];
}
예외
없음.
(VSHFL 셔플)
포맷
어셈블러 구문
VSHFL.dtVRc, VRd, VRa, VRb
VSHFL.dtVRc, VRd, VRa, SRb
여기서 dt={b, b9, h, w, f). .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
지원되는 모드
설명
벡터 레지스터 Ra의 내용이 Rb와 셔플되고, 그 결과가 이하에 도시된 바와 같이 벡터 레지스터 Rc:Rd에 저장된다.
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크를 사용하지 않는다.
(VSHFLH 하이 셔플)
포맷
어셈블러 구문
VSHFLH.dtVRd, VRa, VRb
VSHFLH.dtVRd, VRa, SRb
여기서 dt={b, b9, h, w, f). .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
지원되는 모드
설명
벡터 레지스터 Ra의 내용이 Rb와 셔플되고, 그 결과의 상부가 이하에 도시된 바와 같이 벡터 레지스터 Rd에 저장된다.
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크를 사용하지 않는다.
(VSHFLL 로우 셔플)
포맷
어셈블러 구문
VSHFLL.dtVRd, VRa, VRb
VSHFLL.dtVRd, VRa, SRb
여기서 dt={b, b9, h, w, f). .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
지원되는 모드
설명
벡터 레지스터 Ra의 내용이 Rb와 셔플되고, 그 결과 하부가 이하에 도시된 바와 같이 벡터 레지스터 Rd에 저장된다.
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크를 사용하지 않는다.
(VST 저장)
포맷
어셈블러 구분
VST.stRs, SRb, SRi
VST.stRs, SRb, #IMM
VST.stRs, SRb+, SRi
VST.stRs, SRb+, #IMM
여기서 st={b, b9t, h, w, 4, 8, 16, 32, 64}. Rs={VRs, VRAs, SRs} .b와 .b9t는 동일한 연산을 명시하고, .64와 VRAs는 함께 명시될 수 없다는 것에 유의한다. 캐쉬-오프 저장을 위해서는 VSTOFF를 사용한다.
설명
벡터 또는 스칼라 레지스터를 저장한다.
연산
EA=SRb+{SRi∥sex(IMM7:0)};
if(A==1)SRb=EA;
MEM[EA]=see table below;
예외
무효 데이타 어드레스, 정렬되지 않은 액세스
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
VSTCB 순환 버퍼에의 저장
포맷
어셈블러 구문
VSTCB.stRS.SRb.SRi
VSTCB.stRS.SRb.#IMM
VSTCB.stRS.SRb+.SRi
VSTCB.stRS.SRb+.#IMMi
여기서 st = {b, b9t, h, w, 4, 8, 16, 32, 64} Rs = {VRs, VRAs, SRs}, .b와 .b9t는 동일한 연산을 지정하고, 64와 VRAd는 함께 지정될 수 없다는 것에 유의한다. 캐쉬-오프 로드를 위해서 VSTCBOFF를 이용한다.
설명
SRb+1에 이는 BEGIN 포인터와 SRb+2에 있는 END 포인터에 의해 가리켜진 순환 버퍼로부터 벡터 또는 스칼라 레지스터를 저장한다.
어드레스 갱신 연산은 물론 저장하기 전에 END 어드레스보다 크면 유효 어드레스가 조정된다. 또한, 순환 버퍼 바운드는 .f 와 .w 스칼라 로드를 위해 각각 하프워드 및 워드 경계 상에서 정렬되어야 한다.
연산
EA = SRb+{SRi II sex(IMM＜7:0＞)};
BEGIN = SRb+1;
END = SRb+2;
cbsize = END·BEGIN;
if(EA＞END)EA = BEGIN + (EA·END);
if(A = 1) SRb= EA;
MEM(EA) = see table below;
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
프로그래머는 다음 조건을 확실히 하여 다음 명령이 예상된 대로 동작하게 하여야 한다.
BEGIN＜EA＜2*END-BEGIN
즉, EA-END＜END-BEGIN은 물론 EA-BEGIN.
VSTD 이중저장
포맷
어셈블러 구문
VSTD.stRS.SRb.SRi
VSTD.stRS.SRb.#IMM
VSTD.stRS.SRb+.SRi
VSTD.stRS.SRb+.#IMM
여기서 st = {b, b9t, h, w, 4, 8, 16, 32, 64}, Rs = {VRs, VRAs, SRs}, .b와 .b9t는 동일한 연산을 지정하고, 64와 VRAs는 함께 지정될 수 없다는 것에 유의한다. 캐쉬-오프 로드를 위해서 VSTDOFF를 이용한다.
설명
현재 또는 대체 뱅크로부터의 두개의 벡터 레지스터 또는 네개의 스칼라 레지스터를 저정한다.
연산
EA = SRb+{SRi II sex(IMM＜7:0＞)};
if(A = 1) SRb= EA;
MEM(EA) = see table below;
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
VSTQ Quad 저장
포맷
어셈블러 구문
VSTQ.stRS.SRb.SRi
VSTQ.stRS.SRb.#IMM
VSTQ.stRS.SRb+.SRi
VSTQ.stRS.SRb+.#IMM
여기서 st = {b, b9t, h, w, 4, 8, 16, 32, 64}, Rs = {VRs, VRAs, SRs}, .b와 .b9t는 동일한 연산을 지정하고, 64와 VRAs는 함께 지정될 수 없다는 것에 유의한다. 캐쉬-오프 로드를 위해서 VSTQOFF를 이용한다.
설명
연산
현재 또는 대체 뱅크로부터의 네개의 벡터 레지스터 또는 네개의 스칼라 레지스터를 저장한다.
EA = SRb+{SRi∥sex(IMM＜7:0＞)};
if(A = 1) SRb= EA;
MEM(EA) = see table below;
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
VSTR 반전저장
포맷
어셈블러 구문
VSTR.stRS.SRb.SRi
VSTR.stRS.SRb.#IMM
VSTR.stRS.SRb+.SRi
VSTR.stRS.SRb+.#IMM
여기서 st = {4, 8, 16, 32, 64}, Rs = {VRs, VRAs}, .64와 VRAs는 함께 지정될 수 없다는 것에 유의한다. 캐쉬-오프 저장을 위해서 VSTROFF를 이용한다.
설명
연산
벡터 레지스터를 역 엘리먼트 순으로 저장한다. 이 명령은 스칼라 데이타 소스 레지스터를 지원하지 않는다.
연산
EA = SRb+{SRi∥sex(IMM＜7:0＞)};
if(A=1)SRb= EA;
MEM(EA) = see table below;
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
VSTWS 스트라이드로 저장
포맷
어셈블러 구문
VSTWS.stRS.SRb.SRi
VSTWS.stRS.SRb.#IMM
VSTWS.stRS.SRb+.SRi
VSTWS.stRS.SRb+.#IMM
여기서 st = {8, 16, 32}, Rs = {VRs, VRAs}, .64 모드는 지원되지 않는다 - 대신에 VST를 사용한다. 캐쉬-오프 저장을 위해서 VSTWSOFF를 이용한다.
설명
유효 어드레스에서 시작하여, 스칼라 레지스터 SRb+1를 스트라이드 제어 레지스터로서 사용하여 32바이트가 벡터 레지스터 VRs에서 메모리에 저장된다.
ST는 블럭 크기, 각 블럭에서 저장되는 연속하는 바이트의 수를 지정하고, SRb+1은 스트라이드, 두개의 연속하는 블럭의 시작을 분리하는 바이트의 수를 지정한다.
스트라이드는 블럭 크기와 같거나 커야 한다. EA는 데이타 크기가 정렬되어야 한다. 스크라이드와 블러 크기는 복수의 데이타 크기 유형이어야 한다.
연산
EA = SRb+{SRi∥ sex(IMM＜7:0＞)};
if(A = 1) SRb= EA;
Block_size = (4∥8∥16∥32);
Stride = SRb+1＜31:0＞;
for(i=0:i＜VECSIZE/Block_size;i++)
for(i=0:i＜Block_size;j++)
BYTE[EA+i*Stride+j] = VRs[i*Block_size+j]＜7:0＞;
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
VSUB 뺄셈
포맷
어셈블러 구문
VSUB.dtVRd, VRa, VRb
VSUB.dtVRd, VRa, SRb
VSUB.dtVRd, VRa, #IMM
VSUB.dtSRd, SRa, SRb
VSUB.dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w, f}
지원되는 모드
설명
벡터/스칼라 레지스터 Rb의 내용이 벡터/스칼라 레지스터 Ra의 내용으로부터 감산되고, 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for(i = 0:i ＜ NumElemEMASK[i] ; i++) {
(Bop[i] = {Rb[i]∥SRb∥sex[IMM＜8:0＞])} ;
Rd[i] = Ra[i] - Bop[i];
}
예외
오버플로우, 부동 소수점 무효 오퍼런드.
VSUBS 뺄셈과 세트
포맷
어셈블러 구문
VSUBS.dtSRd, SRa, SRb
VSUBS.dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w, f}
지원되는 모드
설명
SRb가 SRa로부터 감산되고; 결과가 SRd 에 저장되고, VCSR에 있는 VFLAG 비트가 세트된다.
연산
Bop = {SRb∥sex(IMM＜8:0＞)} ;
SRd = SRa - Bop;
VCSR＜lt,eq,gt＞=status(SRa-Bop);
예외
오버플로우, 부동 소수점 무효 오퍼런드.
VUNSHFL 언셔플
포맷
어셈블러 구문
VUNSHFL.dtVRc, VRd, VRa, VRb
VUNSHFL.dtVRc, VRd, VRa, SRb
여기서 dt = {b, b9, h, w, f}, .w와 .f는 동일한 연산을 지정한다는 것에 유의한다.
지원되는 모드
설명
벡터 레지스터 VRb의 내용이 이하에 도시된 바와 같이 벡터 레지스터 VRc;VRd으로 Rb와 언셔플된다.
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크를 사용하지 않는다.
VUNSHFLH 하이로 언셔플
포맷
어셈블러 구문
VUNSHFLH.dtVRd, VRa, VRb
VUNSHFLH.dtVRd, VRa, SRb
여기서 dt = {b, b9, h, w, f}, .w와 .f는 동일한 연산을 지정한다는 것에 유의한다.
지원되는 모드
설명
벡터 레지스터 VRa의 내용이 Rb와 언셔플되고, 그 결과의 상부가 이하에 도시된 바와 같이 벡터 레지스터 VRd에 반환된다.
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크를 사용하지 않는다.
VUNSHFLL 로우로 언셔플
포맷
어셈블러 구문
VUNSHFLL.dtVRd, VRa, VRb
VUNSHFLL.dtVRd, VRa, SRb
여기서 dt = {b, b9, h, w, f}, .w와 .f는 동일한 연산을 지정한다는 것에 유의한다.
지원되는 모드
설명
벡터 레지스터 VRa의 내용이 Rb와 언셔플되고, 그 결과의 하부가 이하에 도시된 바와 같이 벡터 레지스터 VRd로 반환된다.
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크를 사용하지 않는다.
VWBACK 기록
포맷
어셈블러 구문
VWBACK.InSRb, SRi
VWBACK.InSRb, #IMM
VWBACK.InSRb+, SRi
VWBACK.InSRb+, #IMM
여기서 In = {1, 2, 4, 8).
설명
그 인덱스가 벡터 데이타 캐쉬에 있는 EA(그 태그가 EA와 일치하는 것에 반대되는 것으로)에 의해 지정된 캐쉬 라인은 만일 수정된 데이타를 포함하고 있으면 메모리에 갱신된다. 만일 하나 이상의 캐쉬 라인이 지정되어 있으면, 다음의 순차적인 캐쉬 라인이 수정된 데이타를 포함하면 메모리에 갱신된다. 캐쉬 라인의 수는 다음과 같이 지정된다 ;
LN＜1:0＞=00: 1 64 바이트 캐쉬 라인이 기록된다.
LN＜1:0＞=01: 2 64 바이트 캐쉬 라인이 기록된다.
LN＜1:0＞=10: 4 64 바이트 캐쉬 라인이 기록된다.
LN＜1:0＞=11: 8 64 바이트 캐쉬 라인이 기록된다.
만일 유효 어드레스가 64 바이트 경계상에 있지 않으면, 먼저 64 바이트 경계로 정렬되도록 트렁케이트된다.
연산
예외
무효 데이타 어드레스 예외.
프로그래밍 주석
EA＜31:0＞는 국부 메모리에 있는 바이트를 지칭한다.
VWBACKSP 스크래치 패드로부터 기록
포맷
어셈블러 구문
VWBACKSP.InSRp, SRb, SRi
VWBACKSP.InSRp, SRb, #IMM
VWBACKSP.InSRp, SRb+, SRi
VWBACKSP.InSRp, SRb+, #IMM
여기서 In = {1, 2, 4, 8). VWBACK와 VWBACKSP는 동일한 오피코드를 사용한다는 것에 유의한다.
설명
스크래치 패드에서 메모리로 복수의 64 바이트 블럭을 전송한다. 유효 어드레스는 메모리에 시작 어드레스를 제공하고 SRp는 스크래치 패드에 시작 어드레스를 제공한다. 64 바이트 블럭의 수는 다음과 같이 지정된다.
LN＜1:0＞=00: 1 64 블럭이 전송된다.
LN＜1:0＞=01: 2 64 블럭이 전송된다.
LN＜1:0＞=10: 4 64 블럭이 전송된다.
LN＜1:0＞=11: 8 64 블럭이 전송된다.
만일 유효 어드레스가 64 바이트 경계상에 있지 않으면, 먼저 64 바이트 경계로 정렬되도록 트렁케이트된다. 만일 SRp에 있는 스크래치 패드 포인터 어드레스가 64 바이트 경계상에 있지 않으면, 이도 역시 64 바이트 경계로 정렬되도록 트렁케이트된다. 상기 정렬된 스크래치 패드 포인터 어드레스는 전송된 바이트의 수 만큼 증가된다.
연산
EA = SRb + {SRi∥sex(IMM＜7:0＞)};
if(A = 1) SRb = EA;
Num_bytes = (64∥128∥256∥512);
Mem_adrs = EA＜31:6＞:6b'000000;
SRp = SRp＜31:6＞6b'000000;
for(i = 0:1＜Num_bytes;i++)
SPAD(SRp++) = MEM[Mem_adrs+i];
예외
무효 데이타 어드레스 예외.
프로그래밍 주석
EA＜31:0＞는 국부 메모리에 있는 바이트를 지칭한다.
VXNOR XNOR(익스클루시브 NOR)
포맷
어셈블러 구문
VXNOR. dtVRd, VRa, VRb
VXNOR. dtVRd, VRa, SRb
VXNOR. dtVRd, VRa, #IMM
VXNOR. dtSRd, SRa, SRb
VXNOR. dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w}
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 내용이 벡터/스칼라 레지스터 Rb의 내용에 논리적으로 XNOR 되고 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for(i = 0:i ＜ NumElemEMASK[i] ; i++) {
Bop[i] = {VRb[i]∥SRb∥sex(IMM＜8:0＞)} ;
Rd[i]＜k＞ =-( Ra[i]＜k＞＾Bop[i]＜k＞, for k = all bits in element;
}
예외
없음.
VXOR XOR(익스클루시브 OR)
포맷
어셈블러 구문
VXOR. dtVRd, VRa, VRb
VXOR. dtVRd, VRa, SRb
VXOR. dtVRd, VRa, #IMM
VXOR. dtSRd, SRa, SRb
VXOR. dtSRd, SRa, #IMM
여기서 dt = {b, b9, h, w}
지원되는 모드
설명
벡터/스칼라 레지스터 Ra의 내용이 벡터/스칼라 레지스터 Rb의 내용에 논리적으로 XOR 되고 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for(i = 0:i ＜ NumElemEMASK[i] ; i++) {
(Bop[i] = (VRb[i]∥SRb∥sex(IMM＜8:0＞) ;
Rd[i]＜k＞ =( Ra[i]＜k＞＾Bop[i]＜k＞, for k = all bits in element;
}
예외
없음.
VXORALL 모든 엘리먼트의 XOR(익스클루시브 OR)
포맷
어셈블러 구문
VXORALL. dtSRd, VRd
여기서 dt = {b, b9, h, w}, .b와 .b9는 동일한 연산을 지칭한다는 것에 유의한다.
지원되는 모드
설명
VRb에 있는 각 엘리먼트의 최하위 비트가 함께 XOR 되고, 1 비트 결과가 SRd의 최하위 비트에 반환된다. 이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
연산
예외
없음.
내용없음

Claims (9)

  1. 프로세서에 있어서,
    단일 스칼라 값(a single scalar value)을 저장하도록 적응된 스칼라 레지스터;
    다수의 데이타 엘리먼트(a plurality of data elements)를 저장하도록 적응된 벡터 레지스터; 및
    상기 스칼라 레지스터 및 상기 벡터 레지스터에 결합된 프로세싱 회로를 구비하고,
    단일 명령에 응답하여, 상기 프로세싱 회로는 각각의 연산이 상기 벡터 레지스터로부터의 데이타 엘리먼트중의 한 엘리먼트와 상기 스칼라 레지스터로부터의 스칼라 값을 결합하는 연산들을 병렬로 수행하는 것을 특징으로 하는 프로세서.
  2. 명령을 실행하는 프로세싱 회로의 연산 방법에 있어서,
    벡터 값의 성분을 형성하는 레지스터 데이타 엘리먼트로부터 판독하는 단계; 및
    벡터 결과를 생성하기 위해 스칼라 값을 상기 각각의 데이타 엘리먼트와 결합하는 병렬 연산을 수행하는 단계를 포함하는 것을 특징으로 하는 프로세싱 회로 연산 방법.
  3. 제 2 항에 있어서,
    상기 병렬 수행 단계는 벡터 데이타 결과를 생성하기 위해 상기 데이타 엘리먼트 각각으로서 상기 스칼라 값을 곱하는 것을 포함하는 것을 특징으로 하는 프로세싱 회로 연산 방법.
  4. 제 2 항에 있어서,
    상기 병렬 수행 단계는 벡터 데이타 결과를 생성하기 위해 상기 데이타 엘리먼트 각각에 상기 스칼라 값을 더하는 것을 포함하는 것을 특징으로 하는 프로세싱 회로 연산 방법.
  5. 제 2 항에 있어서,
    상기 데이타 엘리먼트와 결합하기 위해 제 2 레지스터로부터 상기 스칼라 값을 판독하는 단계를 더 포함하고, 상기 제 2 레지스터는 단일 스칼라 값을 저장하도록 적응되어 있는 것을 특징으로 하는 프로세싱 회로 연산 방법.
  6. 제 2 항에 있어서,
    상기 데이타 엘리먼트와 결합하기 위해 상기 스칼라 값을 상기 명령으로부터 추출하는 단계를 더 포함하는 것을 특징으로 하는 프로세싱 회로 연산 방법.
  7. 프로세서의 연산 방법에 있어서,
    각각의 스칼라 레지스터가 단일 스칼라 값을 저장하도록 적응되어 있고 각각의 벡터 레지스터가 벡터의 성분을 형성하는 다수의 데이타 엘리먼트를 저장하도록 적응되어 있으며, 프로세서내에 스칼라 레지스터와 벡터 레지스터를 제공하는 단계;
    다른 스칼라 레지스터에 할당된 레지스터 번호와는 구별되는 레지스터 번호를 각각의 스칼라 레지스터에 할당하는 단계;
    상기 벡터 레지스터에 할당된 적어도 일부의 레지스터 번호가 상기 스칼라 레지스터에 할당된 레지스터 번호와 같으며, 다른 벡터 레지스터에 할당된 레지스터 번호와는 구별되는 레지스터 번호를 각각의 벡터 레지스터에 할당하는 단계;
    스칼라 레지스터를 식별하는 레지스터 번호인 제 1 오퍼런드와 벡터 레지스터를
    식별하는 레지스터 번호인 제 2 오퍼런드를 포함하는 명령을 형성하는 단계; 및
    상기 제 1 오퍼런드에 의해 식별된 상기 스칼라 레지스터와 상기 제 2 오퍼런드에 의해 식별된 상기 벡터 레지스터내의 데이타 엘리먼트 간에 데이타를 이동시켜 명령을 실행하는 단계를 포함하는 것을 특징으로 하는 프로세서 연산 방법.
  8. 제 7 항에 있어서,
    상기 형성된 명령은 벡터내의 데이타 엘리먼트를 식별하는 제 3 오퍼런드를 더 포함하고, 상기 제 1 오퍼런드에 의해 식별된 상기 스칼라 레지스터와 상기 제 2 오퍼런드에 의해 식별된 상기 벡터 레지스터내의 상기 제 3 오퍼런드에 의해 식별된 상기 데이타 엘리먼트 간에 데이타를 이동시켜 명령을 실행하는 단계를 포함하는 것을 특징으로 하는 프로세서 연산 방법.
  9. 제 7 항에 있어서,
    상기 형성된 명령은 제 2 스칼라 레지스터를 식별하는 제 3 오퍼런드를 더 포함하고, 상기 제 1 오퍼런드에 의해 식별된 상기 스칼라 레지스터와 상기 제 2 오퍼런드에 의해 식별되고 상기 제 2 스칼라 레지스터에 저장된 값에 의해 식별되는 상기 벡터 레지스터에 있는 데이타 엘리먼트 간에 데이타를 이동시켜 명령을 실행하는 단계를 포함하는 것을 특징으로 하는 프로세서 연산 방법.
KR1019970012609A 1996-08-19 1997-04-04 스칼라/벡터연산이조합된단일명령복수데이터처리 KR100267089B1 (ko)

Applications Claiming Priority (3)

Application Number Priority Date Filing Date Title
US69958596A 1996-08-19 1996-08-19
US8/699,585 1996-08-19
US08/699,585 1996-08-19

Publications (2)

Publication Number Publication Date
KR19980018065A true KR19980018065A (ko) 1998-06-05
KR100267089B1 KR100267089B1 (ko) 2000-11-01

Family

ID=24809983

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1019970012609A KR100267089B1 (ko) 1996-08-19 1997-04-04 스칼라/벡터연산이조합된단일명령복수데이터처리

Country Status (6)

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

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR20150062651A (ko) * 2013-11-29 2015-06-08 삼성전자주식회사 명령어를 실행하는 방법 및 프로세서, 명령어를 부호화하는 방법 및 장치 및 기록매체

Families Citing this family (9)

* 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位三发射的数字信号处理器
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
US11409692B2 (en) * 2017-07-24 2022-08-09 Tesla, Inc. Vector computational unit
US11893393B2 (en) 2017-07-24 2024-02-06 Tesla, Inc. Computational array microprocessor system with hardware arbiter managing memory requests
CN114116513B (zh) * 2021-12-03 2022-07-29 中国人民解放军战略支援部队信息工程大学 多指令集架构向risc-v指令集架构的寄存器映射方法及装置

Family Cites Families (5)

* 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
US5001662A (en) * 1989-04-28 1991-03-19 Apple Computer, Inc. Method and apparatus for multi-gauge computation
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
DE69519449T2 (de) * 1994-05-05 2001-06-21 Conexant Systems Inc Raumzeigersdatenpfad

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR20150062651A (ko) * 2013-11-29 2015-06-08 삼성전자주식회사 명령어를 실행하는 방법 및 프로세서, 명령어를 부호화하는 방법 및 장치 및 기록매체
US10956159B2 (en) 2013-11-29 2021-03-23 Samsung Electronics Co., Ltd. Method and processor for implementing an instruction including encoding a stopbit in the instruction to indicate whether the instruction is executable in parallel with a current instruction, and recording medium therefor

Also Published As

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

Similar Documents

Publication Publication Date Title
KR100236527B1 (ko) 벡터 레지스터의 복수 뱅크를 사용한 단일 명령복수 데이터 처 리
US12019559B2 (en) Method and apparatus for dual issue multiply instructions
US6058465A (en) Single-instruction-multiple-data processing in a multimedia signal processor
KR100500890B1 (ko) 디지탈 신호처리용 집적회로구조
EP0901071B1 (en) Methods for interfacing a processor to a coprocessor
EP1010065B1 (en) Coprocessor data access control
US5983336A (en) Method and apparatus for packing and unpacking wide instruction word using pointers and masks to shift word syllables to designated execution units groups
US20040193837A1 (en) CPU datapaths and local memory that executes either vector or superscalar instructions
US11500631B2 (en) Method and apparatus for implied bit handling in floating point multiplication
EP1124181B1 (en) Data processing apparatus
JPH0926878A (ja) データ処理装置
JPH09311786A (ja) データ処理装置
JP2001202245A (ja) 改良式命令セットアーキテクチャを有するマイクロプロセッサ
WO1998006038A1 (en) Architectural support for software pipelining of loops
US5860154A (en) Method and apparatus for calculating effective memory addresses
CN101802779A (zh) 具有可重新组构的浮点单元的处理器
KR100267089B1 (ko) 스칼라/벡터연산이조합된단일명령복수데이터처리
US5768553A (en) Microprocessor using an instruction field to define DSP instructions
JPH07120284B2 (ja) データ処理装置
KR100267092B1 (ko) 멀티미디어신호프로세서의단일명령다중데이터처리
US6925548B2 (en) Data processor assigning the same operation code to multiple operations
US6728741B2 (en) Hardware assist for data block diagonal mirror image transformation
KR20000048531A (ko) 데이터 처리장치에서의 입력 오퍼랜드 제어
KR20000048529A (ko) 데이터 처리장치의 레지스터 제어
Marzal et al. A N-best sentence hypotheses enumeration algorithm with duration constraints based on the two level algorithm

Legal Events

Date Code Title Description
A201 Request for examination
E902 Notification of reason for refusal
E701 Decision to grant or registration of patent right
GRNT Written decision to grant
FPAY Annual fee payment

Payment date: 20120629

Year of fee payment: 13

FPAY Annual fee payment

Payment date: 20130701

Year of fee payment: 14

LAPS Lapse due to unpaid annual fee