riscv64裸机编程实践与分析

嵌入式IoT 2020-12-31 4452

描述

riscv64 裸机编程实践与分析

1.概述
2.最小工程的构成
3. 链接脚本
4.可执行的程序源代码分析
5.编译与运行
- 5.1 编译
- 5.2 运行
- 5.3 调试
6.总结

1.概述

任何芯片在启动之前都需要有一段汇编代码，从这段汇编代码上就可以体现一些架构设计的特点。往往做嵌入式底层开发都需要关注这段汇编代码的含义，这样在使用的时候才能全面的了解启动时做了什么事情，在后续的程序中遇到问题也能复盘推演。

本文就针对riscv64的最开始的启动部分代码进行分析，从最小的一个裸机代码开始分析，彻底的弄清楚riscv启动的流程。

本次使用的环境是riscv64 qemu，而编译器是通过下面的地址进行下载：

https://www.sifive.com/software

2.最小工程的构成

一个最小的工程包含两个东西：链接脚本以及源代码。

源代码就是可以让cpu执行的代码，通过交叉编译工具链编译生成可执行的二进制程序。

链接脚本文件则可以告诉程序的布局，比如代码段，函数的入口等等。有了这两个文件将编译出来的程序loader到板子上运行即可。

3. 链接脚本

下面看一下hello.ld文件。

OUTPUT_ARCH( "riscv" )
OUTPUT_FORMAT("elf64-littleriscv")
ENTRY( _start )
SECTIONS
{
  /* text: test code section */
  . = 0x80000000;
  .text : { *(.text) }
  /* data: Initialized data segment */
  .gnu_build_id : { *(.note.gnu.build-id) }
  .data : { *(.data) }
  .rodata : { *(.rodata) }
  .sdata : { *(.sdata) }
  .debug : { *(.debug) }
  . += 0x8000;
  stack_top = .;

  /* End of uninitalized data segement */
  _end = .;
}

对于链接脚本(linker script)，往往都是规定如何把输入的文件按照特定的地址放到内存中。

其中就上面的脚本而言：

OUTPUT_ARCH("riscv")：表示输入文件的架构是riscv。

OUTPUT_FORMAT("elf64-littleriscv")：表示elf64小端。一般arm，riscv，x86都是小端，小端是比较主流的。

ENTRY( _start ):表示函数入口是_start。

然后开始进行代码段的布局，起始地址开始处为0x80000000。然后依次放代码段、数据段、只读数据段、全局数据段，debug段等等。

这里需要注意：

  . += 0x8000;
  stack_top = .;

这里说明，栈顶预留了0x8000个字节空间作为程序的栈空间，因为栈是向上增长的，所以这里预留了一些栈空间。

通过反汇编来查看生成程序的布局情况

# riscv64-unknown-elf-objdump -d hello

hello:     file format elf64-littleriscv


Disassembly of section .text:

0000000080000000 <_start>:
    80000000: f14022f3           csrr t0,mhartid
    80000004: 00029c63           bnez t0,8000001c 
    80000008: 00008117           auipc sp,0x8
    8000000c: 04410113           addi sp,sp,68 # 8000804c <_end>
    80000010: 00000517           auipc a0,0x0
    80000014: 03450513           addi a0,a0,52 # 80000044 
    80000018: 008000ef           jal ra,80000020 

000000008000001c :
    8000001c: 0000006f           j 8000001c 

0000000080000020 :
    80000020: 100102b7           lui t0,0x10010
    80000024: 00054303           lbu t1,0(a0)
    80000028: 00030c63           beqz t1,80000040 
    8000002c: 0002a383           lw t2,0(t0) # 10010000 
    80000030: fe03cee3           bltz t2,8000002c 
    80000034: 0062a023           sw t1,0(t0)
    80000038: 00150513           addi a0,a0,1
    8000003c: fe9ff06f           j 80000024 
    80000040: 00008067           ret

对于qemu来说，sifive_u的起始地址为0x80000000，将代码段的入口放在此处。

4.可执行的程序源代码分析

前面已经描述了链接脚本的布局，也就是给程序指定了执行的地址，每个函数以及函数入口在什么地址都已经规划好了，那么具体的入口函数该如何写呢？

看看hello.s的编程代码：

