Múltiplos Dados Simples Instruções

Não são implementados nos microcontroladores UC3. São 29 instruções disponíveis a saber:

PABS.{SB/SH} – empacota o valor absoluto

Descrição: Calcula os valores absolutos de quatro bytes com sinal empacotados (pabs.sb) ou duas meias palavras com sinal empacotado (pabs.sh) da registrador fonte e armazenar os resultados como bytes empacotados ou meias palavras no registrador destino.

Operação: I. Rd[31:24] ← | Rs[31:24] |; Rd[23:16] ← | Rs[23:16] |;

Rd[15:8] ← | Rs[15:8] |; Rd[7:0] ← | Rs[7:0] |;

II. Rd[31:16] ← | Rs[31:16] |;

Rd[15:0] ← | Rs[15:0] |;

Sintaxe: I. pabs.sb Rd, Rs

II. pabs.sh Rd, Rs

Operandos: I, II. {d, s} ∈ {0, 1, ..., 15} 

PACKSH.{UB/SB} – empacota bytes em meia palavra com sinal

Descrição: Coloca os quatro meias palavras com sinal localizados nos dois registradores fonte em quatro bytes no registrador destino. Cada uma das meias palavras com sinal são byte saturados sem sinal (packsh.ub) ou com sinal (packsh.sb).

Operação: I. Rd[31:24] ← SATSU(Rx[31:16], 8); Rd[23:16] ← SATSU(Rx[15:0], 8);

Rd[15:8] ← SATSU(Ry[31:16], 8); Rd[7:0] ← SATSU(Ry[15:0], 8);

II. Rd[31:24] ← SATS(Rx[31:16], 8); Rd[23:16] ← SATS(Rx[15:0], 8);

Rd[15:8] ← SATS(Ry[31:16], 8); Rd[7:0] ← SATS(Ry[15:0], 8);

Sintaxe: I. packsh.ub

II. packsh.sb

Rd, Rx, Ry

Rd, Rx, Ry

Operandos: I, II. {d, x, y} ∈ {0, 1, ..., 15}

PACKSH.{UB/SB} – empacota bytes em meia palavra com sinal

Descrição: Coloca os quatro meias palavras com sinal localizados nos dois registradores fonte em quatro bytes no registrador destino. Cada uma das meias palavras com sinal são byte saturados sem sinal (packsh.ub) ou com sinal (packsh.sb).

Operação: I. Rd[31:24] ← SATSU(Rx[31:16], 8); Rd[23:16] ← SATSU(Rx[15:0], 8);

Rd[15:8] ← SATSU(Ry[31:16], 8); Rd[7:0] ← SATSU(Ry[15:0], 8);

II. Rd[31:24] ← SATS(Rx[31:16], 8); Rd[23:16] ← SATS(Rx[15:0], 8);

Rd[15:8] ← SATS(Ry[31:16], 8); Rd[7:0] ← SATS(Ry[15:0], 8);

Sintaxe: I. packsh.ub

II. packsh.sb

Rd, Rx, Ry

Rd, Rx, Ry

Operandos: I, II. {d, x, y} ∈ {0, 1, ..., 15} 

PACKW.SH – Empacote as palavras com sinal palavras

Descrição: Empacota as duas palavras apresentadas no registrador fonte em dois meias palavras no registo de destino. Cada uma das palavras são saturados de meia palavras com sinal antes de serem empacotadas.

Operação: I. Rd[31:16] ← SATS(Rx, 16);

Rd[15:0] ← SATS(Ry, 16);

Sintaxe: I. packw.sh Rd, Rx, Ry

Operandos: I. {d, x, y} ∈ {0, 1, ..., 15} 

PADD.{B/H} – Empacota a adição

Descrição: Executa a adição de quatro pares de bytes empacotados (padd.b) ou dois pares de meias palavras (padd.h). Após transbordamento quaisquer bits adicionais são descartadas e o resultado é embrulhado em torno de si.

Operação: I. Rd[31:24] ← Rx[31:24] + Ry[31:24]; Rd[23:16] ← Rx[23:16] + Ry[23:16];

