Skip to content

Commit

Permalink
Better portuguese cheatsheet for RISC-V
Browse files Browse the repository at this point in the history
  • Loading branch information
@gboncoffee
gboncoffee committed Apr 22, 2024
1 parent 456decc commit 1c05f30
Showing 1 changed file with 152 additions and 2 deletions.
154 changes: 152 additions & 2 deletions riscv/cheatsheet-pt.md
View file
Original file line number Diff line number Diff line change
@@ -1,16 +1,136 @@
# RISC-V Cheatsheet - EGG

- [RISC-V Cheatsheet - EGG](#risc-v-cheatsheet---egg)
- [Instruções](#instruções)
- [Aritméticas](#aritméticas)
- [Extensão de multiplicação](#extensão-de-multiplicação)
- [Aritméticas com imediato](#aritméticas-com-imediato)
- [Loads (carregar valores da memória)](#loads-carregar-valores-da-memória)
- [Stores (salvar valores na memória)](#stores-salvar-valores-na-memória)
- [Branches (saltos condicionais)](#branches-saltos-condicionais)
- [Jumps (saltos incondicionais)](#jumps-saltos-incondicionais)
- [Miscelânea](#miscelânea)
- [Registradores](#registradores)
- [Sintaxe](#sintaxe)
- [Chamadas do emulador](#chamadas-do-emulador)
- [Carregar imediatos](#carregar-imediatos)
- [Manipular a stack](#manipular-a-stack)
- [Chamar funções](#chamar-funções)
- [Truques do debugger](#truques-do-debugger)
- [Ver o PC](#ver-o-pc)
- [Dump do programa](#dump-do-programa)

## Instruções

![Instructions](instructions.png)
### Aritméticas

| Mnemônico | Argumentos | Descrição | Sinal |
| --------- | ------------------ | ---------------------------------------------------------------------------------------------------------------- | ----- |
| `add` | `rd`, `rs1`, `rs2` | Soma os valores de `rs1` e `rs2`, guardando o resultado em `rd`. | Com. |
| `sub` | `rd`, `rs1`, `rs2` | Subtrai os valores de `rs1` e `rs2`, guardando o resultado em `rd`. | Com. |
| `xor` | `rd`, `rs1`, `rs2` | Realiza o OU EXCLUSIVO entre os valores de `rs1` e `rs2`, guardando o resultado em `rd`. | |
| `or` | `rd`, `rs1`, `rs2` | Realiza o OU lógico entre os valores de `rs1` e `rs2`, guardando o resultado em `rd`. | |
| `and` | `rd`, `rs1`, `rs2` | Realiza o E lógico entre os valores de `rs1` e `rs2`, guardando o resultado em `rd`. | |
| `sll` | `rd`, `rs1`, `rs2` | Realiza um shift lógico para a esquerda do valor de `rs1` pelo valor de `rs2`, guardando o resultado em `rd`. | |
| `srl` | `rd`, `rs1`, `rs2` | Realiza um shift lógico para a direita do valor de `rs1` pelo valor de `rs2`, guardando o resultado em `rd`. | |
| `sra` | `rd`, `rs1`, `rs2` | Realiza um shift aritmético para a direita do valor de `rs1` pelo valor de `rs2`, guardando o resultado em `rd`. | |
| `slt` | `rd`, `rs1`, `rs2` | Compara os valores de `rs1` e `rs2`. O resultado guardado em `rd` é 1 caso `rs1` < `rs2`, e 0 caso contrário. | Com. |
| `sltu` | `rd`, `rs1`, `rs2` | Igual à `slt`, porém considera os valores sem sinal. | Sem. |

#### Extensão de multiplicação

| Mnemônico | Argumentos | Descrição | Sinal |
| --------- | ------------------ | ---------------------------------------------------------------------------------------- | ------ |
| `mul` | `rd`, `rs1`, `rs2` | Multiplica os valores de `rs1` e `rs2`, guardando o resultado em `rd`. | Com. |
| `mulh` | `rd`, `rs1`, `rs2` | Multiplica os valores de `rs1` e `rs2`, guardando a parte alta do resultado em `rd`. | Com. |
| `mulsu` | `rd`, `rs1`, `rs2` | Igual à `mulh`, porém considera o valor de `rs1` COM SINAL e o valor de `rs2` SEM SINAL. | Misto. |
| `mulu` | `rd`, `rs1`, `rs2` | Igual à `mulh`, porém considera os valores sem sinal. | Sem. |
| `div` | `rd`, `rs1`, `rs2` | Divide o valor de `rs1` pelo valor de `rs2`, guardando o resultado em `rd`. | Com. |
| `divu` | `rd`, `rs1`, `rs2` | Igual à `div`, porém considera os valores sem sinal. | Sem. |
| `rem` | `rd`, `rs1`, `rs2` | Guarda em `rd` o resto da divisão do valor de `rs1` pelo valor de `rs2`. | Com. |
| `remu` | `rd`, `rs1`, `rs2` | Igual à `rem`, porém considera os valores sem sinal. | Sem. |

### Aritméticas com imediato

| Mnemônico | Argumentos | Descrição | Sinal |
| --------- | ------------------ | ------------------------------------------------------------------------------------------------------------ | ----- |
| `addi` | `rd`, `rs1`, `imm` | Soma o valor de `rs1` com o `imm`, guardando o resultado em rd. | Com. |
| `xori` | `rd`, `rs1`, `imm` | Realiza o OU EXCLUSIVO entre o valor de `rs1` e o `imm`, guardando o resultado em rd. | |
| `ori` | `rd`, `rs1`, `imm` | Realiza o OU lógico entre o valor de `rs1` e `imm`, guardando o resultado em rd. | |
| `andi` | `rd`, `rs1`, `imm` | Realiza o E lógico entre o valor de `rs1` e `imm`, guardando o resultado em rd. | |
| `slli` | `rd`, `rs1`, `imm` | Realiza um shift lógico para a esquerda do valor de `rs1` pelo `imm`, guardando o resultado em rd. | |
| `srli` | `rd`, `rs1`, `imm` | Realiza um shift lógico para a direita do valor de `rs1` pelo `imm`, guardando o resultado em rd. | |
| `srai` | `rd`, `rs1`, `imm` | Realiza um shift aritmético para a direita do valor de `rs1` pelo `imm`, guardando o resultado em rd. | |
| `slti` | `rd`, `rs1`, `imm` | Compara o valor de `rs1` com o `imm`. O resultado guardado em rd é 1 caso `rs1` < `imm`, e 0 caso contrário. | Com. |
| `sltiu` | `rd`, `rs1`, `imm` | Igual à `slt`, porém considera os valores sem sinal. | Sem. |

### Loads (carregar valores da memória)

| Mnemônico | Argumentos | Descrição | Sinal |
| --------- | ------------------ | ------------------------------------------------------------------------- | ----- |
| `lb` | `rd`, `rs1`, `imm` | Carrega 1 byte do endereço dado por `rs1 + imm` na região baixa de `rd`. | Com. |
| `lh` | `rd`, `rs1`, `imm` | Carrega 2 bytes do endereço dado por `rs1 + imm` na região baixa de `rd`. | Com. |
| `lw` | `rd`, `rs1`, `imm` | Carrega 4 bytes do endereço dado por `rs1 + imm` no `rd`. | |
| `lbu` | `rd`, `rs1`, `imm` | Igual à `lb` porém não extende o sinal do valor carregado. | Sem. |
| `lhu` | `rd`, `rs1`, `imm` | Igual à `lh` porém não extende o sinal do valor carregado. | Sem. |

### Stores (salvar valores na memória)

| Mnemônico | Argumentos | Descrição | Sinal |
| --------- | ------------------ | ----------------------------------------------------------------------- | ----- |
| `sb` | `rd`, `rs1`, `imm` | Salva o byte da região baixa de `rs1` no endereço dado por `rd + imm`. | |
| `sh` | `rd`, `rs1`, `imm` | Salva 2 bytes da região baixa de `rs1` no endereço dado por `rd + imm`. | |
| `sw` | `rd`, `rs1`, `imm` | Salva o valor de `rs1` no endereço dado por `rd + imm`. | |

### Branches (saltos condicionais)

| Mnemônico | Argumentos | Descrição | Sinal |
| --------- | ------------------- | --------------------------------------------------- | ----- |
| `beq` | `rs1`, `rs2`, `imm` | Salta para `PC + imm` caso `rs1 == rs2`. | |
| `bne` | `rs1`, `rs2`, `imm` | Salta para `PC + imm` caso `rs1 != rs2`. | |
| `blt` | `rs1`, `rs2`, `imm` | Salta para `PC + imm` caso `rs1 < rs2`. | Com. |
| `bge` | `rs1`, `rs2`, `imm` | Salta para `PC + imm` caso `rs1 >= rs2`. | Com. |
| `bltu` | `rs1`, `rs2`, `imm` | Igual à `blt` porém realiza a comparação sem sinal. | Sem. |
| `bgeu` | `rs1`, `rs2`, `imm` | Igual à `bge` porém realiza a comparação sem sinal. | Sem. |

### Jumps (saltos incondicionais)

| Mnemônico | Argumentos | Descrição | Sinal |
| --------- | ------------------ | ------------------------------------------------------------------------ | ----- |
| `jal` | `rd`, `imm` | Salta para `PC + imm`, salvando o valor de `PC + 4` em `rd`. | Com. |
| `jalr` | `rd`, `rs1`, `imm` | Salta para o valor de `rs1 + imm`, salvando o valor de `PC + 4` em `rd`. | Com. |

### Miscelânea

| Mnemônico | Argumentos | Descrição | Sinal |
| --------- | ----------- | --------------------------------------------------------------------------------------- | ----- |
| `lui` | `rd`, `imm` | Carrega o valor `imm << 12` em `rd`. | |
| `auipc` | `rd`, `imm` | Carrega o valor `PC + (imm << 12)` em `rd`. | |
| `ecall` | | Realiza uma chamada ao emulador. (ver seção de chamadas) | |
| `ebreak` | | Equivalente à `ecall`, porém não considera argumentos, realiza sempre uma chamada BREAK | |

## Registradores

![Registers](registers.png)
Registradores salvos devem ter seu valor original restaurado pela função que os utilizou.

| Registrador(es) | Nome(es) | Função | Salvo(s)? |
| --------------- | ------------ | --------------------------------------------- | --------- |
| `x0` | `zero` | Constante zero. Escrever nele não tem efeito. | |
| `x1` | `ra` | Endereço de retorno. Utilizado em saltos. | |
| `x2` | `sp` | Endereço da pilha (ela cresce para baixo). | |
| `x3` | `gp` | Pointeiro global. | |
| `x4` | `tp` | Pointeiro da thread. | |
| `x5` à `x7` | `t0` à `t2` | Uso geral, temporários. | |
| `x8` e `x9` | `s0` e `s1` | Uso geral, salvos. | Sim. |
| `x10` e `x11` | `a0` e `a1` | Argumentos de função e valores de retorno. | |
| `x12` à `x17` | `a2` à `a7` | Argumentos de função. | |
| `x18` à `x27` | `s2` à `s11` | Uso geral, salvos. | Sim. |
| `x28` à `x31` | `t3` à `t6` | Uso geral, temporários. | |

## Sintaxe

```asm
; Um ponto e vírgula introduz comentários
addi a7, zero, 3
addi a0, zero, msg
addi a1, zero, 14
Expand Down Expand Up @@ -103,3 +223,33 @@ endereço e então usar 'jalr':
```asm
jalr ra, <reg>, 0
```

## Truques do debugger

### Ver o PC

É possível utilizar o comando `print` com a expressão `#1` para ver o PC. `#1`
significa "ver uma instrução a partir do PC". Exemplo:

```
egg> print #1
0xcafebabe: func: add t0 a0 a1
```

Nesse exemplo, o PC está no endereço `0xcafebabe`, onde há uma etiqueta `func`,
e a instrução é um `add`, guardando a soma de `a0` e `a1` em `t0`.

### Dump do programa

É possível utilizar o EGG para montar um programa em Assembly e guardar em um
arquivo. Para isso, abre-se o programa no emulador e utiliza-se o seguinte
comando:

```
egg> dump # <nome do arquivo>
```

Substituindo `<nome do arquivo>` pelo nome que queira salvar o arquivo do
programa. Note que esse arquivo não terá nenhum formato especial: ele conterá
apenas os bytes correspondentes às instruções do programa, junto com literais
que forem adicionados.

0 comments on commit 1c05f30

Please sign in to comment.