.align 2
.equ UART_BASE,         0x10010000
.equ UART_REG_TXFIFO,   0

.section .text
.globl _start

_start:
        csrr  t0, mhartid             # read hardware thread id (`hart` stands for `hardware thread`)
        bnez  t0, halt                   # run only on the first hardware thread (hartid == 0), halt all the other threads

        la    sp, stack_top           # setup stack pointer

        la    a0, msg                 # load address of `msg` to a0 argument register
        jal   puts                    # jump to `puts` subroutine, return address is stored in ra regster

halt:   j     halt                    # enter the infinite loop

puts:                                 # `puts` subroutine writes null-terminated string to UART (serial communication port)
                                      # input: a0 register specifies the starting address of a null-terminated string
                                      # clobbers: t0, t1, t2 temporary registers

        li    t0, UART_BASE           # t0 = UART_BASE
1:      lbu   t1, (a0)                # t1 = load unsigned byte from memory address specified by a0 register
        beqz  t1, 3f                  # break the loop, if loaded byte was null

                                      # wait until UART is ready
2:      lw    t2, UART_REG_TXFIFO(t0) # t2 = uart[UART_REG_TXFIFO]
        bltz  t2, 2b                  # t2 becomes positive once UART is ready for transmission
        sw    t1, UART_REG_TXFIFO(t0) # send byte, uart[UART_REG_TXFIFO] = t1

        addi  a0, a0, 1               # increment a0 address by 1 byte
        j     1b

3:      ret

.section .rodata
msg:
     .string "Hello.
"

根据汇编语言的规则

.align 2

表示入口程序以2^2也就是4字节对齐。

.equ UART_BASE,         0x10010000
.equ UART_REG_TXFIFO,   0

定义了UART的寄存器的基地址。

接着主要从_start:开始分析。

 csrr  t0, mhartid             # read hardware thread id (`hart` stands for `hardware thread`)
 bnez  t0, halt                   # run only on the first hardware thread (hartid == 0), halt all the other threads

根据riscv的设计，如果一个部件包含一个独立的取指单元，那么该部件被称为核心(core)。

一个RiscV兼容的核心能够通过多线程技术(或者说超线程技术)支持多个RiscV兼容硬件线程(harts)，harts这儿就是指硬件线程， hardware thread的意思。

RISC

上面的就包含一个E51的核和4个U54的核。

而这段汇编就是将其他的核挂起，只运行hartid == 0的核。

紧接着

   la    sp, stack_top           # setup stack pointer

这里将栈指针sp赋值,sp此时指向栈顶。

  la    a0, msg                 # load address of `msg` to a0 argument register
  jal   puts                       # jump to `puts` subroutine, return address is stored in ra regster

对于riscv 架构来说，a0寄存器表示第一个参数赋值，接着跳转到puts函数中。

此时传递过去的参数为a0，也就是

.section .rodata
msg:
     .string "Hello.
"

指向一个只读的字符串结构的数据。

puts的实现

通过汇编来描述一个串口驱动程序的编写是比较重要的。

puts:                           # `puts` subroutine writes null-terminated string to UART (serial communication port)
                                      # input: a0 register specifies the starting address of a null-terminated string
                                      # clobbers: t0, t1, t2 temporary registers

        li    t0, UART_BASE           # t0 = UART_BASE
1:      lbu   t1, (a0)                # t1 = load unsigned byte from memory address specified by a0 register
          beqz  t1, 3f                  # break the loop, if loaded byte was null

                                      # wait until UART is ready
2:      lw    t2, UART_REG_TXFIFO(t0) # t2 = uart[UART_REG_TXFIFO]
        bltz  t2, 2b                  # t2 becomes positive once UART is ready for transmission
        sw    t1, UART_REG_TXFIFO(t0) # send byte, uart[UART_REG_TXFIFO] = t1

        addi  a0, a0, 1               # increment a0 address by 1 byte
        j     1b

3:      ret

首先刚才通过a0寄存器将参数传递过来，然后从1：开始，读取字符串，beqz t1, 3f表示当t1 == 0时，跳转到3：之前。此时会跳出2：循环。

2：则是向串口FIFO送数的过程。

到这里一个字符串输出就可以正常的执行了。

5.编译与运行

