JP3645574B2 - Input operand control in data processing systems - Google Patents

Description

以上をまとめると、１つのレジスタの２つの半分は、互いに独立に、ROBから充填することができる。ROB内のデータは、レジスタ全体用に印が付けられるか、あるいはレジスタの下半分用の２つの16ビットの値としての印が付く。
データをROBにロードするにはARMコプロセッサ命令が使用される。ROBにおいてデータが印を付けられる方法は、転送に使用されたARMコプロセッサ命令がどれであったかによる。ROBにデータを転送するのに使用できるARM命令には以下のものがある。

最初の３つは、LDC命令としてアセンブルされ、MPRとMRPは、MCR命令として、LDPAはCDP命令としてアセンブルされる。
上記＜dest＞は、ピッコロのレジスタ（A0−Z3）を示し、RnはARMレジスタを示し、＜size＞は４の乗数（ゼロを除く）となる定数としてのバイト数であり、＜wrap＞は、定数（１、２、４、８）を示す。｛ ｝によって囲まれた領域は、オプションである。転送がリオーダ・バッファへ当てはまるようにするために、＜size＞は最大で32である。多くの場合、＜size＞は、この制限より小さくしてデッドロックを避ける。＜16/32＞領域は、ロードされるデータが16ビット・データとして扱われ、endianess特定動作（以下を参照）を行うべきか、あるいは32ビットデータであるかを示す。
注1:以下の説明において、LDPまたはLDPWに言及する場合、これらの命令の16ビット用変種と32ビット用変種の両方を含むものとする。
注2:1つのワード（word）は、メモリからの32ビットの固まりであり、それは、16ビットのデータ項目２つから成るか、あるいは32ビットのデータ項目１つからなる。
LDP命令は、多数のデータ項目をフル・レジスタ用として転送する。この命令は、メモリ内のアドレスRnから＜size＞/4ワードをロードし、それらをROBに挿入する。転送することのできるワード数は以下のように制限される。
− ＜size＞の量は、４の非ゼロ倍数でなければならず、
− ＜size＞は、特定の導入についてROBのサイズ以下でなければならない（第１版では８ワード、その後の版では、それ以下にならない保証があること）。転送される最初のデータ項目は目的地が＜dest＞のタグを付け、第２のデータ項目は、＜dest＞＋１というようになる（Z3からA0まではラッピング（wrapping））。もし“!"が指定された場合は、その後、レジスタRnが＜size＞によって１つずつ増加される。
LDP16の変種が使用された場合は、エンダイアン（endian）特定動作が２つの16ビットのハーフワードに行われて、それらがメモリシステムから戻される時には32ビットデータ項目とする。より詳しくは、以下のBig Endian及びLittle Endianサポートを参照せよ。
LDPW命令は、多数のデータ項目をレジスタのセットに転送する。最初に転送されるデータ項目には＜dest＞のタグが付き、次は＜dest＞＋１のタグが付き、以下同様。＜wrap＞転送が起きると、次に転送される項目は、＜dest＞用となり、以下同様。＜wrap＞の量は、ハーフワードの量で指定される。
LDPWには、次の制限がある。
− ＜size＞の量は、４の非ゼロ倍でなければならず、
− ＜size＞は、特定の導入についてROBのサイズ以下でなければならず（第１版では８ワード、その後の版では、それ以下にならない保証がある）、
− ＜dest＞は、｛A0,X0,Y0,Z0｝のいずれか１つでよく、
− ＜wrap＞は、LDP32Wについては｛2,4,8｝のいずれかの個数のハーフワードであり、LDP16Wについては｛1,2,4,8｝のいずれかの個数のハーフワードであり、
− ＜size＞の量は、２＊＜wrap＞より大きくなければならない。さもないと、ラッピングは起きず、代わりにLDP命令が使用される。
たとえば、次の命令

は、２つのワードをROBにロードし、その目的地をフル・レジスタX0とする。
R0は、８増加する。次の命令

は、４つのワードをROBにロードし、それらの目的地をX0,X1,X0,X1（この順序で）とする。R0は影響されない。
LSP16Wに対しては、＜wrap＞は、１、２、４、又は８として指定できる。１のラップが指定されると、すべのデータのタグの目的地が、目的レジスタの下半分＜dest＞.1.となる。これは、ハーフ・レジスタの場合である。
例えば、次の命令

は、２つのワードをROBにロードし、それらを16ビットデータとして目的地をX0.1とする。R0は８増加される。次の命令

は、LDP32Wの例と同様に挙動するが、ただし、エンダイアン特定動作は、メモリから戻されるデータ上に行われる。
LDP命令のすべての使用されないエンコーディングは、将来の拡張用に取っておくことができる。
LDP16U命令は、非ワードを揃え（non−word aligned）16ビットデータの効率良い転送をサポートする。LDP16UサポートはレジスタD4−D15（X,Y,Zバンク）になされる。LDP16Uサポートは、レジスタ32ビットワードのデータ１つ（２つの16ビットデータ項目を含む）をメモリからピッコロへ転送することになる。ピッコロは、このデータの下の16ビットを捨て、上の16ビットを保持レジスタに記憶する。X,Y,Zバンク用の保持レジスタがある。バンクの保持レジスタが通報されると（primed）と、データの目的地がそのバンク内のレジスタであれば、LDP｛ｗ｝命令の挙動が変化する。ROBにロードされたデータは、LDP命令によって転送されつつあるデータの下の16ビットと保持レジスタとの連結によって形成される。転送されつつある上の16ビットは、保持レジスタに入れられる。

このモードの動作は、LDPA命令によって打ち切られるまで続く。保持レジスタは、目的レジスタのタグもサイズも記録しない。これらの性質は、次のdata.1.の値を提供する命令から得られる。
メモリシステムから戻されたデータには、常にエンダイアン特定挙動が起きる可能性がある。LDP16Uと同等の非16ビットはない。というのは、32ビットデータ項目はすべてメモリにおいてワード揃えされるからである。
LDPA命令は、LDP16U命令によって開始された操作の非整列（unaligned）モードを取り止めるのに使用される。非整列モードは、バンクX,Y,Z上で独立に切ることができる。例えば、次の命令

は、バンクX,Y上で非整列モードを打ち切る。これらのバンクの保持レジスタ内のデータは、捨てられる。
非整列モードにないバンク上でLDPAを実行することは可能であり、そのバンクは整列モードのままである。
MPR命令は、ARMレジスタRnの内容をROBに入れ、ピッコロレジスタ＜dest＞に向けられる。目的レジスタ＜dest＞は、A0−Z3の範囲のフルレジスタならどれでもよい。例えば、次の命令

は、R3の内容をROBに移し、そのデータをフルレジスタX0用とする。
データがARMからピッコロに転送される時にエンダイアネス（endianess）特定挙動が生じることがない。というのは、ARMは、内部的に、あまりエンダイアンではないからである。
MPRW命令は、ARMレジスタRnの内容をROBに入れ、それを、16ビットピッコロレジスタ＜dest＞.l.向けの２つの16ビットデータ項目とする。＜dest＞についての制限は、LDPWの命令の場合と同じである（つまり、Z0,X0,Y0,Z0）。例えば、次の命令

は、R3の内容をROBに移し、X0.l.向けの２つの16ビット量のデータとする。尚、ｌでラップするLDP16Wの場合、32ビットレジスタの下半分だけが目的地となり得る。
MPRについては、データに対してエンダイアネス特定操作は何も行われない。
LDPは、次のようにエンコードされる。

ここで、PICCOLO1は、ピッコロの最初のコプロセッサの番号（現在８）である。ＮビットがLDP32（１）とLDP16（０）との間の選択を行う。
LDPWは、次のようにエンコードされる。

ここで、DESTは、目的レジスタA0,X0,Y0,Z0に対する０−３であり、WRAPは、１、２、４、８の値のラップに対して０−３である。PICCOLO2は、ピッコロの第２のコプロセッサ番号（現在９）である。Ｎビットが、LDP32（１）とLDP16（０）との間の選択を行う。
LDP16Uは、次のようにエンコードされる。

ここで、DESTは、目的バンクX,Y,Zに対する１−３である。
LDPAは、次のようにエンコードされる。

ここで、BANK〔3:0〕は、バンクごとの非整列モードを打ち切るのに使用される。BANK〔１〕がセットされると、バンクＸ上の非整列モードが打ち切られる。BANK〔２〕及びBANK〔３〕がセットされれば、それぞれバンクY,Z上の非整列モードが打ち切られる。尚、これはCDP操作である。
MPRは、次のようにエンコードされる。

MPRWは、次のようにエンコードされる。

ここで、DESTは、目的レジスタX0,Y0,Z0に対する１−３である。
出力FIFOは、32ビットの値を８つまで保持することができる。これらは、次の（ARM）オペコード（opcodes）の１つを使用して、ピッコロから転送される。

最初のは、＜size＞/4ワードを出力FIFOから、ARMレジスタRnによって与えられるアドレスへ退避する。“!"があれば、Rnを指示する。デッドロックを避けるために、＜size＞は、出力FIFOのサイズ（この導入例では８エントリ）以下でなければならない。STP16の変種が使用された場合は、メモリシステムから戻されるデータにエンダイアン特定挙動が生じる可能性がある。
MRP命令は、出力FIFOから１つのワードを除去し、それをARMレジスタRnに入れる。MRPと同様に、このデータには、エンダイアン特定操作が適用されることはない。
STP用のARMエンコーディングは以下の通り。

ここで、Ｎは、STP32（１）とSTP16（０）との間の選択を行う。P,U,Wビットの定義については、ARMデータシートを参照せよ。
MRP用のARMエンコーディングは以下の通り。

ピッコロ命令セットは、内部的にはエンダイアン操作がほとんどないと仮定している。例えば、32ビットレジスタに、複数の16ビット・ハーフとしてアクセスする場合、下半分がビット15から０を占めるとする。ピッコロは、大きなエンダイアン・メモリ又は周辺機器（peripherals）のあるシステムで動作することになるので、16ビットでパックされたデータを正しくロードできるようにしなければならない。
ピッコロ（つまり、DSPが採用されたコプロセッサ）は、ARM（例えば、英国、ケンブリッジのアドヴァンストRISCマシンズ・リミテッドによって製造されたARM7マイクロプロセッサ）のように、プログラマがプログラム可能周辺機器で制御できるであろう‘BIGEND'構成ピンを持っている。ピッコロは、このピンを使用して入力リオーダ・バッファ及び出力FIFOを構成する。
ARMがパック16ビットデータをリオーダ（reorder）・バッファにロードする時は、そのことを、LDP命令の16ビット形式を使用して示さなければならない。この情報は、‘BIGEND'構成入力の状態と組み合わされて、データを保持ラッチへ入れ且つリオーダ・バッファを適当な順序にする。特にbig endianモードの時は、保持レジスタはロードされたワードの下16ビットを記憶し、次のロードの上16ビットと対（ペア）にされる。保持レジスタの内容は、常に、リオーダ・バッファへ転送されたワードの下16ビットで終わる。
出力FIFOは、パックされた16ビット又は32ビットデータを含むことができる。プログラマは、STP命令の正確な形式を使用して、16ビットデータがデータバスの正しい半分に提供されていることをピッコロが確認できるようにしなければならない。big endianとして構成されている場合、STPの16ビット形式が使用されると、上16ビットハーフ及び下16ビットハーフが交換される。
ピッコロは、ARMからしかアクセスできないプライベート・レジスタを４つ持っている。これらは、S0−S2と呼ばれる。これらにアクセスできるのは、MRC命令とMCR命令だけである。オペコードは以下の通り。

これらのオペコードは、ARMレジスタRmとプライベート・レジスタSnとの間で32ビット値を転送する。それらは、ARMにおいて、コプロセッサ・レジスタ転送としてエンコードされる。

ここで、Ｌは、MPSRなら０、MRPSなら１である。
レジスタS0は、ピッコロの一意なID及び改定コードを含む。

〔3:0〕ビットは、プロセッサの改定番号を含む。
〔15:4〕ビットは、２進符号化された10進フォーマットの３桁部分の番号（ピッコロなら、0x500）を含む。
〔23:16〕ビットは、アーキテクチャ版数を含む。0x00＝第１版
〔31:24〕ビットは、導入者の商標のASCIIコードを含む。0x41＝Ａ＝ARM Ltd.
レジスタS1は、ピッコロの状態レジスタである。

一次状件コードフラグ（N,Z,C,V）
二次状件コードフラグ（SN,SZ,SC,SV）
Ｅビット：ピッコロは、ARMによってディスエーブルされ、中止した。
Ｕビット：ピッコロは、UNDEFINED（未定義）命令に出会って、中止した。
Ｂビット：ピッコロは、BREAKPOINT（区切点）に出会って、中止した。
Ｈビット：ピッコロは、HALT（中止）命令に出会って、中止した。
Ａビット：ピッコロは、メモリ・アボート（ロード、ストア、又はピッコロ命令）によって、中止した。
Ｄビット：ピッコロは、デッドロック条件を検出し、中止した（以下を参照）。
レジスタS2はピッコロプログラム・カウンタである。

プログラム・カウンタに書き込みすると、ピッコロはそのアドレスで（中止状態であれば中止状態のまま）プログラムの実行を始める。プログラム・カウンタはリセットされた時、未定義である。というのは、プログラム・カウンタへの書き込みによっって、ピッコロは常にスタートされるからである。
実行中、ピッコロは命令の実行及びコプロセッサ・インターフェースの状態を次のようにモニタする。
− ピッコロは、レジスタ再充填されるのを、あるいは出力FIFOが使えるエントリを持つのを、待つ態勢に入った。
− ROB内のスペースが不十分であるか、出力FIFO内の事項（items）が不十分であるかの理由で、コプロセッサ・インターフェースがビジー待ち状態（busy−waiting）にある。
これらの両方の条件が検出されると、ピッコロは、その状態レジスタにＤビットをセットし、中止し、ARMコプロセッサの命令を拒絶し、ARMは未定義命令トラップにはまる。
このデッドロック状態の検出により、少なくともプログラマにこのような条件が生じたことを知らせ、また失敗の正確な点（位置）を知らせることができるシステムが構成される。プログラマは、ARMとピッコロのプログラム・カウンタとレジスタを読めばよい。尚、強調しておくが、デッドロックが生じるのは、間違ったプログラムあるいはピッコロの状態を変造するシステム部分がある場合だけである。デッドロックは、データが少なすぎることや「オーバーロード」によって生じることはない。
ARMからピッコロを制御するのに使用できるいくつかの操作があり、それらはCDP命令によって提供される。これらのCDP命令は、ARMが優先状態にある時に受け付けられる。そうでないと、ピッコロはCDP命令を拒絶し、ARMは未定義命令トラップにはまる。以下の操作が使用可能である。
− Reset（リセット）
− Enter State Access Mode（状態アクセスモードに入る）
− Enable（イネーブル）
− Disable（ディスエーブル）
ピッコロは、PRESET命令によってソフトウェア内でプリセットされる。
PRESET;Clear Piccolo's state（ピッコロの状態をクリアする）
この命令は、次のようにエンコードされる。

この命令が実行されると、次のことが生じる。
− すべてのレジスタが空き（再充填の態勢）の印になる。
− 入力ROBがクリアされる。
− 出力FIFOがクリアされる。
− ループ・カウンタがリセットされる。
− ピッコロは中止状態に入る（そしてS2のＨビットがセットされる）。
PRESET命令の実行には、いくつかのサイクル（この実施の形態では、２から３）が必要である。実行されている間に、以下のピッコロ上で実行されるべきARMコプロセッサ命令がビジー待ちになる。
状態アクセスモードにおいて、ピッコロの状態は、STC及びLDC命令（以下のARMからのピッコロ状態アクセスについての説明を参照）を使って退避され復元される。状態アクセスモードに入るには、PSTATE命令がまず実行されなければならない。
PSTATE;Enter State Access Mode（状態アクセスモードに入る）
この命令は次のようにエンコードされる。

実行されると、PSTATE命令は、
− ピッコロを中止し（すでに中止されているのでなければ）、Ｅビットをピッコロの状態レジスタにセットする。
− ピッコロを状態アクセスモードに構成する。
PSTATE命令の実行が終わるまでにはいくつかのサイクルがある。というのは、ピッコロの命令パイプラインは中止する前に汲み出されなければならないからである。実行中、ピッコロ上で実行される次のARMコプロセッサ命令がビジー待ちになる。
PENABLE及びPDISABLE命令は、高速コンテキスト切替えに使用される。ピッコロがディスエーブルされると、専用レジスタ０と１だけが（IDレシスタ、状態レジスタ）アクセス可能となり、それも優先モードからだけである。これ以外の状態へアクセスすると、またユーザモードからアクセスすると、ARM未定義命令例外が生じる。ピッコロをディスエーブルすると、実行が中止される。ピッコロは、実行を中止すると、状態レジスタにＥビットをセットして応答する。
ピッコロをイネーブルするには、PENABLE命令を実行する。
PENABLE;Enable Piccolo
この命令は次のようにエンコードされる。

ピッコロをディスエーブルするには、PDISABLE命令を実行する。
PDISABLE;Disable Piccolo
この命令は次のようにエンコードされる。

この命令が実行されると、次のことが生じる。
− ピッコロの命令パイプラインが空になる（drain）。
− ピッコロは中止して、状態レジスタにＨビットをセットする。
ピッコロ命令キャッシュは、ピッコロのデータパスを制御するピッコロの命令を保持する。もし存在すれば少なくとも64個の命令を保持し、それを16ワード境界から開始することが保証される。次のARMオペコードがMCRにアセンブルされる。その動作は、強制的にキャッシュに、（16ワード境界上にあるはずの）指定されたアドレスから始まる（16個の）命令のラインを取り込ませる（fetch）。この取り込みは、キャッシュがすでにこのアドレスに関係するデータを保持していても行われる。
PMIR Rm
ピッコロは、PMIRが行われるより前に中止されなければならない。
このオペコードのMCRエンコーディングは以下の通り。

− このセクションは、ピッコロのデータパスを制御するピッコロ命令セット（集合）に言及する。各命令は32ビットの長さである。これらの命令は、ピッコロ命令キャッシュから読み出される。
命令セットのデコードは、非常に直線的である。最初６ビット（26から31）が主要オペコードを与え、22から25までが、いくつかの特定の命令のためのマイナーなオペコードを提供する。灰色の影となっているコードは、現在未使用のものであり、拡張用として使える（それらは現時点で指示された値を含んでいなければならない）。
11の主要命令クラスがある。これは、いくつかのサブクラスのデコードを簡単にするため、命令にファイルされた主要オペコードに完全に対応するものではない。

上の表にある命令には、以下の名前がついている。
Standard Data Operation（標準データ操作）
Logical Operation（論理操作）
Conditional Add/Subtract（条件付加算／減算）
Undefined（未定義）
Shifts（シフト）
Select（選択）
Undefined（未定義）
Parallel Select（並列選択）
Multiply Accumulate（乗算累算）
Undefined（未定義）
Multiply Double（乗算ダブル）
Undefined（未定義）
Move Signed Immediate（符号付即値移動）
Undefined（未定義）
Repeat（反覆）
Repeat（反覆）
Register List Operation（レジスタ・シフト操作）
Branch（ブランチ）
Renaming Parameter Move（リネーム・パラメータ移動）
Halt/Break（中止／中断）
命令の各クラスのフォーマットは、次のセクションに詳しく述べてある。ソース及び目的オペランド領域は、ほとんどの命令において共通であり、レジスタ・リマッピングと同様、別のセクションに述べてある。
ほとんどの命令は２つのソースオペランドSource1,Source2を必要とする。
Source1（SRC1）オペランドは、次の７ビット・フォーマットを持つ。

この領域の要素は、次の意味を持つ。
− Size−読み出すオペランドのサイズを示す（１＝32ビット、０＝16ビット）。
− Refill−レジスタが読み出された後、空きの印になり、ROBから再充填できることを示す。
− Register Number−32ビット、16ビットレジスタのどっちのレジスタを読み出すべきべきかエンコードする。
− Hi/Lo−16ビット読み出しに対して、32ビットレジスタのどちらの半分を読み出すべきかを示す。32ビットオペランドに対してセットされた場合は、レジスタの２つの16ビット半分が入れ換えられなければならないことを示す。

レジスタのサイズは、レジスタ番号に接尾辞を付けることによってアセンブラによって特定される。下位16ビットなら、.l、上位16ビットなら、.h,32ビットの上下の16ビットを入れ換えるなら、.x。
一般のソース２（SCR2）は、次の３つの12ビット・フォーマットの１つを持つ。

図４は、選択されたレジスタの適切な半分をピッコロのデータパスにスイッチするためのHi/Loビット及びSizeビットに応答するマルチプレクサ構成を示す。Sizeビットが16ビットであれば、符号拡張回路がデータパスの高次ビットに適切な０または１を入れる。
最初のエンコーディングは、ソースをレジスタとして指定し、その領域は、SCR1指定子（specifier）と同じエンコーディングを持つ。SCALE領域は、ALUの結果に適用されるべきスケールを指定する。

