Assembly RISC-V

lw t0, 0(a0)
add t1, t0, t2
sw t1, 4(a0)

Com a0=0x1000, uma palavra de valor 7 nesse endereço e t2=5, este fragmento lê 7, soma 5 e guarda 12 em 0x1004. Os registos t0 e t1 guardam os valores intermédios dentro do processador; a memória conserva palavras em endereços de byte, por isso o deslocamento 4 avança exatamente uma palavra.

Cada linha é uma instrução. A ISA, arquitetura do conjunto de instruções, fixa as operações, os registos e os seus efeitos visíveis. Duas organizações internas podem executar o mesmo programa em tempos diferentes.

Trabalhamos em RV32: 32 registos inteiros de 32 bits e instruções base de 32 bits, sem instruções comprimidas. O PC identifica o endereço da instrução em execução, e um salto relativo usa o PC dessa instrução. Numa pipeline, várias instruções coexistem, cada uma com o seu PC, enquanto a obtenção já procura instruções mais novas.

Vídeo de apoio: RISC-V Assembly

Introdução em vídeo de Rodrigo Dias:

Aprende RISC-V Assembly em 30 minutosCarregar vídeo do YouTube

Abrir no YouTube

Registos e convenção de chamadas

Não existe t7. O banco de vírgula flutuante, quando disponível, usa f0 a f31; não é o mesmo banco dos x.

Contas, imediatos e memória

No fragmento inicial, as alterações de estado são:

O add usa o valor carregado, não o endereço 0x1000. Já o sw conserva t1 e modifica memória.

add rd,rs1,rs2 soma dois registos; addi rd,rs1,imm soma um imediato com sinal de 12 bits, entre −2048 e 2047. sub, and, or, xor, slt seguem o formato de três registos. slt compara com sinal; sltu compara sem sinal. Não há flags de comparação globais.

Uma soma inteira mantém os 32 bits baixos, sem gerar uma exceção por overflow. Com sinal, o intervalo é de −2³¹ a 2³¹−1; sem sinal, de 0 a 2³²−1. Por exemplo, 0x7FFFFFFF+1 produz 0x80000000, que se interpreta como −2³¹ com sinal. O padrão continua correto como soma modular, mas já não representa a soma matemática com sinal.

O mesmo padrão 0xFFFFFFFF representa 4294967295 sem sinal ou −1 com sinal, por isso a instrução de comparação escolhida determina a interpretação.

Em lw t0,12(a0), o endereço é a0 + 12, em bytes. Para ler vetor[i] de palavras, calcula base + 4i. ld/sd pertencem ao modelo inteiro RV64, não a este RV32.

A memória é little endian: a palavra 0x12345678 ocupa os bytes 78 56 34 12, do endereço menor para o maior. O alinhamento natural de uma palavra exige endereço múltiplo de 4. Ler um byte com sinal estende esse sinal aos 32 bits: um lb sobre o byte 0xFE produz −2, enquanto lbu produz 254.

Os deslocamentos trabalham por via aritmética ou lógica. slli desloca à esquerda e preenche os bits baixos com zeros. srli preenche os altos com zeros; srai preenche-os com o bit de sinal. Os imediatos de deslocamento em RV32 vão de 0 a 31. Para valores negativos, o arredondamento difere: dividir −3 por 2 com srai dá −2, por arredondar para baixo, enquanto div dá −1, por arredondar para zero. A multiplicação e a divisão, como div, vêm da extensão M. As instruções SIMD empacotadas têm um modelo próprio, tratado em SIMD.

Vírgula flutuante e conversões

As extensões F e D acrescentam operações de precisão simples e dupla. Os endereços e as contagens continuam nos registos inteiros; os valores em vírgula flutuante usam o banco f. O sufixo .s indica precisão simples, com 32 bits, e .d, dupla, com 64 bits. RV32 com D continua a ter registos inteiros de 32 bits; o banco de vírgula flutuante tem a largura necessária para os valores de 64 bits.

Uma carga não converte um inteiro para um número real. Se a memória contém o inteiro 3, flw copia o padrão 0x00000003, que não é a representação de 3,0. Para converter, lê com lw e usa fcvt.s.w.

As instruções fmv.w.x e fmv.x.w copiam bits entre bancos, sem conversão numérica: uma apenas move o padrão, a outra faz o inverso. fmv.s copia entre registos de precisão simples; não alarga um valor para dupla.

Média de elementos não negativos

Suponhamos uma sequência de números finitos de precisão simples, base alinhada a quatro bytes, comprimento positivo e pelo menos um elemento não negativo. Não há overflow nas somas. O fragmento seguinte deixa a média em ft0; altera os temporários e avança a0 até ao fim do vetor.

    mv t2, zero
    fcvt.s.w ft0, zero       # soma = 0,0
    fmv.s ft3, ft0           # constante 0,0
ciclo_media:
    flw ft1, 0(a0)
    addi a0, a0, 4
    addi a1, a1, -1
    flt.s t0, ft1, ft3
    bnez t0, seguinte       # exclui negativos
    fadd.s ft0, ft0, ft1
    addi t2, t2, 1
seguinte:
    bnez a1, ciclo_media
    fcvt.s.w ft2, t2
    fdiv.s ft0, ft0, ft2

Para [1,5; −2,0; 4,5; 0,0], acompanha soma e contagem:

O zero entra na média, porque o teste exclui apenas valores estritamente negativos. O divisor é 3, convertido para 3,0, e a média é 2,0. Dividir a soma filtrada 6,0 pelo comprimento 4 daria 1,5, que não responde a nenhuma das duas perguntas: a média filtrada é 2,0 e a média de todos os elementos é (1,5−2,0+4,5+0,0)/4=1,0.