Rd[15:8] ← Rx[15:8] + Ry[15:8]; Rd[7:0] ← Rx[7:0] + Ry[7:0];

II. Rd[31:16] ← Rx[31:16] + Ry[31:16];

Rd[15:0] ← Rx[15:0] + Ry[15:0];

Sintaxe: I. padd.b

II. padd.h Rd, Rx, Ry Rd, Rx, Ry

Operandos: I, II. {d, x, y} ∈ {0, 1, ..., 15} 

PADDH.{UB/SH} – Empacota: Adição com Reduzir para metade

Descrição: Realizar adição de quatro pares de bytes sem sinal empacotados (paddh.ub) ou dois pares de meias palavras embalados assinados (paddh.sh) com uma redução para metade do resultado para evitar transbordamentos ocorram.

Operação: I. Rd[31:24] ← LSR(ZE(Rx[31:24], 9) + ZE(Ry[31:24], 9), 1) ;

Rd[23:16] ← LSR(ZE(Rx[23:16], 9) + ZE(Ry[23:16], 9), 1);

Rd[15:8] ← LSR(ZE(Rx[15:8], 9) + ZE(Ry[15:8], 9), 1);

Rd[7:0] ← LSR(ZE(Rx[7:0], 9) + ZE(Ry[7:0], 9), 1);

II. Rd[31:16] ← ASR(SE(Rx[31:16], 17) + SE(Ry[31:16], 17), 1);

Rd[15:0] ← ASR(SE(Rx[15:0], 17) + SE(Ry[15:0], 17), 1);

Sintaxe: I. paddh.ub

II. paddh.sh Rd, Rx, Ry Rd, Rx, Ry

Operandos:

I, II. {d, x, y} ∈ {0, 1, ..., 15} 

PADDS.{UB/SB/UH/SH} – Adição Embalado com saturação

Descrição: Executar a adição de quatro pares de bytes empacotados ou dois pares de meias palavras. O resultado é saturado de tanto bytes sem sinal (padds.ub), bytes assinados (padds.sb), meia palavra não assinada (padds.uh) ou meia palavra com sinal meias palavras (padds.sh).

Operação: I.

Rd[31:24] ← SATU(ZE(Rx[31:24], 9) + ZE(Ry[31:24], 9), 8) ;

Rd[23:16] ← SATU(ZE(Rx[23:16], 9) + ZE(Ry[23:16], 9), 8);

Rd[15:8] ← SATU(ZE(Rx[15:8], 9) + ZE(Ry[15:8], 9), 8);

Rd[7:0] ← SATU(ZE(Rx[7:0], 9) + ZE(Ry[7:0], 9), 8);

II.

Rd[31:24] ← SATS(SE(Rx[31:24], 9) + SE(Ry[31:24], 9), 8);

Rd[23:16] ← SATS(SE(Rx[23:16], 9) + SE(Ry[23:16], 9), 8);

Rd[15:8] ← SATS(SE(Rx[15:8], 9) + SE(Ry[15:8], 9), 8);

Rd[7:0] ← SATS(SE(Rx[7:0], 9) + SE(Ry[7:0], 9), 8);

III.

Rd[31:16] ← SATU(ZE(Rx[31:16], 17) + ZE(Ry[31:16], 17), 16);

Rd[15:0] ← SATU(ZE(Rx[15:0], 17) + ZE(Ry[15:0], 17), 16);

IV.

Rd[31:16] ← SATS(SE(Rx[31:16], 17) + SE(Ry[31:16], 17), 16);

Rd[15:0] ← SATS(SE(Rx[15:0], 17) + SE(Ry[15:0], 17), 16);

Sintaxe: I. padds.ub

II. padds.sb

III. padds.uh

IV. padds.sh

Rd, Rx, Ry

Rd, Rx, Ry

Rd, Rx, Ry

Rd, Rx, Ry

Operandos: I, II, III, IV.{d, x, y} ∈ {0, 1, ..., 15} 

PADDSUB.H – Empacota meia palavra com adição e subtração