８ビット即値（immediate）は、回転（rotate）エンコーディングによって、32ビット即値を生成し、それが、８ビット値及び２ビット回転（rotate）によって表現される。次の表は、８ビット値XYから生成される即値を示す。

16ビット即値エンコーディングにより、６ビット符号無し即値（範囲０から63）を、ALUの出力に提供されるスケールと共に使用することができる。
一般のソース２エンコーディングは、ほとんどの命令変種に共通である。この規則には例外が少しあり、それがソース２エンコーディングの限定されたサブセットをサポートするか、あるいは、それを少し変形させる。
− Select Instructions.（選択命令）
− Shift Instructions.（シフト命令）
− Parallel Operations.（並列操作）
− Multiply Accumulate Instructions.（乗算累算命令）
− Multiply Double Instructions.（乗算ダブル命令）
選択命令は、レジスタ又は16ビット符号無し即値であるオペランドをサポートするだけである。スケールは無効である。それは、これらのビットは命令の条件領域によって使用されるからである。

シフト命令は、16ビットレジスタ又は５ビット符号無し即値である１から31のオペランドをサポートするだけである。結果のスケールは無効である。

並列操作の場合、レジスタがオペランドのソースとして指定されていれば、32ビット読み出しが行われなければならない。即値エンコーディングは、並列操作については、少し違った意味を持つ。これにより、即値は、32ビットオペランドの16ビット半分の両方に複製できる。並列操作には少し制限のある範囲のスケールが使用できる。

16ビット即値が使用された場合、常に、32ビット量の半分の両方に複製される。８ビット即値が使用された場合は、それが複製されるのは、それが32ビット量の上半分に回転されるべきであると回転（rotate）が示している時だけである。

並列選択操作にはスケールは無効である。スケール領域は、これらの命令では、０にセットされる。
乗算累算命令では、８ビット回転即値を指定することはできない。領域のビット10は、どのアキュミュレータを使用すべきかを指定する部分となる。ソース２は、16ビットオペランドとして意味される。

乗算ダブル命令は、定数を使用することができない。16ビットレジスタだけが指定できる。この領域のビット10は、どのアキュミュレータを使用すべきかを指定する部分となる。

命令のうちいくつかは、常に32ビット操作（例えば、ADDADD）を含み、その場合、サイズ・ビットは、１にセットされ、Hi/Loビットは、場合によっては32ビットオペランドの２つの16ビット半分を交換するのに使用することができる。また、いくつかの命令は、常に16ビット操作（例えば、MUL）を含み、サイズビットは０に設定されなければならない。Hi/Loビットは、レジスタのどちらの半分が使用されるかを選択する（見えないサイズビットは明らかなものと仮定する）。乗算・累算命令は、ソース・アキュミュレータと目的レジスタを独立に指定することができる。これらの命令においては、Sizeビットは、ソースアキュミュレータを指定するのに使用され、サイズビットは、命令タイプによって０と暗示される。
16ビット値が（Ａ又はＢバスを介して）使用される場合、それは、自動的に32ビット量に符号拡張される。48ビットレジスタが（Ａ又はＢバスを介して）読み出される場合、下の32ビットだけがバスに現れる。それは、どの場合でも、ソース１、ソース２は、32ビット値に変換されるからである。バスＣを使用する累算命令だけがアキュミュレータレジスタの48ビット全部にアクセスすることができる。
再充填ビットがセットされていれば、レジスタは使用後、空きの印になり、普通の再充填メカニズムによってROBから再充填される（ROBについてのセクションを参照）。ピッコロは、再充填が行われる以前にソースオペランドとしてレジスタが再び使用されないかぎり、止まらない。再充填されたデータが有効になる前のサイクルの最小数（最善の場合で、データはROBの先頭で待っている）は、１か２である。従って、再充填されたデータは、再充填要求の次の命令には使わない方が良い。もし、次の２つの命令上でオペランドの使用を避けることができるのであれば、その方が良い。というのは、これにより、より深いパイプライン導入上での性能損失を防ぐことになるから。
再充填ビットは、レジスタ番号に接尾辞“^"を付けることによってアセンブラで指定される。空きの印のついたレジスタのセクションは、レジスタのオペランドに依存する。各レジスタの２つの半分は、独立に、再充填の印をつけることもできる（例えば、X0.1^は、X0の下半分だけを再充填することになり、X0^は、X0全体を再充填することになる）。48ビットレジスタの上「半分」（ビット47:16）が再充填されると、16ビットのデータがビット31:16に書き込まれ、ビット47で符号拡張される。
同じレジスタを２回再充填しようと（例えば、ADD X1,X0^,X0^）しても、再充填は１度しか行われない。アセンブラは、ADD X1,X0,X0^という文法しか許可すべきではない。
レジスタ読み出しが、レジスタの再充填以前に試みられると、ピッコロは、レジスタが再充填されるまでまち状態で止まる。レジスタが再充填の印になると、レジスタは再充填の値が読まれる以前に更新され、その結果、UNPREDICATBLE（予想不可）となる（例えば、ADD X0,X0^,X1は予想不可。なぜなら、X0については再充填の印であるから、X0とX1の合計で埋めることになる）。
４ビットスケール領域は14のスケールタイプをエンコードする。
− ASR＃0,1,2,3,4,6,8,10
− ASR＃12から16
− LSL＃１
並列Max/Min命令は、スケールを提供しないので、ソース２の６ビット定数変種は使用されない（アセンブラにより０にセットされる）。
REPEAT命令内で、レジスタのリマッピングがサポートされ、REPEATが、ループを解かないままレジスタの移動「窓」にアクセスすることができる。これについて、以下、詳しく説明する。
目的オペランドは、次の７ビットフォーマットを持つ。

この基本エンコーディングには10の変種がある。

レジスタ番号（Dx）は16のレジスタのどれがアドレスされているかを示す。Hi/LoビットとSizeビットは、一緒になって、各32ビットレジスタへ16ビットレジスタのペアとしてアドレスする。Sizeビットは、どのようにしたら適切なフラグが、命令タイプに定義されているように、セットされるかを定義するもので、結果がレジスタバンク及び／又は出力FIFOに書き込まれるか否かには関係しない。これにより、比較及び同様の命令の構成ができる。命令の累算クラスのある加算は、結果をレジスタに書き戻さなければならない。

どの場合でも、レジスタへの書き戻し又は出力FIFOへの挿入以前の操作の結果は、48ビット量である。２つの場合がある。
書き込みが16ビットならば、48ビット量は、以下の16ビット〔15:0〕を選択することによって、16ビットに減る。命令が飽和すれば、値は、−2^15から2^15−１の範囲に飽和される。次に16ビット値が指示されたレジスタに書き戻され、また、書き込みFIFOビットがセットされれば、出力FIFOに書き戻される。出力FIFOに書き込まれた場合、それは、次の16ビット値が書き込まれるまで保持される。次の16ビットが書き込まれると、それらの値はペアとなって、単一32ビット値として出力FIFOに入れられる。
32ビットの書き込みならば、48ビットは、下の32ビット〔31:0〕を選んで32ビット量に減る。
32ビット書き込みでも、48ビット書き込みでも、命令が飽和すれば、48ビット値は−2^31−１から2^31の範囲の32ビット値に変換される。飽和すると、
− アキュミュレーへの書き戻しが行われると、48ビット全部が書き込まれる。
− 32ビットレジスタへの書き戻しが行われると、ビット〔31:0〕が書き込まれる。
− 出力FIFOへの書き戻しが行われるた場合も、やはりビット〔31:0〕が書き込まれる。
目的サイズは、レジスタ番号の後の.lまたは.hによって、アセンブラ内で指定される。レジスタへの書き戻しが全く行われない場合は、レジスタ番号は意味がなくなるので、目的レジスタを省略して、レジスタへの書き込み無しとするか、あるいは、＾を使って、出力FIFOだけへの書き込みを指示する。例えば、SUB,X0,Y0は、CMP X0,Y0と等価であり、ADD^,X0,Y0は、X0＋Y0の値を出力FIFOに入れる。
出力FIFOに値を入れる空きがない場合は、ピッコロは、空きができるまで待機する。
16ビット値、例えば、ADD X0.h^,X1,X2が書き出されると、その値は、第２の16ビット値が書かれるまでラッチされる。次にこれら２つの値は結合されて、32ビット数として出力FIFOに入れられる。最初に書き込まれる16ビット値は、常に32ビットワードの下半分に現れる。出力FIFOに入れられたデータは、16又は32ビットデータとしての印がつき、endianessをbig endianシステム上で訂正することができる。
32ビット値が２つの16ビット書き込みの間に書き込まれると、その動作は未定義になる。
REPEAT命令内で、レジスタ・リマッッピングがサポートされ、REPEATは、ループを解く（unroll）ことなしにレジスタの移動「窓」にアクセスすることができる。以下、これについて詳しく説明する。
本発明の好ましい実施の形態において、REPEAT命令は、レジスタ・オペランドがループ内で特定される方法を変更するメカニズムを提供する。このメカニズムの下で、アクセスするレジスタは命令内のレジスタ・オペランドとレジスタバンクのオフセットの機能によって決定される。オフセットは、プログラム可能な方法で変更でき、各命令ループの最後で変更されるのが好ましい。このメカニズムは、X,Y,Zバンク内にあるレジスタ上で独立に動作することができる。好ましい実施の形態では、この機能はＡバンク内のレジスタには使用できない。
論理レジスタ、物理レジスタという概念を使用することができる。命令オペランドは論理レジスタを参照し、これらは、特定のピッコロレジスタ10を同定する物理レジスタ・レファレンスにマップされる。すべての操作は、再充填も含み、物理レジスタ上で動作する。レジスタ・リマッピングが生じるのは、ピッコロ命令ストリームサイドだけであり、ピッコロにロードされるデータは常に物理レジスタを目的とし、リマッピングは行われない。
リマッピングのメカニズムについて、以下、図５を参照して説明する。図５は、ピッコロ・コプロセッサ４の多数の内部構成要素を示すブロック図である。メモリからARMコア２によって検索されるデータ項目は、リオーダ・バッファ12に入れられ、ピッコロレジスタ10は、先に図２を参照した方法で、リオーダ・バッファ12から再充填される。キャッシュ６に記憶されているピッコロの命令は、ピッコロ４内の命令デコーダ50に渡されることによって、ピコロ・プロセッサ・コア54に渡される前にデコードされる。ピッコロ・プロセッサ・コア54は、先に図３を参照して述べた乗算器／加算器回路20と、累算／退出回路22と、スケール／飽和（saturate）回路24とを備える。
命令デコーダ50がREPEAT命令によって同定された命令ループの一部を構成する命令を扱っていて、且つ、そのREPEAT命令が多数のレジスタのリマッピングを行うことが必要であると指示した場合は、レジスタ・リマッピング論理52が使用されて、必要なリマッピングが行われる。レジスタ・リマッピング論理52は、命令デコーダ50の一部であると考えて良い。ただし、当業者には明らかなように、レジスタ・リマッピング論理52は、命令デコーダ50に対して全く別のものとして提供されてもかまわない。
典型的な命令は、その命令にとって必要なデータ項目を含むレジスタを同定する１つまたは２つ以上のオペランドを備える。例えば、典型的な命令は、２つのソースオペランドと１つの目的ペランドを含むことができ、その命令が必要とするデータ項目を含む２つのレジスタと、その命令の結果を入れるべきレジスタを同定する。レジスタ・リマッピング論理52は、命令デコーダ50から命令のオペランドを受け取るが、それらは論理レジスタ・レファレンスを同定する。論理レジスタ・レファレンスに基づき、レジスタ・リマッピング論理は、物理レジスタのリマッピングをすべきかどうかを決定し、必要なら、物理レジスタ・レファレンスにリマッピングを適用する。また、リマッピングを適用すべきではないと決定された場合は、論理レジスタ・レファレンスが物理レジスタ・レファレンスとして提供される。リマッピングを行う好ましい方法については、後で、詳しく説明する。
レジスタ・リマッピング論理から各出力物理レジスタ・レファレンスは、ピッコロ・プロセッサ・コア54に渡されることによって、プロセッサ・コアが、物理レジスタ・レファレンスによって同定される特定のレジス10内のデータ項目に命令を適用できるようにする。
好ましい実施の形態によるリマッピングのメカニズムによれば、レジスタの各バンクは、２つのセクション、つまりその中でレジスタがリマップされるセクションと、レジスタがリマッピング無しで元のレジスタ・レファレンスを保持するセクションとの２つのセクションに割ることができる。好ましい実施の形態において、リマップされたセクションは、リマップされているレジスタ・バンクの下から開始される。
このリマッピングのメカニズムは多数のパラメータを使用し、これらのパラメータについては、図６を参照しながら、詳細に説明する。図６は、様々なパラメータがレジスタ・リマッピング論理52によっていかに使用されるかを示すブロック図である。尚、これらのパラメータは、リマップされているバンク内の点、例えば、バンクの下からの相対的値を与えられている。
レジスタ・リマッピング論理52は、２つの主要論理ブロック、つまりRemap（リマップ）ブロック56とBase Update（ベース更新）ブロック58とからなると考えることができる。レジスタ・リマッピング論理52は、論理レジスタ・レファレンスに加えられるべきオフセット値を提供するベース・ポインタを使用する。このベース・ポインタの値は、ベース更新ブロック58によってリマップ・ブロックに提供される。
BASESTART信号を使用して、ベースポインタの初期値を定義することができる。例えば、典型的には、ゼロであるが、他の値を指定することもできる。このBASESTART信号は、ベース更新ブロック58内のマルチプレクサ60に渡される。命令ループの最初の繰り返しで、BASESTART信号は、マルチプレクサ60によって、記憶エレメント66に渡され、ループのその後の繰り返しでは、次のベース・ポインタ値がマルチプレクサ60によって記憶エレメント66に渡される。
記憶エレメント66の出力は、現在のベース・ポインタ値としてリマップ論理56に渡され、またベース更新論理58内の加算器62の入力の１つにも渡される。加算器62は、ベース・インクリメント値を提供するBASEINC信号を受け取る。加算器62は、記憶エレメント66によって供給される現在のベース・ポインタ値を、BASEINC値分だけインクリメントし、結果をモジュロ回路64へ渡すようになっている。
また、モジュロ回路は、BASEWRAP値を受け取り、この値を加算器62からの出力ベース・ポインタ信号と比較する。インクリメントされたベース・ポインタ値がBASEWRAP値以上であれば、その新しいベース・ポインタがラップラウンドされて、新しいオフセット値となる。モジュロ回路64の出力は、記憶エレメント66に記憶されるべき次のベース・ポインタ値となる。この出力はマルチプレクサ60に提供され、そこから、記憶エレメント66に提供される。
しかしながら、この次のベース・ポインタ値は、REPEAT命令を管理するループ・ハードウェアからBASEUPDATE信号を記憶エレメント66が受け取らないうちは、記憶エレメント66に記憶できない。BASEUPDATE信号は、ループ・ハードウェアによって周期的に生成され、例えば、命令ループが反復されるごとに、生成される。BASEUPDATE信号を記憶エレメント66が受け取ると、記憶エレメントは、以前のベース・ポインタ値にマルチプレクサ60から提供される次のベース・ポインタ値を上書きする。このように、リマップ論理58に供給されるベース・ポインタ値は、新しいベース・ポインタ値に変わる。
レジスタバンクのリマップされたセクション内でアクセスされるべき物理レジスタは、命令のオペランド内に含まれる論理レジスタ・レファレンスに、ベース更新論理58によって提供されるベース・ポインタ値を加えることによって決定される。この加算を行うのは加算器68であり、その出力は、モジュロ回路70に渡される。好ましい実施の形態において、モジュロ回路70は、レジスタ・ラップ値を受け取り、加算器68からの出力信号（論理レジスタ・レファレンスとベース・ポインタ値の和）がレジスタ・ラップ値を越えると、その結果へ、リマップされた領域の下でラップ（wrap）が行われる。モジュロ回路70の出力は、マルチプレクサ72に提供される。
REGCOUNT値がリマップ・ブロック56内の論理74に提供され、リマップされるべきバンク内のレジスタの個数を同定する。論理74は、このREGCOUNT値を論理レジスタ・レファレンスと比較し、比較の結果により、制御信号をマルチプレクサ72に渡す。マルチプレクサ72は、その２つの入力で、論理レジスタ・レファレンスとモジュロ回路70からの出力（リマップされたレジスタ・レファレンス）を受け取る。本発明の好ましい実施の形態において、論理レジスタ・レファレンスがREGCOUNT値より小さければ、論理74は、マルチプレクサ72にリマップされたレジスタ・レファレンスを物理レジスタ・レファレンスとして出力させる。ただし、もし、論理レジスタ・レファレンスがREGCOUNT値以上であれば、論理74は、マルチプレクサ72に論理レジスタ・レファレンスを直接、物理レジスタ・レファレンスとして出力させる。
先に述べたように、好ましい実施の形態において、リマッピング・メカニズムを引き起こすのはREPEAT命令である。後で、より詳しく述べるように、REPEAT命令は、ハードウェアで４つのゼロサイクルループを提供する。これらのハードウェア・ループは、図５に命令デコーダ50の部分として図示されている。命令デコーダ50がキャッシュ６から命令を要求する度に、キャッシュはその命令を命令デコーダに戻し、それにより、命令デコーダは、戻された命令がREPEAT命令であるかどうかを判断する。もしそれであれば、ハードウェア・ループの１つが、そのREPEAT命令を扱うように構成される。
各繰り返し命令は、ループ内の命令の数と、ループを繰り返す回数（定数またはピッコロ・レジスタから読み出される）を指定する。２つのオペコードREPEATとNEXTがハードウェアループの定義用に提供され、NEXTオペコードは単に区切りとして使用されるだけで、命令としてアセンブルはされない。REPEATがループの頭に行き、NEXTがループの最後を区切ることによって、アセンブラはループ・本体内の命令の数を数えることができる。好ましい実施の形態において、REPEAT命令は、レジスタ・リマッピング論理52が使用すべきREGCOUNT,BASEINC,BASEWRAP,REGWRAPパラメータのようなリマッピング・パラメータを含むことができる。
レジスタ・リマッピング論理によって使用されるリマッピング・パラメータを記憶する多数のレジスタを提供することができる。これらのレジスタ内で、前もって定義されたリマッピング・パラメータの多数のセット（集合）を提供することができる一方、いくつかのレジスタはユーザ定義リマッピング・パラメータを記憶するために残される。REPEAT命令と共に指定されたリマッピング・パラメータが、前もって定義されたリマッピング・パラメータの１つと等しい場合、適当なREPEATエンコーディングが使用され、これにより、マルチプレクサ等が適当なリマッピング・パラメータをレジスタから直接にレジスタ・リマッピング論理へ提供する。一方、リマッピング・パラメータが前もって定義されたリマッピング・パラメータのどれとも等しくない場合は、アセンブラがRemapping Parameter Move（RMOV）命令を生成する。これにより、ユーザ定義レジスタ・リマッピング・パラメータの構成が可能となり、RMOV命令の後にREPEAT命令が続く。好ましくは、ユーザ定義リマッピング・パラメータは、RMOV命令によって、そのようなユーザ定義リマッピング・パラメータを記憶すべく残されていたレジスタに入れられ、マルチプレクサは、それらのレジスタの内用をレジスタ・リマッピング論理に渡すようプログラムされる。
好ましい実施の形態において、REGCOUNT,BASEIN,BASEWRAP,REGWRAPパラメータは、以下のチャートに示された値の１つを取る。

図６に戻り、リマップ・ブロック56によって様々なパラメータが使用される例を次に示す（この例では、論理及び物理レジスタ値は、特定バンクに対する相対値である。）

ループの最後で、ループの次の繰り返しが始まる前に、次のベース・ポインタ更新がベース更新論理58によって行われる。
Base＝（Base＋BASEINC）MOD BASEWRAP
リマッピング・ループの最後でレジスタ・リマッピングが打ち切られ、すべてのレジスタは物理レジスタとしてアクセスされる。好ましい実施の形態において、１つのリマッピングREPEATだけがどの時点においてもアクティブである。ループは、ネストされたままであるが、ある特定の時点で１つだけがリマッピング変数を更新してよい。ただし、所望するなら、リマッピング繰り返しはネストできるようにする。
本発明の好ましい実施の形態に基づくリマッピング・メカニズムを使用した結果としてのコード密度に関して達成される効果を示すために、以下、典型的なブロック・フィルタ・アルゴリズムについて説明する。まず、ブロック・フィルタ・アルゴリズムの原則について、図７を参照しながら説明する。図７に示されているように、アキュミュレータ・レジスタA0は、多数の乗算操作の結果を累算するように備えられている。この乗算操作というのは、係数c0とデータ項目d0との乗算、係数c1とデータ項目d1との乗算、係数c2とデータ項目d2との乗算などである。レジスタA1は、乗算操作の同様のセットの結果を累算していくが、今度は、係数がずれて、c0とd1、c1とd2、c2とd3と組み合わせの乗算になる。同様に、レジスタA2は、係数値を更にずらして、c0とd2、c1とd3、c2とd4といった組み合わせの乗算の結果を累算する。このシフト、乗算、累算のプロセスが、繰り返され、その結果がレジスタA3に入れられる。
本発明の好ましい実施の形態に基づくレジスタ・リマッピングを使用しないと、ブロック・フィルタ命令を実行するには、次のような命令ループが必要となる。

