ADDHH.W– Adiciona meias palavras na palavra
Descrição: Adiciona duas meias palavras do registrador especificado
e armazena o resultado no registrador destino em palavra. As meias
palavras do registrador são selecionados como a parte alta ou baixa
do registrador operando.
Operação:
I.
If (Rx-part == t) then operand1 = SE(Rx[31:16]) else operand1 =
SE(Rx[15:0]);
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
Rd ←
operand1 + operand2;
Sintaxe:
I. addhh.wRd, Rx:<part>, Ry:<part>
Operandos:
I. {d, x, y} ∈ {0, 1, ..., 15}
/ part ∈ {t,b}
MACHH.D – Multiplica as meias palavras e soma com palavra dupla
Descrição: Multiplica as duas meias palavras dos registradores
especificados e soma o resultado com a dupla palavra do registrador
especificado. Apenas os 48 bits mais elevado dos possíveis 64 bits
na palavra dupla da soma são utilizados. Os 16 bits inferiores são
zerados. As meias palavras dos registador são selecionados ou como a
parte alta ou baixa dos registradores operando.
Operação:
I.
If (Rx-part == t) then operand1 = SE(Rx[31:16]) else operand1 =
SE(Rx[15:0]);
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
(Rd+1:Rd)[63:16]
← (operand1 × operand2)[31:0] + (Rd+1:Rd)[63:16];
Rd[15:0]
← 0;
Sintaxe:
I.
machh.d Rd, Rx:<part>, Ry:<part>
Operandos:
I.
d ∈ {0, 2, 4, ..., 14}
/ {x, y} ∈ {0, 1, ..., 15}
/ part ∈
{t,b}
MACHH.W – Multiplica meias palavras e soma com palavra
Descrição: Multiplica dois registadores especificados em meia
palavra e soma o resultado ao registrador especificada em palavra. As
meias palavras dos registadores são selecionados ou como a parte
alta ou baixa dos registradores operando.
Operação:
I.
If (Rx-part == t) then operand1 = SE(Rx[31:16]) else operand1 =
SE(Rx[15:0]);
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
Rd ←
(operand1 × operand2) + Rd;
Sintaxe:
I.
machh.w Rd, Rx:<part>, Ry:<part>
Operandos:
I.
{d, x, y} ∈ {0, 1, ..., 15}
/ part ∈ {t,b}
MACWH.D – Multiplica palavra com meia palavra e acumula em dupla palavra
Descrição:
Multiplica registadores em palavra e em meia palavra especificado e
adiciona o resultado ao registador de dupla palavra especificado. O
registrador em meia palavra é selecionado ou como a parte alta ou
baixa do registador Ry. Apenas os 48 mais elevado dos possíveis 64
bits na palavra dupla do acumulador são utilizados. Os 16 menores
bits são zerados.
Operação:
I.
operand1 = Rx;
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
(Rd+1:Rd)[63:16]
← (operand1 × operand2)[47:0] + (Rd+1:Rd)[63:16];
Rd[15:0]
← 0;
Sintaxe:
I.
macwh.d Rd, Rx, Ry:<part>
Operandos:
I.
d ∈ {0, 2, ..., 14}
/ {x, y} ∈ {0, 1, ..., 15}
/ part ∈
{t,b}
MULHH.W – Multiplica meia palavra com meia palavra
Descrição: Multiplica as duas meias palavras dos registradores
especificados e armazena o resultado no registrador destino em
palavra. As meias palavras dos registadores são selecionados ou como
a parte alta ou baixa dos registros operando.
Operação:
I.
If (Rx-part == t) then operand1 = SE(Rx[31:16]) else operand1 =
SE(Rx[15:0]);
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
Rd ←
operand1 × operand2;
Sintaxe:
I.
mulhh.w Rd, Rx:<part>, Ry:<part>
Operandos:
I.
{d, x, y} ∈ {0, 1, ..., 15}
/ part ∈ {t,b}
MULWH.D – Multiplica a palavra com meia palavra
Descrição:
Multiplica o registrador no tamanho de palavra com o registrador no
tamanho de meia palavra especificado e armazena o resultado no par de
registradores destino. A meio palavra do registrador é escolhida
como parte alta ou baixa do Ry. Uma vez que a parte mais
significativa do produto é armazenado, não irá ocorrer
transbordamento.
Operação:
I. operand1 = Rx;
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
(Rd+1:Rd)[63:16]
← operand1 × operand2;
Rd[15:0]
← 0;
Sintaxe:
I.
mulwh.d Rd, Rx, Ry:<part>
Operandos:
I.
d ∈ {0, 2, 4, ..., 14}
/ {x, y} ∈ {0, 1, ..., 15} / part ∈
{t,b}
MULNHH.W – Multiplica meia palavra com meia palavra negada
Descrição:
Multiplica os dois registradores em meia palavra especificado e
armazena o resultado no registador em palavra. As meias palavras dos
registadores são selecionados ou como a parte alta ou baixa dos
registro operando. O resultado é negada.
Operação:
I. If (Rx-part == t) then operand1 = SE(Rx[31:16]) else operand1 =
SE(Rx[15:0]);
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
Rd ← -
(operand1 × operand2);
Sintaxe:
I.
mulnhh.w Rd, Rx:<part>, Ry:<part>
Operandos:
I.
{d, x, y} ∈ {0, 1, ..., 15}
/ part ∈ {t,b}
MULNWH.D – Multiplica palavra com negada meia palavra
Descrição: Multiplica a palavra do registrador com o registador em
meia palavra especificado e armazena o resultado negada no para de
registadores destino. A meia palavra do registrador é selecionado ou
como a parte alta ou baixa do registador Ry. Uma vez que a parte mais
significativa do produto é armazenado, não irá ocorrer
transbordamento.
Operação:
I.
operand1 = Rx;
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
(Rd+1:Rd)[63:16]
← - (operand1 × operand2);
Rd[15:0]
← 0;
Sintaxe:
I.
mulnwh.d
Rd, Rx, Ry:<part>
Operandos:
I.
d ∈ {0, 2, 4, ..., 14}
/ {x, y} ∈ {0, 1, ..., 15}
/ part ∈
{t,b}
SATADD.H – Adicionar saturadas de meia palavras
Descrição: Adiciona dois registradores de meia palavra
especificados e armazena o resultado no registrador de destino. O
resultado está saturado se estouro da gama representado pelo 16
bits. Se ocorrer a saturação, a bandeira Q é elevado.
Operação:
I. temp ← ZE(Rx[15:0]) + ZE(Ry[15:0]));
se
(Rx[15] ∧ Ry[15] ∧ ¬temp[15]) ∨ (¬Rx[15] ∧ ¬Ry[15] ∧
temp[15]) então
se Rx[15]
== 0 então
Rd ←
0x00007fff;
senão
Rd ←
0xffff8000;
senão
Rd ←
SE(temp[15:0]);
Sintaxe:
I.
satadd.h Rd, Rx, Ry
Operandos:
I.
{d, x, y} ∈ {0, 1, ..., 15}
SATADD.W – Adiciona palavras saturando
Descrição:
Adiciona os dois registradores especificados e armazena o resultado
no registrador de destino. O resultado é saturado se ocorrer um
estouro no complemento de dois. Se ocorrer a saturação a bandeira Q
é elevado.
Operação:
I.
temp ← Rx + Ry;
se
(Rx[31] ∧ Ry[31] ∧ ¬temp[31]) ∨ (¬Rx[31] ∧ ¬Ry[31] ∧
temp[31]) então
se Rx[31]
== 0 then
Rd ←
0x7fffffff;
senão
Rd ←
0x8000000;
senão
Rd ←
temp;
Sintaxe:
I. satadd.wRd, Rx, Ry
Operandos:
I. {d, x, y} ∈ {0, 1, ..., 15}
SATSUB.H – Subtração de Meia palavras com saturação
Descrição:
Realiza uma subtração das meias palavras especificadas e armazena o
resultado no registrador de destino. O resultado está saturado se
transborda o representável gama com 16 bits. Se ocorrer a saturação,
a bandeira Q é elevada.
Operação:
I. temp ←
ZE(Rx[15:0]) - ZE(Ry[15:0]) ;
se
(Rx[15] ∧ ¬Ry[15] ∧ ¬temp[15]) ∨ (¬Rx[15] ∧ Ry[15] ∧
temp[15]) então
se
Rx[15]==0 então
Rd ←
0x00007fff;
senão
Rd ←
0xffff8000;
senão
Rd ←
SE(temp[15:0]);
Sintaxe:
I. satsub.hRd, Rx, Ry
Operandos:
I. {d, s} ∈ {0, 1, ..., 15}
SATSUB.W – Subtração saturada das Palavras
Descrição: Realiza uma subtração e armazena o resultado no
registrador de destino. O resultado está saturado se ocorrer um
transbordamento no complemento de dois. Se ocorrer a saturação, a
bandeira Q está definida.
Operação:
I. temp ←
Rx - Ry;
II. temp
← Rs – SE(imm16));
Format I:
OP1 = Rx, OP2 = Ry
Format
II: OP1 = Rs, OP2 = SE(imm16)
se
(OP1[31] ∧ ¬OP2[31] ∧ ¬temp[31]) ∨ (¬OP1[31] ∧ OP2[31] ∧
temp[31]) então
se
(OP1[31]==0) then
Rd ←
0x7fffffff;
senão
Rd ←
0x80000000;
senão
Rd ←
temp
Sintaxe:
I. satsub.w Rd, Rx, Ry
II.
satsub.w Rd, Rs, imm
Operandos:
I. {d, x,
y} ∈ {0, 1, ..., 15}
II. {d,
s} ∈ {0, 1, ..., 15}
imm ∈
{-32768, -32767, ..., 32767}
SATRNDS – saturadas com arredondamento e com sinal
Descrição: Esta instrução considera o valor em
(Rd >> SA) [bp-1: 0] como um valor assinado. O arredondamento é
realizada após o deslocamento. Se o valor em (Rd >> sa) [31:
bp] não é um sinal de extensão desse valor, ocorre o
transbordamento e a saturação é feita para o valor máximo do
positivo ou negativo. Se ocorrer a saturação, a bandeira Q é
elevada. Um deslocamento aritmético é realizada em Rd. Se pb é
igual a zero, saturação não é executada.
Operação:
I. Temp ←
Rd >> sa
se (sa !=
0)
Rnd =
Rd[sa-1]
Temp =
Temp + Rnd;
es ((Temp
== SE( Temp[bp-1:0])) || (bp == 0) )
Rd ←
Temp;
senão
if
(Temp[31] == 1)
Rd ←
-2bp-1;
senão
Rd ←
2bp-1 - 1;
Sintaxe:
I. satrnds Rd >> sa, bp
Operandos:
I. d ∈ {0, 1, ..., 15} e {sa, bp} ∈ {0, 1, ..., 31}
SATRNDU – saturar com arredondamento sem sinal
Descrição: Esta instrução considera o valor em (Rd >> SA)
[bp-1: 0] como um valor sem sinal. Arredondamento é realizada após
a deslocamento. Se o valor em (Rd >> sa) [31: bp] não é
meramente uma extensão deste valor de zero, ocorre o transbordamento
e a saturação é feita para o máximo valor positivo sem sinal ou
zero. Se ocorrer a saturação, a bandeira Q é elevada. Um
deslocamento aritmético é realizada em Rd. Se pb é igual a zero, a
saturação não é executada.
Operação:
Temp ←
Rd >> sa
se (sa !=
0)
Rnd =
Rd[sa-1]
Temp =
Temp + Rnd;
se ((Temp
== ZE( Temp[bp-1:0])) || (bp == 0) )
Rd ←
Temp;
senão
se
(Temp[31] == 1)
Rd ←
0x0000_0000;
senão
Rd ←
2bp - 1;
Sintaxe:
I.
satrndu Rd >> sa, bp
Operandos:
I.
d ∈ {0, 1, ..., 15} e {sa, bp} ∈ {0, 1, ..., 31}
SATS – Saturado com sinal
Descrição: Esta instrução considera o valor em (Rd >> SA
[bp-1: 0] como um valor com sinal se o valor em (Rd >> SA) [31:
BP] não é apenas um sinal de extensão desse valor, ocorre
transbordamento e a saturação é feita para o valor máximo do
positivo ou negativo. Se ocorrer a saturação, a bandeira Q é
elevada. Um deslocamento aritmético é realizada em Rd. Se pb é
igual a zero, a saturação não é executada.
Operação:
I. Temp ←
Rd >> sa
se ((Temp
== SE( Temp[bp-1:0])) || (bp == 0))
Rd ←
Temp;
senão
se
(Temp[31] == 1)
Rd ←
-2bp-1;
senão
Rd ←
2bp-1 - 1;
Sintaxe:
I. sats Rd >> sa, bp
Operandos:
I. d ∈ {0, 1, ..., 15}
{sa, bp}
∈ {0, 1, ..., 31}
SATU – Saturação sem sinal
Descrição: Esta instrução considera o valor em (Rd >> SA)
[bp-1: 0] como um valor sem sinal. Se o valor em (Rd >> sa)
[31: bp] não for meramente uma extensão deste valor de zero, não
ocorreu transbordamento e a saturação é feita para o máximo valor
positivo sem sinal ou zero. Se ocorrer a saturação, a bandeira Q é
elevada. Um deslocamento aritmético é realizada em Rd. Se pb é
igual a zero, saturação não é executada.
Operação:
I. Temp ←
Rd >> sa
se ((Temp
== ZE( Temp[bp-1:0])) || (bp == 0) )
Rd ←
Temp;
senão
se
(Temp[31] == 1)
Rd ←
0x0000_0000;
senão
Rd ←
2bp - 1;
Sintaxe:
I. satu Rd >> sa, bp
Operandos:
I. d ∈ {0, 1, ..., 15} e {sa, bp} ∈ {0, 1, ..., 31}
SUBHH.W– Subtrai meia palavras em palavra
Descrição:
Subtrai as duas meias palavras dos registradores
especificados e armazena a palavra resultante no registrador destino.
Os registradores de meias palavras são selecionados como parte alta
ou baixa do registrador operando.
Operação:
I. se (Rx-part == t) então operand1 = SE(Rx[31:16]) senão operand1
= SE(Rx[15:0]);
se
(Ry-part == t) então operand2 = SE(Ry[31:16]) senão operand2 =
SE(Ry[15:0]);
Rd ←
operand1 - operand2;
Sintaxe:
I. subhh.wRd, Rx:<part>, Ry:<part>
Operandos:
I. {d, x, y} ∈ {0, 1, ..., 15} / part ∈ {t,b}
MULSATHH.H – Multiplique Meia palavras com saturação em meia palavra
Descrição: Multiplica os dois registradores em meia palavra
especificado, desloca o resultado em uma posição à esquerda e
armazena o resultado em meia palavra com sinal extendido no
registrador destino em palavra. Se os dois operandos é igual a 1, o
resultado é saturado com o maior número fraccionário positivo de
16-bit. As meias palavras do registador são selecionados ou como a
parte alta ou baixa dos registradores operando.
Operação:
I. If (Rx-part == t) then operand1 = SE(Rx[31:16]) else operand1 =
SE(Rx[15:0]);
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
If
(operand1 == operand2 == 0x8000)
Rd ←
0x7FFF;
else
Rd ←
SE( (operand1 × operand2) >> 15 );
Sintaxe:
I.
mulsathh.h Rd, Rx:<part>, Ry:<part>
Operandos:
I. {d, x, y} ∈ {0, 1, ..., 15} / part ∈ {t,b}
MULSATHH.W – Multiplica as meias palavras com saturação em palavra
Descrição:
Multiplica os dois registadores em meia palavra especificado, muda os
resultados de uma posição para a esquerda e armazena o resultado no
registador destino em palavra. Se os dois operandos for igual a -1, o
resultado é saturado com o maior número fraccionário positivo de
32 bits. As meias palavras são registradores selecionados ou como a
parte alta ou baixa dos registrador operando.
Operação:
I. If (Rx-part == t) then operand1 = SE(Rx[31:16]) else operand1 =
SE(Rx[15:0]);
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
If
(operand1 == operand2 == 0x8000)
Rd ←
0x7FFF_FFFF;
else
Rd ←
(operand1 × operand2) << 1;
Sintaxe:
I.
mulsathh.w Rd, Rx:<part>, Ry:<part>
Operandos:
I.
{d, x, y} ∈ {0, 1, ..., 15}
/ part ∈ {t,b}
MULSATRNDHH.H – Multiplica as meias palavras com saturação e arredondamento em meia palavra
Descrição: Multiplica os dois registradores em meia palavra
especificado, muda o resultado de uma posição para a esquerda e
armazena o resultado no registador destino em palavra. Se os dois
operandos igual -1, o resultado é saturado com o maior número
fraccionário positivo de 16-bit. As meias palavras são
registradores selecionados ou como a parte alta ou baixa dos
registradores operando. O produto é arredondada.
Operação:
I.
If (Rx-part == t) then operand1 = SE(Rx[31:16]) else operand1 =
SE(Rx[15:0]);
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
If
(operand1 == operand2 == 0x8000)
Rd ←
0x7FFF;
else
Rd ←
SE( ((operand1 × operand2) + 0x4000 ) >> 15 );
Sintaxe:
I.
mulsatrndhh.h Rd, Rx:<part>, Ry:<part>
Operandos:
I.
{d, x, y} ∈ {0, 1, ..., 15}
/ part ∈ {t,b}
MULSATRNDWH.W – Multiplica a palavra e meia palavra com saturação e arredondamento em palavra
Descrição: Multiplica o registador em palavra com o registador em
meia palavra especificado, arredonda para cima o resultado de 32 bits
e o armazena no registador destino em palavra. O registo em meia
palavra é selecionado ou como parte alta ou baixa do registador Ry.
Uma vez que a parte mais significativa do produto é armazenado, não
irá ocorrer transbordamento. Se os dois operandos é igual a -1, o
resultado é saturado com o maior número fraccionário positivo de
32 bits.
Operação:
I.
operand1 = Rx;
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
If
((operand1 == 0x8000_0000) && (operand2 == 0x8000))
Rd ←
0x7FFF_FFFF;
else
Rd ←
SE( ((operand1 × operand2) + 0x4000 ) >> 15 );
Sintaxe:
I.
mulsatrndwh.w Rd, Rx, Ry:<part>
Operandos:
I.
{d, x, y} ∈ {0, 1, ..., 15}
/ part ∈ {t,b}
MULSATWH.W – Multiplica a palavra e meia palavra com saturação em palavra
Descrição: Multiplica o registador em palavra com o registador em
meia palavra especificado e armazena os 32 bits superiores resultante
no registador destino em palavra. O registrador em meia palavra é
selecionado ou como a parte alta ou baixa do registrador Ry. Uma vez
que a parte mais significativa do produto é armazenado, não
ocorrerá transbordamento. Se os dois operandos igual -1, o resultado
é saturado com o maior número fraccionário positivo de 32 bits.
Operação:
I.
operand1 = Rx;
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
If
((operand1 == 0x8000_0000) && (operand2 == 0x8000))
Rd ←
0x7FFF_FFFF;
else
Rd ←
(operand1 × operand2) >> 15;
Sintaxe:
I.
mulsatwh.w
Rd, Rx, Ry:<part>
Operandos:
I.
{d, x, y} ∈ {0, 1, ..., 15}
/ part ∈ {t,b}
MACSATHH.W – Multiplica e acumula meia palavras com saturação em palavra
Descrição: Multiplica dois registadores em meia palavra
especificados, desloca os resultados de uma posição para a esquerda
e armazena temporariamente o produto do resultado com o tamanho em
palavra. Se os dois operandos forem igual a -1, o produto é saturado
com o maior número fraccionário positivo de 32 bits. As meias
palavras são registradores selecionados ou como a parte alta ou
baixa dos registradores operando. O produto temporário é somado com
saturação ao registador Rd.
Operação:
I. If (Rx-part == t) then operand1 = SE(Rx[31:16]) else operand1 =
SE(Rx[15:0]);
If
(Ry-part == t) then operand2 = SE(Ry[31:16]) else operand2 =
SE(Ry[15:0]);
If
(operand1 == operand2 == 0x8000)
product ←
0x7FFF_FFFF;
else
product ←
(operand1 × operand2) << 1;
Rd ←
Sat(product + Rd);
Sintaxe:
I. macsathh.w Rd, Rx:<part>, Ry:<part>
Operandos:
I. {d, x, y} ∈ {0, 1, ..., 15} / part ∈ {t,b}
Nenhum comentário:
Postar um comentário