Descrição: Realizar uma adição e subtração com os mesmos meia palavra operandos que são selecionados a partir dos registradores de origem. Os dois resultados de meia palavra são empacotados no registrador de destino sem realizar qualquer saturação.

Operação: I. If (Rx-part == t) then operand1 = Rx[31:16] else operand1 = Rx[15:0];

If (Ry-part == t) then operand2 = Ry[31:16] else operand2 = Ry[15:0];

Rd[31:16] ← operand1 + operand2;

Rd[15:0] ← operand1 - operand2;

Sintaxe: I. paddsub.h Rd, Rx:<part>, Ry:<part>

Operandos: I. {d, x, y} ∈ {0, 1, ..., 15} / part ∈ {t,b} 

PADDSUBH.SH – Empacota meia palavra com adição e subtração e com redução pela metade

Descrição: Realizar uma adição e subtração com os mesmos operandos em meia palavra com sinal que são selecionados a partir dos registradores de origem. Os resultados em meias palavras são reduzidos pela metade, a fim de evitar que ocorram excessos.

Operação: I. If (Rx-part == t) then operand1 = Rx[31:16] else operand1 = Rx[15:0];

If (Ry-part == t) then operand2 = Ry[31:16] else operand2 = Ry[15:0];

Rd[31:16] ← ASR(SE(operand1, 17) + SE(operand2, 17), 1);

Rd[15:0] ← ASR(SE(operand1, 17) - SE(operand2, 17), 1);

Sintaxe: I. paddsubh.sh Rd, Rx:<part>, Ry:<part>

Operandos: I. {d, x, y} ∈ {0, 1, ..., 15} / part ∈ {t,b} 

PADDSUBS.{UH/SH} – Empacota a meia palavra da adição e subtração com saturação

Descrição: Realizar uma adição e subtração com os mesmos operandos em meia palavra que são selecionados a partir dos registradores de origem. As meias palavras resultantes estão saturados sem sinal (paddsubs.uh) ou meias palavras com sinal (paddsubs.sh) e em seguida empacotadas em conjunto no registrador destino.

Operação: I. If (Rx-part == t) then operand1 = Rx[31:16] else operand1 = Rx[15:0];

If (Ry-part == t) then operand2 = Ry[31:16] else operand2 = Ry[15:0];

Rd[31:16] ← SATU(ZE(operand1, 17) + ZE(operand2, 17), 16);

Rd[15:0] ← SATSU(ZE(operand1, 17) - ZE(operand2, 17), 16);

II. If (Rx-part == t) then operand1 = Rx[31:16] else operand1 = Rx[15:0];

If (Ry-part == t) then operand2 = Ry[31:16] else operand2 = Ry[15:0];

Rd[31:16] ← SATS(SE(operand1, 17) + SE(operand2, 17), 16);

Rd[15:0] ← SATS(SE(operand1, 17) - SE(operand2, 17), 16);

Sintaxe: I. paddsubs.uh

II. paddsubs.sh Rd, Rx:<part>, Ry:<part> Rd, Rx:<part>, Ry:<part>

Operandos: I,II. {d, x, y} ∈ {0, 1, ..., 15} / part ∈ {t,b} 

PADDX.H – Empacota meia palavra da adição com Operando cruzados

Descrição: Soma a metade superior da palavra em Rx com a metade inferior da palavra em Ry e a metade inferior da palavra em Rx com a metade superior palavra em Ry. As meias palavras resultantes são empacotadas em conjunto no registrador destino sem realizar qualquer saturação.

Operação: I. Rd[31:16] ← Rx[31:16] + Ry[15:0] ;

Rd[15:0] ← Rx[15:0] + Ry[31:16];

Sintaxe: I. paddx.h Rd, Rx, Ry

Operandos: I. {d, x, y} ∈ {0, 1, ..., 15} 

PADDXH.SH – Empacota a adição de meias palavras com sinal, com Operando cruzados e Redução pela metade

Descrição: Soma a metade superior da palavra em Rx com a metade inferior da palavra em Ry e a metade inferior da palavra em Rx com a metade superior da palavra em Ry. As meias palavras resultantes são reduzidos pela metade, de modo a evitar qualquer transbordamento e, em seguida, empacotadas em conjunto no registrador destino.

