Programar em RISC-V

Para guardar o menor de dois números, o programa compara os registos, salta para o ramo escolhido e copia o valor para o destino. Assembly torna explícitas estas operações e os endereços de memória, por isso um mapa dos registos e uma condição sobre o estado de cada ciclo ajudam a verificar a tradução.

Condições e ciclos

Para if (x < y) z=x; else z=y, coloca x em t0, y em t1 e z em t2:

    bge t0, t1, caso_y
    mv t2, t0
    j fim
caso_y:
    mv t2, t1
fim:

O salto testa a condição inversa para ir ao else. Depois do caso x, o salto incondicional evita executar também o caso y. Se x e y forem valores sem sinal, usa bgeu.

Um while testa antes do corpo, podendo executar zero vezes. Um do...while testa depois, executando pelo menos uma vez. Uma condição i<n precisa de um teste final quando i já chegou a n.

Somar um vetor

Queremos somar quatro words 7,-3,10,0. O programa usa t0 como apontador, t1 como número de elementos por ler e t2 como soma. No início de cada iteração, t2 é a soma dos elementos já lidos e t0 aponta para o próximo por ler.

.data
.align 2
vetor: .word 7, -3, 10, 0
.text
.globl main
main:
    la t0, vetor
    li t1, 4
    li t2, 0
loop:
    beq t1, zero, done
    lw t3, 0(t0)
    add t2, t2, t3
    addi t0, t0, 4
    addi t1, t1, -1
    j loop
done:
    mv a0, t2
    li a7, 1
    ecall
    li a7, 10
    ecall

Aqui os valores e o resultado cabem em RV32 com sinal. Para outros dados, add continua a guardar apenas os 32 bits inferiores; se precisares da soma matemática exata, tens de detetar overflow ou usar uma representação mais larga. O comprimento é um inteiro não negativo e nunca excede os elementos disponíveis.

Em cada passagem, lw t3,0(t0) lê um elemento, add t2,t2,t3 acumula, o apontador t0 avança 4 bytes e o contador t1 diminui. Quando t1 é zero, o programa salta para done antes de ler memória, por isso o caso vazio imprime 0 sem acessos inválidos; este exemplo corre em main e termina com ecall, não sendo uma rotina com retorno em a0. Para o tornar rotina, recebe base em a0 e comprimento em a1 e devolve a soma em a0, sem ecall.

Traçado com [7,-3,10,0], t0=base, t1=por ler, t2=soma, t3=elemento:

Para procurar o máximo, um vetor vazio precisa de contrato próprio, como devolver um sinal de erro. Num vetor não vazio, inicializa o máximo com o primeiro elemento, não com zero, pois caso contrário [-8,-3] daria incorretamente 0; depois percorre os restantes com comparação com sinal.

Para inverter um vetor, usa apontadores para a primeira e última word. Lê ambos os valores antes de escrever qualquer um, troca-os e aproxima os apontadores por 4 bytes. Termina quando se encontram ou cruzam. O caso ímpar deixa o elemento central no lugar.

Inverter sem perder elementos

No vetor [7,-3,10,0,8], trocamos primeiro 7 com 8, depois -3 com 0. O resultado é [8,0,10,-3,7]; o 10 central não muda. Durante cada troca é necessário ler as duas words antes da primeira escrita, para não apagar o segundo valor que ainda precisamos.

.data
.align 2
vetor: .word 7, -3, 10, 0, 8
.text
.globl main
main:
    andi sp, sp, -16
    la a0, vetor
    li a1, 5
    jal ra, inverter
    la t0, vetor
    li t1, 5
mostrar:
    beq t1, zero, terminar
    lw a0, 0(t0)
    li a7, 1
    ecall
    li a0, 10
    li a7, 11
    ecall
    addi t0, t0, 4
    addi t1, t1, -1
    j mostrar
terminar:
    li a7, 10
    ecall
inverter:
    li t0, 2
    bltu a1, t0, voltar
    mv t0, a0
    slli t1, a1, 2
    add t1, a0, t1
    addi t1, t1, -4
trocar:
    bgeu t0, t1, voltar
    lw t2, 0(t0)
    lw t3, 0(t1)
    sw t3, 0(t0)
    sw t2, 0(t1)
    addi t0, t0, 4
    addi t1, t1, -4
    j trocar
voltar:
    ret

A rotina recebe a base em a0 e o comprimento em a1. Se houver menos de dois elementos, volta antes de calcular a última posição. Caso contrário, slli t1,a1,2 converte elementos em bytes e o último elemento fica em base+4×comprimento−4. A comparação sem sinal entre os apontadores termina o ciclo quando se encontram ou cruzam. Supomos um vetor válido, alinhado e que não atravessa o fim do espaço de endereços. A rotina é leaf e só altera registos caller-saved.

