Anatomia de uma instrução ARM

O esqueleto de 32 bits

Uma instrução de processamento de dados (o ADD, SUB, MOV, CMP, AND... da família) tem este layout:

Decodificando à mão

Compile estas dez instruções e olhe o objdump — anat.s (.elf):

    add   r0, r1, r2            @ registrador
    add   r0, r1, #255          @ imediato pequeno
    add   r0, r1, #0x3F00       @ imediato com rotate
    add   r0, r1, r2, lsl #3    @ registrador deslocado (barrel shifter)
    addeq r0, r1, r2            @ condicional (cond = EQ)
    adds  r0, r1, r2            @ atualiza flags (S = 1)
    ldr   r0, [r1, #4]          @ offset, base inalterada
    ldr   r0, [r1, #4]!         @ pre-index com writeback
    ldr   r0, [r1], #4          @ post-index
    ldrb  r0, [r1]              @ acesso de 1 byte

e0810002 = add r0, r1, r2

Junte os nibbles: 1110 0000 1000 0001 0000 0000 0000 0010 = 0xE0810002. Confere.

O que muda em cada variante

O Operand2 e o barrel shifter

Doze bits, dois formatos:

Imediato (I = 1):rotate[11:8] + imm8[7:0]. O valor final é imm8 rotacionado à direita por 2 × rotate. É por isso que #0x3F00 cabe (0x3F ror 24) mas #0x3F1 não — não existe rotação par de um byte que produza esse padrão. O montador resolve isso por você ou reclama.

Registrador deslocado (I = 0):shift[11:4] + Rm[3:0]. O shift pode ser por imediato (Rm, LSL #3) ou por outro registrador (Rm, LSL r4). Os tipos:

O barrel shifter é um circuito dedicado no caminho de dados: ele aplica esse shift ao operando de graça, no mesmo ciclo da operação. add r0, r1, r2, lsl #3 é uma única instrução — um multiplicar-e-somar embutido.

Load/store: os bits de endereçamento

LDR/STR trocam o Operand2 por um bloco de bits de modo de endereçamento:

As três formas do assembly:

E ldrb r0, [r1] (e5d10000) é só o bit B ligado — o nibble 9 vira D. Esse post-index ([r1], #4) é o que faz um laço de varredura de vetor andar de 4 em 4 sem uma instrução de incremento separada — exatamente o padrão do artigo de carga e armazenamento.

Espelho no código: ArmDecoder

O decodificador do arm-jitter faz, em Java, o que você acabou de fazer no papel. ArmDecoder.decode(memory, address):

public DecodedInstruction decode(AddressSpace memory, int address) {
    int raw = memory.fetch32(address & ~3);
    Condition condition = decodeCondition(raw >>> 28);   // os 4 bits de cond

    // cond == 0b1111 não é "condição": é um espaço de encoding à parte
    // (NEON, PLD, BLX imediato, CPS, barreiras) desde o ARMv5.
    if ((raw >>> 28) == 0xF) {
        return decodeUnconditional(address, raw, condition);
    }
    // ...
}

O resultado é um record neutro, com os campos que você separou virando propriedades:

public record DecodedInstruction(
        int address,
        int raw,                       // a palavra de 32 bits, crua
        InstructionSet instructionSet,
        Condition condition,           // <- raw >>> 28
        InstructionKind kind,          // <- opcode + subdispatch
        int destinationRegister,       // <- Rd, ou -1
        int sourceRegister,            // <- Rn, ou -1
        int secondSourceRegister,      // <- Rm, ou -1
        int immediate,                 // <- imm8 JÁ rotacionado / offset / nº de SWI
        boolean immediateOperand,      // <- o bit I
        boolean setFlags,              // <- o bit S
        boolean link,                  // <- BL vs B
        int accessSizeBytes,           // <- 1 (bit B) ou 4
        boolean writeback,             // <- o bit W
        boolean postIndexed,           // <- o bit P invertido
        /* ... */) { }

Repare que immediate já vem expandido: o decoder aplica a rotação do imediato de 12 bits ali, para o resto do pipeline não precisar saber do formato rotate|imm8. É a mesma decisão que o montador toma na direção oposta.

Glossário

Comandos

Próximo passo

Você já sabe ler uma instrução parada. O próximo artigo coloca ela em movimento: o ciclo fetch–decode–execute e como ele vira o laço ArmCore.step() do emulador.

Trilha: Curso de Arquitetura ARM · Módulo 1, lição 3. Ver também: Decodificando instruções ARM à mão.