5.1 编译

上述程序分析完成会，可以将其进行编译。

riscv64-unknown-elf-gcc -march=rv64g -mabi=lp64 -static -mcmodel=medany  -fvisibility=hidden -nostdlib -nostartfiles -Thello.ld -Isifive_u   hello.s -o hello

上述编译过程可以生成hello程序。

#readelf -h hello
ELF Header:
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF64
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           RISC-V
  Version:                           0x1
  Entry point address:               0x80000000
  Start of program headers:          64 (bytes into file)
  Start of section headers:          4680 (bytes into file)
  Flags:                             0x0
  Size of this header:               64 (bytes)
  Size of program headers:           56 (bytes)
  Number of program headers:         1
  Size of section headers:           64 (bytes)
  Number of section headers:         7
  Section header string table index: 6

可以分析一下gcc携带的参数。

-march：可以指定编译出来的架构，比如rv32或者rv64等等。

-static：表示静态编译。

-mabi=lp64：数据模型和浮点参数传递规则

数据模型：

-	int字长	long字长	指针字长
ilp32/ilp32f/ilp32d	32bits	32bits	32bits
lp64/lp64f/lp64d	32bits	64bits	64bits

浮点传递规则

-	需要浮点扩展指令？	float参数	double参数
ilp32/lp64	不需要	通过整数寄存器（a0-a1）传递	通过整数寄存器（a0-a3）传递
ilp32f/lp64f	需要F扩展	通过浮点寄存器（fa0-fa1）传递	通过整数寄存器（a0-a3）传递
ilp32d/lp64d	需要F扩展和D扩展	通过浮点寄存器（fa0-fa1）传递	通过浮点寄存器（fa0-fa1）传递

-mcmodel=medany：对于-mcmodel=medlow与-mcmodel=medany。

-mcmodel=medlow

使用 LUI 指令取符号地址的高20位。LUI 配合其它包含低12位立即数的指令后，可以访问的地址空间是 -2GiB ～ 2GiB。

对于 RV64 而言，能访问的就是 0x0000000000000000 ~ 0x000000007FFFFFFF，以及 0xFFFFFFFF800000000 ~ 0xFFFFFFFFFFFFFFFF 这两个区域，前一个区域即 +2GiB 的地址空间，后一个区域即 -2GiB 的地址空间。其它地址空间就访问不到了。

-mcmodel=medany

使用 AUIPC 指令取符号地址的高20位。AUIPC 配合其它包含低12位立即数的指令后，可以访问当前 PC 的前后2GiB (PC - 2GiB ~ PC + 2GiB)的地址空间。

对于RV64，取决于当前 PC 值，能访问到是 PC - 2GiB 到 PC + 2GiB 这个地址空间。假设当前 PC 是 0x1000000000000000，那么能访问的地址范围是 0x0000000080000000 ~ 0x100000007FFFFFFF。假设当前 PC 是 0xA000000000000000，那么能访问的地址范围是0x9000000080000000~0xA00000007FFFFFFF。

-fvisibility=hidden：动态库部分需要对外显示的函数接口显示出来。

-nostdlib：不连接系统标准启动文件和标准库文件，只把指定的文件传递给连接器。

-nostartfiles：不带main函数的入口程序。

-Thello.ld：加载链接地址。

5.2 运行

输入下面的命令即可看到Hello.字符串输出。

# qemu-system-riscv64 -nographic -machine sifive_u -bios none -kernel hello
Hello.

5.3 调试

调试过程比较只需在运行的后面加-s -S，即

qemu-system-riscv64 -nographic -machine sifive_u -bios none -kernel hello -s -S

另外再开一个终端输入

riscv64-unknown-elf-gdb hello

接着输入target remote localhost:1234即可。

通过b _start打断点，并且通过si进行单步跳转可实现程序的单步运行。

6.总结

riscv64最小裸机程序的运行很好理解，主要梳理清楚其启动地址与链接文件即可。还有就是注意gcc的编译参数，这些对于riscv的启动来说也是非常关键的部分。

责任编辑：xj

原文标题：riscv64 裸机编程实践与分析

文章出处：【微信公众号：嵌入式IoT】欢迎添加关注！文章转载请注明出处。

打开APP阅读更多精彩内容