assembly - raspberry - ¿Cómo enmascarar bytes en el ensamblaje de ARM?

ensamblador en raspberry pi

Question

Tengo una palabra de 32 bits (hexadecimal) 0xaabbccdd y tengo que cambiar el 2. y el 3. byte. al final debería parecerse a 0xaaccbbdd

¿Cómo puedo "enmascarar" el 2do y el 3er byte para cargarlos primero para registrar r1 yr2 y cambiarlos? También sé que tengo que trabajar con los comandos lsl e lsr pero no sé cómo comenzar.

perdón por mi mal inglés. ¡Espero que alguien pueda ayudarme!

saludos, sebastian

Answer 1

Debería usar punteros para intercambiar dos bytes

static union {
 BYTE   BBuf[4];
 WORD   WWBuf[2];
 DWORD  DWBuf;
}swap;

unsigned char *a;
unsigned char *b;
swap.DWBuf = 0xaabbccdd;

a = &swap.BBuf[1];
b = &swap.BBuf[2];

*a ^= *b;
*b ^= *a;
*a ^= *b;

Y ahora el resultado es

swap.DWbuf == 0xaaccbbdd;

Answer 2

Hmmm, no sé lo que pasó, presentó mi respuesta antes de que realmente comenzara.

Al principio no pensé que podría hacerlo con solo dos registros, pero luego decidí que podía hacerlo y lo hice. Estas soluciones son solo de registro, no tiene memoria (excepto la ldr r0, = que puede reemplazar con cuatro instrucciones). Si usa memoria y hmmm, dos registros, puede reducir el número de instrucciones, quizás, str, bic, bic, ldrb, orr lsl, ldrb, orr lsl. De acuerdo, lo hice en una instrucción menos, pero luego necesitas la ubicación de la memoria y las tiendas y los ciclos de costos de carga para la misma cantidad de memoria y más ciclos para que lo haga con la memoria. Alguien más puede tener algunos buenos trucos. Creo que algunos de los núcleos más nuevos tienen una instrucción de intercambio endian que lo haría aún más fácil.

.globl midswap
midswap:
    mov r2,r0,lsl #8      ;@ r2 = BBCCDDAA
    mov r3,r0,lsr #8      ;@ r3 = DDAABBCC (this might drag a sign bit, dont care)
    and r2,r2,#0x00FF0000 ;@ r2 = 00CC0000
    and r3,r3,#0x0000FF00 ;@ r3 = 0000BB00
    bic r0,r0,#0x00FF0000 ;@ r0 = AA00CCDD
    bic r0,r0,#0x0000FF00 ;@ r0 = AA0000DD
    orr r0,r0,r2          ;@ r0 = AACC00DD
    orr r0,r0,r3          ;@ r0 = AACCBBDD
    bx lr ;@ or mov pc,lr for older arm cores


.globl tworegs
tworegs:
    mov r2,r0,ror #8       ;@ r2 = DDAABBCC
    bic r2,r2,#0xFF000000  ;@ r2 = 00AABBCC
    bic r2,r2,#0x00FF0000  ;@ r2 = 0000BBCC
    orr r2,r2,ror #16      ;@ r2 = BBCCBBCC
    bic r2,r2,#0xFF000000  ;@ r2 = 00CCBBCC
    bic r2,r2,#0x000000FF  ;@ r2 = 00CCBB00
    bic r0,r0,#0x00FF0000  ;@ r0 = AA00CCDD
    bic r0,r0,#0x0000FF00  ;@ r0 = AA0000DD
    orr r0,r0,r2           ;@ r0 = AACCBBDD
    bx lr

testfun:
    ldr r0,=0xAABBCCDD
    bl midswap

Answer 3

En el pasado, solíamos confiar mucho en EOR para este tipo de engaños.

Puedes hacerlo en 4 ciclos.

Primero, necesitamos el hecho de que: A ^ (A ^ B) = B

Comenzamos con 0xAABBCCDD, y queremos 0xAACCBBDD. Para llegar allí, necesitamos 0x00EEEE00 ^ 0xAABBCCDD, donde EE = BB ^ CC.

Ahora, necesitamos unos ciclos para construir 00EEEE00:

eor     r1,r0,r0,lsr #8
and     r1,r1,#0xFF00
orr     r1,r1,r1,lsl #8
eor     r0,r0,r1

Cª:

t=x^(x>>8);
t=t&0xFF00;
t=t|(t<<8);
x^=t;

Después de cada línea, el resultado calculado es: comenzando con: AABBCCDD

eor  XXXXEEXX
and  0000EE00
orr  00EEEE00
eor  AACCBBDD

Esto funcionará en cualquier núcleo ARM de 32 bits.

Answer 4

¿Puedes usar BFI y UBFX para facilitar tu trabajo?

Answer 5

Esa no es una tarea sencilla en el ensamblaje de ARM porque no puede usar fácilmente las constantes de 32 bits. Debe dividir todas las operaciones que enmascaran los bytes para usar constantes de 8 bits cada una (también estas constantes se pueden rotar).

Enmascara los bytes 2 y 3 usando la instrucción AND y realiza el cambio más tarde. en ARM-assembler tiene la mayoría de las instrucciones de un turno de forma gratuita, por lo que el cambio de posición y la combinación con los otros bits a menudo terminan siendo una sola instrucción.

Aquí hay un código no probado que realiza el intercambio de bytes del medio (ARMv4, no el conjunto de instrucción de pulgar):

        .text

swap_v4:
        AND     R2, R0, #0x00ff0000     @ R2=0x00BB0000 get byte 2
        AND     R3, R0, #0x0000ff00     @ R3=0x0000CC00 get byte 1
        BIC     R0, R0, #0x00ff0000     @ R0=0xAA00CCDD clear byte 2
        BIC     R0, R0, #0x0000ff00     @ R0=0xAA0000DD clear byte 1
        ORR     R0, R2, LSR #8          @ R0=0xAA00BBDD merge and shift byte 2
        ORR     R0, R3, LSL #8          @ R0=0xAACCBBDD merge and shift byte 1
        B       LR

Que traducir línea por línea en el siguiente código c:

int swap (int R0)
{
  int R2,R3;
  R2 = R0 & 0x00ff0000;
  R3 = R0 & 0x0000ff00;
  R0 = R0 & 0xff00ffff;
  R0 = R0 & 0xffff00ff;
  R0 |= (R2>>8);
  R0 |= (R3<<8);
  return R0;
}

Verá - muchas líneas para una tarea tan simple. Ni siquiera la arquitectura ARMv6 ayuda mucho aquí.

EDITAR: Versión ARMv6 (también no probados, pero dos instrucciones más cortas)

swap_v6:
        @ bits in R0: aabbccdd
        ROR     R0, R0, #8              @ r0 = ddaabbcc
        REV     R1, R0                  @ r1 = ccbbaadd
        PKHTB   R0, R0, R1              @ r0 = ddaaccbb
        ROR     R0, R0, #24             @ r0 = aaccbbdd
        BX      LR