Sobre Virgule e seu simulador emulsiV

• Motivação e escopo
• Arquitetura do Processador
  • Relação com a especificação RISC-V
  • Registradores
  • Organização da Memória
  • Interrupções
  • Conjunto de Instruções
  • Codificação das Instruções
• Memória e Periféricos
  • Layout da memória
  • Entrada e Saída de texto
  • Entrada e Saída de propósito geral
  • Saída de bitmap
• Criando programas para o emulsiV com o "GNU toolchain"
  • Instalação
  • Usando o assembler
  • Usando o compilador C
  • Usando o linker
  • Convertendo um executável para o formato "hex"
• Licença

emulsiV é um simulador virtual para um processador RISC simples, chamado Virgule.

Virgule é um processador de núcleo RISC de 32-bits que implementa um conjunto mínimo de instruções RISC-V. Aqui, “mínimo” significa que Virgule aceita somente as instruções que o compilador C deve gerar a partir de um programa "C stand-alone".

Motivativação e Escopo

Virgule e emulsiV são usados para ensinar arquitetura e projeto de circuitos digitais para iniciante em ESEO. Antes de escolher uma arquitetura de processador, nos tivemos os seguintes requisitos em mente:

• Uma arquitetura aberta que nos possamos usar e implementar sem precisar de permissão.
• Um conjunto de instruções simples e regular, completo o suficiênte para ser um "target" para um compilador C.
• Um arquitetura em linha com as tendência atuais de mercado, de preferência com a atual implementação das industrias.
• Um toolchain aberto e gratuito.

Dentre as arquiteturas candidatas, o RISC-V preencheu todos os requisitos:

• Ela tem uma especificação aberta.
• Ela é uma arquitetura RISC no estado da arte (state-of-the-art), com um conjunto de instruções claro e simples.
• A fundação RISC-V tem uma lista de membros impressionante; Os cores e chips RISC-V já estão disponíveis atualmente.
• A arquitetura é suportada pela ferramentas GNU de compilação.

Estas propriedades permite diversos cenários de ensino.

Em um curso de arquitetura de computadores, estudantes descobrem como um processador funciona, que tipo de linguagem e ferramentas podem ser usadas para criar um programa em baixo nível (Assembly, C). Um simulador é a melhor forma de visualizar como cada instrução afeta o caminho dos dados.

Em um curso de projeto de circuitos digitais, estudantes podem implementar um core de processador em VHDL ou Verilog, ou instânciar um para fazer seu próprio system-on-chip.

Arquitetura do Processador

Relação com a especificação RISC-V

Virgule implementa todas as instruções computacionais, de transferência de controle, e acesso a memória do subconjunto de inteiros do RV32I da especificação RISC-V. Ele também fornece uma instrução de retorno de exceção que pode ser usada em funções de tratamento de interrupção.

As seguintes intruções não estão disponíveis:

• Instruções de ordenação de memória.
• Chamada de ambiente e pontos de interrupção.
• Instruções de Controle e Registradores de Status - Control and Status Register (CSR).

A arquitetura RISC-V define três níveis de privilégios: user, supervisor, e machine. Virgule somente suporta o nível machine.

Registradores

Virgule contem os seguintes registradores 32-bit:

• 32 registradores de proposito geral nomeados x0 até x32 como especificado no conjunto base de instruções RV32E da especificação RISC-V.
• O contador de programa pc. Este registrador conteim o endereço da instrução corrente. Ao ser resetado este valor retorna para zero e sempre será multiplo de 4.
• O contador de programa para exceções de máquina mepc. Este registrador recebe o endereço de retorno quando uma exceção a nível de máquina ocorre.

Organização da memória

Formato do dado para instruções de carga e gravação seguem as seguintes convenções:

Em memória, 16-bit e 32-bit os dados seguem a ordenção little-endian.

Os dois endereços a seguir tem uma regra específica:

• Após o reset, a execução inicializa no endereço 0. Neste endereço, nos tipicamente encontramos uma instrução de branch para o início do programa.
• No endereço 4, Virgule esepra encontrar a função de tratamento de interrupção.

Interrupções

O Virgule implementa um hardware simples para o esquema de interrupção no modo previlegiado de máquina. Não controle de interrupção ou registrador de estatus internamente no core de processador.

Quando ele recebe uma requisição de interrupção, Virgule executa as seguintes operações:

1. Completa a intrução corrente.
2. Chaveia para um estado de interrupção.
3. Define mepc para o endereço da próxima instrução.
4. Define pc para 4, que transferirá o controle para a função de tratamento de interrupção.

Retornando de uma função de tratamento de interrupção é feito com a instrução mret. Esta intrução tem o seguinte efeito:

1. Copia mepc para pc.
2. Chaveia para um estado de interrompível.

Conjunto de Instruções