この例において、データ値はレジスタのＸバンクに入れられ、係数値はレジスタのＹバンクに入れられる。第１ステップとして、４つのアキュミュレータ・レジスタA0,A1,A2,A3はゼロにセットされる。アキュミュレータ・レジスタがリセットされると、命令ループが開始され、このループはREPEAT命令及びNEXT命令によって区切られる。Z1の値は、この命令ループが繰り返される回数を示し、また後で述べる理由により、この回数は、実際には、係数の個数（c0,c1,c2など）を４で割った数に等しい。
命令ループには16の乗算累算命令（MULA:multiply accumulate instructions）があり、１回目の繰り返しが終わると、その結果、レジスタA0,A1,A2,A3は、REPEAT命令と第１のMULA命令との間で上のコードで示される計算の結果を含む。乗算累算操作がどのように動作するかを示すために、最初の４つのMULA命令を考えることにする。最初の命令によって、Ｘバンク・レジスタ・ゼロの最初のすなわち下の16ビット内のデータ値と、Ｙバンク・レジスタ・ゼロ内の下の16ビットとが掛け合わされ、その結果がレジスタA0に加えられる。これと同時に、Ｘバンク・レジスタ・ゼロの下の16ビットが再充填の印になり、レジスタのこの部分に新しいデータ値が再充填できることを示す。このように印がつき、図７から明らかなように、データ項目d0が係数c0で乗算されると（これは最初のMULAによって表される）、d0は、ブロック・フィルタ命令の残り部分では不要になり、新しいデータ値で置き換えられる。
次に、第２のMULAによって、Ｘバンク・レジスタ・ゼロの第２のすなわち上の16ビットと、Ｙバンク・レジスタ・ゼロの下の16ビットとが掛け合わされ（これは、図７における,d1 ｘ c0を表す）。同様に、第３、第４のMULA命令が、d2 ｘ c0,及びd3 ｘ c0の乗算を行う。図７から明らかなように、これらの４つの計算が行われると、係数C0は不要となり、レジスタY0.lは、再充填の印がつき、他の係数（c4）で上書きできるようになる。
次の４つのMULA命令は、それぞれ、d1xc1,d2xc1,d3xc1,d4xc1の計算を表す。d1xc1の計算が終了すると、d1は不要になるので、レジスタX0.hは再充填ビットの印がつく。同様に、４つの計算すべてが終了すると、係数c1は不要になるので、レジスタY0.hは再充填用の印がつく。同様に、次の４つのMULA命令は、d2xc2,d3xc2,d4xc2,d5xc2の計算に対応し、最後の４つの計算は、d3xc3,d4xc3,d5xc3,d6xc3の計算に対応する。
上記の実施の形態において、リジスタはリマップできず、各乗算操作は、オペランドで指定される特定レジスタによって明示的に再生されなければならない。16のMULA命令の実行が終了すると、係数c4からc7及びデータ項目d4からd10まで、命令ループを繰り返すことができる。また、ループは、繰り返し１回につき４つの係数値で操作するので、係数値の個数は、４の倍数でなければならず、Z1＝係数/4個の計算が行われる。
本発明の好ましい実施の形態におけるリマッピング・メカニズムを使用することによって、命令ループは飛躍的に減らすことができ、４つの乗算累算命令を含むだけになる。さもなければ16の乗算累算命令が必要になる。このリマッピング・メカニズムを使用すると、コードは以下のように書くことができる。

先に述べたのと同様に、第１のステップで、４つのアキュミュレータ・レジスタA0−A3をゼロにセットする。次に、REPEATオペコードとNEXTオペコードによって区切られる命令ループに入る。REPEAT命令は、以下のように多数のパラメータを持つ。
Ｘ＋＋：レジスタのＸバンクに、BASEINCが‘1'であることを示す。
n4:REGCOUNTが‘4'であり、従って、最初の４つのＸバンクレジスタX0.1からX1.hがリマップされることを示す。
w4:レジスタのＸバンクに、BASEWRAPが‘4'であることを示す。
Ｙ＋＋：レジスタのＹバンクに、BASEINCが‘1'であることを示す。
n4:REGCOUNTが‘4'であり、従って、最初の４つのＹバンクレジスタY0.1からY1.hがリマップされることを示す。
w4:レジスタのＹバンクに、BASEWRAPが‘4'であることを示す。
r4:レジスタのＹバンクに、REGWRAPが‘4'であることを示す。
尚、Z1の値は、先行技術の例では、係数の個数/4に等しくなるが、ここでは、係数の個数と等しくなる。
命令ループの最初の繰り返しで、ベースポインタの値はゼロであり、リマッピングはない。ただし、次にループが実行される時は、ＸバンクもＹバンクもベース・ポインタの値は‘1'であるから、オペランドは次のようにマップされる。
X0.lはX0.hになる
X0.hはX1.lになる
X1.lはX1.hになる
X1.hはX0.lになる（BASEWRAPが‘4'だから）
Y0.1はY0.hになる
Y0.hはY1.lになる
Y1.lはY1.hになる
Y1.hはY0.lになる（BASEWRAPが‘4'だから）
従って、２回目の繰り返しでは、本発明のリマッピングを含まない先に述べた例における第５から第８番目のMULA命令によって示される計算を、４つのMULA命令が実際に行うことがわかる。同様に、３回目、４回目のループの繰り返しでは、先行技術コードの第９から第12番目、そして第13から第16番目のMULA命令によって実行された計算が行われる。
従って、上記コードは、先行技術のコードと全く同様のブロック・フィルタ・アルゴリズムを行うわけだが、ループ本体内のコード密度を４倍に改善している。つまり、先行技術では16の命令が必要であったのに比較して、４つの命令ですむ。
本発明の好ましい実施の形態に基づくレジスタ・リマッピング技術を使用することによって、以下のような利点が得られる。
1.コード密度を改善する。
2.場合によっては、レジスタを空きとして印をしてからピッコロのリオーダ・バッファによって再充填されるまでのレイテンシー（latency）を隠すこともできる。これは増えるコードサイズを捨ててアンローリングループによって実現される。
3.アクセスされるべきレジスタの数を変化させることができる。ループ繰り返し実行数を変化させることによって、アクセスされるレジスタの数を変化させることができる。
4.アルゴリズム開発を簡単にすることができる。適当なアルゴリズムについて、プログラマはアルゴリズムのｎ番目の段に対する１つのコードを生成して、レジスタ・リマッピングを使用して、その公式をデータのスライディング・セットに適用することができる。
上記レジスタ・リマッピング・メカニズムは、本発明の範囲から離れることなく、ある程度の変形が可能であることが明らかになるであろう。例えば、レジスタ10のバンクは、プログラマによって命令オペランドに指定される以上の物理レジスタを提供することができる。これらの余分のレジスタは直接的にはアクセスできないが、レジスタ・リマッピング・メカニズムでは、これらのレジスタを使用することができる。例えば、先に出した例を考えてみよう。レジスタのＸバンクに、プログラマの使える32ビットレジスタが４つあり、従って８つの16ビットレジスタが論理レジスタ・レファレンスによって指定するこができる。レジスタのＸバンクが、実際には、例えば６つの32ビットレジスタから成る場合、プログラマにとって直接アクセスできない16ビットレジスタが余分に４つあることになる。しかしながら、これらの４つのレジスタは、リマッピング・メカニズムによって使用可能となり、データ項目の記憶のための付加的レジスタを提供する。
以下のアセンブラ・シンタクス（文法）を使用することができる。
＞＞は、論理右シフト、又は、シフト・オペランドが負であれば、左シフトを意味する（下の＜1scale＞を参照）。
−＞＞は、算術右シフト、又は、シフト・オペランドが負であれば、左シフトを意味する（下の＜scale＞を参照）。
RORは、右回転を意味する。
SAT（ａ）は、ａの飽和値を意味する（目的レジスタのサイズによって、16ビット又は32ビットで飽和する）。特に、16ビットで飽和するために、＋0x7fffより大きいどんな値も＋0x7fffで置き換えられ、−0x8000より小さいどんな値も−0x8000で置き換えられる。32ビット飽和は、どうように、極限値＋0x7fffffffと−0x80000000がある。目的レジスタが48ビットである場合も、飽和は32ビットで行われる。
ソース・オペランド１は、次のフォーマットの１つを取ることができる。
＜src1＞は、

の短縮形として使用される。別の言い方をするなら、ソース・スペシファイアの７ビットはすべて有効であり、レジスタは32ビット値として（希望すれば、交換される）、または符号拡張した16ビット値として読まれる。アキュムレータに取っては、下の32ビットだけが読まれる。“^"は、レジスタ再充填を指定する。
＜src_16＞は、

の短縮形として使用される16ビット値だけが読まれる。
＜src_32＞は、

の短縮形として使用される。32ビット値だけが読まれ、上半分及び下半分は希望すれば交換できる。
ソース・オペランド２は、次のフォーマットの１つを取ることができる。
＜src2＞は、３つのオプションの短縮形として使用される。

の形のソース・レジスタ、プラス最終結果のスケール（＜scale＞）。
− オプションでシフトされた８ビット定数（＜immed_8＞）、ただし、最終結果のスケールではない。
− ６ビット定数（＜immed_6＞）、プラス、最終結果のスケール（＜scale＞）。
＜src2_maxmin＞は、＜src2＞と同じであるが、ただし、スケールは許可されない。
＜src2_shift＞シフト命令は、＜src2＞の限定的サブセットを提供する詳細は上記を参照。
＜src2_par＞＜src2_shift＞用である。
第３のオペランドを指定する命令に対して：
＜acc＞は、４つのアキュミュレータ・レジスタ

のいずれかを示す短縮形。48ビットすべてが読まれる。再充填は指定されない。
目的レジスタは次のフォーマットを持つ：
＜dest＞これは、

の短縮形。“."の拡張はない。
レジスタ全部が書かれる（アキュミュレータの場合は、48ビット）。レジスタへの書き戻しが必要ない場合は、使用されるレジスタは重要でない。アセンブラが、目的レジスタの省略をサポートし、書き戻しの必要がないこと、又は“.l"つまり、書き戻しは必要ないが結果が16ビット量であるかのようにフラグをセットすべきであることを示す。＾は、値が出力FIFOに書き込まれることを示す。
＜scale＞これは、代数スケールの数を表す。14のスケールが使用できる。
ASR＃0,1,2,3,4,6,8,10
ASR＃12から16
LSL＃１
＜immed_8＞これは、符号無し８ビット即値を表す。これは、０、８、16、又は24シフトで左回転された１バイトから成る。従って、0xYZ000000,0x00YZ0000、0x0000YZ00、0x000000YZの値が、任意のYZに対してエンコードできる。回転は、２ビット量としてエンコードされる。
＜imm_6＞これは、符号無し６ビット即値を表す。
＜PARAMS＞これは、レジスタ・リマッピングを指定し、次のフォーマットを持つ：＜BANK＞＜BASIC＞ｎ＜RENUMBER＞ｗ＜BASEWRAP＞

＜cond＞という表現は、以下の条件コードの任意の１つの短縮形である。尚、エンコーディングは、ARMと少し異なる。それは、符号無しLS及びHIコードは、より役立つ符号付きオーヴァーフロー／アンダーフローのテストで置き換えられているからである。Ｖフラグ及びＮフラグは、ピッコロ上で、ARMとは違う方法でセットされるので、条件テストからフラグ・チェックへの翻訳も、ARMとは異なる。

ピッコロが扱うのは符号付き量であるから、符号無しLS及びHI条件は、落とされ、オーバーフローの方向を記述するVPとVNで置き換えられている。ALUの結果は48ビット幅であるから、MIとLTが、同様にPLとGEが同じ機能を行う。
すべての操作は、特に注意書のない限り、符号付きである。
第１条件コード及び第２条件コードは、それぞれ、次のものから成る。
Ｎ 負
Ｚ ゼロ
Ｃ キャリー／符号無しオーバーフロー
Ｖ 符号付きオーバーフロー
算術命令は、並列命令と「フル幅」命令の２つに分けることができる。「フル幅」命令というのは、一次フラグをセットするだけであるのに対して、並列オペレータは、結果の上16ビット半分と下16ビット半分とに基づき、一次フラグと２次フラグをセットする。
N,Z,Vフラグは、スケールを適用した後に、目的に書き込まれる前に、ALUの結果に基づいて計算される。ASRは常に、結果を記憶するのに必要なビット数を減らすが、ASLだと、それを増やす。これを避けるために、ピッコロは、ASLスケールが適用された場合、48ビットの結果を削って、ゼロ検出及びオーバーフローが行われるビット数を制限する。
Ｎフラグの計算は、符号付き算術計算が行われると推定して、行われる。それは、オーバーフローが起きた場合、結果の最上位ビットはＣフラグかＮフラグであり、それは、入力オペランドが符合付きか符号無しかによるからである。
Ｖフラグは、選択された目的に結果を書き込んだ結果、精度の損失があるか否かを示す。書き戻しが選択されなかった場合も、「サイズ」は含まれており、オーバーフロー・フラグは正しくセットされる。オーバーフローが起きるのは、次の場合である。
− 結果が、−2^15から2^15−１の範囲にないのに16ビットレジスタに書き込んだ場合。
− 結果が、−2^31から2^31−１の範囲にないのに32ビットレジスタに書き込んだ場合。
並列加算／減算命令は、結果の上半分及び下半分に独立にN,Z,Vフラグをセットする。
アキュミュレータに書き込みを行うと、32ビットレジスタに書き込まれたかのように、Ｖフラグがセットされる。
飽和絶対命令（SABS）も、入力オペランドの絶対値が指定された目的に合わないと、オーバーフロー・フラグをセットする。
キャリー・フラグは、加算と減算命令によりセットされ、MAX/MIN,SABS、CLB命令によって「バイナリー」フラグとして使用される。乗算操作を含む他のすべての命令は、（単数または複数の）キャリー・フラグを保存する。
加算と減算操作については、キャリーは、ビット31又はビット15又は目的が32ビット幅であるか16ビット幅であるかの、結果によって生成される。
標準的算術命令は、フラグのセット方法によって、多くのタイプに分類することができる。
加算命令、減算命令の場合、Ｎビットがセットされると、すべてのフラグが保存される。Ｎビットがセットされないと、フラグは、次のように更新される。
Ｚがセットされるのは、フル48ビット結果が０だった場合。
Ｎがセットされるのは、フル48ビット結果にビット47のセットがあった場合（負だった場合）。
Ｖがセットされるのは：
目的レジスタが16ビットであり、符号付き結果が16ビットレジスタに合わない（−2^15＜＝ｘ＜2^15の範囲にない）場合
目的レジスタが32/48ビットレジスタであり、符号付き結果が32ビットに合わない場合
＜dest＞が32又は48ビットレジスタである場合でＣフラグがセットされるのは、＜scr1＞と＜scr2＞を合計してビット31からキャリーがある時、又は、＜scr1＞から＜scr2＞を減算してビット31から借り（borrow）が生じない時（ARM上と同じキャリー）。＜dest＞が16ビットレジスタである場合でＣフラグがセットされるのは、合計のビット15からキャリーがある時。
２次フラグ（SZ,SN,SV,SC）は保存される。
48ビットレジスタから乗算又は累算を行う命令の場合。
Ｚがセットされるのは、フル48ビット結果が０だった場合。
Ｎがセットされるのは、フル48ビット結果にビット47のセットがあった場合（負だった場合）。
Ｖがセットされるのは：（１）目的レジスタが16ビットであり、符号付き結果が16ビットレジスタに合わない（−2^15＜＝ｘ＜2^15の範囲にない）場合、（２）目的レジスタが32/48ビットレジスタであり、符号付き結果が32ビットに合わない場合
Ｃは保存される。
２次フラグ（SZ,SN,SV,SC）は保存される。
論理操作、並列加算及び減算、maxおよびmin、シフトなどを含むその他の命令は、以下のようにカバーされる。
加算命令、減算命令は、２つのレジスタを加算又は減算し、結果をスケールして、レジスタに戻して記憶させる。オペランドは、符号付き値として扱われる。不飽和変種に対するフラグ更新は、オプショナルであり、Ｎを命令の最後に付け足すことによって抑制することもできる。

OPCは、命令のタイプを指定する。

アセンブラは以下のオペコードをサポートする
CMP＜src1＞，＜src2＞
CMN＜src1＞，＜src2＞
CMPは、レジスタ書き込みディスエーブル（disabled）のフラグをセットする減算であり、CMNは、レジスタ書き込みディスエーブルのフラグをセットする加算である。
フラグ：
これについては、上記の通り。
含める理由
ADCは、shift/MAX/MIN操作に続いてレジスタの下にキャリーを挿入するのに使える。また、32/32割算を行うのにも使用される。さらに、拡張精密加算を提供する。Ｎビットを加算することによって、フラグを細かく制御することができ、特にキャリーを制御できる。これにより、１ビットにつき２サイクルで、32/32ビット割算ができる。
飽和加算及び減算が、G.729などに必要である。
カウンタのインクリメント／ディクリメント。RSBは計算シフト（ｘ＝32−ｘが普通の操作）に使える。飽和RSBは、飽和否定（G.729で使用される）に必要である。
加算／減算累算命令は、累算及びスケーリング／飽和を伴う加算及び減算を行う。乗算累算命令と違って、アキュミュレータ番号は、目的レジスタと独立に指定することはできない。目的レジスタの下２ビットは、累算に使う48ビットアキュミュレータの番号、accを与える。従って、ADDA X0,X1,X2,A0及びADDA A3,X1,X2,A3は有効であるが、ADDA X1,X1,X2,A0は無効である。このクラスの命令では、結果はレジスタに書き戻されなければならず、目的領域の書き戻し無しエンコーディングは許可されない。

OPCは、命令のタイプを指定する。以下において、accは（DEST〔1:0〕）である。Saビットは、飽和を示す。
動作（OPC）：

ニューモニック：

フラグ：
上記を参照
含める理由
ADDA（加算累算）命令は、１サイクルにつき、整数アレーの２ワードとアキュミュレータ（例えば、それらの平均を見つけるのに）の和を取るのに使える。SUBA（減算累算）命令は、差の和を計算するのに（例えば相関のために）使え、２つの別個の値を減算して、その差を第３のレジスタに加える。
＜acc＞とは異なる＜dest＞を使用することによって、丸め（rounding）をともなう加算をすることもできる。例えば、X0＝（X1＋X2＋16384）＞＞15は、16384をA0に保持しながら１サイクルで行うことができる。丸め付定数加算は、ADDA X0,X1,＃16384,A0で行うことができる。
ビットの正確な導入には：
sum of（（a_i^＊b_i）＞＞ｋ）（一般的にはTrueSpeechで使用される）
標準ピッコロ・コードは以下のようになる：

このコードには２つの問題がある。１つは長すぎること、もう１つは、加算が48ビット精密加算ではなくガードビットが使用できないこと。これに対処するには、ADDAを使うことである。

これにより、25％のスピードアップが得られる、48ビット精度が保持される。
並列命令における加算／減算は、32ビットレジスタに対（ペア）で保持される２つの符号付き16ビット量で行われる。一次条件コードフラグは、最上位16ビットの結果からセットされ、二次フラグは、下位半分から更新される。これらｈの命令のソースとして指定できるのは32ビットレジスタだけであるが、値は、ハーフワード交換できる。各レジスタの個々の半分は、符号付き値として扱われる。計算及びスケーリングは、精度損失無しで行われる。従って、ADDADD X0,X1,X2,ASR＃１は、X0の上半分及び下半分における正しい平均を生成する。各命令にはオプショナル飽和が提供され、それには、Saビットをセットする。

OPCが操作を定義する。
動作（OPC）：

Saビットがセットされている場合、各和／差分は独立に飽和する。
ニューモニック：

コマンドの前のＳは飽和を示す。
アセンブラは以下のものもサポートする

書き戻しなしの標準命令によって生成される。
フラグ
Ｃがセットされるのは、２つの上の16ビット半分を加算する時に、ビット15のキャリーがある場合。
Ｚ がセットされるのは、上の16ビット半分の和が０である場合。
Ｎ がセットされるのは、上の16ビット半分の和が負である場合。
Ｖ がセットされるのは、上の16ビット半分の符号付き17ビット和が16ビットに当てはまらない（ポスト・スケール）場合。
SZ,SN,SV,SCが、同様に、下の16ビット半分に対してセットされる。
含める理由
並列加算及び減算命令は、単一32ビットレジスタに保持される複素数を操作するのに使用でき、FFTカーネルで使用される。また、16ビットデータのベクトルの単純な加算／減算にも使え、１サイクルで２つの要素を処理することができる。
ブランチ（条件付き）命令は、制御フローにおける条件付き変更を行うことを可能とする。ピッコロは、取られたブランチを実行するのに３サイクル使う。

