RISC-V Tutorial

#!/bin/bash
if [[ $# == 0 ]]; then
    echo "usage qemu-gdb.sh <exec>"
    exit 1
fi

app=$1

cat >/tmp/gdb.cmds <<hello
target remote localhost:12345
hello

qemu-riscv64 -g 12345  ./a.out &
qemu_pid=$!
gdb-multiarch $app -x /tmp/gdb.cmds
kill -9 $qemu_pid &>/dev/null

// 2022-02-25 19:31
#include <stdio.h>

void bubble_sort(int *data, int start, int end) {
    for (int i = start; i < end; i++) {
        for (int j = i; j < end; j++) {
            if (data[j] < data[i]) {
                /* swap i, j */
                int tmp = data[i];
                data[i] = data[j];
                data[j] = tmp;
            }
        }
    }
}

void dump(int *data, int len) {
    for (int i = 0; i < len; i++) {
        printf("%d ", data[i]);
    }
    printf("\n");
}

int main(int argc, char *argv[]) {
    int data[] = {1, 1, 4, 3, 10, 5};
    int len = sizeof(data) / sizeof(data[0]);
    dump(data, len);

    bubble_sort(data, 0, len);

    dump(data, len);
    return 0;
}

    ## riscv64-linux-gnu-gcc test.s -static
    .global main

    .text
dump:
    addi sp, sp, -4
    sw ra, 4(sp)

    la s0, data
    la s1, data_end
    addi s0, s0, -8

.Lprint_loop:
    addi s0, s0, 8
    beq s0, s1, .Lprint_end

    la a0, print_fmt
    ld a1, 0(s0)
    call printf
    j .Lprint_loop

.Lprint_end:
    la a0, print_fmt_new_line
    call printf

    lw ra, 4(sp)
    addi sp, sp, 4
    ret

main:
    addi sp, sp, -4
    sw ra, 4(sp)

    call dump

    la t0, data
    addi t0, t0, -8
    la t2, data_end

.Lmain_outer_loop:
    addi t0, t0, 8
    beq t0, t2, .Lmain_end
    addi t1, t0, -8

.Lmain_inner_loop:
    addi t1, t1, 8
    beq t1, t2, .Lmain_outer_loop
    ld s0, 0(t0)
    ld s1, 0(t1)
    blt s0, s1, .Lmain_continue
    ## swap
    sd s1, 0(t0)
    sd s0, 0(t1)
.Lmain_continue:
    j .Lmain_inner_loop

.Lmain_end:
    call dump
    lw ra, 4(sp)
    addi sp, sp, 4
    move a0, zero
    ret

    .data
data:
    .dword 1
    .dword 1
    .dword 4
    .dword 3
    .dword 10
    .dword 5
data_end:

print_fmt_new_line:
    .asciz "\n"

print_fmt:
    .asciz "%ld "

#include <stdio.h>

void swap(int *data, int a, int b) {
    int temp = data[a];
    data[a] = data[b];
    data[b] = temp;
}

void quick_sort(int *data, int start, int end) {
    int pivort = start;
    int curr = start + 1;
    if (curr >= end) {
        return;
    }
    while (curr < end) {
        if (data[curr] < data[pivort]) {
            swap(data, curr, pivort + 1);
            swap(data, pivort, pivort + 1);
            pivort += 1;
        }
        curr += 1;
    }
    quick_sort(data, start, pivort);
    quick_sort(data, pivort + 1, end);
}

void dump (int* data, int len) {
    for (int i = 0; i < len; i++) {
        printf("%d ", data[i]);
    }
    printf("\n");
}

int main(int argc, char *argv[]) {
    int data[] = {1, 1, 4, 3, 10, 5};
    int len = sizeof(data) / sizeof(data[0]);
    dump(data, len);

    quick_sort(data, 0, len);

    dump(data, len);
    return 0;
}

    ## riscv64-linux-gnu-gcc test.s -static
    .global main

    .text

.macro enter
    addi sp, sp, -4
    sw ra, 4(sp)
.endm

.macro leave
    lw ra, 4(sp)
    addi sp, sp, 4
    move a0, zero
    ret
.endm

print_data:
    enter

    la s0, .Ldata_start
    la s1, .Ldata_end
    addi s0, s0, -8

    .Lprint_loop:
    addi s0, s0, 8
    beq s0, s1, .Lprint_end

    la a0, .Lprint_fmt
    ld a1, 0(s0)
    call printf
    j .Lprint_loop

    .Lprint_end:
    la a0, .Lprint_fmt_new_line
    call printf

    leave

quick_sort:
    addi sp, sp, -64
    sw ra, 8(sp)
    sw s0, 16(sp)
    sw s1, 24(sp)
    sw s2, 32(sp)
    sw s3, 40(sp)
    sw s4, 48(sp)
    sw s5, 56(sp)
    sw s6, 64(sp)

    ## gnu as 本身并不支持 define, 这里依赖 gcc 的 preprocessor
    ## 来处理 define, 所以需要用 gcc 编译而不能用 as
    ##
    #define end s6
    #define start s0
    #define loop s1
    #define pivort s2
    #define loop_v s3
    #define pivort_v s4
    #define tmp s5

    move start, a0
    move end, a1
    move pivort, start
    addi loop, a0, 8
    bge loop, end, .Lquick_sort_end

    addi loop, loop,-8
1:
    addi loop, loop, 8
    bge loop, end, 1f

    ld loop_v, 0(loop)
    ld pivort_v, 0(pivort)
    bge loop_v, pivort_v, 1b
    ## swap
    ld tmp, 8(pivort)
    sd loop_v, 8(pivort)
    sd tmp, 0(loop)
    ## swap
    ld tmp, 8(pivort)
    sd pivort_v, 8(pivort)
    sd tmp, 0(pivort)
    ## inc pivort
    addi pivort, pivort, 8
    j 1b

1:
    move a0, start
    move a1, pivort
    call quick_sort

    addi a0, pivort, 8
    move a1, end
    call quick_sort

    .Lquick_sort_end:
    lw ra, 8(sp)
    lw s0, 16(sp)
    lw s1, 24(sp)
    lw s2, 32(sp)
    lw s3, 40(sp)
    lw s4, 48(sp)
    lw s5, 56(sp)
    lw s6, 64(sp)

    addi sp, sp, 64
    ret

main:
    enter

    call print_data

    la a0, .Ldata_start
    la a1, .Ldata_end

    call quick_sort
    call print_data

    leave

    .data
    .Ldata_start:
    .dword 4
    .dword 3
    .dword 10
    .dword 5
    .rep 2
    .dword 3
    .endr
    .fill 2, 8, 1
    .space 8, 0xff
    .Ldata_end:

.Lprint_fmt_new_line:
    .asciz "\n"

.Lprint_fmt:
    .asciz "%ld "

    ## riscv64-linux-gnu-gcc test.s -static
    .global main

    .text

foo:
    addi    sp,sp,-16
    sd      ra,8(sp)

    ## 这里是 gcc 生成的代码, 实际上可以用 fmv.x.d a2, fa0 代替 fsd/ld
    ## fmv.x.d a2, fa0
    fsd     fa0,16(sp)
    ld      a2,16(sp)

    mv      a1,a0
    la      a0,.Lprint_fmt
    call    printf

    ld      ra,8(sp)
    addi    sp,sp,16
    ret

main:
    addi sp, sp, -8
    sd ra, 8(sp)

    li a0, 0x1234
    la t0, 1f
    fld fa0, 0(t0)

    call foo

    ld ra, 8(sp)
    addi sp, sp, 8
    move a0, zero
    ret

1:
    .double 1.1

    .Lprint_fmt:
    .asciz "%x %f\n"

    ## riscv64-linux-gnu-gcc test.s -static
    .global main

    .text

main:
    addi sp, sp, -8
    sd ra, 8(sp)

    la a0, .Lprint_fmt
    li a1, 0x1234
    la t0, 1f
    ## 直接做为整数 load
    ld a2, 0(t0)
    ## 或者使用 fmv.x.d 搬运一次
    ## fld fa0, 0(t0)
    ## fmv.x.d a2, fa0

    call printf

    ld ra, 8(sp)
    addi sp, sp, 8
    move a0, zero
    ret

1:
    .double 1.1

.Lprint_fmt:
    .asciz "0x%x %f\n"

    ## 这段代码实现的功能是 *mem += 1
    la t2, mem
    lw t0, 0(t2)
retry:
    addi t1, t0, 1
    cmpxchg t0, t2, t1
    beqz zf, retry

    .global main
    .text
main:
    addi sp, sp, -8
    sd ra, 8(sp)

    ## amoadd.w 相当于 rd=offset(rs2), offset(rs2)=rs1+offset(rs2)
    la a0, print_fmt
    la t0, data
    li t2, 10
    amoadd.w a1, t2, 0(t0)
    call printf

    ## amoswap 相当于 rd=offset(rs1); offset(rs1)=rs2
    la a0, print_fmt
    la t0, data
    addi t2, zero, 1
    amoswap.w a1, t2, 0(t0)
    call printf

    la a0, print_fmt
    la t0, data
    lw a1, 0(t0)
    call printf

    ld ra, 8(sp)
    addi sp, sp, 8
    move a0, zero
    ret

    .data
print_fmt:
    .asciz "%d\n"

data:
    .word 10

    ## a0 地址为 1 时表示 locked, 为 0 表示 unlocked
    li t0, 1
1:  amoswap.w.aq t1, t0, (a0)
    bnez t1, 1b
    ## acquired
    ## ...
    amoswap.w.rl zero, zero, (a0)

    .global main
    .text
main:
    addi sp, sp, -8
    sd ra, 8(sp)
    la t0, data

    ## 成对的 lr/sc 需要操作相同的地址 t0
    ## 读取 t0 的旧数据
1:  lr.w t2, 0(t0)
    ## 要写入 t0 的新数据
    addi t2, t2, 10
    ## 若 t0 中途被其它 sc 修改, 则不会写入新数据, 且 t3 会返回 0
    ## 否则写入新数据, 且 t3 返回 1
    sc.w t3, t2, 0(t0)
    bnez t3, 1b

    la a0, print_fmt
    lw a1, data
    call printf

    ld ra, 8(sp)
    addi sp, sp, 8
    move a0, zero
    ret

    .data
print_fmt:
    .asciz "%d\n"
data:
    .word 10

    ## lock
1:  lr.w t0, (a0)
    bnez t0, 1b
    li t0, 1
    sc.w t1, t0, (t0)
    bnez t1, 1b

    ## unlock
1:  lr.w zero, (a0)
    sc.w t1, zero, (t0)
    bnez t1, 1b

li x0, 0xffffffff
li x1, 0x1
add x2, x0, x1
beqz x2, handler