Operação: I. Rd[31:16] ← ASR(SE(Rx[31:16], 17) + SE(Ry[15:0], 17), 1);

Rd[15:0] ← ASR(SE(Rx[15:0], 17) + SE(Ry[31:16], 17), 1);

Sintaxe: I. paddxh.sh Rd, Rx, Ry

Operandos: I. {d, x, y} ∈ {0, 1, ..., 15}

PADDXS.{UH/SH} – Empacota a adição de meias palavras com o operando cruzados e saturação

Descrição: Soma a metade superior da palavra em Rx com a metade inferior da palavra em Ry e a metade inferior da palavra e Rx com a metade superior palavra em Ry. Resultando em meias palavras saturadas sem sinal (paddxh.uh) ou palavras meias assinados (paddxh.sh) e em seguida empacotadas em conjunto no registrador destino.

Operação: I. Rd[31:16] ← SATU(ZE(Rx[31:16], 17) + ZE(Ry[15:0], 17), 16) ;

Rd[15:0] ← SATU(ZE(Rx[15:0], 17) + ZE(Ry[31:16], 17), 16);

II. Rd[31:16] ← SATS(SE(Rx[31:16], 17) + SE(Ry[15:0], 17), 16) ;

Rd[15:0] ← SATS(SE(Rx[15:0], 17) + SE(Ry[31:16], 17), 16);

Sintaxe: I. paddxs.uh

II. paddxs.sh

Rd, Rx, Ry

Rd, Rx, Ry

Operandos: I, II. {d, x, y} ∈ {0, 1, ..., 15} 

PASR.{B/H} – Empacota o deslocamento aritmética à direita

Descrição: Realizar um deslocamento aritmético à direita em cada um dos bytes empacotados ou palavras meia no registador fonte.

Operação: I. Rd[31:24] ← ASR(Rs[31:24], sa3);

Rd[23:16] ← ASR(Rs[23:16], sa3);

Rd[15:8] ← ASR(Rs[15:8], sa3);

Rd[7:0] ← ASR(Rs[7:0], sa3);

II. Rd[31:16] ← ASR(Rs[31:16], sa4);

Rd[15:0] ← ASR(Rs[15:0], sa4);

Sintaxe: I. pasr.b

II. pasr.h

Rd, Rs, sa

Rd, Rs, sa

Operandos: I, II. {d, s} ∈ {0, 1, ..., 15}

I. sa ∈ {0, 1, ..., 7}

II. sa ∈ {0, 1, ..., 15} 

PAVG.{UB/SH} – empacota a média

Descrição: Calcula a média dos pares de bytes empacotados sem sinal (pavg.ub) ou meias palavras empacotados com sinal (pavg.sh). As médias são calculadas adicionando dois valores ao mesmo tempo, a adição de um fator de arredondamento no bit menos significativo. O resultado é então reduzido pela metade, deslocando-se uma posição à direita.

Operação: I. Rd[31:24] ← LSR(ZE(Rx[31:24], 9) + ZE(Ry[31:24], 9) + 1, 1);

Rd[23:16] ← LSR(ZE(Rx[23:16], 9) + ZE(Ry[23:16], 9) + 1, 1);

Rd[15:8] ← LSR(ZE(Rx[15:8], 9) + ZE(Ry[15:8], 9) + 1, 1);

Rd[7:0] ← LSR(ZE(Rx[7:0], 9) + ZE(Ry[7:0], 9) + 1, 1);

II. Rd[31:16] ← ASR(SE(Rx[31:16], 17) + SE(Ry[31:16], 17) + 1, 1);

Rd[15:0] ← ASR(SE(Rx[15:0], 17) + SE(Ry[15:0], 17) + 1, 1);

Sintaxe: I. pavg.ub

II. pavg.sh

Rd, Rx, Ry

Rd, Rx, Ry

Operandos: I, II. {d, x, y} ∈ {0, 1, ..., 15} 