動作
一次フラグに基づき＜cond＞が保持されれば、オフセットによるブランチ。
オフセットは、符号付き16ビット番号のワードである。この時、オフセットの範囲は、−32768から＋32767ワードに制限される。
アドレス計算は次のようにされる。
目的アドレス＝ブランチ命令アドレス＋４＋オフセット
ニューモニック：
Ｂ＜cond＞＜destination_label＞
フラグ：
影響されない
含める理由：
殆どのルーチンで非常に役立つ。
条件付き加算又は減算命令は、条件付きでsrc2をsrc1へ加算または減算する。

OPCが命令のタイプを指定する。
動作（OPC）：

ニューモニック：

フラグ：
上記参照
含める理由
条件付き加算または減算命令により、効率のよい除算コードを構成することができる。
例1:X0にある32ビット符号無し値を、X1にある16ビット符号無し値で割る（X0＜（X1＜＜16）且つX1.h＝０と仮定する）。

ループの最後で、X0.1は除算の商を保持する。余りは、キャリーの値に従って、X0.hから復元される。
例2:X0にある32ビット正の値を、X1にある32ビット正の値で割り、早く終了する。

最後に、X2が商を保持し、余りは、X0から復元される。
カウント・リーディング・ビット命令により、データが正規化される。

動作
destは、src1にある値が左にシフトされるべき場所数にセットされて、ビット31がビット30と異なるようにする。これは０−30の範囲の値であるが、例外として、src1が−１又は０の場合は、31が戻される。
ニューモニック
CLB＜dest＞，＜src1＞
フラグ
Ｚ がセットされるのは、結果が０の時。
Ｎ はクリアされる。
Ｃ がセットされるのは、src1が−１又は０の時。
Ｖ は未使用。
含む理由：
正規化に必要なステップ
ピッコロの実行を止めるには、Halt及びBreakpoint命令がある。

OPCは命令のタイプを指定する。
動作（OPC）
０ ピッコロの実行が止められ、Haltビットがピッコロ状態レジスタにセットされる。
１ ピッコロの実行が止められ、Breakビットがピッコロ状態レジスタにセットされ、ARMが中断され、ブレークポイントに到達したことを知らせる。
ニューモニック
０ HALT
１ BREAK
フラグ
影響されない。
論理演算命令は、32又は16ビットレジスタ上で論理演算を行う。オペランドは、符号無し値として扱われる。

OPCは、実行すべき論理操作をエンコードする。
動作（OPC）：

ニューモニック：

アセンブラが以下のオペコードをサポートする

TSTは、レジスタ書き込みがディスエーブルされたANDである。TEQはレジスタ書き込みがディスエーブルされたEORである。
フラグ
Ｚ がセットされるのは、結果が全て０の時。
N,C,Vは保存される。
SZ,SN,SC,SVは保存される。
含む理由：
スピーチ圧縮アルゴリズムは、情報をエンコードするために、パックされたビット領域を使用する。ビットマスク命令は、これらの領域の抽出／パック化を助ける。
Max及びMin操作命令は、最大及び最小操作を実行する。

OPCは命令のタイプを指定する。
動作（OPC）：

ニューモニック：

フラグ
Ｚ がセットされるのは、結果が０の時。
Ｎ がセットされるのは、結果が負の時。
Ｃ Maxでは、src2＞＝src1（dest＝src1の場合）の時にセットされる。Minでは、src2＞＝src1（dest＝src2の場合）の時にセットされる。
Ｖ 保存される
含む理由：
信号の強さを見るために、多数のアルゴリズムがサンプルをスキャンして、サンプルの絶対値の最大／最小を決める。これに、MAX,MIN操作が使用できる。信号の最初の最大値か最後の最大値のどちらかを見つけたいかによって、オペランドsrc1及びsrc2は、交換することができる。
MAX X0,X0,＃０は、X0を正の数に変換し下をクリップする。
MIN X0,X0,＃255は、X0の上をクリップする。これは、グラフィック処理に役立つ。
並列命令におけるMAX,MIN操作は、並列16ビットデータ上で最大値最小値操作を行う。

OPCは、命令のタイプを指定する。
動作（OPC）：

ニューモニック：

フラグ
Ｚ がセットされるのは、結果の上16ビットがゼロの場合。
Ｎ がセットされるのは、結果の上16ビットが負の場合。
Ｃ Max:src2.h＞＝scrc1.h（dest＝src1の場合）の時にセットされる。
Min:src2.h＝scrc1.h（dest＝src2の場合）の時にセットされる。
Ｖ 保存される
SZ,SN,SC,SVは、同様に、下16ビット半分用にセットされる。
含む理由：
32ビットMax,Minについて。
Move Long Immeidate Operation命令により、レジスタは、どの符号付き16ビットの符号拡張値をセットされることができる。これらの命令のうち２つは、32ビットレジスタに任意の値にセットすることができる（連続する高位半分と低位半分にアクセスすることによって）。レジスタ間の移動については、選択操作を参照。

アセンブラは、MOV命令を使用して非インターロックNOP操作を提供することができる。つまり、NOPは、MOV,＃０と等価である。
フラグ
フラグは影響されない。
含む理由：
レジスタ／カウンタをイニシアライズする。
乗算累算操作命令は、符号付き乗算を行い、累算または退出（deaccumulation）、スケーリング及び飽和を伴う。

OPC領域は命令のタイプを特定する。
動作（OPC）：

各場合、Saビットがセットされていれば、結果は目的に書き込まれる前に飽和される。
ニューモニック：

コマンドの手前のＳは飽和を示す。
フラグ：
上記を参照。
含む理由：
１サイクル保持されたMULAがFIRコードに必要である。MULSは、FFTバタフライで使用される。また、MULAは、丸め（rounding）付き乗算に役立つ。例えば、A0＝（X0＊X1＋16384）＞＞15は、16384を別のアキュミュレータ（例えばA1）に保持することによって、１つのサイクルで行うことができる。FFTカーネルには異なった＜dest＞及び＜acc＞が必要である。
Multiply Double Operation命令は、符号付き乗算を行い、結果をダブルにしてから累算又は退出、スケーリング、飽和を行う。

OPCは命令のタイプを指定する。
動作（OPC）：

ニューモニック：

フラグ：
上記参照
含む理由：
MLD命令は、G.729など、分数（fractional）算術を使用するアルゴリズムにとって必要である。殆どのDSPは、累算又は書き戻しの前に乗数の出力において１ビット左にシフトさせることのできる分数モードを提供する。これを特定命令としてサポートすることにより、プログラマにはより大きなフレキシビリティーが与えられる。Ｇシリーズの基本操作のいくつかと同等の名前を以下に示す。

これらは、１ビット左シフトする時に乗数の飽和を利用する。一連の分数の乗算・累算が必要な場合、精度のロスなしに、MULAを使うことができ、その和は、33.14フォーマットで保持される。必要なら、左シフト及び飽和を最後に利用して、1.15フォーマットに変換することができ８る。
乗算演算命令は、符号付き乗算、及びオプショナルなスケーリング／飽和を行う。ソース・レジスタ（16ビットのみ）は、符号付き数として扱われる。

OPCは命令のタイプを指定する。
動作（OPC）：

ニューモニック：

フラグ：
上記を参照。
含む理由。
符号付き且つ飽和乗算は、多くの処理で必要となる。
Register List操作は、複数のレジスタのセット（集合）に操作を行う時に使用される。Empty and Zero命令は、ルーチンを始める前に、あるいはルーチンとルーチンとの間で、レジスタの選択をリセットするのに使用する。Output命令を使って、レジスタのリストの内容を出力FIFOに記憶することができる。

OPCは命令のタイプを指定する。
動作（OPC）：

ニューモニック：

フラグ
影響されない
例

その場合、MOV^,Rn命令を使ってレジスタを１つ出力することになる。
EMPTY命令は、空であるすべてのレジスタが有効データを含む（すなわち、空きでない）まで、止まっている。
リマッピングREPEATループ内では、レジスタ・リスト操作は使用されるべきでない。
OUPTUT命令が出力用に指定することができるレジスタは８つまでである。
含む理由：
１つのルーチンが終了した後、次のルーチンは、ARMからデータを受け取れるようすべてのレジスタが空きであることを期待する。これを遂行するために、EMPTY命令が必要となる。FIRそのたのフィルタを実行する前に、すべてのアキュミュレータ及び部分的結果がゼロにされなければならない。これには、ZERO命令が助けとなる。これらの命令は、一連の単一レジスタ移動を置き換えることによってコード密度を改善するよう設計されている。OUTPUT命令は、一連のMOV^,Rn命令を置き換えることによってコード密度を改善するべく含まれる。
リマッピング・パラメータ・移動命令RMOVが提供されるので、ユーザ定義のレジスタ・リマッピング・パラメータの構成を取ることができる。
命令エンコーディングは以下の通り。

各PARAMS領域は次のエントリから成る：

これらのエントリの意味を以下に示す。

ニューモニック：

RMOV命令の使用がリマッピングのアクティブ中だと、その挙動は、UNPREDICATABLE（予測不可）である。
フラグ
影響されない。
Repeat命令は、４つのゼロ・サイクル・ループをハードウェアで提供する。REPEAT命令は、新しいハードウェア・ループを定義する。ピッコロは、最初のREPEAT命令にハードウェア・ループ０を使用し、最初のrepeat命令に埋め込まれた（nested）REPEAT命令にハードウェア・ループ１を使用し、以下同様である。REPEAT命令は、どのループが使用されているかを指定する必要はない。REPEAT命令は厳密に埋め込まれなければならない。深さ４を越える埋め込みを試みると、挙動は、予想不可となる。
各REPEAT命令は、（REPEAT命令の直後の）ループ内の命令の数を指定し、そのループを何回巡るかの回数（定数またはピッコロレジスタから読み込まれる）を指定する。
ループ内の命令の数が小さい（１又は２）場合、ピッコロはそのループをセットアップするために余分のサイクルを使っても良い。
ループ・カウントがレジスタ指定であれば、32ビットアクセスという意味になる（S1＝１）が、下の16ビットだけが意味を持ち、その数は符号無しであるとされる。ループ・カウントがゼロの場合、ループの動作は未定義である。ループ・カウントのコピーが取られ、レジスタはループに影響せずに直接再利用（又は、再充填さえ）できる。
REPEAT命令は、ループ内でレジスタ・オペランドが指定される方法を変えるメカニズムを提供する。詳細は上記の通り。
ループ数がレジスタ指定されたREPEATのエンコーディング：

固定されたループ数のREPEATのエンコーディング：

RFIELDオペランドは、ループ内でどの16リマッピングパラメータ構成を使用すべきかを指定する。

アセンブラは、ハードウェア・ループを定義するためにREPEATとNEXTという２つのオペコードを提供する。REPEATはループの始めに行き、NEXTはループの最後を区切ることによって、アセンブラはループ本体内にある命令の数を数えることができる。REPEATにとって必要なことは、ループの数を定数あるいはレジスタとして指定すればよいだけである。例えば：

これは、２つのMULA命令をX0回実行する。また、

は、10回乗算累算を行う。
アセンブラは、次のシンタクス（文法）をサポートする。
REPEAT＃iterations［，＜PARAMS＞］
REPEATのために使用するリマッピング・パラメータを指定する。必要なリマッピング・パラメータが前もって定義されたパラメータのセットの１つと等しい場合は、適当なREPEATエンコーディングが使用される。そうでなければ、アセンブラはRMOVを生成してREPEAT命令に続くユーザ定義パラメータをロードする。RMOV命令及びリマッピング・パラメータ・フォーマットの詳細については前記を参照。
ループの繰り返し（iteration）の回数が０であれば、REPEATの動作はUNPREDICATABLE（予想不可）である。
命令数領域が０にセットされると、REPEATの動作は、予想不可である。
ループに１つの命令しかなく、その命令がブランチであれば、予想不可能の挙動をする。
REPEATループの範囲からそのループの外へのブランチは、予想不可である。
飽和絶対命令は、ソース１の飽和絶対値（saturated absolute）を計算する。

動作：
dest＝SAT（（src1＞＝０）?src1:−src1）．値は常に飽和する。特に、0x80000000の絶対値は0x7fffffffであり、0x80000000ではない。
ニューモニック：
SABS＜dest＞，＜src1＞
フラグ
Ｚ がセットされるのは、結果が０の時。
Ｎ は保存される。
Ｃ がセットされるのは、scr＜０（dest＝_scr1の場合）。
Ｖ がセットされるのは、飽和が生じた時。
含む理由：
多くのDSPアプリケーションで役立つ。
選択（select）操作（条件付き移動）は、条件付きでソース１またはソース２を目的レジスタに移動させる。選択は、常に、移動と等価である。並列加算／減算の後で使用するための並列操作もある。
尚、両方のソースオペランドは、導入理由のための命令によっても読み出すことができるので、一方が空きであれば、そのオペランドが絶対的に必要であるかどうかに関係なく、命令は止まる。

OPCは命令のタイプを指定する。
動作（OPC）：

ニューモニック：

レジスタが再充填の印になっていると、それは、無条件で再充填される。また、アセンブラ、次のニューモニックも提供する。

MOV＜cond＞A,Bは、SEL＜cond＞A,B,Aと等価である。SELFTとSELFFは、SELTF,SELTTを使用して、src1とsrc2を交換することによって得ることができる。
フラグ
すべてのフラグは、一連の選択が行われるよう保存される。
含む理由：
簡単な決定をブランチに頼ることないインラインにするために使用される。最大要素のためにサンプル又はベクトルをスキャンする時に、そしてビタビ（Viterbi）アルゴリズムによって使用される。
シフト操作命令は、指定量の左右の論理シフト、右算術シフト、回転（rotate）を提供する。シフト量は、レジスタの内容の下８ビットから取られた−128から＋127の間の符号付き整数、又は、＋１から＋31の範囲内の即値である。負の量のシフトは、ABS（シフト量）分反対方向にシフトさせる。
入力オペランドは、32ビットに符号拡張され、結果の32ビット出力は、書き戻し前に48ビットに符号拡張され、48ビットレジスタへの書き込みが感度よく機能する。

OPCは、命令のタイプを指定する。
動作（OPC）：

ニューモニック：

フラグ
Ｚ がセットされるのは、結果が０の時。
Ｎ がセットされるのは、結果が負の時。
Ｖ は保存される。
Ｃ は、最後にシフトされて出た（ARM上として）ビット値にセットされる。
レジスタ指定されたシフトの挙動は以下の通り。
−32によるLSLの結果は０で、src1のビット０にＣがセットされる。
−32を越えるものでのLSLは、結果が０で、Ｃは０にセットされる。
−32によるLSRの結果は０で、src1のビット31にＣがセットされる。
−32を越えるものでのLSRは、結果が０で、Ｃは０にセットされる。
−32以上でのASRの結果は充填され、Ｃはsrc1のビット31に等しい。
−32でのRORの結果はsrc1に等しく、Ｃがsrc1のビット31にセットされる。
−32を越えるｎによるRORは、ｎ−32によるRORと同じ結果とキャリーアウト（carry out）になるので、量が１から32の範囲内になるまで、繰り返し32をｎから引く。上記参照。
含む理由：
２のべき乗による乗算／除算。ビット及び領域抽出。シリアル・レジスタ。
未定義の命令が、上記命令セットリストで挙げてある。それらの実行により、ピッコロは、実行を停止し、状態レジスタにＵビットをセットし、それ自身をディスエーブルする（制御レジスタ内のＥビットがクリアされたかのように）。これにより、命令が将来拡張された場合も、それがトラップされて、オプショナルに、既存の手段上でエミュレートされることが可能である。
ARMからピッコロ状態へのアクセスは以下の通り。状態アクセス・モードを使用して、ピッコロの状態を観察／変更する。このメカニズムが提供されるのは次の２つの理由からである。
−文脈（Context）切替え
−デバッグ
ピッコロは、PSTATE命令を行うことで、状態アクセスモードになる。このモードでは、ピッコロの状態を退避して、一連のSTC及びLDC命令で復元される。状態アクセスモードに入ると、ピッコロ・コプロセッサID PICCOLOlの使用が変更されて、ピッコロの状態にアクセスできるようになる。ピッコロの状態には７つのバンクがある。特定バンク内のすべてのデータは、単一のLDC又はSTCでロードし記憶することができる。
バンク0:プライベート・レジスタ
− ピッコロIDレジスタ（Read Only）の値を含む１つの32ビットワード
− 制御レジスタの状態を含む１つの32ビットワード
− 状態レジスタの状態を含む１つの32ビットワード
− プログラム・カウンタの状態を含む１つの32ビットワード
バンク1:汎用レジスタ（GPR）
− 汎用レジスタの状態を含む16個の32ビットワード
バンク2:アキュミュレータ
− アキュミュレータ・レジスタの上の32ビットを含む４つの32ビットワード（注:GPR状態の複製が復元に必要だということは、さもないとレジスタバンク上で別の書き込みイネーブルを意味する）。
バンク3:レジスタ／ピッコロROB/出力FIFO状態
− どのレジスタが再充填用の印（各32ビットレジスタにつき２ビット）になっているかを示す32ビットワードが１つ。
− ROBタグ（ビット７から０に記憶されている７ビット項目８つ）の状態を含む32ビットワード８つ。
− 連合していない（unaligned）ROBラッチ（ビット17から０）の状態を含む32ビットワード３つ。
− 出力シフトレジスタ内のどのスロットが有効データを含むかを示す32ビットワードが１つ（ビット４は空きを示し、ビット３から０は、使用中のエントリの数をエンコードする）。
− ラッチ（ビット17から０）を保持する出力FIF0の状態を含む32ビットワード１つ。
バンク4:ROB入力データ
− 32ビットデータ値が８つ。
バンク5:出力FIFOデータ
− 32ビットデータ値が８つ。
バンク6:ループハードウェア
− ループ開始アドレスを含む32ビットワード４つ。
− ループ最終アドレスを含む32ビットワード４つ。
− ループ回数（ビット15から０）を含む32ビットワード４つ。
− ユーザ定義リマッピング・パラメータその他のリマッピング状態を含む32ビットワードが１つ。
LDC命令は、ピッコロが状態アクセスモードにある時にピッコロの状態をロードするのに使う。BANK領域はロードされるバンクを特定する。

次の一連の動作により、ピッコロのすべての状態がレジスタR0内のアドレスからロードされる。

STC命令は、ピッコロが状態アクセスモードにある時にピッコロの状態を記憶させるのに使う。BANK領域はどのバンクが記憶されるかを特定する。

次の一連の動作により、ピッコロのすべての状態がレジスタR0内のアドレスから記憶される。

