RISC-V
Minimum Sized ISA
Tiny RISC-V
"Tiny RISC-V only supports a 1MB virtual memory address space from 0x00000000 to 0x000fffff. The result of memory accesses to addresses larger than 0x000fffff are undefined."
Xcondensed
RISC-V Compressed
This is intended to be used with the 32bit ISA. Would it work standalone?
RV32E
RV32E is the embedded extension that lowers from 32 registers to 16...
"RV32E uses a subset of the Soft-Float calling convention. As only 16 integer registers x0–x15 are present, there are only six argument registers (x10–x15), two saved registers (x8–x9), and three temporary registers (x5–x7). The stack is kept aligned on a four-byte boundary."
"RV32E uses the same instruction set encoding as RV32I, except that use of register specifiers x16–x31 in an instruction will result in an illegal instruction exception being raised."
"A further simplification is that the counter instructions (rdcycle[h],rdtime[h], rdinstret[h]) are no longer mandatory."
"The mandatory counters require additional registers and logic, and can be replaced with more application-specific facilities."
Registers
- R32, 5-Bits specify register. 32 registers
- 4-bits will get you 16 (12)
- 3-Bits will get you 8 (4)
- 2-Bits will get you 4 (0) - Similar to a 8bit cpu... But the regs are all used...
- Some registers are fixed though. R0 is always zero, XLEN-1 (last reg) is PC. x1 return. x4-thread pointer might be dropped.
With only 8 registers, could save 2 bits...? Except missing some of the registers are specified in the calling conventions... x8, x9, x10, x11, x12-17 Are the calling conventions actually needed?
Could some of the argument registers be reused?
Calling Conventions
- x0 = zero
- x1 = ra (return address)
- x2 = sp (stack pointer)
- x3 = gp (global pointer)
- x4 = tp (thread pointer) <- Not needed...
- x5-x7 = t0-t2 (temp)
- x8 = s0/fp saved register/frame pointer
- x9 = s1 (saved register)
- x10-x11 = function arguments/return values
- x12-x17 = a2-a7 function arguments <- Don't need this many arguments...
- x18-x27 = s2-s11 saved registers <- Find out what saved are for... Do we need more than x8?
- x28-x31 = t3-6 temporaries <- Don't need these
- Spec 2.1p109
RV32E
"For resource-constrained embedded applications, we have defined the RV32E subset, which only has 16 registers (Chapter 3)." - Spec (2.1p10)
"A further simplification is that the counter instructions (rdcycle[h],rdtime[h], rdinstret[h]) are no longer mandatory." - RV32E
"RV32E uses a subset of the Soft-Float calling convention. As only 16 integer registers x0–x15 are present, there are only six argument registers (x10–x15), two saved registers (x8–x9), and three temporary registers (x5–x7). The stack is kept aligned on a four-byte boundary."
- x0 = zero
- x1 = ra (return address)
- x2 = sp (stack pointer)
- x3 = gp (global pointer)
- x4 = tp (thread pointer)
- x5-x7 = t0-t2 (temp)
- x8-x9 = s0-s1 (saved registers)
- x10-x15 = Argument registers
Opcode Flag Bits
All the 32-bit instructions in the base ISA have their lowest two bits set to 11. The optional compressed 16-bit instruction-set extensions have their lowest two bits equal to 00, 01, or 10. Standard instruction- set extensions encoded with more than 32 bits have additional low-order bits set to 1, with the conventions for 48-bit and 64-bit lengths shown in Figure 1.1. Instruction lengths between 80 bits and 176 bits are encoded using a 3-bit field in bits [14:12] giving the number of 16-bit words in addition to the first 5×16-bit words. The encoding with bits [14:12] set to 111 is reserved for future longer instruction encodings.
For all 16bit instructions, the first 12 bits are something other than 11. Won't save any space, but would allow more instructions in the 16 bit space.
Op Codes
- "All the 32-bit instructions in the base ISA have their lowest two bits set to 11" - Spec
xxxxxxxxxxxxxxaa 16-bit (aa != 11) xxxxxxxxxxxbbb11 32-bit (bbb != 111) xxxxxxxxxx011111 48-bit xxxxxxxxx0111111 64-bit xnnnxxxxx1111111 (80+16*nnn)-bit, nnn != 111 x111xxxxx1111111 Reserved for ≥192-bits
Table 9.1 on page 53 has the opcodes. "In the base ISA, there are four core instruction formats (R/I/S/U), as shown in Figure 2.2. All are a fixed 32 bits in length and must be aligned on a four-byte boundary in memory. An instruction address misaligned exception is generated on a taken branch or unconditional jump if the target address is not four-byte aligned." - Spec (2.2)
- R-type
31 25 24 20 19 15 14 12 11 7 6 0 +------------+---------+---------+------+---------+-------------+ | funct7 | rs2 | rs1 |funct3| rd | opcode | +------------+---------+---------+------+---------+-------------+
- I-type
31 20 19 15 14 12 11 7 6 0 +----------------------+---------+------+---------+-------------+ | imm | rs1 |funct3| rd | opcode | +----------------------+---------+------+---------+-------------+
- S-type
31 25 24 20 19 15 14 12 11 7 6 0 +------------+---------+---------+------+---------+-------------+ | imm | rs2 | rs1 |funct3| imm | opcode | +------------+---------+---------+------+---------+-------------+
- U-type
31 11 7 6 0 +---------------------------------------+---------+-------------+ | imm | rd | opcode | +---------------------------------------+---------+-------------+
Immediate Encoding
"There are a further two variants of the instruction formats (SB/UJ) based on the handling of immediates" - Spec 2.3
"The only difference between the S and SB formats is that the 12-bit immediate field is used to encode branch offsets in multiples of 2 in the SB format. Instead of shifting all bits in the instruction- encoded immediate left by one in hardware as is conventionally done, the middle bits (imm[10:1]) and sign bit stay in fixed positions, while the lowest bit in S format (inst[7]) encodes a high-order bit in SB format."
"Similarly, the only difference between the U and UJ formats is that the 20-bit immediate is shifted left by 12 bits to form U immediates and by 1 bit to form J immediates. The location of instruction bits in the U and UJ format immediates is chosen to maximize overlap with the other formats and with each other."
"Integer computational instructions are either encoded as register-immediate operations using the I-type format or as register-register operations using the R-type format."
Instructions
- ADDI adds the sign-extended 12-bit immediate to register rs1. ADDI rd, rs1, 0 is used to implement the MV
rd, rs1 assembler pseudo-instruction.