关于RISC-V中lb、sa、li指令的用法与语法规范，以及字符串字符访问等效实现方式的技术问询

Hey there! Let's tackle your RISC-V questions one by one, nice and clear.

Wait, quick note first: RISC-V doesn't have an official sa instruction—my guess is you meant sb (Store Byte), the logical counterpart to lb (Load Byte). I'll cover that instead, since it's the standard byte-store instruction.

lb (Load Byte) #

• What it does: Loads a signed 8-bit byte from memory into a register, automatically performing sign extension (propagating the byte's highest bit to fill all higher bits of the 32/64-bit register).
• Syntax: lb rd, offset(rs1)
  • rd: Target register where the loaded value will be stored
  • offset: 12-bit signed immediate value (adds to the base address)
  • rs1: Base register holding the starting memory address; final address = rs1 value + offset
• Example: lb t0, 0(a0) — Loads the byte at the memory address pointed to by a0 into t0, sign-extended to 32 bits (for RV32)

sb (Store Byte) #

• What it does: Stores the least significant 8 bits of a register into a memory location, ignoring the register's higher bits.
• Syntax: sb rs2, offset(rs1)
  • rs2: Source register whose lowest byte will be stored
  • offset: 12-bit signed immediate value (adds to the base address)
  • rs1: Base register holding the starting memory address; final address = rs1 value + offset
• Example: sb t0, 4(a1) — Stores the lowest byte of t0 into the memory address a1 + 4

li (Load Immediate) #

• What it does: A pseudo-instruction (translated by the assembler into real RISC-V instructions) that loads an immediate value into a register. Works for small and large values (the assembler handles splitting big numbers into lui + addi if needed).
• Syntax: li rd, immediate
  • rd: Target register to hold the immediate value
  • immediate: Any integer value (8-bit, 12-bit, or larger; the assembler handles encoding)
• Examples:
  • li a0, 42 — Loads the value 42 into a0 (assembles to addi a0, x0, 42)
  • li t1, 0x12345678 — Loads a 32-bit value into t1 (RV32: assembles to lui t1, 0x1234 + addi t1, t1, 0x5678)

Great question! RISC-V works exactly like C under the hood here—strings are stored as contiguous bytes in memory, terminated by a null byte (\0, 0x00). The equivalent to C's str[i] is calculating the memory address base_address + i and loading that byte.

Here's a step-by-step breakdown with example code:

Step 1: Get the string's base address #

First, load the starting address of your string into a register. For static strings (defined in .data), use the la (Load Address) pseudo-instruction:

.data
my_string: .asciz "Hello, RISC-V!"  # .asciz adds the null terminator automatically

.text
main:
    la a0, my_string  # Load base address of my_string into a0

Step 2: Calculate the address of the i-th character #

Just like C's &str[0] + i, add your index value to the base address:

li t0, 0  # Initialize index i = 0

loop:
    add t1, a0, t0  # t1 = base address + i (address of the i-th character)

Step 3: Load the character #

Use lb (or lbu for unsigned bytes) to load the byte from memory:

lb t2, 0(t1)  # Load the i-th character into t2 (sign-extended)
# Or use lbu t2, 0(t1) for unsigned (zero-extended)

Step 4: Check for the null terminator #

To stop at the end of the string, check if the loaded character is 0:

beq t2, x0, exit_loop  # If t2 is 0 (null byte), exit the loop

Full Example: Traverse and Process Each Character #

Here's a complete RV32 assembly snippet that loops through a string (like a C for loop):

.data
my_string: .asciz "Hello, RISC-V!"

.text
main:
    la a0, my_string       # Load string base address
    li t0, 0               # Index i = 0

loop:
    add t1, a0, t0         # Calculate address of str[i]
    lb t2, 0(t1)           # Load str[i] into t2
    beq t2, x0, exit_loop  # Exit if we hit the null terminator

    # Add your character processing here!
    # For example, pass t2 to a print function (hypothetical print_char)
    mv a1, t2
    jal print_char

    addi t0, t0, 1         # i++
    j loop                 # Repeat loop

exit_loop:
    li a7, 10              # System call number for exit
    ecall

This is directly equivalent to the C code:

char my_string[] = "Hello, RISC-V!";
for (int i = 0; my_string[i] != '\0'; i++) {
    print_char(my_string[i]);
}

内容的提问来源于stack exchange，提问作者Eri Cupt