Na seguinte tabela:

• rd é o registrador de proposito geral de destino.
• rs1 e rs2 são os registradores de proposito geral para de dados.
• imm é um valor inteiro literal (immediate).

if rs1 = rs2:
    pc ← pc + imm
else:
    pc ← pc + 4

if rs1 ≠ rs2:
    pc ← pc + imm
else:
    pc ← pc + 4

if signed(rs1) < signed(rs2):
    pc ← pc + imm
else:
    pc ← pc + 4

if signed(rs1) ≥ signed(rs2):
    pc ← pc + imm
else:
    pc ← pc + 4

if unsigned(rs1) < unsigned(rs2):
    pc ← pc + imm
else:
    pc ← pc + 4

if unsigned(rs1) ≥ unsigned(rs2):
    pc ← pc + imm
else:
    pc ← pc + 4

if signed(rs1) < signed(imm):
    rd ← 1
else:
    rd ← 0

if unsigned(rs1) < unsigned(imm):
    rd ← 1
else:
    rd ← 0

if signed(rs1) < signed(rs2):
    rd ← 1
else:
    rd ← 0

if unsigned(rs1) < unsigned(rs2):
    rd ← 1
else:
    rd ← 0

Na tabela acima, operações lógicas e deslocamento tem o seguinte significado:

Codificação de Instrução

Uma palavra (word - 4 bytes) de instrução pode ser composta pelos seguintes campos:

• funct7, funct3 e opcode definem a operação a ser executada;
• rd é o indice do registrador de propósito geral de destino (valores permitidos na faixa de 0 a 15).
• rs1 e rs2 são indices dos registradores de propósito geral como fontes de dados(valores permitidos na faixa de 0 a 15);
• imm representa um valor inteiro literal (immediate);

O conjunto de instruções RISC-V define seis formatos de instrução:

Valores Immediate (Imediatos)

Valores Immediate são extendidos no sinal (sign-extended) para 32 bits. quando eles não são explicitamente codificados no campo imm, o bit menos significante é 0.

Na especificação, formatos B e J são descritos como variantes dos formatos S e U. Nos formatos B e J, valores immediate representam offsets de instruções ramificações do código relativas. Elas são codificadas para que eles compartilhem o máximo de bits com outros formatos, enqaunto preservam seus bits mais significantes na localização 31 da palavra (word - 4 bytes) de instrução.

A Seguinte tabela mostra o mapeamento entre os bits de uma palavra (word - 4 bytes) de instrução e os bits de um valor imediato:

Opcodes base

No Virgule, nos tempos retido o seguinte opcotes de base da especificação RISC-V. cara opcode corresponde a um formato de instrução específico:

Valores de campos para cada instrução

Quando decodificando uma palavra de instruão, Virgule usa os seguintes campos para identificar a instrução atual. Nesta tabela, a coluna opcode refere-se aos nomes de base do opcode na tabela acima.

Dispositivo de memória e periféricos

Layout de memória

O espaço de endereçamento é organizado como segue.

Entrada/Saida Texto

O dispositivo de entrada de texto é representado por um campo de texto na interface de usuário do simulador. Ele tem dois registradores de 8-bit:

O registrador de controle/Estatus trabalha da seguinte forma:

• No reset, bits 6 e 7 são limpos.
• Bit 6 é setado após o usuário entrar um caracter no campo de texto A única forma de limpa-lo é escrever um zero usando uma instrução store.
• O dispositivo irá enviar uma requisição de interrupção para o procesador quando os bits 7 e 6 forem ambos definidos como 1.

O dispositivo de saída de texto é representado por uma área de texto na interface de usuário do simulador. Ele tem somente um registrador somente escrita:

Entrada/Saída de propósito geral

O GPIO (Entrada e Saída de propósito geral) de periféricos permite conectar pelo menos 32 dispostivos simples de entrada e saída:

• Push-buttons.
• Chaves comuns.
• LEDs.

As entradas são organizadas em um grid de 8×4 na parte inferior da seção E/S de propósito geral do simulador. Clique com o botão direito do mouse na célula para trocar o seu tipo. Clique com o botão esquerdo do mouse na célula alterar o estado do botão ou da chave.

Ele tem os seguintes registradores de 32-bits:

Durante o reset, todos os pinos são configurados como entradas e interrupções são desabilitadas.

Eventos de subida de borda ou descida de borda devem ser limpos por software usando instruções de store quando o evento foi processados.

Saída de Bitmap

O simulador fornece uma área de "display" gráfico com 32 linhas com 32 pixels cada. Cada pixel é mapeado para um bate da RAM e sua cor é codificada da seguinte forma:

O bitmap na RAM segue uma ordem "raster-scan". Para cada endereço, esta tabela mostra coordenadas (x, y) do pixel correspondente:

