LD.UB – Carrega um byte com zero estendido
Descrição: Lê um byte localizado da memória especificada e zero
estendido.
Operação:
I. Rd ← ZE( *(Rp) );
Rp ← Rp
+ 1;
II.
Rp ←
Rp - 1;
Rd ←
ZE( *(Rp) );
III. Rd ←
ZE( *(Rp + (ZE(disp3))) );
IV.
Rd ←
ZE( *(Rp + (SE(disp16))) );
V.
Rd ←
ZE( *(Rb + (Ri << sa2)) );
Sintaxe:
I. ld.ub
Rd, Rp++
II.
ld.ub
Rd, --Rp
III.
ld.ub
Rd, Rp[disp]
IV.
ld.ub
Rd, Rp[disp]
V.
ld.ub
Rd, Rb[Ri<<sa]
Operandos:
I-V. d, p, b, i ∈ {0, 1, ..., 15}
III. disp ∈ {0, 1, ..., 7}IV. disp ∈ {-32768, -32767, ..., 32767}
V. sa ∈ {0, 1, 2, 3}
LD.UB{cond4} – Condicionalmente lê um byte zero estendido
Descrição:
Lê um byte localizado na memória especificada e zero estendido se a
condição dada for satisfeita.
Operação:
I. if (cond4)
Rd ←
ZE( *(Rp + (ZE(disp9))) );
Sintaxe:
I. ld.ub{cond4} Rd, Rp[disp]
Operandos:
I. d, p ∈ {0, 1, ..., 15}
/ disp ∈ {0, 1, ..., 511}
/ cond4 ∈
{eq, ne, cc/hs, cs/lo, ge, lt, mi, pl, ls, gt, le, hi, vs, vc, qs,
al}
LD.SB – Carrega um byte com sinal estendido
Descrição: Lê um byte localizado na memória especificado e sinal
estende.
Operação:
I. Rd ← SE( *(Rp + (SE(disp16))) );
II.
Rd ←
SE( *(Rb + (Ri << sa2)) );
Sintaxe:
I. ld.sb
II.
ld.sb
Rd,
Rp[disp]
Rd,
Rb[Ri<<sa]
Operandos:
I. d, p ∈ {0, 1, ..., 15}
/ disp ∈ {-32768, -32767, ...,
32767}
II.
d,
b, i ∈ {0, 1, ..., 15}
/ sa ∈ {0, 1, 2, 3}
LD.SB{cond4} – Condicionalmente lê um byte com sinal estendido
Descrição: Lê um byte localizado na memória especificada e o
sinal estendido se a condição dada for satisfeita.
Operação:
I.
if (cond4)
Rd ←
SE( *(Rp + (ZE(disp9))) );
Sintaxe:
I. ld.sb{cond4} Rd, Rp[disp]
Operandos:
I. d, p ∈ {0, 1, ..., 15}
/ disp ∈ {0, 1, ..., 511}
/ cond4 ∈
{eq, ne, cc/hs, cs/lo, ge, lt, mi, pl, ls, gt, le, hi, vs, vc, qs,
al}
LD.UH – Carrega a meio palavra zero estendida
Descrição: Lê a meia palavra localizada na memória especificados
e zero estendido nele.
Operação:
I. Rd ← ZE( *(Rp) );
Rp ← Rp
+ 2;
II.
Rp ←
Rp - 2;
Rd ←
ZE( *(Rp) );
III. Rd ←
ZE( *(Rp + (ZE(disp3) << 1)) );
IV.
Rd ←
ZE( *(Rp + (SE(disp16))) );
V.
Rd ←
ZE( *(Rb + (Ri << sa2)) );
Sintaxe:
I. ld.uh
Rd, Rp++
II.
ld.uh
Rd, --Rp
III.
ld.uh
Rd, Rp[disp]
IV.
ld.uh
Rd, Rp[disp]
V.
ld.uh
Rd, Rb[Ri<<sa]
Operandos:
I-V. d, p, b, i ∈ {0, 1, ..., 15}
III.
disp ∈ {0, 2, ..., 14}
IV.
disp
∈ {-32768, -32767, ..., 32767}
V.
sa ∈
{0, 1, 2, 3}
LD.UB{cond4} – Condicionalmente lê um byte zero estendido
Descrição:
Lê um byte localizado na memória especificada e zero estendido se a
condição dada for satisfeita.
Operação:
I. if (cond4)
Rd ←
ZE( *(Rp + (ZE(disp9))) );
Sintaxe:
I. ld.ub{cond4} Rd, Rp[disp]
Operandos:
I. d, p ∈ {0, 1, ..., 15}
/ disp ∈ {0, 1, ..., 511}
/ cond4 ∈
{eq, ne, cc/hs, cs/lo, ge, lt, mi, pl, ls, gt, le, hi, vs, vc, qs,
al}
LD.SH – Carrega a meio palavra com sinal estendido
Descrição: Lê o meia palavra localizada na memória especificada e
sinal estende.
Operação:
I. Rd ← SE( *(Rp) );
Rp ← Rp
+ 2;
II.
Rp ←
Rp - 2;
Rd ←
SE( *(Rp) );
III. Rd ←
SE( *(Rp + (ZE(disp3) << 1)) );
IV.
Rd ←
SE( *(Rp + (SE(disp16)));
V.
Rd ←
SE( *(Rb + (Ri << sa2));
Sintaxe:
I. ld.sh
Rd, Rp++
II.
ld.sh
Rd, --Rp
III.
ld.sh
Rd, Rp[disp]
IV.
ld.sh
Rd, Rp[disp]
V.
ld.sh
Rd, Rb[Ri<<sa]
Operandos:
I-V.
d, p, b, i ∈ {0, 1, ..., 15}
III.
disp ∈ {0, 2, ..., 14}
IV.
disp
∈ {-32768, -32767, ..., 32767}
V.
sa ∈
{0, 1, 2, 3}
LD.SH{cond4} – Condicionalmente lê meia palavra com sinal estendido
Descrição: Lê a meia palavra localizada da memória especificada e
sinal estendido se a condição dada for satisfeita.
Operação:
I. if (cond4)
Rd ←
SE( *(Rp + (ZE(disp9<<1))) );
Sintaxe:
I. ld.sh{cond4} Rd, Rp[disp]
Operandos:
I. d, p ∈ {0, 1, ..., 15}
/ disp ∈ {0, 2, ..., 1022}
/ cond4 ∈
{eq, ne, cc/hs, cs/lo, ge, lt, mi, pl, ls, gt, le, hi, vs, vc, qs,
al}
LD.W – Lê uma palavra
Descrição: formato de I a V: Lê a palavra no local de memória
especificada.
Formato VI: Esta instrução extrai um byte especificado de Ri. Este
valor é zero extendido, deslocada para a esquerda e duas posições
Rb adicionado para formar um endereço. O conteúdo deste endereço é
carregado no Rd. A instrução é útil para tabelas indexáveis.
Operação:
I. Rd ← *(Rp);
Rp ← Rp
+ 4;
II.
Rp ←
Rp - 4;
Rd ←
*(Rp);
III. Rd ←
*(Rp + (ZE(disp5) << 2));
IV.
Rd ←
*(Rp + (SE(disp16)));
V.
Rd ←
*(Rb + (Ri << sa2));
VI. If
(part == b)
Rd ←
*(Rb + (Ri[7:0] << 2) );
else if
(part == l)
Rd ←
*(Rb + (Ri[15:8] << 2) );
else if
(part == u)
Rd ←
*(Rb + (Ri[23:16] << 2) );
else
Rd ←
*(Rb + (Ri[31:24] << 2) );
Sintaxe:
I. ld.w
Rd, Rp++
II.
ld.w
Rd, --Rp
III. ld.w
Rd, Rp[disp]
IV.
ld.w
Rd, Rp[disp]
V.
ld.w
Rd, Rb[Ri<<sa]
VI. ld.w
Rd, Rb[Ri:<part> << 2]
LD.W{cond4} – Condicionalmente lê a palavra
Descrição: Lê o local de memória em palavra especificado se a
condição dada é satisfeita.
Operação:
I. if (cond4)
Rd ←
*(Rp + (ZE(disp9<<2)));
Sintaxe:
I. ld.w{cond4} Rd, Rp[disp]
Operandos:
I. d, p ∈ {0, 1, ..., 15}
/ disp ∈ {0, 4, ..., 2044}
/ cond4
∈ {eq, ne, cc/hs, cs/lo, ge, lt, mi, pl, ls, gt, le, hi, vs, vc,
qs, al}
LD.D – Lê uma palavra dupla
Descrição: Lê uma palavra dupla localizada na memória
especificada.
Operação:
I. Rd+1:Rd ← *(Rp);
Rp ← Rp
+ 8;
II.
Rp ←
Rp - 8;
Rd+1:Rd ←
*(Rp);
III.
Rd+1:Rd ← *(Rp);
IV.
Rd+1:Rd ← *(Rp + (SE(disp16)));
V.
Rd+1:Rd ← *(Rb + (Ri << sa2));
Sintaxe:
I. ld.d
Rd, Rp++
II.
ld.d
Rd, --Rp
III. ld.d
Rd, Rp
IV.
ld.d
Rd, Rp[disp]
V.
ld.d
Rd, Rb[Ri<<sa]
Operandos:
I-V. D ∈ {0, 2, 4, ..., 14}
/ p, b, i ∈ {0, 1, ..., 15}
IV.
disp
∈ {-32768, -32767, ..., 32767}
V.
sa ∈
{0, 1, 2, 3}
LDINS.{B,H} – Carrega e inseri byte ou meia palavra no registrador
Descrição: Esta instrução carrega um byte ou uma meia palavra da
memória e insere-o no endereço do byte ou na posição da meia
palavra no registador Rd. As outras partes do registador Rd não são
afetadas.
Operação:
I. If (part == b)
Rd[7:0] ←
*(Rp+SE(disp12));
else if
(part == l)
Rd[15:8]
← *(Rp+SE(disp12));
else if
(part == u)
Rd[23:16]
← *(Rp+SE(disp12));
else
Rd[31:24]
← *(Rp+SE(disp12));
II.
If (part
== b)
Rd[15:0]
← *(Rp+SE(disp12) << 1);
else
Rd[31:16]
← *(Rp+SE(disp12) << 1);
Sintaxe:
I. ldins.b Rd:<part>, Rp[disp]
II.
ldins.h Rd:<part>, Rp[disp]
Operandos:
I. {p, d} ∈ {0, 1, ..., 15}
/ part ∈ {t, u, l, b}
/ disp ∈
{-2048, -2047, ..., 2047}
II. {p,
d} ∈ {0, 1, ..., 15}
/ part ∈ {t, b}
/ disp ∈ {-4096, -4094,
..., 4094}
LDSWP.{SH, UH, W} – Carrega e troca
Descrição: Esta instrução carrega uma meia
palavra ou uma palavra da memória. Se a carga de meia palavra é
cumprida, o valor carregado é zero ou sinal estendido. Os bytes no
valor carregado são embaralhadas e o resultado é escrito de volta
no registrador de destino Rd. A instrução pode ser utilizada para a
realização as cargas das memórias de ordeneção diferente.
Operação:
I. temp[15:0] ← *(Rp+SE(disp12) << 1);
Rd ←
SE(temp[7:0], temp[15:8]);
II.
temp[15:0] ← *(Rp+SE(disp12) << 1);
Rd ←
ZE(temp[7:0], temp[15:8]);
III. temp
← *(Rp+SE(disp12) << 2);
Rd ←
(temp[7:0], temp[15:8], temp[23:16], temp[31:24]);
Sintaxe:
I. ldswp.shRd, Rp[disp]
II.
ldswp.uhRd, Rp[disp]
III.
ldswp.w Rd, Rp[disp]
Operandos:
I, II. {d, p} ∈ {0, 1, ..., 15}
/ disp ∈ {-4096, -4094, ...,
4094}
III.
{d,
p} ∈ {0, 1, ..., 15}
/ disp ∈ {-8192, -8188, ..., 8188}
LDDPC – Cargamento relativo ao PC com Deslocamento
Descrição: Executa uma carga relativa ao registrador PC e um
deslocamento de um registador destino Rd.
Operação:
I. Rd ← *( (PC && 0xFFFF_FFFC) + (ZE(disp7) <<
2));
Sintaxe:
I. Lddpc
Rd, PC[disp]
Operandos:
I. d ∈ {0, 1, ..., 15}
/ disp ∈ {0, 4, ..., 508}
LDDSP – Carregamento relativo à SP com Deslocamento
Descrição: Lê o valor localizado na memória referida pelo
registrador apontador de pilha e um deslocamento.
Operação:
I. Rd ← *( (SP && 0xFFFF_FFFC) + (ZE(disp7) <<
2));
Sintaxe:
I. Lddsp
Rd, SP[disp]
Operandos:
I. D ∈ {0, 1, ..., 15}
/ disp ∈ {0, 4, ..., 508}
ST.B – armazena um byte
Descrição:
O byte do registrador fonte é armazenado na posição de memória
indexada pelo endereço de ponteiro.
Operação:
I.
*(Rp)
← Rs[7:0];
Rp ← Rp
+ 1;
II. Rp ←
Rp - 1;
*(Rp) ←
Rs[7:0];
III. *(Rp
+ ZE(disp3)) ← Rs[7:0];
IV.
*(Rp
+ SE(disp16)) ← Rs[7:0];
V.
*(Rb
+ (Ri << sa2)) ← Rs[7:0];
Sintaxe:
I.
st.b
II. st.b
III.
st.b
IV. st.b
V.
st.b
Rp++, Rs
--Rp, Rs
Rp[disp],
Rs
Rp[disp],
Rs
Rb[Ri <<
sa], Rs
Operandos:
I, II. {s
, p} ∈ {0, 1, ..., 15}
III.
{s
, p} ∈ {0, 1, ..., 15}
disp ∈
{0, 1, ..., 7}
IV. {s ,
p} ∈ {0, 1, ..., 15}
disp ∈
{-32768, -32767, ..., 32767}
V.
{b,
i, s} ∈ {0, 1, ..., 15}
sa ∈
{0, 1, 2, 3}
ST.B{cond4} – armazena byte condicionalmente
Descrição: O byte do registrador fonte é
armazenado na posição de memória referenciada pelo ponteiro de
endereço se a condição determinada for satisfeita.
Operação:
I.
se
(cond4)
*(Rp +
ZE(disp9)) ← Rs[7:0];
Sintaxe:
I.
st.b{cond4} Rp[disp], Rs
Operandos:
I.
s, p
∈ {0, 1, ..., 15}
disp ∈
{0, 1, ..., 511}
cond4 ∈
{eq, ne, cc/hs, cs/lo, ge, lt, mi, pl, ls, gt, le, hi, vs, vc, qs,
al}
ST.D – armazena dupla palavras
Descrição: as palavras duplas dos registradores
de origem são armazenados como palavra na memória indexada pelo
ponteiro de endereço.
Operação:
I.
*(Rp)
← Rs+1:Rs;
Rp ← Rp
+ 8;
II. Rp ←
Rp - 8;
*(Rp) ←
Rs+1:Rs;
III.
*(Rp) ← Rs+1:Rs;
IV.
*(Rp
+ SE(disp16)) ← Rs+1:Rs;
V.
*(Rb
+ (Ri << sa2)) ← Rs+1:Rs;
Sintaxe:
I.
st.d
II. st.d
III.
st.d
IV.
st.d
V.
st.d
Rp++, Rs
--Rp, Rs
Rp, Rs
Rp[disp],
Rs
Rb[Ri <<
sa], Rs
Operandos:
I, II,
III. p ∈ {0, 1, ..., 15}
s ∈ {0,
2, ..., 14}
IV.
p ∈ {0,
1, ..., 15}
s ∈ {0,
2, ..., 14}
disp ∈
{-32768, -32767, ..., 32767}
V.
{b, i} ∈
{0, 1, ..., 15}
s ∈ {0,
2, ..., 14}
sa ∈
{0, 1, 2, 3}
ST.H – armazena meia palavra
Descrição: a meia palavra do registo fonte é armazenado na posição
de memória referente ao endereço do ponteiro.
Operação:
I.
*(Rp)
← Rs[15:0];
Rp ← Rp
+ 2;
II. Rp ←
Rp - 2;
*(Rp) ←
Rs[15:0];
III. *(Rp
+ ZE(disp3 << 1)) ← Rs[15:0];
IV. *(Rp
+ SE(disp16)) ← Rs[15:0];
V.
*(Rb
+ (Ri << sa2)) ← Rs[15:0];
Sintaxe:
I.
st.h
II.
st.h
III.
st.h
IV.
st.h
V.
st.h
Rp++, Rs
--Rp, Rs
Rp[disp],
Rs
Rp[disp],
Rs
Rb[Ri <<
sa], Rs
Operandos:
I, II. {s
, p} ∈ {0, 1, ..., 15}
III.
{s
, p} ∈ {0, 1, ..., 15}
disp ∈
{0, 2, ..., 14}
IV. {s ,
p} ∈ {0, 1, ..., 15}
disp ∈
{-32768, -32767, ..., 32767}
V.
{b,
i, s} ∈ {0, 1, ..., 15}
sa ∈
{0, 1, 2, 3}
ST.H{cond4} – armazena meia palavra condicionalmente
Descrição: A meia palavra do registrador fonte é armazenado na
posição de memória referente ao endereço do ponteiro se a
condição for satisfeito.
Operação:
I.
se
(cond4)
*(Rp +
ZE(disp9<<1)) ← Rs[15:0];
Sintaxe:
I.
st.h{cond4} Rp[disp], Rs
Operação:
I.
s, p
∈ {0, 1, ..., 15}
disp ∈
{0, 2, ..., 1022}
cond4 ∈
{eq, ne, cc/hs, cs/lo, ge, lt, mi, pl, ls, gt, le, hi, vs, vc, qs,
al}
ST.W – armazena a palavra
Descrição
:
a palavra do registrador fonte é armazenada na posição de memória
referente ao ponteiro.
Operação:
I.
*(Rp)
← Rs;
Rp ← Rp
+ 4;
II. Rp ←
Rp - 4;
*(Rp) ←
Rs;
III. *(Rp
+ ZE(disp4 << 2)) ← Rs;
IV.
*(Rp
+ SE(disp16)) ← Rs;
V.
*(Rb
+ (Ri << sa2)) ← Rs;
Sintaxe:
I.
st.w
II. st.w
III.
st.w
IV.
st.w
V.
st.w
Rp++, Rs
--Rp, Rs
Rp[disp],
Rs
Rp[disp],
Rs
Rb[Ri <<
sa], Rs
Operandos:
I, II.
{s , p} ∈ {0, 1, ..., 15}
III.
{s
, p} ∈ {0, 1, ..., 15}
disp ∈
{0, 4, ..., 60}
IV.
{s ,
p} ∈ {0, 1, ..., 15}
disp ∈
{-32768, -32767,..., 32767}
V.
{b,
i, s} ∈ {0, 1, ..., 15}
sa ∈
{0, 1, 2, 3}
ST.W{cond4} – armazena a palavra condicionalmente
Descrição: O registrador fonte palavra é armazenado na posição
de memória referida pelo endereço do ponteiro se a condição dada
for satisfeita.
Operação:
I.
if
(cond4)
*(Rp +
ZE(disp9<<2)) ← Rs;
Sintaxe:
I.
st.w{cond4} Rp[disp], Rs
Operandos:
I.
s, p ∈
{0, 1, ..., 15}
disp ∈
{0, 4, ..., 2044}
cond4 ∈
{eq, ne, cc/hs, cs/lo, ge, lt, mi, pl, ls, gt, le, hi, vs, vc, qs,
al}
STCOND – armazena uma palavra condicionalmente
Descrição: O registrador fonte palavra é armazenado na posição
de memória referente ao endereço do ponteiro se SREG [L] estiver em
um. Além disso, SREG [L] é copiado no SREG [Z] para indicar um
sucesso ou a falha da operação. Esta instrução é usada para
acesso à memória atomicamente.
Operação:
I.
SREG[Z] ← SREG[L];
se
SREG[L]
*(Rp +
SE(disp16)) ← Rs;
Sintaxe:
I.
stcond Rp[disp], Rs
Operandos:
I.
{s ,
p} ∈ {0, 1, ..., 15}
disp ∈
{-32768, -32767, ..., 32767}
STDSP – armazena relativo o ponteiro da pilha
Descrição: Armazena o valor do registrador fonte na posição de
memória que se refere ao endereço especificado pelo ponteiro de
pilha e o deslocamento.
Operação: I. * ((SP && 0xFFFF_FFFC) + (ZE (disp7) <<
2)) ← Rs;
Sintaxe: I. stdsp SP [DISP], Rs
Operandos: I. disp ∈ {0, 4, ..., 508} s ∈ {0, 1, ..., 15}
STHH.W – armazena meia palavras em palavra
Descrição: As meias palavras selecionadas dos registradores de
origem são combinados e armazenadas na memória designado pelo
endereço ponteiro em palavra.
Operação: se (Rx-part == t) então high-part = Rx[31:16] senão
high-part = Rx[15:0];
se (Ry-part == t) então low-part = Ry[31:16] senão low-part =
Ry[15:0];
I.*(Rp + ZE(disp8 << 2)) ← {high-part, low-part};
II.*(Rb + (Ri << sa2)) ← {high-part, low-part};
Sintaxe:
I. sthh.w Rp [DISP], Rx: <part>, Ry: <part>
I. sthh.w Rp [DISP], Rx: <part>, Ry: <part>
II. sthh.w Rb [Ri << sa], Rx: <part>, Ry: <part>
Operandos:
I. {p, x, y} ∈ {0, 1, ..., 15} disp ∈ {0, 4, ..., 1020} parte ∈ {b, t}
I. {p, x, y} ∈ {0, 1, ..., 15} disp ∈ {0, 4, ..., 1020} parte ∈ {b, t}
II. {b, i, x, y} ∈ {0, 1, ..., 15} sa ∈ {0, 1, 2, 3} parte ∈
{b, t}
STSWP.{H, W} – troca e armazena
Descrição: Esta instrução troca os bytes em um meia palavra ou
uma palavra no arquivo de registradores e armazena o resultado na
memória. A instrução pode ser utilizada para realização de
armazenar na memória de diferente ordenação.
Operação:
I.
temp[15:0] ← (Rs[7:0], Rs[15:8]);
*(Rp+SE(disp12)
<< 1) ← temp[15:0];
II.
temp[31:0] ← (Rs[7:0], Rs[15:8], Rs[23:16], Rs[31:24]);
*(Rp+SE(disp12)
<< 2) ← temp[31:0];
Sintaxe:
I. stswp.h Rp[disp], Rs
II.
stswp.w Rp[disp], Rs
XCHG – Troca entre o registrador e a memória
Descrição : Lê uma palavra da memória apontada por Rx no
registrador Rd, e escreve o valor do registrador Ry na posição de
memória.
Sugestões: Estas instruções podem ser utilizadas para implementar
os semáforos binários (semáforos). O stcond instrução deve ser
usado para implementar a contagem de semáforos.
Operação: I. Temp ← *(Rx); / *(Rx) ← Ry; / Rd ←
Temp;
Syntax: I. xchg Rd, Rx, Ry
Operandos: I. {d,x,y} ∈ {0, 1, ..., 14}
Nenhum comentário:
Postar um comentário