São 19 instruções disponíveis a saber:
COP – Operação do coprocessador
Descrição: endereça um coprocessador e executa a operação
especificada nos registradores especificados.
Operação:
I.
CP#(CRd) ← CP#(CRx) Op CP#(CRy);
Sintaxe:
I. Cop CP#, CRd, CRx, CRy, Op
Operandos:
I.
# ∈ {0, 1, ..., 7} / Op ∈ {0, 1, ..., 127}
/ {d, x, y} ∈
{0, 1, ..., 15}
LDC.{D,W} – Lê coprocessador
Descrição: Lê o local de memória especificado no endereçado
coprocessador.
Operação:
I. CP#(CRd+1:CRd) ← *(Rp + (ZE(disp8) << 2));
II.
Rp ←
Rp-8;
CP#(CRd+1:CRd)
← *(Rp);
III.
CP#(CRd+1:CRd) ← *(Rb + (Ri << sa2));
IV.
CP#(CRd) ← *(Rp + (ZE(disp8) << 2));
V.
Rp ←
Rp-4;
CP#(CRd)
← *(Rp);
VI.
CP#(CRd) ← *(Rb + (Ri << sa2));
Sintaxe:
I. ldc.d
CP#, CRd, Rp[disp]
II.
ldc.d
CP#, CRd, --Rp
III.
ldc.d
CP#, CRd, Rb[Ri<<sa]
IV.
ldc.w
CP#, CRd, Rp[disp]
V.
ldc.w
CP#, CRd, --Rp
VI. ldc.w
CP#, CRd, Rb[Ri<<sa]
LDC0.{D,W} – Lê coprocessador 0
Descrição:
Lê o local de memória especificado no coprocessador 0.
Operação:
I. CP0(CRd+1:CRd) ← *(Rp + (ZE(disp12) << 2));
II.
CP0(CRd) ← *(Rp + (ZE(disp12) << 2));
Sintaxe:
I. ldc0.d CRd, Rp[disp]
II.
ldc0.w CRd, Rp[disp]
Operandos:
I,II p ∈ {0, 1, ..., 15}
I.
d ∈
{0, 2, ..., 14}
II. d ∈
{0, 1, ..., 15}
I, II.
disp ∈ {0, 4, ..., 16380}
LDCM.{D,W} – Carrega múltiplos registadores no coprocessador
Lê
os locais de memória especificados no endereçado coprocessador. O
registrador ponteiro pode opcionalmente ser atualizado depois da
operação.
Operação:
I. Loadaddress ←Rp;
for (i =
7 to 0)
if
ReglistCPD8[i] == 1 then
CP#(CR(2*i+1))
←*(Loadaddress++);
CP#(CR(2*i))
←*(Loadaddress++);
if
Opcode[++] == 1 then
Rp ←
Loadaddress;
II.
Loadaddress ←Rp;
for (i =
7 to 0)
if
ReglistCPH8[i] == 1 then
CP#(CRi+8)
←*(Loadaddress++);
if
Opcode[++] == 1 then
Rp ←
Loadaddress;
III.
Loadaddress ←Rp;
for (i =
7 to 0)
if
ReglistCPL8[i] == 1 then
CP#(CRi)
←*(Loadaddress++);
if
Opcode[++] == 1 then
Rp ←
Loadaddress;
Sintaxe:
I. ldcm.d CP#, Rp{++}, ReglistCPD8
II.
ldcm.w CP#, Rp{++}, ReglistCPH8
III.
ldcm.w CP#, Rp{++}, ReglistCPL8
MVCR.{D,W} – Mova o registador do coprocessador para arquivo de arquivo
Descrição: endereça um com co-processador e move os registradores
especificados no arquivo de registradores.
Sintaxe:
I. mvcr.d CP#, Rd, CRs
II.
mvcr.w CP#, Rd, CRs
Operandos:
I. # ∈ {0, 1, ..., 7} / {d, s} ∈ {0, 2, 4, ..., 14}
II.
# ∈
{0, 1, ..., 7}
/ {d, s} ∈ {0, 1, ..., 15}
MVRC.{D,W} – Move o registrador o registrador de arquivo para o endereço do coprocessador
Descrição: Move o registrador especificado para o registador do
coprocessador.
Operação:
I.
CP#(CRd+1:CRd) ← Rs+1:Rs;
II.
CP#(CRd) ← Rs;
Sintaxe:
I.
mvrc.d CP#, CRd, Rs
II.
mvrc.w CP#, CRd, Rs
Operandos:
I.
# ∈ {0, 1, ..., 7} / {d, s} ∈ {0, 2, 4, ..., 14}
I.
# ∈
{0, 1, ..., 7}
/ {d, s} ∈ {0, 1, ..., 15}
STC.{D,W} – armazena o Coprocessor
Operação:
I.
*(Rp
+ (ZE(disp8) << 2)) ← CP#(CRd+1:CRd);
II. *(Rp)
← CP#(CRd+1:CRd);
Rp ←
Rp+8;
III. *(Rb
+ (Ri << sa2)) ← CP#(CRd+1:CRd);
IV.
*(Rp
+ (ZE(disp8) << 2)) ← CP#(CRd);
V.
*(Rp)
← CP#(CRd);
Rp ←
Rp+4;
VI. *(Rb
+ (Ri << sa2)) ← CP#(CRd);
Sintaxe:
I.
stc.d
II.
stc.d
III.
stc.d
IV.
stc.w
V.
stc.w
VI.
stc.w
CP#,
Rp[disp], CRs
CP#,
Rp++, CRs
CP#,
Rb[Ri<<sa], CRs
CP#,
Rp[disp], CRs
CP#,
Rp++, CRs
CP#,
Rb[Ri<<sa], CRs
Operandos:
I-VI.
#
∈ {0, 1, ..., 7}
I-II,
IV-V.s ∈ {0, 1, ..., 15}
I-III.
s
∈ {0, 2, ..., 14}
I, IV.
disp ∈ {0, 4, ..., 1020}
III, VI.
{b, i} ∈ {0, 1, ..., 15}
III, VI.
Sa ∈ {0, 1, 2, 3}
STC0.{D,W} – armazena o registrador 0 do Coprocessor
Descrição: Armazena o valor do registrador fonte
0 do coprocessador para o local especificado pelo modo de
endereçamento.
Operação:
I. *(Rp +
(ZE(disp12) << 2)) ← CP#(CRd+1:CRd);
- *(Rp + (ZE(disp12) << 2)) ← CP#(CRd);
Sintaxe:
I.
stc0.d Rp[disp], CRs
II.
stc0.w Rp[disp], CRs
Operandos:
I-II.
p
∈ {0, 1, ..., 15}
I.
s ∈
{0, 2, ..., 14}
II. s ∈
{0, 1, ..., 15}
I, IV.
disp ∈ {0, 4, ..., 16380}
STCM {D, W} - armazena múltiplos registradores no coprocessador
Descrição: Escreve vários registradores no coprocessador nas
posições de memória especificados.
Operação:
I.
Storeaddress ←Rp;
if
Opcode[--] == 1 then
for (i
= 0 to 7)
if
ReglistCPD8[i] == 1 then
*(--Storeaddress) ←CP#(CR(2*i));
*(--Storeaddress) ←CP#(CR(2*i+1));
Rp ←
Storeaddress;
else
for (i
= 7 to 0)
if
ReglistCPD8[i] == 1 then
*(Storeaddress++) ←CP#(CR(2*i+1));
*(Storeaddress++) ←CP#(CR(2*i));
II.
Storeaddress ←Rp;
if
Opcode[--] == 1 then
for (i
= 0 to 7)
if
ReglistCPH8[i] == 1 then
*(--Storeaddress) ←CP#(CRi+8);
Rp ←
Storeaddress;
else
for (i
= 7 to 0)
if
ReglistCPH8[i] == 1 then
*(Storeaddress++)
←CP#(CRi+8);
Storeaddress ←Rp;
if
Opcode[--] == 1 then
for (i =
0 to 7)
if
ReglistCPL8[i] == 1 then
*(--Storeaddress)
←CP#(CRi);
III.
Storeaddress ←Rp;
if
Opcode[--] == 1 then
for (i =
0 to 7)
if
ReglistCPL8[i] == 1 then
*(--Storeaddress)
←CP#(CRi);
Rp ←
Storeaddress;
else
for (i =
7 to 0)
if
ReglistCPL8[i] == 1 then
*(Storeaddress++)
←CP#(CRi);
Sintaxe:
I.
stcm.d CP#, {--}Rp, ReglistCPD8
II.
stcm.w CP#, {--}Rp, ReglistCPH8
III.
stcm.w CP#, {--}Rp, ReglistCPL8
Operandos:
I-III. # ∈ {0, 1, ..., 7}
p ∈ {0,
1, ..., 15}
I.
ReglistCPD8 ∈ {CR0-CR1,CR2-CR3,CR4-CR5,CR6-CR7,CR8-CR9,
CR10-CR11,CR12-CR13,CR14-CR15}
II.
ReglistCPH8 ∈ {CR8, CR9, CR10, ..., CR15}
III.
ReglistCPL8 ∈ {CR0, CR1, CR2, ..., CR7}
Nenhum comentário:
Postar um comentário