PLSL.{B/H} – empacota o deslocamento lógico a esquerda

descrição: realizar um deslocamento lógico à direita em cada um dos bytes empacotados ou meias palavras e armazena os resultados nos respectivos registadores destinos.

Operação: I. Rd[31:24] ← LSL(Rs[31:24], sa3);

Rd[23:16] ← LSL(Rs[23:16], sa3);

Rd[15:8] ← LSL(Rs[15:8], sa3);

Rd[7:0] ← LSL(Rs[7:0], sa3);

II. Rd[31:16] ← LSL(Rs[31:16], sa4);

Rd[15:0] ← LSL(Rs[15:0], sa4);

Sintaxe: I. plsl.b

II. plsl.h

Rd, Rs, sa

Rd, Rs, sa

Operandos: I, II. {d, s} ∈ {0, 1, ..., 15}

I. sa ∈ {0, 1, ..., 7}

II. sa ∈ {0, 1, ..., 15} 

PLSR.{B/H} – empacota o deslocamento lógico a direita

descrição: realizar um deslocamento lógico à direita em cada um dos bytes empacotados ou meias palavras e armazena os resultados nos respectivos registadores destinos.

Sintaxe: I. plsr.b

II. plsr.h

Rd, Rs, sa

Rd, Rs, sa

Operandos: I, II. {d, s} ∈ {0, 1, ..., 15}

I. sa ∈ {0, 1, ..., 7}

II. sa ∈ {0, 1, ..., 15} 

PMAX.{UB/SH} – Empacota o valor máximo

Descrição: Calcule os valores máximos dos pares de bytes empacotados sem sinal (pmax.ub) ou meias palavras empacotadas com sinal (pmax.sh).

Operação: I. If ( Rx[31:24] > Ry[31:24] ) then Rd[31:24] ← Rx[31:24] else Rd[31:24] ← Ry[31:24] ;

If ( Rx[23:16] > Ry[23:16] ) then Rd[23:16] ← Rx[23:16] else Rd[23:16] ← Ry[23:16] ;

If ( Rx[15:8] > Ry[15:8] ) then Rd[15:8] ← Rx[15:8] else Rd[15:8] ← Ry[15:8] ;

If ( Rx[7:0] > Ry[7:0] ) then Rd[7:0] ← Rx[7:0] else Rd[7:0] ← Ry[7:0] ;

II. If ( Rx[31:16] > Ry[31:16] ) then Rd[31:16] ← Rx[31:16] else Rd[31:16] ← Ry[31:16] ;

PMIN.{UB/SH} – Empacota o valor mínimo

Descrição: Calcule os valores mínimos dos pares de bytes empacotados sem sinal (pmin.ub) ou meias palavras empacotas sem sinal (pmin.sh).

Operação: I. If ( Rx[31:24] < Ry[31:24] ) then Rd[31:24] ← Rx[31:24] else Rd[31:24] ← Ry[31:24] ;

If ( Rx[23:16] < Ry[23:16] ) then Rd[23:16] ← Rx[23:16] else Rd[23:16] ← Ry[23:16] ;

If ( Rx[15:8] < Ry[15:8] ) then Rd[15:8] ← Rx[15:8] else Rd[15:8] ← Ry[15:8] ;

If ( Rx[7:0] < Ry[7:0] ) then Rd[7:0] ← Rx[7:0] else Rd[7:0] ← Ry[7:0] ;

II. If ( Rx[31:16] < Ry[31:16] ) then Rd[31:16] ← Rx[31:16] else Rd[31:16] ← Ry[31:16] ;

If ( Rx[15:0] < Ry[15:0] ) then Rd[15:0] ← Rx[15:0] else Rd[15:0] ← Ry[15:0] ;

Sintaxe: I. pmin.ub

Rd, Rx, Ry

II. pmin.sh

Rd, Rx, Ry

Operandos: I, II. {d, x, y} ∈ {0, 1, ..., 15} 

PSAD – empacota a diferença absoluta da soma

Descrição: Calcule a soma absoluta das diferenças (SAD) de quatro pares de bytes empacotados sem sinal a partir dos registradores de origem e armazena o resultado no registrador de destino.