O comprimento zero precisa de verificação antes da primeira carga, e uma sequência só de negativos precisa de tratamento antes da divisão por zero. Esses casos estão excluídos do contrato do fragmento, não resolvidos pelo ciclo.

Para acumular em dupla dados guardados em simples, mantém o avanço de quatro bytes. Converte cada carga com fcvt.d.s, inicializa a soma com fcvt.d.w ...,zero, usa fadd.d, converte a contagem com fcvt.d.w e divide com fdiv.d. Só no retorno usa fcvt.s.d se o resultado pedido for simples. Aumentar a precisão do cálculo não aumenta o tamanho dos elementos em memória nem torna exatas todas as somas.

Codificar uma instrução

O opcode identifica a família da instrução; funct3 e funct7 distinguem operações dentro dela. rd é o destino, rs1/rs2 são origens e imm é uma constante codificada na instrução. Os campos conservam posições quando possível:

Na expressão seguinte, << desloca bits à esquerda e | combina os campos com OR. Como cada campo ocupa bits distintos, os campos não se sobrepõem.

Os tamanhos de opcode, rd, funct3, rs1, rs2 são 7, 5, 3, 5 e 5 bits. Em lw t2,40(t6), rd=7, rs1=31, funct3=2, opcode=3 e imm=40:

Em B e J, o bit zero do deslocamento é implícito. Reconstrói o deslocamento com sinal em bytes, antes de o somar ao PC da própria instrução. Para um salto de 0x100 para 0x0F0, o deslocamento é −16, não −20.

Saltos e decisões

beq/bne comparam igualdade. blt/bge comparam com sinal; bltu/bgeu, sem sinal. Se não houver salto, o PC avança 4 bytes neste modelo sem instruções comprimidas.

jal ra,funcao guarda PC+4 em ra. jalr rd,imm(rs1) guarda também PC+4 e salta para (rs1+imm) & ~1. ret é a pseudoinstrução jalr zero,0(ra).

Uma pseudoinstrução pode expandir-se em várias instruções reais. mv t0,t1 equivale a addi t0,t1,0; j L, a jal zero,L. li, la e call dependem da constante ou distância. Conta as instruções expandidas se o problema pedir ciclos ou códigos máquina.

Para formar 0x12345ABC com lui/addi, repara que a parte baixa 0xABC é negativa como imediato de 12 bits: −1348. Por isso usa lui t0,0x12346 seguido de addi t0,t0,-1348. O incremento da parte alta compensa essa extensão de sinal.

Chamadas e a pilha

O chamador guarda temporários de que precisa depois de uma chamada. O chamado guarda e repõe os s que altera. Uma função que chama outra deve proteger o seu ra. A pilha cresce para endereços menores e mantém alinhamento de 16 bytes na convenção usada aqui.

O programa seguinte calcula dobro(7)+5 = 19. s0 conserva o 5 durante a chamada; o ra exterior fica no frame. As funções não usam variáveis globais para guardar retornos, permitindo chamadas aninhadas.

.text
.globl main
main:
    andi sp, sp, -16
    li a0, 7
    jal ra, dobro_mais_cinco
    li a7, 1
    ecall
    li a7, 10
    ecall

dobro_mais_cinco:
    addi sp, sp, -16
    sw ra, 12(sp)
    sw s0, 0(sp)
    li s0, 5
    jal ra, dobro
    add a0, a0, s0
    lw s0, 0(sp)
    lw ra, 12(sp)
    addi sp, sp, 16
    ret

dobro:
    slli a0, a0, 1
    ret

As chamadas ecall deste bloco usam os serviços do simulador: imprimir inteiro com a7=1 e terminar com a7=10. São a interface de execução do exemplo, não instruções de entrada e saída universais de RV32.

Vídeo de apoio: pilha e stack pointer

A pilha e o registo sp são o tema deste vídeo de Rodrigo Dias.

Percebe a Stack e Stack Pointer em RISC-VCarregar vídeo do YouTube

Abrir no YouTube

Profundidade da pilha na recursão

Uma função recursiva tem vários frames ativos ao mesmo tempo. Cada chamada guarda o seu retorno e os valores de que precisa depois da chamada seguinte. O deslocamento 12(sp) repete-se no código, mas o endereço absoluto muda porque cada chamada tem outro sp.

Esta rotina calcula a soma de 1 até n. Assume 1 ≤ n ≤ 65535, resultado de 32 bits com sinal e espaço de pilha suficiente. Guarda n em s0 para o recuperar depois de a0 receber a soma da chamada interior.

soma_recursiva:
    addi sp, sp, -16
    sw ra, 12(sp)
    sw s0, 8(sp)
    mv s0, a0
    li t0, 1
    beq a0, t0, repor_soma
    addi a0, a0, -1
    jal ra, soma_recursiva
    add a0, a0, s0
repor_soma:
    lw s0, 8(sp)
    lw ra, 12(sp)
    addi sp, sp, 16
    ret

Com n=5, antes de começar a retornar:

O caso base também reserva o frame, porque a reserva ocorre antes do teste. O pico é $5\times16=80$ bytes, embora cada frame guarde apenas duas palavras, oito bytes úteis. Contam-se também os oito bytes de espaço reservado para manter o alinhamento.

O caso base retorna 1. As chamadas seguintes formam 3, 6, 10 e 15, libertando um frame em cada retorno. No fim, sp e s0 têm os valores que tinham antes da chamada inicial. Cinco chamadas sucessivas que retornassem antes da próxima reutilizariam a mesma região: o pico seria 16 bytes, não 80. A memória máxima depende das chamadas simultaneamente ativas, não só do número total de chamadas.