デバッグ・モード−ピッコロは、ARMによってサポートされているものと同じデバッグ・メカニズム、すなわち、DemonとAngelを介したソフトウェア、及び埋め込まれたICEを備えたハードウェア、に応答しなければならない。ピッコロのシステムをデバッグするためのいくつかのメカニズムがある。
−ARM命令ブレークポイント
−データ・ブレークポイント（ウオッチポイント）
−ピッコロ命令ブレークポイント
−ピッコロ・ソフトウェア・ブレークポイント
ARM命令ブレークポイント及びデータ・ブレークポイントは、ARM埋め込みICEモジュールによって扱われる。ピッコロ命令ブレークポイントは、ピッコロ埋め込みICEモジュールによって扱われる。ピッコロ・ソフトウェア・ブレークポイントは、ピッコロ・コアによって扱われる。ハードウェア・ブレークポイント・システムは、ARMとピッコロの両方がブレークポイントされるように構成される。
ソフトウェア・ブレークポイントを扱うのは、ピッコロ命令（Halt又はBreak）で、ピッコロに実行を止めさせ、デバッグ・モードに入れ（状態レジスタのＢビットがセットされる）、自身をディスエーブルする（ピッコロがPDISABLE命令によってディスエーブルされたようになる）。プログラム・カウンタは有効のままで、ブレークポイントのアドレスが回復できる。ピッコロは、それ以上、命令を実行しなくなる。
Single stepping Piccoloは、ピッコロ命令ストリーム上に次々にブレークポイントをセットすることによって行われる。
ソフトウェア・デバッグ−ピッコロによって提供される基本的機能は、状態アクセスモードにある時、コプロセッサ命令を介して、すべての状態をメモリーにロード及び退避させる能力である。これにより、デバッガーは、すべての状態をメモリーに退避させ、それを読み出し，及び／又は更新し、それをピッコロに復元することができる。ピッコロの記憶状態メカニズムは、非破壊的であり、つまり、ピッコロの状態を記憶する動作は、ピッコロの内部状態を駄目にすることはない。つまり、ピッコロは、その状態をダンプした後、それを復元することなしに、再開できる。
ピッコロ・キャッシュの状態を見つけるメカニズムを決定しなければならない。
ハードウェア・デバッグ−ハードウェア・デバッグは、ピッコロのコプロセッサ・インターフェース上のスキャン・チェインによって行うことができる。
ピッコロは状態アクセスモードになり、スキャン・チェインを介して、その状態を調査／変更してもらう。
ピッコロの状態レジスタは、ブレークポイント付き命令を実行したことを示す単一ビットを含む。ブレークポイント付き命令が実行されると、ピッコロは、状態レジスタにＢビットをセットし、実行を中止する。ピッコロに質問をするには、デバッガーは、ピッコロをイネーブルし、次のアクセスが起きる前に、制御レジスタに書き込むことによって、状態アクセスモードにしなければならない。
図４は、Hi/LoビットとSizeビットに応答して、選択されたレジスタの適当な半分をピッコロ・データパスに切り換えるマルチプレクサ構成を示す。Sizeビットが16ビットなら、符号拡張回路が必要に応じてデータパスの高次ビットに０か１を入れる。The present invention relates to a data processing system. In particular, the invention relates to a data processing system comprising a plurality of registers for storing data words that are manipulated by an arithmetic unit under the control of program instruction words.
Known program instructions are provided that specify whether an operation is performed on an input operand contained in one register or an input operand contained in two registers but to be treated as a single input operand. Yes.
U.S. Pat. No. 5,442,769 discloses a coprocessor having a register area with areas where different portions of a physical register can be selected for operation.
European published patent application EP-A-0,654,733 also discloses a processor that allows multi-gauge processing to perform two N / 2-bit operations in parallel on an N-bit data path.
The present invention is viewed from one side.
A plurality of registers each having a capacity of at least N bits for storing a data word to be manipulated;
An arithmetic unit for performing an operation specified by the program instruction word in response to the program instruction word;
A data processing apparatus comprising: the arithmetic unit comprising:
(I) a source register bit area designating a source register of the plurality of registers for storing an input operand data word for the program instruction word;
(Ii) an input operand size flag that specifies whether the input operand data word is N bit size or (N / 2) bit size;
(Iii) When the input size flag specifies (N / 2) bit size, it indicates whether the input operand data word is in the upper bit position of the source register or the lower bit position of the source register Upper / lower flags to
And when the input size flag specifies an N-bit size, the upper / lower flag uses the lower bit position to store those bits stored in the upper bit position before using it as an N-bit input operand data word. Specifies whether to move to the bit position and move those bits stored in the lower bit position to the upper bit position
A data processing apparatus is provided that is responsive to at least one program instruction word.
Recently, in data processing, there is a tendency to increase the data path width of the system. Early systems were 8-bit data paths. That is the 16-bit data path, and now 32-bit and 64-bit data paths are common. With such an increase in data path, the registers in the data processing system have also increased to have a corresponding width. The present invention has considered that if the data words to be manipulated are smaller than the data path width, full use of registers to store these words would be a waste of device resources. This is particularly problematic for load / store architecture machines where all the data to be manipulated must be placed in registers, when it is desired to reduce the number of times data is fetched from the cache main memory. In view of such circumstances, the present invention uses the input operand size flag and the upper / lower flag to indicate the size of the input operand and indicate in which part of the register the above-mentioned information is stored. Solve a problem. Thus, the ability of a register to hold more than one input operand allows the input operands to be manipulated separately while more efficiently using the device's register resources. Further, when the input size flag specifies an N bit size, the upper / lower flag moves the bit stored in the upper bit position to the lower bit position before using it as an N-bit input operand data word. , Specifies whether the bit stored in the lower bit position should be moved to the upper bit position. This feature is particularly useful during conversion operations.
The advantages of the present invention are even greater when an N-bit data bus links a data storage device to a register. In this case, by using the data bus to transfer two operands at a time, the bandwidth of the bus can be used more effectively, and the performance bottleneck can be reduced.
In a preferred embodiment of the present invention, the arithmetic unit includes a first (N / 2) bit input operand data word and a second (N / N) stored in the upper bit position and the lower bit position of one source register, respectively. 2) Respond to at least one parallel operation program instruction word that performs different operations on the bit input operand data word.
By providing a parallel operation program instruction word, even if the input operand is smaller than the maximum data path width, two independent operations can be performed by the arithmetic unit by fully utilizing the N-bit data path capacity. it can. This can significantly increase the data processing capacity of the system without incurring much extra overhead.
As a modification, the arithmetic unit has a signal path that functions as a carry chain between bit positions in an arithmetic operation, and when executing a parallel operation program instruction word, the signal path is the first (N / 2) Divide between the bit input operand data word and the second (N / 2) bit input operand data word.
Although the parallel operation program instruction can take various forms, it is preferable that the parallel operation program instruction word performs the following one operation.
(I) Parallel addition in which two parallel (N / 2) bit additions are performed;
(Ii) parallel subtraction with two parallel (N / 2) bit subtractions;
(Iii) a parallel shift in which two parallel (N / 2) bit shifts are performed;
(Iv) Parallel addition / subtraction in which (N / 2) bit addition and (N / 2) bit subtraction are performed in parallel.
The hardware introduction of this function is particularly effective when the (N / 2) bit input operand data word stored in either the upper bit position or the lower bit position of the source register is selected and the lower ( N / 2) with at least one multiplexer responding to the upper / lower flags for supplying bits.
In order to perform a signed operation without extra complication, it is preferable to provide a circuit for sign-extending an (N / 2) -bit input operand data word before inputting to the N-bit data path.
In addition, the present invention is viewed from other aspects.
Storing the data word to be manipulated in a plurality of registers each having a capacity of at least N bits;
Performing an operation designated by the program instruction word in response to the program instruction word;
A data processing method comprising:
In response to at least one program instruction word,
(I) selecting a source register of the plurality of registers for storing an input operand data word for the program instruction word using a source register bit area in the program instruction word;
(Ii) using the input operand size flag in the program instruction word to select whether the input operand data word is N bit size or (N / 2) bit size;
(Iii) Using the upper / lower flags in the program instruction word, when the input size flag specifies (N / 2) bit size, the upper bit position of the source register and the lower bit of the source register Select which of the bit positions the input operand data word is in,
If the input size flag specifies an N bit size, the bit stored in the upper bit position is moved to the lower bit position and stored in the lower bit position before being used as an N bit input operand data word The data processing method is characterized in that the upper / lower flag indicates whether or not the transferred bit should be moved to the upper bit position.
Embodiments of the present invention will be described below with reference to the accompanying drawings.
FIG. 1 shows a high level configuration of a digital signal processing device,
Figure 2 shows an input buffer with a coprocessor register configuration,
FIG. 3 shows the data path in the coprocessor,
FIG. 4 shows a multiplexing circuit for reading high-order or low-order bits from a register,
FIG. 5 is a block diagram illustrating register remapping logic used by the coprocessor in the preferred embodiment;
FIG. 6 shows details of the register remapping logic shown in FIG.
FIG. 7 is a table showing a block filter algorithm.
The system described below relates to digital signal processing (DSP). The DSP can take various forms, but is typically a process that requires high-speed (real-time) processing of a large amount of data. This data is typically an analog physical signal. A good example of DSP is that used for digital mobile phones. There, radio signals are transmitted and received, and decoding and encoding (typically using convolution, conversion, correlation operations) from and to analog audio signals is required. Another example is a disk driver controller in which a signal from a disk head is processed to perform head tracking control.
In the above context, a description of a digital signal processing system on a microprocessor core (here an ARM core from a range of microprocessors designed by Advanced RISC Machine Limited in Cambridge, UK) To do. The interface between the microprocessor and the coprocessor architecture itself has a specific configuration to provide DSP functionality. In the following description, the microprocessor core is ARM and the coprocessor is Piccolo. The ARM and Piccolo are typically manufactured as a single integrated circuit that includes other components (eg, DRAM on chip, ROM, D / A converter, A / D converter) as part of the ASIC.
Since Piccolo is an ARM coprocessor, it executes part of a set of ARM instructions. ARM coprocessor instructions allow ARM to exchange data between piccolo and memory (using the Load Coprocessor, LDC and Store Coprocessor, STC instructions), and (move to coprocessor, MCR, and move from coprocessor, ARM can exchange ARM registers with Piccolo (using MCR instruction). From one point of view, the ARM-Piccolo interaction acts as a powerful address generator for ARMGA Piccolo data, which frees up DSP operations that need to deal with large amounts of data in real time. Is to produce a corresponding real-time result.
FIG. 1 shows how ARM2 issues a control signal to piccolo 4 to transmit a data word to piccolo 4 and to transfer a data word from piccolo 4. The instruction cache 6 stores a piccolo program instruction word necessary for the piccolo 4. A single DRAM memory 8 stores all data and instruction words required for both ARM2 and Piccolo 4. ARM2 is responsible for addressing memory 8 and controlling all data transfers. A configuration consisting of a single memory 8 and a set of data and address buses is simpler and more costly than a typical DSP approach that requires multiple memories and a high bandwidth bus. easy.
The piccolo executes a second instruction stream (digital signal processing program instruction word) from the instruction cache 6, which controls the data path of the piccolo. These instructions include digital signal processing scheme operations, such as Multiply-Accumulate, and control flow instructions, such as zero overhead loop instructions. These instructions operate on the data held in Piccolo's register 10 (see FIG. 2). This data was previously transferred from the memory 8 by the ARM2. Multiple instructions are streamed out of the instruction cache 6, which places the data bus under full control. The small piccolo instruction cache 6 is a directly mapped cache (64 instructions) with 4 lines of 16 words per line. Depending on the method of introduction, the instruction cache may be made larger.
In this way, the two tasks run independently. ARM loads the data and Piccolo processes it. This maintains single cycle data processing on 16 bit data. With Piccolo's data entry mechanism (shown in FIG. 2), ARM captures sequential data first and loads that data before it is needed by Piccolo. Piccolo can access the loaded data in any order, and automatically refills its registers when the old data is last used (all instructions are source register per source operand). With 1 bit indicating that it should be refilled). This input mechanism is called a reorder buffer and comprises an input buffer 12. Every value loaded into Piccolo (via LDC or MCR below) has a tag Rn that indicates which register the value is destined for. The tag Rn is stored on the data word side in the input buffer. When a register is accessed via the register select circuit 14 and the instruction specifies a refill of the data register, the register is marked “empty” by the signal E. The register is then automatically filled by the refill control circuit 16 with the earliest loaded oldest value directed to that register in its input buffer 12. The reorder buffer holds eight tagged values. The format of the input buffer 12 is similar to a FIFO, but a data word can be extracted from the center of the key, after which a later stored word is passed to fill the empty space. Therefore, when the data word farthest from the input is the oldest and the input buffer 12 holds two data words with the correct tag Rn, the oldest data word is used to register which data word. Can be refilled.
As shown in FIG. 3, the piccolo stores data in the output buffer 18 (FIFO) and outputs the data. Data is written sequentially to the FIFO and read out to the memory 8 in the same order by the ARM. The output buffer 18 holds eight 32-bit values.
Piccolo is connected to ARM via a coprocessor interface (CP control signal in FIG. 1). Upon execution of an ARM coprocessor instruction, the piccolo can execute it, wait for the ARM to wait for the piccolo to execute the instruction, or refuse to execute the instruction. In the last case, ARM assumes an undefined instruction exception.
The most common coprocessor instructions that Piccolo executes are LDC and STC, which load and store (STC) and store (STC) data words into and out of memory 8 via the data bus, respectively. Generates all addresses. These instructions also load data into the reorder buffer and store the data from the output buffer 18. Piccolo will leave ARM as LDC if there is not enough room to load data into the input reorder buffer, and leave ARM as STC if there is not enough data to be stored in the output buffer. Piccolo also performs ARM / coprocessor register transfers to allow ARM access to Piccolo's special registers.
The piccolo fetches its own instructions from memory and controls the piccolo data path shown in FIG. 3 to transfer data from the reorder buffer to the register and from the register to the output buffer 18. Piccolo's arithmetic unit for executing these instructions has a multiplication / addition circuit 20, which performs multiplication, addition, subtraction, multiplication / accumulation, logical operation, shift, and rotation. The data path also includes an accumulation / decumulate circuit 22 and a scale / saturate circuit 24.
A piccolo instruction is first loaded from memory into the instruction cache 6, to which piccolo accesses and does not need to access back to main memory.
If the memory aborts, Piccolo cannot repair it. Thus, when piccolo is used in a virtual memory system, all piccolo data must be in physical memory from the beginning to the end of the piccolo task. This is not a big problem considering the real-time nature of Piccolo's tasks, such as real-time DSP. When a memory abort occurs, the piccolo stops and sets a flag in the status register S2.
FIG. 3 shows the overall data path function of Piccolo. Register bank 10 uses three read ports and two write ports. One write port (L port) is used to refill registers from the reorder register. The output buffer 18 is updated directly from the ALU result bus 26, and the output from the output buffer 18 is under ARM program control. The ARM coprocessor interface performs LDC (Load coprocessor) instructions on the reorder buffer, STC (Store Coprocessor) instructions from the output buffer 18, and MCR and MRC (Move ARM register to / from on register bank 10) CP register).
The remaining register ports are used for ALU. The read ports (A and B) drive the input to the multiply / add circuit 20 and the C read port is used to drive the accumulate / decumulate circuit 22 input. The remaining write port W is used to return the result to the register bank 10.
Multiplier 20 performs signed or unsigned 16x16 multiplications, optionally with 48-bit accumulation. A scaler unit 24 can provide an immediate arithmetic or logical shift right from 0 to 31 and then perform saturation if necessary. The shifter and logic unit 20 can perform a shift or logic operation in each cycle.
Piccolo has 16 general purpose registers named D0-D15 or A0-A3, X0-X3, Y0-Y3, Z0-Z3. The first four registers (A0-A3) are for accumulation and are 48 bits wide, with the extra 16 bits providing a guard against overflow from occurring during many consecutive calculations. The remaining registers are 32 bits wide.
Each Piccolo register can be treated as containing two independent 16-bit values. Bits 0 to 15 include the lower half, and bits 16 to 31 include the upper half. The instruction can specify 16 bits, half of each register, as the source operand, or it can specify the entire 32-bit register.
Piccolo also provides for saturation computation. Variables for multiply, add, and subtract instructions provide a saturated result if the result is larger than the size of the destination register. If the destination register is a 48-bit accumulator, the value is saturated at 32 bits (that is, there is no way to saturate a 48-bit value). There is no overflow detection in the 48-bit register. This is an affordable limitation. This is because at least 65536 multiply-accumulate instructions are required to cause an overflow.
Each Piccolo's register is “empty” (E flag, see FIG. 2) or contains one value (only half of the register is free). In the initial state, all registers are marked empty. At each cycle, the piccolo fills one of the empty registers with the value from the input reorder buffer by the refill control circuit 16. Alternatively, when a value from the ALU is written in the register, it is not “free”. If there is a write from the ALU to the register and at the same time a value is put into the register from the reorder buffer, the result is undefined. If a free register is read, the Piccolo execution unit will stop.
The input order buffer (ROB) is between the coprocessor interface and Piccolo's register bank. When data is loaded into the ROB, the ARM coprocessor transfers it. The ROB contains a number of 32-bit values, each with a tag that indicates the Piccolo register that is the destination of the value. The tag also indicates whether the data should be transferred to the entire 32-bit register or only the lower 16 bits in the 32 bits. If data is transferred to the entire register, the lower 16 bits of the entry are transferred to the lower half of the destination register, and the upper 16 bits are transferred to the upper half of the register (the destination register is the 48-bit accumulator The case is extended). If the destination of the data is only the lower half of the register (so-called half register), the lower 16 bits are transferred first.
The register tag always indicates the physical purpose register, and no register remapping is performed (see below for register remapping).
At each cycle, Piccolo tries to transfer the data entry from the ROB to the register bank as follows:
Each entry in the ROB is examined and the tag is compared with an empty register to determine if transfer from some or all of the entries to the register is possible.
-The oldest entry is selected from the set of transferable entries and its data is transferred to the register bank.
-The tag of this entry is updated to make the entry empty. When only a part of the entry is transferred, only the transferred part becomes an empty mark.
For example, if the target register is completely empty and the data included in the selected ROB entry is for one entire register, the entire 32 bits are transferred and the entry is marked as empty. If the lower half of the target register is empty and the data contained in the ROB is for the lower half of the register, the lower 16 bits of the ROB entry are transferred to the lower half of the target register and the lower half of the ROB is marked as free. Become.
In any entry, the upper 16 bits and the lower 16 bits can be transferred independently. If there is no entry including data that can be transferred to the register bank, transfer is not performed in that cycle. The table below shows all possible combinations of target ROB entries and target register states.

In summary, the two halves of a register can be filled from the ROB independently of each other. The data in the ROB is marked for the entire register, or as two 16-bit values for the lower half of the register.
ARM coprocessor instructions are used to load data into the ROB. The way the data is marked in the ROB depends on which ARM coprocessor instruction was used for the transfer. The ARM instructions that can be used to transfer data to the ROB are:

The first three are assembled as LDC instructions, MPR and MRP are assembled as MCR instructions, and LDPA is assembled as CDP instructions.
<Dest> indicates the Piccolo register (A0-Z3), Rn indicates the ARM register, <size> is the number of bytes as a constant that is a multiplier of 4 (excluding zero), and <wrap> , Constants (1, 2, 4, 8) are shown. The area enclosed by {} is optional. <Size> is a maximum of 32 to ensure that the transfer applies to the reorder buffer. In many cases, <size> is smaller than this limit to avoid deadlocks. The <16/32> area indicates whether the data to be loaded is handled as 16-bit data and an endianess specifying operation (see below) should be performed or 32-bit data.
Note 1: In the following description, reference to LDP or LDPW includes both 16-bit and 32-bit variants of these instructions.
Note 2: A word is a 32-bit chunk from memory that consists of two 16-bit data items or one 32-bit data item.
The LDP instruction transfers a number of data items for a full register. This instruction loads <size> / 4 words from address Rn in memory and inserts them into ROB. The number of words that can be transferred is limited as follows.
-The amount of <size> must be a non-zero multiple of 4,
-<Size> must be less than or equal to the size of the ROB for a particular implementation (there is a guarantee that it will not be less than 8 words in the first version and in subsequent versions). The first data item to be transferred is tagged with a <dest> destination and the second data item is <dest> +1 (wrapping from Z3 to A0). If "!" Is specified, then the register Rn is incremented by 1 by <size>.
If an LDP16 variant is used, an endian specific operation is performed on two 16-bit halfwords, which are 32-bit data items when they are returned from the memory system. For more details, see Big Endian and Little Endian support below.
The LDPW instruction transfers a number of data items to a set of registers. The first transferred data item is tagged <dest>, the next is tagged <dest> +1, and so on. When <wrap> transfer occurs, the next transfer item is for <dest>, and so on. The amount of <wrap> is specified by the amount of halfwords.
LDPW has the following limitations:
-The amount of <size> must be a non-zero multiple of 4
-<Size> must be less than or equal to the size of the ROB for a particular deployment (there is a guarantee that it will not be less than 8 words in the first version and in subsequent versions)
-<Dest> can be any one of {A0, X0, Y0, Z0}
-<Wrap> is any number of {2,4,8} halfwords for LDP32W, any number of {1,2,4,8} halfwords for LDP16W,
-The amount of <size> must be greater than 2 * <wrap>. Otherwise, no wrapping will occur and the LDP instruction will be used instead.
For example, the instruction

Loads two words into ROB and sets its destination to full register X0.
R0 increases by 8. Next instruction

Loads four words into the ROB and sets their destination to X0, X1, X0, X1 (in that order). R0 is not affected.
For LSP16W, <wrap> can be specified as 1, 2, 4, or 8. If 1 wrap is specified, the destination of all data tags is <dest> .1. This is the case of a half register.
For example, the instruction

Loads two words into the ROB, makes them 16-bit data, and sets the destination to X0.1. R0 is increased by 8. Next instruction

Behaves in the same way as the LDP32W example, except that the endian specific operation is performed on the data returned from the memory.
All unused encodings of the LDP instruction can be reserved for future extensions.
The LDP16U instruction supports efficient transfer of non-word aligned 16-bit data. LDP16U support is provided in registers D4-D15 (X, Y, Z banks). LDP16U support will transfer a single register 32-bit word of data (including two 16-bit data items) from memory to Piccolo. Piccolo discards the lower 16 bits of this data and stores the upper 16 bits in a holding register. There are holding registers for X, Y and Z banks. When a bank holding register is reported (primed), the behavior of the LDP {w} instruction changes if the data destination is a register in the bank. The data loaded into the ROB is formed by concatenating 16 bits below the data being transferred by the LDP instruction and the holding register. The upper 16 bits being transferred are placed in a holding register.

This mode of operation continues until aborted by the LDPA instruction. The holding register does not record the tag or size of the target register. These properties are derived from instructions that provide the following data.1 values.
Data returned from the memory system may always have endian specific behavior. There is no non-16 bit equivalent to LDP16U. This is because all 32-bit data items are word aligned in memory.
The LDPA instruction is used to cancel the unaligned mode of operation initiated by the LDP16U instruction. Unaligned mode can be cut independently on banks X, Y, and Z. For example, the instruction

Aborts the unaligned mode on banks X and Y. Data in the holding registers of these banks is discarded.
It is possible to run LDPA on a bank that is not in unaligned mode, and that bank remains in aligned mode.
The MPR instruction places the contents of ARM register Rn into ROB and is directed to piccolo register <dest>. The target register <dest> may be any full register in the range A0-Z3. For example, the instruction