Operação: I. Rd ← | Rx[31:24] - Ry[31:24] | + | Rx[23:16] - Ry[23:16] | +

| Rx[15:8] - Ry[15:8] | + | Rx[7:0] - Ry[7:0] |;

Sintaxe: I. psad

Rd, Rx, Ry

Operandos: I, II. {d, x, y} ∈ {0, 1, ..., 15} 

PSUB.{B/H} – empacota a subtração

Descrição: Realizar a subtração de quatro pares de bytes empacotados (psub.b) ou dois pares de meias palavras (psub.h). Após são descartados o estouro adicional em qualquer bit e o resultado é enrolado.

Operação: I. Rd[31:24] ← Rx[31:24] - Ry[31:24]; Rd[23:16] ← Rx[23:16] - Ry[23:16];

Rd[15:8] ← Rx[15:8] - Ry[15:8]; Rd[7:0] ← Rx[7:0] - Ry[7:0];

II. Rd[31:16] ← Rx[31:16] - Ry[31:16];

Rd[15:0] ← Rx[15:0] - Ry[15:0];

Sintaxe: I. psub.b

II. psub.h

Rd, Rx, Ry

Rd, Rx, Ry

Operandos: I, II. {d, x, y} ∈ {0, 1, ..., 15} 

PSUBADD.H – Empacota a meia palavra da subtração e adição

Descrição: Realizar uma subtração e adição em meia palavra nos mesmos operandos que são selecionados a partir dos registrador de origem. Os dois meias palavras resultantes são empacotados no registrador destino sem realizar qualquer saturação.

Operação: I. If (Rx-part == t) then operand1 = Rx[31:16] else operand1 = Rx[15:0];

If (Ry-part == t) then operand2 = Ry[31:16] else operand2 = Ry[15:0];

Rd[31:16] ← operand1 - operand2;

Rd[15:0] ← operand1 + operand2;

Sintaxe: I. psubadd.h

Rd, Rx:<part>, Ry:<part>

Operandos: I. {d, x, y} ∈ {0, 1, ..., 15} / part ∈ {t,b} 

PSUBADDH.SH – Empacota subtração de meia palavra com sinal e adição com redução à metade

Descrição: Realiza uma subtração e adição nos mesmos operandos meia palavra que são selecionados a partir dos registrores de origem. Os resultados em meia palavra são reduzidos pela metade a fim de evitar que ocorram em excessos.

Operação: I. If (Rx-part == t) then operand1 = Rx[31:16] else operand1 = Rx[15:0];

If (Ry-part == t) then operand2 = Ry[31:16] else operand2 = Ry[15:0];

Rd[31:16] ← ASR(SE(operand1, 17) - SE(operand2, 17), 1);

Rd[15:0] ← ASR(SE(operand1, 17) + SE(operand2, 17), 1);

Sintaxe: I. psubaddh.sh

Rd, Rx:<part>, Ry:<part>

Operandos: I. {d, x, y} ∈ {0, 1, ..., 15} / part ∈ {t,b} 

PSUBADDS.{UH/SH} – Empacota a subtração de meia palavra e adição com saturação

Descrição: Realizar uma subtração e adição nos mesmos operandos em meia palavra que são selecionados a partir dos registrores de origem. As meias palavras resultantes estão saturados sem sinal (psubadds.uh) ou meias palavras com sinal (psubadds.sh) e, em seguida, empacotado em conjunto no registrador destino.

Operação: I. If (Rx-part == t) then operand1 = Rx[31:16] else operand1 = Rx[15:0];

If (Ry-part == t) then operand2 = Ry[31:16] else operand2 = Ry[15:0];

Rd[31:16] ← SATSU(ZE(operand1, 17) - ZE(operand2, 17), 16);

Rd[15:0] ← SATU(ZE(operand1, 17) + ZE(operand2, 17), 16);

II. If (Rx-part == t) then operand1 = Rx[31:16] else operand1 = Rx[15:0];

If (Ry-part == t) then operand2 = Ry[31:16] else operand2 = Ry[15:0];