Texto ASCII

Uma string .asciz termina num byte zero. lbu lê um byte e o apontador avança 1; o terminador não conta no comprimento. Para reconhecer um dígito, testa '0'<=c<='9'; se for verdadeiro, o valor é c−48.

Para uma letra, testa separadamente os intervalos A a Z e a a z. Não basta o intervalo de A a z, porque inclui pontuação entre as maiúsculas e minúsculas.

.data
texto: .asciz "A-7_z!"
.text
.globl main
main:
    la t0, texto
    li t1, 0
loop:
    lbu t2, 0(t0)
    beq t2, zero, done
    li t3, 48
    bltu t2, t3, next
    li t3, 57
    bgeu t3, t2, count
    li t3, 65
    bltu t2, t3, next
    li t3, 90
    bgeu t3, t2, count
    li t3, 97
    bltu t2, t3, next
    li t3, 122
    bltu t3, t2, next
count:
    addi t1, t1, 1
next:
    addi t0, t0, 1
    j loop
done:
    mv a0, t1
    li a7, 1
    ecall
    li a7, 10
    ecall

A classificação conta só letras e dígitos ASCII: em A-7_z!, conta A, 7 e z, dando 3. O traço, o underscore e a exclamação ficam excluídos. Não é uma rotina Unicode.

Converter decimal sem overflow

Para converter uma string ASCII de dígitos num inteiro, começa com acumulador $v=0$. Cada novo dígito $d=c-48$ ocupa a casa das unidades e desloca os anteriores:

Em 204, os estados do acumulador são 2, 20 e 204. Testa primeiro se o byte é zero ou se está entre 48 e 57; o terminador fecha a conversão e um byte fora do intervalo torna a entrada inválida. O contrato deve decidir se uma string vazia representa zero ou é rejeitada.

Para um resultado sem sinal de 32 bits, o máximo é $M=2^{32}-1=4294967295$. Antes da multiplicação, divide esse limite em quociente e resto por 10:

Rejeita se $v>429496729$, ou se $v=429496729$ e $d>5$. Nos restantes casos, $10v+d$ cabe. Usa comparações sem sinal; a constante grande precisa de li e de um registo, não cabe no imediato de addi.

A entrada 4294967295 chega ao último passo com v=429496729 e d=5, por isso é aceite. 4294967296 falha com o mesmo v e d=6 antes de alterar o acumulador. Testar só depois de mul e add não basta: essas instruções conservam 32 bits e podem produzir um valor pequeno depois de perder os bits altos.

Máscaras e deslocamentos

Para testar o bit k, calcula x & (1 << k). Para o limpar, faz AND com a máscara complementar. Para o colocar a 1, faz OR. Para o trocar, faz XOR. Um AND com 1 isola o bit menos significativo.

Contar bits a 1 por deslocamento usa srli até a palavra ficar zero. Com srai, uma palavra com bit de sinal 1 pode nunca chegar a zero. Uma rotação à esquerda por k combina $(x\ll k)$ com $(x\gg(32-k))$ através de OR; trata k=0 em separado para não assumir um deslocamento efetivo de 32.

Soma de várias palavras

Um inteiro de 64 bits pode ser guardado em duas words, baixa e alta. Soma primeiro as baixas e obtém carry se a soma sem sinal for menor que uma das entradas; depois soma as altas e o carry, com

A igualdade não indica carry: se $B_L=0$, L pode ser igual a $A_L$ sem ter havido transbordo.

.text
.globl main
main:
    li t0, 0x80000005
    li t1, 0
count_loop:
    beq t0, zero, count_done
    andi t2, t0, 1
    add t1, t1, t2
    srli t0, t0, 1
    j count_loop
count_done:
    mv a0, t1
    li a7, 1
    ecall
    li a0, 10
    li a7, 11
    ecall
    li t0, -1
    li t1, 1
    li t2, 1
    li t3, 2
    add t4, t0, t2
    sltu t5, t4, t0
    add t6, t1, t3
    add t6, t6, t5
    mv a0, t4
    li a7, 1
    ecall
    li a0, 10
    li a7, 11
    ecall
    mv a0, t6
    li a7, 1
    ecall
    li a7, 10
    ecall

As palavras do resultado são impressas separadamente para mostrar o carry entre a word baixa e a alta.

Para analisar um binary32 guardado como bits, extrai expoente com deslocamento e máscara e verifica a fração. NaN exige expoente 0xFF e fração diferente de zero; infinito tem fração zero. A máscara de magnitude 0x7FFFFFFF permite reconhecer ambos os zeros sem confundir -0 com um número negativo não nulo.