Moves the contents of R3 to ROB and uses the data for full register X0.
There is no endianess specific behavior when data is transferred from ARM to Piccolo. This is because ARM is not very endian.
The MPRW instruction places the contents of ARM register Rn into ROB and makes it two 16-bit data items for 16-bit piccolo register <dest> .l. The restrictions on <dest> are the same as in the LDPW instruction (that is, Z0, X0, Y0, Z0). For example, the instruction

Moves the contents of R3 to ROB, and uses two 16-bit data for X0.l. In the case of LDP16W wrapped with l, only the lower half of the 32-bit register can be the destination.
For MPR, no endeaness specific operations are performed on the data.
LDP is encoded as follows:

Here, PICCOLO1 is the number of Piccolo's first coprocessor (currently 8). N bits select between LDP32 (1) and LDP16 (0).
LDPW is encoded as follows.

Here, DEST is 0-3 for the target registers A0, X0, Y0, Z0, and WRAP is 0-3 for wraps of 1, 2, 4, and 8 values. PICCOLO2 is Piccolo's second coprocessor number (currently 9). N bits select between LDP32 (1) and LDP16 (0).
LDP16U is encoded as follows.

Here, DEST is 1-3 for the target banks X, Y, and Z.
LDPA is encoded as follows:

Here, BANK [3: 0] is used to cancel the non-alignment mode for each bank. When BANK [1] is set, the unaligned mode on bank X is aborted. If BANK [2] and BANK [3] are set, the non-alignment modes on banks Y and Z are aborted, respectively. This is a CDP operation.
The MPR is encoded as follows:

MPRW is encoded as follows:

Here, DEST is 1-3 for the target registers X0, Y0, Z0.
The output FIFO can hold up to eight 32-bit values. These are transferred from Piccolo using one of the following (ARM) opcodes.

The first saves <size> / 4 words from the output FIFO to the address given by the ARM register Rn. If "!" Is present, specify Rn. To avoid deadlock, <size> must be less than or equal to the size of the output FIFO (8 entries in this implementation). If an STP16 variant is used, endian specific behavior may occur in the data returned from the memory system.
The MRP instruction removes one word from the output FIFO and places it in ARM register Rn. As with MRP, no endian specific operations are applied to this data.
The ARM encoding for STP is as follows.

Here, N selects between STP32 (1) and STP16 (0). See the ARM data sheet for the definition of the P, U, and W bits.
ARM encoding for MRP is as follows.

The Piccolo instruction set assumes that there are few endian operations internally. For example, when accessing a 32-bit register as multiple 16-bit halves, the lower half occupies bits 15-0. Since Piccolo will work on systems with large endian memory or peripherals, it must be able to correctly load 16-bit packed data.
Piccolo (that is, coprocessor with DSP) can be controlled by a programmer with programmable peripherals such as ARM (for example, ARM7 microprocessor manufactured by Advanced RISC Machines Limited in Cambridge, UK). Has a 'BIGEND' configuration pin. Piccolo uses this pin to configure the input reorder buffer and output FIFO.
When ARM loads packed 16-bit data into a reorder buffer, it must indicate this using the 16-bit form of the LDP instruction. This information, combined with the state of the 'BIGEND' configuration input, places data into the holding latch and places the reorder buffer in the proper order. Especially in big endian mode, the holding register stores the lower 16 bits of the loaded word and is paired with the upper 16 bits of the next load. The contents of the holding register always end with the last 16 bits of the word transferred to the reorder buffer.
The output FIFO can contain packed 16-bit or 32-bit data. The programmer must use the exact form of the STP instruction to allow Piccolo to confirm that 16-bit data is being provided on the correct half of the data bus. When configured as big endian, when the 16-bit format of STP is used, the upper 16-bit half and the lower 16-bit half are exchanged.
Piccolo has four private registers that can only be accessed from ARM. These are called S0-S2. Only MRC and MCR instructions can access them. The opcodes are as follows:

These opcodes transfer 32-bit values between ARM register Rm and private register Sn. They are encoded in ARM as coprocessor register transfers.

Here, L is 0 for MPSR and 1 for MRPS.
The register S0 includes a piccolo unique ID and a revision code.

[3: 0] bits contain the revision number of the processor.
The [15: 4] bits include a binary encoded 3-digit number (0x500 for Piccolo) in decimal format.
[23:16] bits contain the architecture version number. 0x00 = 1st edition
[31:24] bits contain the ASCII code of the introducer's trademark. 0x41 = A = ARM Ltd.
The register S1 is a piccolo status register.

Primary status code flag (N, Z, C, V)
Secondary condition code flag (SN, SZ, SC, SV)
E bit: Piccolo was disabled by ARM and discontinued.
U-bit: Piccolo encountered an UNDEFINED order and stopped it.
B bit: Piccolo met a BREAKPOINT and stopped.
H bit: Piccolo met the HALT order and stopped.
A bit: The piccolo was aborted by a memory abort (load, store, or piccolo instruction).
D bit: Piccolo detected deadlock condition and aborted (see below).
Register S2 is a piccolo program counter.

When writing to the program counter, Piccolo starts executing the program at that address (if it is in a suspended state, it remains in the suspended state). The program counter is undefined when it is reset. This is because the piccolo is always started by writing to the program counter.
During execution, Piccolo monitors instruction execution and coprocessor interface status as follows.
-Piccolo is ready to wait for the register to be refilled or to have an entry that can use the output FIFO.
-The coprocessor interface is busy-waiting because of insufficient space in the ROB or insufficient items in the output FIFO.
If both of these conditions are detected, Piccolo sets the D bit in its status register, aborts, rejects the ARM coprocessor instruction, and ARM enters an undefined instruction trap.
The detection of this deadlock condition constitutes a system that at least informs the programmer that such a condition has occurred and can tell the exact point (position) of the failure. The programmer only has to read the ARM and Piccolo program counters and registers. It should be emphasized that deadlock occurs only when there is a wrong program or system part that alters the state of Piccolo. Deadlocks are not caused by too little data or “overload”.
There are a number of operations that can be used to control the piccolo from ARM, and they are provided by the CDP instruction. These CDP instructions are accepted when the ARM is in a priority state. Otherwise, Piccolo rejects the CDP instruction and ARM gets stuck in an undefined instruction trap. The following operations can be used.
− Reset
– Enter State Access Mode
− Enable
− Disable
Piccolo is preset in software by the PRESET instruction.
PRESET; Clear Piccolo's state
This instruction is encoded as follows:

When this instruction is executed, the following occurs:
-All registers are marked as empty (refilling status).
− The input ROB is cleared.
− The output FIFO is cleared.
-The loop counter is reset.
-Piccolo enters abort state (and the S2 H bit is set).
Execution of the PRESET instruction requires several cycles (2 to 3 in this embodiment). While executing, the ARM coprocessor instruction to be executed on the following piccolo waits busy.
In state access mode, the piccolo state is saved and restored using STC and LDC instructions (see the description of piccolo state access from ARM below). To enter state access mode, the PSTATE instruction must first be executed.
PSTATE; Enter State Access Mode
This instruction is encoded as follows:

When executed, the PSTATE instruction is
-Stop the piccolo (if not already stopped) and set the E bit in the piccolo's status register.
-Configure the piccolo to state access mode.
There are several cycles before the execution of the PSTATE instruction. This is because Piccolo's instruction pipeline must be pumped before it can be stopped. During execution, the next ARM coprocessor instruction to be executed on Piccolo is busy waiting.
PENABLE and PDISABLE instructions are used for fast context switching. When Piccolo is disabled, only dedicated registers 0 and 1 (ID register, status register) are accessible, and only from the priority mode. Access to any other state or from user mode will result in an ARM undefined instruction exception. If you disable Piccolo, execution will be aborted. When Piccolo stops executing, it responds by setting the E bit in the status register.
To enable piccolo, execute the PENABLE instruction.
PENABLE; Enable Piccolo
This instruction is encoded as follows:

To disable piccolo, execute the PDISABLE instruction.
PDISABLE; Disable Piccolo
This instruction is encoded as follows:

When this instruction is executed, the following occurs:
-The piccolo instruction pipeline is drained.
-Stop Piccolo and set the H bit in the status register.
The piccolo instruction cache holds piccolo instructions that control the data path of the piccolo. If present, it holds at least 64 instructions and is guaranteed to start on a 16 word boundary. The next ARM opcode is assembled into the MCR. The action forces the cache to fetch (16) instruction lines starting at the specified address (which should be on a 16-word boundary). This capture is done even if the cache already holds data related to this address.
PMIR Rm
Piccolo must be stopped before PMIR takes place.
The MCR encoding of this opcode is as follows.

-This section refers to a piccolo instruction set that controls the data path of the piccolo. Each instruction is 32 bits long. These instructions are read from the piccolo instruction cache.
Instruction set decoding is very linear. The first 6 bits (26 to 31) provide the main opcode, and 22 to 25 provide minor opcodes for some specific instructions. Gray shaded code is currently unused and can be used for expansion (they must contain the currently indicated value).
There are 11 major instruction classes. This does not fully correspond to the main opcode filed in the instruction to simplify the decoding of some subclasses.

The instructions in the table above have the following names:
Standard Data Operation
Logical operation
Conditional Add / Subtract
Undefined
Shifts
Select
Undefined
Parallel Select
Multiply Accumulate
Undefined
Multiply Double
Undefined
Move Signed Immediate
Undefined
Repeat
Repeat
Register List Operation (register shift operation)
Branch
Renaming Parameter Move
Halt / Break (Cancel / Break)
The format of each class of instructions is detailed in the next section. The source and destination operand areas are common to most instructions and are described in separate sections as well as register remapping.
Most instructions require two source operands Source1, Source2.
The Source1 (SRC1) operand has the following 7-bit format:

The elements in this area have the following meanings:
-Size-Indicates the size of the operand to be read (1 = 32 bits, 0 = 16 bits).
-Refill-After the register is read, it will become empty and indicate that it can be refilled from the ROB.
-Register Number-Encode which register to read, 32-bit or 16-bit register.
– Hi / Lo – Indicates which half of the 32-bit register should be read for a 16-bit read. When set for a 32-bit operand, it indicates that the two 16-bit halves of the register must be interchanged.

The size of the register is specified by the assembler by adding a suffix to the register number. .L if the lower 16 bits, .x if the upper and lower 16 bits of .h and 32 bits are interchanged if the upper 16 bits.
General source 2 (SCR2) has one of three 12-bit formats:

FIG. 4 shows a multiplexer configuration responsive to the Hi / Lo and Size bits to switch the appropriate half of the selected register to the Piccolo data path. If the Size bit is 16 bits, the sign extension circuit places an appropriate 0 or 1 in the higher order bits of the data path.
The first encoding specifies the source as a register, and the region has the same encoding as the SCR1 specifier. The SCALE field specifies the scale to be applied to the ALU result.

An 8-bit immediate generates a 32-bit immediate value by a rotation encoding, which is represented by an 8-bit value and a 2-bit rotate. The following table shows the immediate value generated from the 8-bit value XY.

With 16-bit immediate encoding, a 6-bit unsigned immediate (range 0 to 63) can be used with the scale provided at the output of the ALU.
General source 2 encoding is common to most instruction variants. There are a few exceptions to this rule, which either support a limited subset of the source 2 encoding, or make it a bit distorted.
− Select Instructions.
− Shift Instructions.
− Parallel Operations.
− Multiply Accumulate Instructions.
− Multiply Double Instructions.
Select instructions only support operands that are registers or 16-bit unsigned immediate values. The scale is invalid. This is because these bits are used by the condition area of the instruction.

Shift instructions only support 1 to 31 operands that are 16-bit registers or 5-bit unsigned immediate values. The result scale is invalid.

For parallel operations, a 32-bit read must be performed if a register is specified as the source of the operand. Immediate encoding has a slightly different meaning for parallel operations. This allows immediate values to be replicated in both 16-bit halves of 32-bit operands. A somewhat limited range of scales can be used for parallel operations.

When a 16-bit immediate value is used, it is always duplicated in both half of the 32-bit quantity. If an 8-bit immediate value is used, it is replicated only when the rotate indicates that it should be rotated to the upper half of the 32-bit quantity.

Scale is not valid for parallel selection operations. The scale area is set to 0 for these instructions.
In a multiply-accumulate instruction, an 8-bit rotation immediate value cannot be specified. Bit 10 of the area is a part that specifies which accumulator should be used. Source 2 is meant as a 16-bit operand.

Multiply double instructions cannot use constants. Only 16-bit registers can be specified. Bit 10 in this area is a part for designating which accumulator should be used.

Some of the instructions always include 32-bit operations (eg, ADDADD), where the size bit is set to 1 and the Hi / Lo bit is possibly two 16-bit halves of the 32-bit operand Can be used to replace. Also, some instructions always include 16 bit operations (eg, MUL) and the size bit must be set to zero. The Hi / Lo bit selects which half of the register is used (assuming that the invisible size bits are obvious). In the multiply / accumulate instruction, the source accumulator and the target register can be specified independently. In these instructions, the Size bit is used to specify the source accumulator, and the size bit is implied as 0 by the instruction type.
If a 16 bit value is used (via the A or B bus), it is automatically sign extended to a 32 bit quantity. If the 48-bit register is read (via the A or B bus), only the lower 32 bits appear on the bus. This is because in any case, source 1 and source 2 are converted to 32-bit values. Only accumulated instructions using bus C can access all 48 bits of the accumulator register.
If the refill bit is set, the register is marked empty after use and is refilled from the ROB by the normal refill mechanism (see section on ROB). Piccolo does not stop unless the register is used again as a source operand before refilling takes place. The minimum number of cycles (in the best case, data is waiting at the beginning of the ROB) before the refilled data becomes valid is 1 or 2. Therefore, it is better not to use the refilled data for the next instruction of the refill request. If you can avoid using operands on the next two instructions, that is better. This will prevent performance loss on deeper pipelines.
The refill bit is specified in the assembler by adding a suffix “^” to the register number. The section of the register marked as empty depends on the operand of the register. The two halves of each register can be independently marked for refilling (for example, X0.1 ^ will only refill the lower half of X0, and X0 ^ will refill the entire X0. Will be filled). When the upper half of the 48-bit register (bits 47:16) is refilled, 16 bits of data are written to bits 31:16 and sign extended with bits 47.
If you try to refill the same register twice (for example, ADD X1, X0 ^, X0 ^), it will only be refilled once. Assemblers should only allow ADD X1, X0, X0 ^ syntax.
If a register read is attempted before the register is refilled, the piccolo will remain stuck until the register is refilled. When a register is marked for refill, the register is updated before the refill value is read, resulting in UNPREDICATBLE (for example, ADD X0, X0 ^, X1 is unpredictable, because X0 Since it is a mark of refilling, it will be filled with the sum of X0 and X1).
The 4-bit scale area encodes 14 scale types.
− ASR # 0,1,2,3,4,6,8,10
− ASR # 12 to 16
-LSL # 1
The parallel Max / Min instruction does not provide scale, so the 6-bit constant variant of source 2 is not used (set to 0 by the assembler).
Within the REPEAT instruction, register remapping is supported, allowing REPEAT to access the register move "window" without unwrapping the loop. This will be described in detail below.
The target operand has the following 7-bit format.

There are 10 variants of this basic encoding.

The register number (Dx) indicates which of the 16 registers is addressed. The Hi / Lo bit and the Size bit together address each 32-bit register as a 16-bit register pair. The Size bit defines how the appropriate flag is set as defined in the instruction type and whether the result is written to the register bank and / or the output FIFO. It doesn't matter. As a result, comparison and similar instruction configuration are possible. An addition with an accumulation class of instructions must write the result back to the register.

In any case, the result of the operation prior to writing back to the register or inserting into the output FIFO is a 48-bit quantity. There are two cases.
If the write is 16 bits, the 48 bit quantity is reduced to 16 bits by selecting the following 16 bits [15: 0]. If the instruction saturates, the value is saturated in the range −2 ^ 15 to 2 ^ 15-1. The 16-bit value is then written back to the indicated register, and written back to the output FIFO if the write FIFO bit is set. If written to the output FIFO, it is held until the next 16-bit value is written. As the next 16 bits are written, the values are paired and placed in the output FIFO as a single 32-bit value.
For 32-bit writing, 48 bits are reduced to 32 bits by selecting the lower 32 bits [31: 0].
For both 32-bit and 48-bit writes, if the instruction saturates, the 48-bit value is converted to a 32-bit value in the range of −2 ^ 31-1 to 2 ^ 31. When saturated,
-When writing back to Accumulator, all 48 bits are written.
-When writing back to the 32-bit register, bits [31: 0] are written.
-Bits [31: 0] are also written when writing back to the output FIFO.
The target size is specified in the assembler by .l or .h after the register number. If there is no write back to the register, the register number is meaningless, so the target register is omitted and no write to the register is performed, or the ^ is used to write only to the output FIFO. Instruct. For example, SUB, X0, Y0 is equivalent to CMP X0, Y0, and ADD ^, X0, Y0 puts the value of X0 + Y0 into the output FIFO.
If there is no room to put a value in the output FIFO, Piccolo waits until there is room.
When a 16-bit value, eg, ADD X0.h ^, X1, X2, is written, the value is latched until a second 16-bit value is written. These two values are then combined and placed in the output FIFO as a 32-bit number. The first 16-bit value written always appears in the lower half of the 32-bit word. Data placed in the output FIFO is marked as 16 or 32 bit data, and endianess can be corrected on big endian systems.
If a 32-bit value is written between two 16-bit writes, the behavior is undefined.
Within the REPEAT instruction, register remapping is supported, and REPEAT can access the register move "window" without unrolling the loop. This will be described in detail below.
In the preferred embodiment of the present invention, the REPEAT instruction provides a mechanism to change the way register operands are specified in the loop. Under this mechanism, the register to access is determined by the function of the register operand and register bank offset in the instruction. The offset can be changed in a programmable manner and is preferably changed at the end of each instruction loop. This mechanism can operate independently on registers in the X, Y, and Z banks. In the preferred embodiment, this function is not available for registers in the A bank.
The concepts of logical registers and physical registers can be used. Instruction operands refer to logical registers, which are mapped to physical register references that identify a particular piccolo register 10. All operations, including refilling, operate on physical registers. Register remapping occurs only on the piccolo instruction stream side, and the data loaded into the piccolo is always intended for physical registers and is not remapped.
The remapping mechanism will be described below with reference to FIG. FIG. 5 is a block diagram showing a number of internal components of the piccolo coprocessor 4. Data items retrieved from memory by the ARM core 2 are placed in the reorder buffer 12, and the piccolo register 10 is refilled from the reorder buffer 12 in the manner previously described with reference to FIG. Piccolo instructions stored in the cache 6 are decoded before being passed to the pico processor core 54 by being passed to the instruction decoder 50 in the piccolo 4. The piccolo processor core 54 includes the multiplier / adder circuit 20, the accumulation / egression circuit 22, and the scale / saturate circuit 24 described above with reference to FIG.
If the instruction decoder 50 is dealing with an instruction that forms part of the instruction loop identified by the REPEAT instruction and the REPEAT instruction indicates that it is necessary to remap a number of registers, register Remapping logic 52 is used to perform the necessary remapping. Register remapping logic 52 may be considered part of instruction decoder 50. However, as will be apparent to those skilled in the art, the register remapping logic 52 may be provided entirely separate from the instruction decoder 50.
A typical instruction comprises one or more operands that identify a register that contains the data items required for the instruction. For example, a typical instruction can include two source operands and one target operand, identifying two registers that contain the data items that the instruction requires and a register into which the result of the instruction is to be placed. Register remapping logic 52 receives the operands of the instruction from instruction decoder 50, which identifies the logical register reference. Based on the logical register reference, the register remapping logic determines whether to remap the physical register and applies the remapping to the physical register reference if necessary. Also, if it is determined that remapping should not be applied, the logical register reference is provided as a physical register reference. A preferred method for performing remapping will be described in detail later.
Each output physical register reference from the register remapping logic is passed to the Piccolo processor core 54, which causes the processor core to instruct the data item in the particular register 10 identified by the physical register reference. Make it applicable.
According to the remapping mechanism according to the preferred embodiment, each bank of registers has two sections: a section in which the register is remapped and a section in which the register holds the original register reference without remapping. And can be divided into two sections. In the preferred embodiment, the remapped section starts from below the remapped register bank.
This remapping mechanism uses a number of parameters, which will be described in detail with reference to FIG. FIG. 6 is a block diagram illustrating how various parameters are used by the register remapping logic 52. These parameters are given relative values from points in the remapped bank, for example from the bottom of the bank.
The register remapping logic 52 can be thought of as consisting of two main logic blocks: a Remap block 56 and a Base Update block 58. Register remapping logic 52 uses a base pointer that provides an offset value to be added to the logical register reference. This base pointer value is provided by the base update block 58 to the remap block.
The initial value of the base pointer can be defined using the BASESTART signal. For example, typically zero, but other values can be specified. This BASESTART signal is passed to the multiplexer 60 in the base update block 58. In the first iteration of the instruction loop, the BASESTART signal is passed to storage element 66 by multiplexer 60 and in the subsequent iteration of the loop, the next base pointer value is passed to storage element 66 by multiplexer 60.
The output of storage element 66 is passed to remap logic 56 as the current base pointer value and also to one of the inputs of adder 62 in base update logic 58. Adder 62 receives a BASEINC signal that provides a base increment value. The adder 62 increments the current base pointer value supplied by the storage element 66 by the BASEINC value and passes the result to the modulo circuit 64.
The modulo circuit also receives the BASEWRAP value and compares this value with the output base pointer signal from adder 62. If the incremented base pointer value is greater than or equal to the BASEWRAP value, the new base pointer is wrapped and becomes the new offset value. The output of the modulo circuit 64 becomes the next base pointer value to be stored in the storage element 66. This output is provided to multiplexer 60 and from there to storage element 66.
However, this next base pointer value cannot be stored in the storage element 66 until the storage element 66 receives a BASEUPDATE signal from the loop hardware that manages the REPEAT instruction. The BASEUPDATE signal is periodically generated by loop hardware, for example, every time an instruction loop is repeated. When storage element 66 receives the BASEUPDATE signal, the storage element overwrites the previous base pointer value with the next base pointer value provided from multiplexer 60. In this way, the base pointer value provided to the remap logic 58 is changed to a new base pointer value.
The physical register to be accessed in the remapped section of the register bank is determined by adding the base pointer value provided by the base update logic 58 to the logical register reference contained in the operand of the instruction. It is the adder 68 that performs this addition, and its output is passed to the modulo circuit 70. In the preferred embodiment, the modulo circuit 70 receives the register wrap value, and when the output signal from the adder 68 (the sum of the logical register reference and the base pointer value) exceeds the register wrap value, to that result. A wrap is performed under the remapped area. The output of modulo circuit 70 is provided to multiplexer 72.
A REGCOUNT value is provided to logic 74 in remapping block 56 to identify the number of registers in the bank to be remapped. The logic 74 compares this REGCOUNT value with the logic register reference, and passes a control signal to the multiplexer 72 according to the comparison result. Multiplexer 72 receives at its two inputs the logical register reference and the output from modulo circuit 70 (remapped register reference). In the preferred embodiment of the present invention, if the logical register reference is less than the REGCOUNT value, the logic 74 causes the multiplexer 72 to output the remapped register reference as a physical register reference. However, if the logical register reference is greater than or equal to the REGCOUNT value, the logic 74 causes the multiplexer 72 to output the logical register reference directly as a physical register reference.
As mentioned earlier, in the preferred embodiment, it is the REPEAT instruction that causes the remapping mechanism. As will be described in more detail later, the REPEAT instruction provides four zero cycle loops in hardware. These hardware loops are illustrated as part of the instruction decoder 50 in FIG. Each time the instruction decoder 50 requests an instruction from the cache 6, the cache returns the instruction to the instruction decoder so that the instruction decoder determines whether the returned instruction is a REPEAT instruction. If so, one of the hardware loops is configured to handle the REPEAT instruction.
Each repeat instruction specifies the number of instructions in the loop and the number of times to repeat the loop (read from a constant or piccolo register). Two opcodes, REPEAT and NEXT, are provided for the definition of the hardware loop, the NEXT opcode is only used as a delimiter and not assembled as an instruction. As REPEAT goes to the beginning of the loop and NEXT marks the end of the loop, the assembler can count the number of instructions in the loop body. In a preferred embodiment, the REPEAT instruction can include remapping parameters such as REGCOUNT, BASEINC, BASEWRAP, REGWRAP parameters that the register remapping logic 52 should use.
A number of registers can be provided that store remapping parameters used by the register remapping logic. Within these registers, multiple sets of predefined remapping parameters can be provided, while some registers are left to store user-defined remapping parameters. If the remapping parameter specified with the REPEAT instruction is equal to one of the pre-defined remapping parameters, the appropriate REPEAT encoding is used, so that the multiplexer, etc., can send the appropriate remapping parameter directly from the register. To the register remapping logic. On the other hand, if the remapping parameter is not equal to any of the previously defined remapping parameters, the assembler generates a Remapping Parameter Move (RMOV) instruction. This allows for the configuration of user-defined register remapping parameters, and the REPEAT instruction follows the RMOV instruction. Preferably, user-defined remapping parameters are placed in registers left to store such user-defined remapping parameters by the RMOV instruction, and the multiplexer uses register redirection for register re-use. Programmed to pass to mapping logic.
In the preferred embodiment, the REGCOUNT, BASEIN, BASEWRAP, and REGWRAP parameters take one of the values shown in the following chart.