Rd[31:16] ← SATS(SE(operand1, 17) - SE(operand2, 17), 16 );

Rd[15:0] ← SATS(SE(operand1, 17) + SE(operand2, 17), 16);

Sintaxe: I. psubadds.uh

II. psubadds.sh

Rd, Rx:<part>, Ry:<part>

Rd, Rx:<part>, Ry:<part>

Operands: I. {d, x, y} ∈ {0, 1, ..., 15} / part ∈ {t,b} 

PSUBH.{UB/SH} – Empacota a subtração com redução à metade

Descrição: Realiza a subtração de quatro pares de bytes sem sinal empacotados (psub.ub) ou dois pares de meias palavras com sinal (psub.sh) com redução à metade do resultado para evitar que ocorram transbordamentos.

Operação: I. Rd[31:24] ← LSR(ZE(Rx[31:24], 9) - ZE(Ry[31:24], 9), 1);

Rd[23:16] ← LSR(ZE(Rx[23:16], 9) - ZE(Ry[23:16], 9), 1);

Rd[15:8] ← LSR(ZE(Rx[15:8], 9) - ZE(Ry[15:8], 9), 1);

Rd[7:0] ← LSR(ZE(Rx[7:0], 9) - ZE(Ry[7:0], 9), 1);

II. Rd[31:16] ← ASR(SE(Rx[31:16], 17) - SE(Ry[31:16], 17), 1);

Rd[15:0] ← ASR(SE(Rx[15:0], 17) - SE(Ry[15:0], 17), 1);

Sintaxe: I. psubh.ub

II. psubh.sh

Rd, Rx, Ry

Rd, Rx, Ry

Operandos: I, II. {d, x, y} ∈ {0, 1, ..., 15} 

PSUBS.{UB/SB/UH/SH} – Empacota a subtração com saturação

Descrição: Executa a subtração de quatro pares de bytes empacotados ou dois pares de meias palavras. O resultado é saturado em bytes sem sinal (psubs.ub), bytes com sinal (psubs.sb), meia palavra sem sinal (psubs.uh) ou meia palavra sem sinal (psubs.sh).

Operação: I. Rd[31:24] ← SATSU(ZE(Rx[31:24], 9) - ZE(Ry[31:24], 9), 8) ;

Rd[23:16] ← SATSU(ZE(Rx[23:16], 9) - ZE(Ry[23:16], 9), 8);

Rd[15:8] ← SATSU(ZE(Rx[15:8], 9) - ZE(Ry[15:8], 9), 8);

Rd[7:0] ← SATSU(ZE(Rx[7:0], 9) - ZE(Ry[7:0], 9), 8);

II. Rd[31:24] ← SATS(SE(Rx[31:24], 9) - SE(Ry[31:24], 9), 8);

Rd[23:16] ← SATS(SE(Rx[23:16], 9) - SE(Ry[23:16], 9), 8);

Rd[15:8] ← SATS(SE(Rx[15:8], 9) - SE(Ry[15:8], 9), 8);

Rd[7:0] ← SATS(SE(Rx[7:0], 9) - SE(Ry[7:0], 9), 8);

III. Rd[31:16] ← SATSU(ZE(Rx[31:16], 17) - ZE(Ry[31:16], 17), 16);

Rd[15:0] ← SATSU(ZE(Rx[15:0], 17) - ZE(Ry[15:0], 17), 16);

IV. Rd[31:16] ← SATS(SE(Rx[31:16], 17) - SE(Ry[31:16], 17), 16);

Rd[15:0] ← SATS(SE(Rx[15:0], 17) - SE(Ry[15:0], 17), 16);

Sintaxe: I. psubs.ub

Rd, Rx, Ry

II. psubs.sb

Rd, Rx, Ry

III. psubs.uh

Rd, Rx, Ry

IV. psubs.sh

Rd, Rx, Ry

Operandos: I, II, III, IV.{d, x, y} ∈ {0, 1, ..., 15} 

PSUBX.H – Embalado meia palavra subtração com operando cruzados

