Rápido saturar e deslocamento dois meias palavras em ARM asm

Question

Eu tenho dois assinado valores de 16 bits em uma palavra de 32 bits, e eu preciso transferi-los para a direita (dividir) em valor constante (que pode ser de 1 a 6) e saturar a byte (0..0xFF) .

Por exemplo,

• 0x FFE1 00AA com Shift = 5 deve tornar-se 0x 0000 0005 ;
• 0x 2345 1234 deve tornar-se 0x 00FF 0091

Eu estou tentando saturar os valores ao mesmo tempo, algo como isto pseudo-código:

AND RT, R0, 0x80008000; - mask high bits to get negatives
ORR RT, RT, LSR #1
ORR RT, RT, LSR #2
ORR RT, RT, LSR #4
ORR RT, RT, LSR #8; - now its expanded signs in each halfword
MVN RT, RT
AND R0, RT; now negative values are zero
; here something to saturate high overflow and shift after

mas o código que eu tenho é muito feio e lento. :) A melhor coisa (mais rápido) que tenho agora é a saturação separada de cada semestre, como este:

MOV RT, R0, LSL #16
MOVS RT, RT, ASR #16+5
MOVMI RT, #0
CMP RT, RT, #256
MOVCS RT, #255
MOVS R0, R0, ASR #16+5
MOVMI R0, #0
CMP R0, R0, #256
MOVCS R0, #255
ORR R0, RT, R0, LSL #16

Mas é 10 ciclos. :( Pode ser mais rápido?

P.S .: Mais tarde eu descobri instrução USAT16 para isso, mas é apenas para ARMv6. E eu preciso de código para o trabalho em ARMv5TE e ARMv4.

---

Editar: agora eu reescrever meu primeiro código:

ANDS RT, 0x10000, R0 << 1;      // 0x10000 is in register. Sign (HI) moves to C flag, Sign (LO) is masked
SUBNE RT, RT, 1;            // Mask LO with 0xFFFF if it's negative
SUBCS RT, RT, 0x10000;      // Mask HI with 0xFFFF if it's negative
BIC R0, R0, RT;         // Negatives are 0 now. The mask can be used as XOR too
TST R0, 0xE0000000;         // check HI overflow             
ORRNE R0, R0, 0x1FE00000        // set HI to 0xFF (shifted) if so
TST R0, 0x0000E000          // check LO overflow             
ORRNE R0, R0, 0x00001FE0        // set LO to 0xFF if so          
AND R0, 0x00FF00FF, R0 >> 5;    // 0x00FF00FF is in register     

mas não é bonito.

Answer 1

Foi uma boa idéia usar um cheque de sinalizadores definidos para duas operações. Mas eu não posso fazer isso por segunda parte. Eu posso fazer outra coisa :) Aqui está variante universal para usar com qualquer mudança de 1 a 6:

;prepare:
MOV RMask, ((0xFF00 << shift) & 0xFF00) << 16;  Mask overflow bits
MOV R_0xFF00FF, 0xFF;
ORR R_0xFF00FF, 0xFF000000;
;...
; innerloop:
;....
TST R0, RMask, R0 << 16;            Set flags for LO half
ORRNE R0, R0, 0xFF << shift;        It is overflow. First try positive
BICMI R0, R0, 0xFF << shift;        Fix it if negative. LO half is ready
TST R0, RMask, R0;              Set flags for HI half. Can TST R0, R0, #Mask also
ORRNE R0, R0, 0xFF << (shift+16)
BICNE R0, R0, 0xFF << (shift+16)
AND R0, R_0xFF00FF, R0 >> shift;        Shift and mask

Por isso é 7 ciclos agora. :)

Pode ser melhor?

---

Editar: parece com estouros são suficientes raro, por isso é uma boa idéia para adicionar algo como isto:

TST R0, 0xE000E000
BEQ no_saturation_needed
... ; saturation ops here

Answer 2

O que você tem é quase tão bom como você vai fazer para o problema como indicado. Se você está fazendo isso para uma grande quantidade de dados em um loop apertado, e pode pagar alguns registros para máscaras de espera, você pode ser capaz de salvar um ciclo ou dois, mas não vai ser uma grande melhoria. Simplesmente não há grande apoio para este tipo de "pequeno-vetor" operação saturação em ARM antes da arquitetura v6.

Basicamente, a menos que este é o único gargalo no seu programa, é hora de colocar isso para longe e passar para a próxima hotspot.