Criando programas para emulsiV com as ferramentas GNU.

O simulador permite criar e editar programas pela entrada de instruções na columna "Assembly" do visualizador de memória. Outra opçlão é digitar seu programa no editor de texto e gerar um executável para o emulsiV usando as ferramentas GNU.

Instalação

Você pode usar as seguintes intruções para instalar as ferramentas GNU para RISC-V no ambiente Linux Debian ou no Ubuntu. O projeto riscv-gnu-toolchain fornece informações adicionais se você precisa instalar o toolchain em outra distribuição, ou se você precisa recursos que não estão tratados aqui.

Para o processo de "build" serão necessários os seguintes pacotes:

sudo apt install autoconf automake autotools-dev curl libmpc-dev zlib1g-dev \
     libmpfr-dev libgmp-dev gawk build-essential bison flex texinfo gperf \
     libtool patchutils bc zlib1g-dev libexpat-dev git-core

Clone o repositório fonte da ferramenta RISC-V GNU:

git clone --recursive https://github.com/riscv/riscv-gnu-toolchain

Configure e faça o "build" das ferramentas com suporte para o target RV32E. O comando make irá tentar instalar a ferramenta em /opt/riscv. Você pode alterar a opção --prefix se você deseja instalar em outro lugar. Execute o comando sudo make se você não tem permissão para criar o folder destino.

cd riscv-gnu-toolchain
./configure --prefix=/opt/riscv --with-arch=rv32e --with-abi=ilp32
make

Antes de usar as ferramentas, atualize a variável PATH da seguinte forma:

export PATH=$PATH:/opt/riscv/bin

Usando o "assembler"

Este comando compila o arquivo fonte example.s gerando um arquivo de objetos example.o:

riscv32-unknown-elf-gcc -march=rv32e -c -o example.o example.s

Aqui está um módulo típico de inicialização (startup.s) que você pode usar para seu programa. Outros arquivos fontes "assembly" ou "C" devem definir o subprograma main, e opcionalmente sobreescrever o subprograma irq_handler.

    .section vectors, "x"

    .global __reset
__reset:
    j start

__irq:
    j irq_handler

    .text
    .align 4

    .weak irq_handler
irq_handler:
    mret

start:
    la gp, __global_pointer
    la sp, __stack_pointer
    la t0, __bss_start
    la t1, __bss_end
    bgeu t0, t1, memclr_done
memclr:
    sw zero, (t0)
    addi t0, t0, 4
    bltu t0, t1, memclr

memclr_done:
    call main
    j .

Usando o compilador C

Este comando compila o arquivo fonte example.c em um arquivo objeto example.o:

riscv32-unknown-elf-gcc -march=rv32e -ffreestanding -c -o example.o example.c

Se você deseja escrever uma função para tratar uma interrupção em C, você pode sobrescrever o subprograma irq_handler, adicionando o atributo interrupt como a seguir:

__attribute__((interrupt("machine")))
void irq_handler(void) {
    // Insert your code here.
}

Usando o "linker"

Este comando liga startup.o e example.o em um arquivo executável example.elf:

riscv32-unknown-elf-gcc -nostdlib -T emulsiv.ld -o example.elf startup.o example.o

O mapa de memória do do simulador é configurado no "linker script" emulsiv.ld apresentado abaixo:

ENTRY(__reset)

MEM_SIZE    = 4K;
STACK_SIZE  = 512;
BITMAP_SIZE = 1K;

SECTIONS {
    . = 0x0;

    .text : {
        *(vectors)
        *(.text)
        __text_end = .;
    }

    .data   : { *(.data) }
    .rodata : { *(.rodata) }

    __global_pointer = ALIGN(4);

    .bss ALIGN(4) : {
        __bss_start = .;
        *(.bss COMMON)
        __bss_end = ALIGN(4);
    }

    . = MEM_SIZE - STACK_SIZE - BITMAP_SIZE;

    .stack ALIGN(4) : {
        __stack_start = .;
        . += STACK_SIZE;
        __stack_pointer = .;
    }

    .bitmap ALIGN(4) : {
        __bitmap_start = .;
        *(bitmap)
    }

    __bitmap_end = __bitmap_start + BITMAP_SIZE;
}

Convertendo um executável para o formato hex

Este comando converte um arquivo binário do tipo ELF example.elf em um arquivo texto example.hex com o formato Intel Hex:

riscv32-unknown-elf-objcopy -O ihex example.elf example.hex

No simulador, use o botão "Open an hex file from your computer" e escolha arquivo hex para ser carregado.

Licença

emulsiV é um software livre e é distribuido sobre os termos da licença Mozilla Public 2.0.

Este documento foi criado por Guillaume Savaton, ESEO. E é licenciado sobre os termos da licença Creative Commons Attribution-ShareAlike 4.0 International License.