Returning to FIG. 6, an example is shown in which various parameters are used by the remap block 56 (in this example, logical and physical register values are relative to a particular bank).

At the end of the loop, the next base pointer update is performed by the base update logic 58 before the next iteration of the loop begins.
Base = (Base + BASEINC) MOD BASEWRAP
At the end of the remapping loop, register remapping is aborted and all registers are accessed as physical registers. In the preferred embodiment, only one remapping REPEAT is active at any time. The loop remains nested, but only one may update the remapping variable at any particular time. However, if desired, remapping iterations can be nested.
To illustrate the effect achieved with respect to code density as a result of using a remapping mechanism according to a preferred embodiment of the present invention, a typical block filter algorithm will be described below. First, the principle of the block filter algorithm will be described with reference to FIG. As shown in FIG. 7, accumulator register A0 is provided to accumulate the results of multiple multiplication operations. This multiplication operation includes multiplication of coefficient c0 and data item d0, multiplication of coefficient c1 and data item d1, multiplication of coefficient c2 and data item d2, and the like. Register A1 accumulates the results of a similar set of multiplication operations, but this time the coefficients are shifted to a combination of c0 and d1, c1 and d2, and c2 and d3. Similarly, the register A2 further shifts the coefficient value and accumulates the result of the combination of combinations of c0 and d2, c1 and d3, and c2 and d4. This shifting, multiplying and accumulating process is repeated and the result is placed in register A3.
Without register remapping according to the preferred embodiment of the present invention, the following instruction loop is required to execute the block filter instruction:

In this example, the data value is placed in the X bank of the register and the coefficient value is placed in the Y bank of the register. As a first step, the four accumulator registers A0, A1, A2, A3 are set to zero. When the accumulator register is reset, an instruction loop is started, which is delimited by the REPEAT and NEXT instructions. The value of Z1 indicates the number of times this instruction loop is repeated, and for reasons explained later, this number is actually equal to the number of coefficients (c0, c1, c2, etc.) divided by four.
There are 16 multiply accumulate instructions (MULA) in the instruction loop. When the first iteration is completed, the result is that registers A0, A1, A2, and A3 contain the REPEAT instruction and the first MULA instruction. Including the result of the calculation shown in the code above. To illustrate how the multiply-accumulate operation works, consider the first four MULA instructions. The first instruction multiplies the data value in the first or lower 16 bits of X bank register zero by the lower 16 bits in Y bank register zero and adds the result to register A0. . At the same time, the 16 bits under X bank register zero are marked for refill, indicating that this part of the register can be refilled with a new data value. Marked in this way and, as is clear from FIG. 7, when data item d0 is multiplied by coefficient c0 (which is represented by the first MULA), d0 is not needed in the rest of the block filter instruction And replaced with a new data value.
The second MULA then multiplies the second or upper 16 bits of the X bank register zero by the lower 16 bits of the Y bank register zero (this is shown in FIG. x c0). Similarly, the third and fourth MULA instructions multiply d2 x c0 and d3 x c0. As is apparent from FIG. 7, when these four calculations are performed, the coefficient C0 becomes unnecessary, and the register Y0.l is marked for refilling and can be overwritten with another coefficient (c4).
The next four MULA instructions represent the computation of d1xc1, d2xc1, d3xc1, and d4xc1, respectively. When the calculation of d1xc1 ends, d1 is no longer needed, so register X0.h is marked with a refill bit. Similarly, when all four calculations are complete, the coefficient c1 is no longer needed, so the register Y0.h is marked for refilling. Similarly, the next four MULA instructions correspond to the calculations of d2xc2, d3xc2, d4xc2, d5xc2, and the last four calculations correspond to the calculations of d3xc3, d4xc3, d5xc3, d6xc3.
In the above embodiment, the register cannot be remapped, and each multiplication operation must be explicitly reclaimed by a specific register specified by the operand. When the 16 MULA instructions have been executed, the instruction loop can be repeated for coefficients c4 to c7 and data items d4 to d10. Also, since the loop operates with four coefficient values per iteration, the number of coefficient values must be a multiple of 4, and Z1 = coefficient / 4 calculations are performed.
By using the remapping mechanism in the preferred embodiment of the present invention, the instruction loop can be dramatically reduced and will only contain four multiply accumulate instructions. Otherwise, 16 multiply accumulate instructions are required. Using this remapping mechanism, the code can be written as follows:

As described above, in the first step, the four accumulator registers A0-A3 are set to zero. Next, the instruction loop delimited by the REPEAT opcode and the NEXT opcode is entered. The REPEAT instruction has a number of parameters as follows.
X ++: Indicates that BASEINC is “1” in the X bank of the register.
n4: REGCOUNT is '4', thus indicating that the first four X bank registers X0.1 to X1.h are remapped.
w4: Indicates that BASEWRAP is '4' in the X bank of the register.
Y ++: Indicates that BASEINC is “1” in the Y bank of the register.
n4: REGCOUNT is '4', thus indicating that the first four Y bank registers Y0.1 to Y1.h are remapped.
w4: Indicates that BASEWRAP is '4' in the Y bank of the register.
r4: Indicates that REGWRAP is '4' in the Y bank of the register.
Note that the value of Z1 is equal to the number of coefficients / 4 in the prior art example, but here it is equal to the number of coefficients.
At the first iteration of the instruction loop, the base pointer value is zero and there is no remapping. However, the next time the loop is executed, since the base pointer value is '1' in both the X bank and the Y bank, the operands are mapped as follows.
X0.l becomes X0.h
X0.h becomes X1.l
X1.l becomes X1.h
X1.h becomes X0.l (because BASEWRAP is '4')
Y0.1 becomes Y0.h
Y0.h becomes Y1.l
Y1.l becomes Y1.h
Y1.h becomes Y0.l (because BASEWRAP is '4')
Therefore, in the second iteration, it can be seen that the four MULA instructions actually perform the calculations indicated by the fifth to eighth MULA instructions in the example described above that do not include the remapping of the present invention. Similarly, in the third and fourth loop iterations, calculations performed by the ninth to twelfth and thirteenth to sixteenth MULA instructions of the prior art code are performed.
Thus, the above code performs exactly the same block filter algorithm as the prior art code, but improves the code density in the loop body by a factor of four. In other words, compared to 16 commands required in the prior art, only 4 commands are required.
By using the register remapping technique according to the preferred embodiment of the present invention, the following advantages are obtained.
1. Improve code density.
2. In some cases, the latency between marking a register as empty and being refilled by the Piccolo reorder buffer can be hidden. This is achieved by the Unrolling Group, discarding the increasing code size.
3. The number of registers to be accessed can be changed. By changing the number of loop iterations, the number of accessed registers can be changed.
4. The algorithm development can be simplified. For a suitable algorithm, the programmer can generate one code for the nth stage of the algorithm and apply the formula to a sliding set of data using register remapping.
It will be apparent that the register remapping mechanism can be modified to some extent without departing from the scope of the present invention. For example, the bank of registers 10 can provide more physical registers than specified by the programmer as instruction operands. These extra registers are not directly accessible, but the register remapping mechanism can use these registers. For example, consider the previous example. There are four 32-bit registers available to the programmer in the X bank of registers, so eight 16-bit registers can be specified by logical register references. If the X bank of registers actually consists of six 32-bit registers, for example, there will be four extra 16-bit registers that are not directly accessible to the programmer. However, these four registers are made available by the remapping mechanism and provide additional registers for the storage of data items.
The following assembler syntax can be used:
>> means a logical right shift or a left shift if the shift operand is negative (see <1scale> below).
->> means an arithmetic right shift or a left shift if the shift operand is negative (see <scale> below).
ROR means right rotation.
SAT (a) means a saturation value of a (saturates at 16 bits or 32 bits depending on the size of the target register). In particular, to saturate at 16 bits, any value greater than + 0x7fff is replaced with + 0x7fff, and any value less than −0x8000 is replaced with −0x8000. For 32-bit saturation, there are extreme values + 0x7fffffff and -0x80000000. Even if the target register is 48 bits, saturation is done at 32 bits.
Source operand 1 can take one of the following formats:
<Src1> is

Used as a shortened form. In other words, all 7 bits of the source specifier are valid, and the registers are read as 32-bit values (swapped if desired) or as sign-extended 16-bit values. For the accumulator, only the lower 32 bits are read. “^” Specifies register refill.
<Src_16> is

Only 16-bit values used as shorthand for are read.
<Src_32> is

Used as a shortened form. Only 32-bit values are read and the upper and lower halves can be exchanged if desired.
Source operand 2 can take one of the following formats:
<Src2> is used as an abbreviation for three options.

A source register of the form plus the scale of the final result (<scale>).
-An optional shifted 8-bit constant (<immed_8>), but not the scale of the final result.
-6-bit constant (<immed_6>), plus, final result scale (<scale>).
<Src2_maxmin> is the same as <src2> except that scale is not allowed.
The <src2_shift> shift instruction provides a limited subset of <src2>, see above for details.
For <src2_par><src2_shift>.
For an instruction that specifies a third operand:
<Acc> is the four accumulator registers

An abbreviation that indicates one of the following. All 48 bits are read. Refill is not specified.
The target register has the following format:
<Dest> This is

Abbreviated form. There is no "." Extension.
All registers are written (48 bits for accumulators). If no write back to the register is required, the register used is not important. The assembler supports omission of the target register and should not be written back, or should be flagged as “.l”, ie no write back is required but the result is a 16-bit quantity It shows that. ^ Indicates that the value is written to the output FIFO.
<Scale> This represents a number on the algebraic scale. 14 scales can be used.
ASR # 0,1,2,3,4,6,8,10
ASR # 12-16
LSL # 1
<Immed_8> This represents an unsigned 8-bit immediate value. This consists of one byte rotated left by 0, 8, 16, or 24 shifts. Therefore, the values 0xYZ000000, 0x00YZ0000, 0x0000YZ00, and 0x000000YZ can be encoded for any YZ. The rotation is encoded as a 2-bit quantity.
<Imm — 6> This represents an unsigned 6-bit immediate value.
<PARAMS> This specifies register remapping and has the following format: <BANK><BASIC> n <RENUMBER> w <BASEWRAP>

The expression <cond> is an abbreviation for any one of the following condition codes. The encoding is a little different from ARM. This is because the unsigned LS and HI codes have been replaced by more useful signed overflow / underflow tests. Since the V flag and the N flag are set on the piccolo differently from ARM, the translation from the conditional test to the flag check is also different from ARM.

Since Piccolo handles signed quantities, the unsigned LS and HI conditions are dropped and replaced with VP and VN that describe the direction of overflow. Since the ALU result is 48 bits wide, MI and LT perform the same function as PL and GE.
All operations are signed unless otherwise noted.
Each of the first condition code and the second condition code includes the following.
N negative
Z zero
C carry / unsigned overflow
V Signed overflow
Arithmetic instructions can be divided into two types: parallel instructions and “full width” instructions. A “full width” instruction only sets the primary flag, whereas the parallel operator sets the primary and secondary flags based on the upper 16-bit half and the lower 16-bit half of the result .
The N, Z, and V flags are calculated based on the ALU results after applying the scale and before writing to the purpose. ASR always reduces the number of bits needed to store the result, but ASL increases it. To avoid this, Piccolo trims the 48-bit result when the ASL scale is applied, limiting the number of bits where zero detection and overflow occurs.
The calculation of the N flag is performed assuming that a signed arithmetic calculation is performed. That is, when an overflow occurs, the most significant bit of the result is the C flag or the N flag, depending on whether the input operand is signed or unsigned.
The V flag indicates whether there is a loss of accuracy as a result of writing the result for the selected purpose. Even if writeback is not selected, "size" is included and the overflow flag is set correctly. An overflow occurs when:
-The result is not in the range of -2 ^ 15 to 2 ^ 15-1, but is written to a 16-bit register.
-The result is not in the range -2 ^ 31 to 2 ^ 31-1, but is written to a 32-bit register.
The parallel add / subtract instruction sets the N, Z, and V flags independently in the upper and lower halves of the result.
When writing to the accumulator, the V flag is set as if it were written to a 32-bit register.
A saturated absolute instruction (SABS) also sets an overflow flag if the absolute value of the input operand does not meet the specified purpose.
The carry flag is set by the add and subtract instructions and is used as a “binary” flag by the MAX / MIN, SABS and CLB instructions. All other instructions, including multiplication operations, save the carry flag (s).
For addition and subtraction operations, a carry is generated depending on the result of bit 31 or bit 15 or whether the purpose is 32 or 16 bits wide.
Standard arithmetic instructions can be classified into many types depending on how the flags are set.
For add and subtract instructions, all flags are saved when the N bit is set. If the N bit is not set, the flag is updated as follows:
Z is set when the full 48-bit result is 0.
N is set when bit 47 is set in the full 48-bit result (if it is negative).
V is set:
When the target register is 16 bits and the signed result does not fit the 16-bit register (not in the range of −2 ^ 15 <= x <2 ^ 15)
The target register is a 32/48 bit register and the signed result does not fit in 32 bits
When <dest> is a 32- or 48-bit register, the C flag is set when <scr1> and <scr2> are summed and there is a carry from bit 31, or from <scr1> to <scr2> When borrowing from bit 31 does not occur (same carry as on ARM). When <dest> is a 16-bit register, the C flag is set when there is a carry from bit 15 in total.
Secondary flags (SZ, SN, SV, SC) are saved.
For instructions that multiply or accumulate from a 48-bit register.
Z is set when the full 48-bit result is 0.
N is set when bit 47 is set in the full 48-bit result (if it is negative).
V is set: (1) If the target register is 16 bits and the signed result does not fit the 16-bit register (not in the range of −2 ^ 15 <= x <2 ^ 15), ) If the target register is a 32 / 48-bit register and the signed result does not fit in 32 bits
C is stored.
Secondary flags (SZ, SN, SV, SC) are saved.
Other instructions including logical operations, parallel addition and subtraction, max and min, shifts, etc. are covered as follows.
Addition and subtraction instructions add or subtract two registers, scale the result, and store it back in the register. Operands are treated as signed values. Flag updates for unsaturated variants are optional and can be suppressed by adding N to the end of the instruction.

OPC specifies the type of instruction.

The assembler supports the following opcodes:
CMP <src1>, <src2>
CMN <src1>, <src2>
CMP is a subtraction that sets a register write disable flag, and CMN is an addition that sets a register write disable flag.
flag:
This is as described above.
Reason for inclusion
The ADC can be used to insert a carry under the register following a shift / MAX / MIN operation. It is also used to perform 32/32 division. In addition, extended precision addition is provided. By adding N bits, the flag can be finely controlled, and in particular, the carry can be controlled. As a result, 32/32 bit division can be performed in two cycles per bit.
Saturation addition and subtraction are necessary for G.729 and the like.
Counter increment / decrement. RSB can be used for calculation shifts (x = 32−x is a normal operation). Saturated RSB is required for saturation negation (used in G.729).
Add / subtract accumulate instructions perform addition and subtraction with accumulation and scaling / saturation. Unlike the multiply-accumulate instruction, the accumulator number cannot be specified independently of the target register. The lower 2 bits of the target register give the number of the 48-bit accumulator used for accumulation, acc. Therefore, ADDA X0, X1, X2, A0 and ADDA A3, X1, X2, A3 are valid, but ADDA X1, X1, X2, A0 are invalid. In this class of instructions, the result must be written back to the register, and no destination write-back encoding is allowed.

OPC specifies the type of instruction. In the following, acc is (DEST [1: 0]). The Sa bit indicates saturation.
Operation (OPC):

Numonic:

flag:
See above
Reason for inclusion
The ADDA (addition and accumulation) instruction can be used to sum two words of an integer array and an accumulator (eg, to find their average) per cycle. The SUBA (subtract accumulation) instruction can be used to calculate the sum of differences (eg, for correlation), and subtracts two separate values and adds the difference to a third register.
By using <dest> different from <acc>, addition with rounding can also be performed. For example, X0 = (X1 + X2 + 16384) >> 15 can be performed in one cycle while 16384 is held at A0. The rounded constant addition can be performed by ADDA X0, X1, # 16384, A0.
For an accurate introduction of bits:
sum of ((a_i ^* b_i) >> k) (generally used in TrueSpeech)
The standard Piccolo code is as follows:

There are two problems with this code. One is too long and the other is that the addition is not a 48-bit precision addition and guard bits cannot be used. The solution is to use ADDA.

This preserves 48-bit accuracy, resulting in a 25% speedup.
Addition / subtraction in parallel instructions is performed with two signed 16-bit quantities held in pairs in a 32-bit register. The primary condition code flag is set from the most significant 16-bit result, and the secondary flag is updated from the lower half. Only 32-bit registers can be specified as the source of these h instructions, but the values can be exchanged halfword. Individual halves of each register are treated as signed values. Calculation and scaling are done without loss of accuracy. Thus, ADDADD X0, X1, X2, ASR # 1 produces the correct average in the upper and lower halves of X0. Each instruction is provided with optional saturation, which sets the Sa bit.