Descrição: Subtrai a metade inferior da palavra em Ry com a metade superior palavra em Rx e a metade superior palavra em Ry com a da metade inferior da palavra em Rx. As meias palavras resultantes são embalados juntas no registrador de destino sem realizar qualquer saturação.

Operação: I. Rd[31:16] ← Rx[31:16] - Ry[15:0] ;

Rd[15:0] ← Rx[15:0] - Ry[31:16];

Sintaxe: I. psubx.h

Rd, Rx, Ry

Operandos: I. {d, x, y} ∈ {0, 1, ..., 15} 

PSUBXH.SH – embala a subtração com sinal das meias palavras com Operando cruzados e redução a metade

Descrição: Subtraia a metade inferior da palavra em Ry com a metade superior da palavra em Rx e a metade superior da palavra em Ry com a metade inferior da palavra em Rx. As meias palavras resultantes são reduzidos a metade, de modo a evitar qualquer transbordamento e, em seguida, embalados em conjunto no registrador de destino.

Operação: I. Rd[31:16] ← ASR(SE(Rx[31:16], 17) - SE(Ry[15:0], 17), 1);

Rd[15:0] ← ASR(SE(Rx[15:0], 17) - SE(Ry[31:16], 17), 1);

Sintaxe: I. psubxh.sh

Rd, Rx, Ry

Operandos: I. {d, x, y} ∈ {0, 1, ..., 15} 

PSUBXS.{UH/SH} – Empacota a subtração das meias palavras com operandos cruzados e saturação

Descrição: Subtrai a metade inferior da meia palavra em Ry com a metade superior da palavra em Rx e metade superior da palavra em Ry com a metade inferior da palavra em Rx. As meias palavras resultantes estão saturadas na meia palavra sem sinal (psubxh.uh) ou na meia palavra com sinal (psubxh.sh) e em seguida embalados em conjunto no registrador destino.

Operação: I. Rd[31:16] ← SATSU(ZE(Rx[31:16], 17) - ZE(Ry[15:0], 17), 16) ;

Rd[15:0] ← SATSU(ZE(Rx[15:0], 17) - ZE(Ry[31:16], 17), 16);

II. Rd[31:16] ← SATS(SE(Rx[31:16], 17) - SE(Ry[15:0], 17), 16) ;

Rd[15:0] ← SATS(SE(Rx[15:0], 17) - SE(Ry[31:16], 17), 16);

Sintaxe: I. psubxs.uh

II. psubxs.sh

Rd, Rx, Ry

Rd, Rx, Ry

Operandos: I, II. {d, x, y} ∈ {0, 1, ..., 15} 

PUNPCK{SB/UB}.H – descompacta um byte em duas meia palavras

Descrição: Descompacta dois bytes sem sinal (punpckub.h) ou dois bytes com sinal (punpcksb.h) do registador fonte para duas meia palavras embaladas no registrador destino.

Operação: I. se ( Rs-part == top ) então

Rd[31:16] ← ZE(Rs[31:24], 16); Rd[15:0] ← ZE(Rs[23:16], 16);

senão

Rd[31:16] ← ZE(Rs[15:8], 16); Rd[15:0] ← ZE(Rs[7:0], 16);

II. se ( Rs-part == top ) então

Rd[31:16] ← SE(Rs[31:24], 16); Rd[15:0] ← SE(Rs[23:16], 16);

senão

Rd[31:16] ← SE(Rs[15:8], 16); Rd[15:0] ← SE(Rs[7:0], 16);

Sintaxe: I. punpckub.h

II. punpcksb.h

Rd, Rs:<part>

Rd, Rs:<part>

Operandos: I, II. {d, s} ∈ {0, 1, ..., 15} / part ∈ {t, b} 

If ( Rx[15:0] > Ry[15:0] ) then Rd[15:0] ← Rx[15:0] else Rd[15:0] ← Ry[15:0] ;

Sintaxe: I. pmax.ub Rd, Rx, Ry

II. pmax.sh Rd, Rx, Ry

Operandos: I, II. {d, x, y} ∈ {0, 1, ..., 15}