OPC defines operations.
Operation (OPC):

When the Sa bit is set, each sum / difference saturates independently.
Numonic:

S before the command indicates saturation.
The assembler also supports:

Generated by standard instructions without writeback.
flag
C is set when there is a carry of bit 15 when adding the top 16-bit halves of the two.
Z is set when the sum of the above 16-bit halves is zero.
N is set when the above 16-bit half sum is negative.
V is set if the above 16-bit half signed 17-bit sum does not apply to 16 bits (post scale).
SZ, SN, SV, SC are similarly set for the lower 16-bit half.
Reason for inclusion
Parallel add and subtract instructions can be used to manipulate complex numbers held in a single 32-bit register and are used in the FFT kernel. It can also be used for simple addition / subtraction of vectors of 16-bit data, and two elements can be processed in one cycle.
A branch (conditional) instruction allows a conditional change in the control flow. Piccolo uses 3 cycles to execute the taken branch.

Action
If <cond> is held based on the primary flag, branch by offset.
An offset is a signed 16-bit number word. At this time, the range of the offset is limited to −32768 to +32767 words.
The address calculation is as follows.
Target address = branch instruction address + 4 + offset
Numonic:
B <cond><destination_label>
flag:
Unaffected
Reason for inclusion:
Very useful in most routines.
Conditional addition or subtraction instructions conditionally add or subtract src2 to src1.

OPC specifies the type of instruction.
Operation (OPC):

Numonic:

flag:
See above
Reason for inclusion
An efficient division code can be configured by a conditional addition or subtraction instruction.
Example 1: Divide the 32-bit unsigned value at X0 by the 16-bit unsigned value at X1 (assuming X0 <(X1 << 16) and X1.h = 0).

At the end of the loop, X0.1 holds the division quotient. The remainder is restored from X0.h according to the carry value.
Example 2: Divide the 32-bit positive value in X0 by the 32-bit positive value in X1 and exit early.

Finally, X2 holds the quotient and the remainder is restored from X0.
The data is normalized by the count leading bit instruction.

Action
dest is set to the number of places where the value in src1 should be shifted left so that bit 31 is different from bit 30. This is a value in the range 0-30, except that if src1 is -1 or 0, 31 is returned.
Numonic
CLB <dest>, <src1>
flag
Z is set when the result is zero.
N is cleared.
C is set when src1 is -1 or 0.
V is unused.
Reasons for including:
Steps required for normalization
There are Halt and Breakpoint instructions to stop the execution of Piccolo.

OPC specifies the type of instruction.
Operation (OPC)
0 Piccolo execution is stopped and the Halt bit is set in the Piccolo status register.
1 Piccolo execution is stopped, Break bit is set in the piccolo status register, indicating that ARM has been interrupted and a breakpoint has been reached.
Numonic
0 HALT
1 BREAK
flag
Not affected.
A logical operation instruction performs a logical operation on a 32 or 16 bit register. Operands are treated as unsigned values.

OPC encodes the logical operations to be performed.
Operation (OPC):

Numonic:

The assembler supports the following opcodes:

TST is an AND with register write disabled. TEQ is an EOR with register write disabled.
flag
Z is set when the result is all zeros.
N, C and V are preserved.
SZ, SN, SC, SV are preserved.
Reasons for including:
Speech compression algorithms use packed bit regions to encode information. Bitmask instructions help to extract / pack these areas.
The Max and Min operation commands perform maximum and minimum operations.

OPC specifies the type of instruction.
Operation (OPC):

Numonic:

flag
Z is set when the result is zero.
N is set when the result is negative.
In C Max, it is set when src2> = src1 (when dest = src1). In Min, it is set when src2> = src1 (when dest = src2).
V Saved
Reasons for including:
To see the strength of the signal, a number of algorithms scan the sample to determine the maximum / minimum absolute value of the sample. You can use MAX and MIN operations for this. Depending on whether you want to find the first maximum value or the last maximum value of the signal, the operands src1 and src2 can be interchanged.
MAX X0, X0, # 0 converts X0 to a positive number and clips below.
MIN X0, X0, # 255 clips on X0. This is useful for graphic processing.
MAX and MIN operations in parallel instructions perform maximum and minimum operations on parallel 16-bit data.

OPC specifies the type of instruction.
Operation (OPC):

Numonic:

flag
Z is set if the first 16 bits of the result are zero.
N is set if the first 16 bits of the result are negative.
It is set when C Max: src2.h> = scrc1.h (when dest = src1).
Min: Set when src2.h = scrc1.h (when dest = src2).
V Saved
SZ, SN, SC, and SV are similarly set for the lower 16-bit half.
Reasons for including:
About 32-bit Max and Min.
With the Move Long Immeidate Operation instruction, the register can be set with any signed 16-bit sign extension value. Two of these instructions can be set to any value in a 32-bit register (by accessing the consecutive high and low halves). See Select operation for moving between registers.

The assembler can provide non-interlocking NOP operations using the MOV instruction. That is, NOP is equivalent to MOV, # 0.
flag
The flag is not affected.
Reasons for including:
Initialize register / counter.
Multiply accumulate operation instructions perform signed multiplication and involve accumulation or deaccumulation, scaling and saturation.

The OPC area specifies the type of instruction.
Operation (OPC):

In each case, if the Sa bit is set, the result is saturated before being written to the destination.
Numonic:

S before the command indicates saturation.
flag:
See above.
Reasons for including:
MULA held for one cycle is required for FIR code. MULS is used in the FFT butterfly. MULA is also useful for multiplication with rounding. For example, A0 = (X0 * X1 + 16384) >> 15 can be done in one cycle by holding 16384 in another accumulator (eg, A1). The FFT kernel requires different <dest> and <acc>.
The Multiply Double Operation instruction performs signed multiplication, doubles the result, and then performs accumulation or exit, scaling, and saturation.

OPC specifies the type of instruction.
Operation (OPC):

Numonic:

flag:
See above
Reasons for including:
MLD instructions are necessary for algorithms that use fractional arithmetic, such as G.729. Most DSPs provide a fractional mode that can be shifted one bit left in the multiplier output prior to accumulation or writeback. Supporting this as a specific instruction gives the programmer greater flexibility. The names equivalent to some of the basic operations of the G series are shown below.

These use multiplier saturation when shifting left by one bit. If a series of fractional multiplications / accumulations is required, MULA can be used without loss of precision, and the sum is retained in the 33.14 format. If necessary, left shift and saturation can be used last to convert to 1.15 format.
Multiply operation instructions perform signed multiplication and optional scaling / saturation. Source registers (16 bits only) are treated as signed numbers.

OPC specifies the type of instruction.
Operation (OPC):

Numonic:

flag:
See above.
Reason to include.
Signed and saturated multiplication is required in many processes.
The Register List operation is used when an operation is performed on a plurality of register sets. The Empty and Zero instruction is used to reset register selection before starting a routine or between routines. The output instruction can be used to store the contents of the list of registers in the output FIFO.

OPC specifies the type of instruction.
Operation (OPC):

Numonic:

flag
Unaffected
Example

In that case, one register is output using the MOV ^, Rn instruction.
The EMPTY instruction is stopped until all empty registers contain valid data (ie not empty).
Within the remapping REPEAT loop, register list operations should not be used.
The OUPTUT instruction can specify up to eight registers for output.
Reasons for including:
After one routine finishes, the next routine expects all registers to be free to receive data from the ARM. To accomplish this, an EMPTY instruction is required. All accumulators and partial results must be zeroed before running the FIR filter. This is aided by the ZERO instruction. These instructions are designed to improve code density by replacing a series of single register moves. OUTPUT instructions are included to improve code density by replacing a series of MOV ^, Rn instructions.
A remapping, parameter, and move instruction RMOV is provided so that user-defined registers, remapping and parameters can be configured.
The instruction encoding is as follows.

Each PARAMS area consists of the following entries:

The meaning of these entries is shown below.

Numonic:

If the use of the RMOV instruction is active during remapping, the behavior is UNPREDICATABLE (unpredictable).
flag
Not affected.
The Repeat instruction provides four zero cycle loops in hardware. The REPEAT instruction defines a new hardware loop. Piccolo uses hardware loop 0 for the first REPEAT instruction, uses hardware loop 1 for the REPEAT instruction nested in the first repeat instruction, and so on. The REPEAT instruction need not specify which loop is being used. The REPEAT command must be strictly embedded. Attempting to embed deeper than 4 makes the behavior unpredictable.
Each REPEAT instruction specifies the number of instructions in the loop (immediately following the REPEAT instruction) and how many times the loop is to be read (read from a constant or piccolo register).
If the number of instructions in a loop is small (1 or 2), Piccolo may use extra cycles to set up the loop.
If the loop count is designated by the register, it means 32-bit access (S1 = 1), but only the lower 16 bits are meaningful and the number is unsigned. If the loop count is zero, the behavior of the loop is undefined. A copy of the loop count is taken and the registers can be reused directly (or even refilled) without affecting the loop.
The REPEAT instruction provides a mechanism to change the way register operands are specified in the loop. Details are as above.
REPEAT encoding with loop number registered:

REPEAT encoding with a fixed number of loops:

The RFIELD operand specifies which 16 remapping parameter configuration should be used in the loop.

The assembler provides two opcodes, REPEAT and NEXT, to define the hardware loop. REPEAT goes to the beginning of the loop, NEXT delimits the end of the loop, and the assembler can count the number of instructions in the loop body. All that is necessary for REPEAT is to specify the number of loops as a constant or register. For example:

This executes two MULA instructions X0 times. Also,

Performs multiplication and accumulation 10 times.
The assembler supports the following syntax (grammar):
REPEAT # iterations [, <PARAMS>]
Specifies the remapping parameters used for REPEAT. If the required remapping parameter is equal to one of the predefined set of parameters, the appropriate REPEAT encoding is used. Otherwise, the assembler generates RMOV and loads the user-defined parameters following the REPEAT instruction. See above for details on RMOV instruction and remapping parameter format.
If the number of loop iterations is 0, the REPEAT operation is UNPREDICATABLE (unpredictable).
If the instruction count area is set to 0, REPEAT operation is unpredictable.
If there is only one instruction in the loop and that instruction is a branch, it will behave unpredictably.
A branch from the scope of a REPEAT loop out of that loop is unpredictable.
The saturated absolute instruction computes the source 1 saturated absolute.

Operation:
dest = SAT ((src1> = 0)? src1: -src1). The value is always saturated. In particular, the absolute value of 0x80000000 is 0x7fffffff, not 0x80000000.
Numonic:
SABS <dest>, <src1>
flag
Z is set when the result is zero.
N is saved.
C is set when scr <0 (when dest = _scr1).
V is set when saturation occurs.
Reasons for including:
Useful in many DSP applications.
A select operation (conditional move) moves source 1 or source 2 to the target register conditionally. Selection is always equivalent to movement. There are also parallel operations for use after parallel addition / subtraction.
Note that both source operands can also be read by an instruction for introduction reasons, so if one is empty, the instruction stops regardless of whether that operand is absolutely necessary.

OPC specifies the type of instruction.
Operation (OPC):

Numonic:

If the register is marked for refill, it is unconditionally refilled. The assembler also provides the following mnemonics.

MOV <cond> A, B is equivalent to SEL <cond> A, B, A. SELFT and SELFF can be obtained by exchanging src1 and src2 using SELTF and SELTT.
flag
All flags are saved to make a series of selections.
Reasons for including:
Used to make simple decisions inline without relying on branches. Used when scanning a sample or vector for the largest element and by the Viterbi algorithm.
The shift operation command provides a specified amount of left and right logical shift, right arithmetic shift, and rotation. The shift amount is a signed integer between −128 and +127 taken from the lower 8 bits of the register contents, or an immediate value in the range of +1 to +31. A negative shift is shifted in the opposite direction by ABS (shift amount).
The input operand is sign-extended to 32 bits, and the resulting 32-bit output is sign-extended to 48 bits before writing back, so that writing to a 48-bit register functions sensitively.

OPC specifies the type of instruction.
Operation (OPC):

Numonic:

flag
Z is set when the result is zero.
N is set when the result is negative.
V is stored.
C is set to the last shifted bit value (as on ARM).
The shift behavior specified by the register is as follows.
The LSL result of -32 is 0, and C is set to bit 0 of src1.
LSL above -32 results in 0 and C is set to 0.
The LSR result by -32 is 0, and C is set in bit 31 of src1.
LSR above -32 results in 0 and C is set to 0.
ASR results above -32 are filled and C equals bit 31 of src1.
The result of ROR at −32 is equal to src1, and C is set to bit 31 of src1.
ROR with n over -32 results in the same result and carry out as ROR with n-32, so subtract 32 repeatedly from n until the quantity is in the range of 1 to 32. See above.
Reasons for including:
Multiply / divide by a power of two. Bit and region extraction. Serial register.
Undefined instructions are listed in the instruction set list above. With their execution, Piccolo stops execution, sets the U bit in the status register, and disables itself (as if the E bit in the control register was cleared). This allows an instruction to be expanded in the future, and it can be trapped and optionally emulated on existing means.
Access to Piccolo state from ARM is as follows. Use state access mode to observe / change piccolo state. This mechanism is provided for the following two reasons.
-Context switching
−Debug
Piccolo enters the state access mode by executing the PSTATE instruction. In this mode, the state of Piccolo is saved and restored by a series of STC and LDC instructions. When entering the state access mode, the use of the piccolo coprocessor ID PICCOLOl is changed to allow access to the piccolo state. There are seven banks in the Piccolo state. All data in a specific bank can be loaded and stored in a single LDC or STC.
Bank 0: Private register
-One 32-bit word containing the value of the Piccolo ID register (Read Only)
One 32-bit word containing the state of the control register
One 32-bit word containing the status register status
One 32-bit word containing the status of the program counter
Bank 1: General-purpose registers (GPR)
-16 32-bit words containing general register status
Bank 2: Accumulator
-4 32-bit words containing 32 bits above the accumulator register (Note: A copy of the GPR state is needed for restoration otherwise it means another write enable on the register bank).
Bank 3: Register / Piccolo ROB / Output FIFO status
-One 32-bit word indicating which registers are marked for refill (2 bits for each 32-bit register).
Eight 32-bit words containing the state of the ROB tag (eight 7-bit items stored in bits 7 to 0).
3 32-bit words containing the state of the unaligned ROB latch (bits 17 to 0).
One 32-bit word indicating which slot in the output shift register contains valid data (bit 4 indicates empty, bits 3 to 0 encode the number of entries in use);
One 32-bit word containing the state of output FIF0 holding the latch (bits 17 to 0).
Bank 4: ROB input data
-8 32-bit data values.
Bank 5: Output FIFO data
-8 32-bit data values.
Bank 6: Loop hardware
-Four 32-bit words containing the loop start address.
-4 32-bit words containing the loop end address.
-Four 32-bit words containing the loop count (bits 15 to 0).
-One 32-bit word containing user-defined remapping parameters and other remapping states.
The LDC command is used to load the piccolo state when the piccolo is in state access mode. The BANK area specifies the bank to be loaded.

The next series of operations loads all the states of piccolo from the address in register R0.

The STC command is used to store the piccolo state when the piccolo is in state access mode. The BANK area specifies which bank is stored.

By the next series of operations, all the states of the piccolo are stored from the address in the register R0.

Debug mode-Piccolo must respond to the same debug mechanism supported by ARM, ie software via Demon and Angel, and hardware with embedded ICE. There are several mechanisms for debugging the Piccolo system.
-ARM instruction breakpoint
-Data breakpoints (watchpoints)
-Piccolo instruction breakpoint
-Piccolo software breakpoint
ARM instruction breakpoints and data breakpoints are handled by the ARM embedded ICE module. Piccolo instruction breakpoints are handled by the Piccolo embedded ICE module. Piccolo software breakpoints are handled by the Piccolo core. The hardware breakpoint system is configured so that both ARM and Piccolo are breakpointed.
The software breakpoint is handled by a piccolo instruction (Halt or Break) that causes the piccolo to stop execution, enters debug mode (the B bit in the status register is set), and disables itself (the piccolo is disabled) As if it were disabled by the PDISABLE instruction). The program counter remains valid and the breakpoint address can be recovered. Piccolo will no longer execute instructions.
Single stepping Piccolo is done by setting breakpoints one after another on the Piccolo instruction stream.
Software Debug-The basic function provided by Piccolo is the ability to load and save all state to memory via coprocessor instructions when in state access mode. This allows the debugger to save all state to memory, read and / or update it, and restore it to piccolo. The memory state mechanism of the piccolo is non-destructive, that is, the action of memorizing the piccolo state does not ruin the internal state of the piccolo. That is, the piccolo can resume without dumping its state and restoring it.
The mechanism for finding the state of the Piccolo cache must be determined.
Hardware Debug-Hardware debug can be done by a scan chain on Piccolo's coprocessor interface.
Piccolo enters the state access mode and has its state investigated / changed via the scan chain.
The Piccolo status register contains a single bit that indicates that an instruction with a breakpoint has been executed. When an instruction with a breakpoint is executed, Piccolo sets the B bit in the status register and stops execution. To interrogate piccolo, the debugger must be in state access mode by enabling piccolo and writing to the control register before the next access occurs.
FIG. 4 shows a multiplexer configuration that switches the appropriate half of the selected register to the Piccolo data path in response to the Hi / Lo and Size bits. If the Size bit is 16 bits, the sign extension circuit inserts 0 or 1 into the higher order bits of the data path as necessary.

Claims (10)

A plurality of registers (10) each having a capacity of at least N bits for storing a data word to be manipulated;
A data processing apparatus comprising an arithmetic unit (20, 22, 24) that performs an operation specified by the program instruction word in response to a program instruction word, wherein the arithmetic unit includes:
(I) a source register bit area (Register Number) for designating a source register of the plurality of registers for storing an input operand data word for the program instruction word;
In response to at least one program instruction word, and at least one of the program instruction words specifies (ii) whether the input operand data word is N bits or (N / 2) bits in size Input operand size flag (size),
(Iii) high / low flag (Hi / Lo),
If the input size flag specifies (N / 2) bit size, indicates whether the input operand data word is in the upper bit position of the source register or the lower bit position of the source register;
If the input size flag specifies an N bit size, the bit stored in the upper bit position is moved to the lower bit position and stored in the lower bit position before being used as an N bit input operand data word. A data processing apparatus comprising the upper / lower flag indicating whether or not a bit should be moved to the upper bit position. The apparatus of claim 1, further comprising an N-bit data bus for exchanging data words between a data storage device and the plurality of registers. The apparatus of claim 1, further comprising an input buffer for receiving a data word from the N-bit data bus and supplying the N-bit data word to the plurality of registers. For the first (N / 2) bit input operand data word and the second (N / 2) bit input operand data word stored in the upper bit position and lower bit position of one source register, respectively 4. The apparatus according to claim 1, wherein the apparatus is responsive to at least one parallel operation program instruction word that performs different operations. When the arithmetic unit has a signal path that functions as a carry chain between bit positions in an arithmetic operation, and when executing a parallel operation program instruction word, the signal path is the first (N / 2) bit input operand 5. The apparatus of claim 4, wherein there is a break between a data word and the second (N / 2) bit input operand data word. The parallel operation program instruction word is:
(I) Parallel addition in which two parallel (N / 2) bit additions are performed;
(Ii) parallel subtraction with two parallel (N / 2) bit subtractions;
(Iii) a parallel shift in which two parallel (N / 2) bit shifts are performed;
6. (iv) One operation of parallel addition / subtraction in which (N / 2) bit addition and (N / 2) bit subtraction are performed in parallel is performed. apparatus. 7. A device according to claim 1, wherein the arithmetic unit comprises an N-bit data path. For selecting the (N / 2) bit input operand data word stored in either the upper or lower bit position of the source register as supplied to the lower (M / 2) bit of the data path 9. The apparatus of claim 8, comprising at least one multiplexer responsive to the upper / lower flag. 10. The apparatus according to claim 8, further comprising a circuit for sign extending a (N / 2) bit input operand data word before the N bit data path input. Storing the data word to be manipulated in a plurality of registers each having a capacity of at least N bits;
A data processing method comprising: performing an operation designated by the program instruction word in response to the program instruction word,
In response to at least one program instruction word,
(I) selecting a source register of the plurality of registers for storing an input operand data word for the program instruction word using a source register bit area in the program instruction word;
(Ii) using the input operand size flag in the program instruction word to select whether the input operand data word is N bit size or (N / 2) bit size;
(Iii) Using the upper / lower flags in the program instruction word, when the input size flag specifies (N / 2) bit size, the upper bit position of the source register and the lower bit of the source register Select which of the bit positions the input operand data word is in,
If the input size flag specifies an N-bit size, the bit stored in the upper bit position is moved to the lower bit position and stored in the lower bit position before being used as an N-bit input operand data word A data processing method, wherein the upper / lower flag indicates whether or not the transferred bit should be moved to the upper bit position.

Images