（转）Nios II的Boot过程分析（II）
原文地址：http://blog.ednchina.com/rationalpower/
5.1 boot_loader.s解读
#ifdef EPCS
#define FIND_PAYLOAD sub_find_payload_epcs // 查找EPCS中数据负荷子程序
#define READ_INT sub_read_int_from_flash_epcs // 从EPCS中读取一个32位word
#define STREAMING_COPY sub_streaming_copy_epcs // 从EPCS中拷贝流的子程序
#define CLOSE_DEVICE sub_epcs_close // 关闭EPCS器件的子程序
#else
#define FIND_PAYLOAD sub_find_payload_cfi // 查找CFI并行flash中数据负荷的子程序
#define READ_INT sub_read_int_from_flash_cfi // 从CFI并行flash中读取一个32位的word
#define STREAMING_COPY sub_streaming_copy_cfi // 从CFI并行flash中拷贝流的子程序
#endif
#include "boot_loader.h"
.global reset
.global _start
.global main
.global end_of_boot_copier
reset:
_start:
main:
// 清除CPU的状态寄存器禁止中断，这个动作在硬件复位的时候其实已经自动完成。.
wrctl status, r_zero
// 冲刷指令cache.
// Nios II 最多支持64Kbytes的指令cache，所以只初始化了64Kbytes的指令cache
movhi r_flush_counter,%hi(0x10000)
cache_loop:
initi r_flush_counter
// 没有必要初始化数据cache, bootloader不存取存贮器数据
addi r_flush_counter, r_flush_counter,-32
bne r_flush_counter, r_zero, cache_loop
// 冲刷流水线
flushp
// r_flash_ptr = find_payload();
// 调用查找数据负荷子程序寻找数据负荷
nextpc return_address_less_4
br FIND_PAYLOAD
// 拷贝.
//
// 在循环的开始，寄存器r_flash_ptr 包含“程序记录”的地址。
//
// 1) 读取“程序记录”的长度域（4-bytes）(r_data_size)
// 2) 读取“程序记录”的目的地址域（4-bytes）(r_dest)
// 3) 循环:
// 拷贝 r_data_size 个字节, 一次一个字节: *r_dest++ = *r_flash_ptr++
// 把0xFFFFFFFF装入r_halt_record，用于测试是否要停机。
subi r_halt_record, r_zero, 1
per_record_loop:
//读取“程序记录”的长度域，r_data_size = READ_INT(r_flash_ptr++)。
nextpc return_address_less_4
br READ_INT
mov r_data_size, r_read_int_return_value
// 读取“程序记录”的目的地址域，r_dest = READ_INT(r_flash_ptr++)。
nextpc return_address_less_4
br READ_INT
mov r_dest, r_read_int_return_value
// 测试长度域是否为0
// 如果是就直接运行程序
beq r_data_size, r_zero, last_program_record
// 如果长度域为-1（0xFFFFFFFF），就停机。
halt_record_forever:
beq r_data_size, r_halt_record, halt_record_forever
// 使用拷贝流子程序搬移数据
nextpc return_address_less_4
br STREAMING_COPY
// 程序运行到这里，表明已经处理了当前的“程序记录”了，
// 而且知道这不是最后一个“程序记录”因为它的长度域不为0，
// 这就意味着要处理下一个“程序记录”。
br per_record_loop
last_program_record:
// 处理完最后一个程序记录后就要把控制权转给实际的运行程序.
// r_dest是实际程序的入口地址
// 在中止boot-loader之前要关闭EPCS器件，如果不做这一步，
// 会导致HAL的open()调用要花好几秒钟才能打开EPCS器件
#ifdef EPCS
nextpc return_address_less_4
br CLOSE_DEVICE
#endif
// 跳转到目的地址运行程序
callr r_dest
afterlife: // 程序跑到这里表明有问题。
br afterlife
.end
5.2 boot_loader_epcs_bits.s解读
// 从EPCS串行flash设备读取字节的子过程
// 通过寄存器和EPCS打交道获取字节数
#include "boot_loader.h"
.global sub_find_payload_epcs
.global sub_read_int_from_flash_epcs
.global sub_streaming_copy_epcs
.global sub_epcs_close
// EPCS控制和状态寄存器的偏移量
#define EPCS_RXDATA_OFFSET 0x00
#define EPCS_TXDATA_OFFSET 0x04
#define EPCS_STATUS_OFFSET 0x08
#define EPCS_CONTROL_OFFSET 0x0C
// EPCS的位掩码
#define EPCS_STATUS_TMT_MASK 0x20
#define EPCS_STATUS_TRDY_MASK 0x40
#define EPCS_STATUS_RRDY_MASK 0x80
#define EPCS_CONTROL_SSO_MASK 0x400
// EPCS命令
#define EPCS_COMMAND_READ 0x03
.text
//
// 查找EPCS的数据负荷
//
// 过程：
// - 在偏移量为0的地方打开EPCS器件（FPGA配置数据在这里）
// - 分析配置数据获取数据负荷开始的地址
// - 关闭EPCS
// - 在数据负荷的开始的地址再次打开EPCS
//
sub_find_payload_epcs:
// 修正并存贮返回地址
addi r_findp_return_address, return_address_less_4, 4
//
// 计算EPCS控制/状态寄存器块的地址
// 它在离本段代码的开头偏移量为512个字节的地方
// 因为这段代码必须在512字节边界处，
// 我们简单地把当前地址园整到下一个512个地址的边界。
//
// |
// | 为了调试，你可以定义EPCS_REGS_BASE
// | 作为EPCS寄存器基地址。否则就假设下一个512字节边界。
// |
nextpc r_findp_temp
#ifdef EPCS_REGS_BASE
movhi r_epcs_base_address, %hi(EPCS_REGS_BASE)
addi r_epcs_base_address, r_epcs_base_address, %lo(EPCS_REGS_BASE)
#else
ori r_epcs_base_address, r_findp_temp, 511
addi r_epcs_base_address, r_epcs_base_address, 1
#endif
//
// 在偏移量为0的地方打开EPCS器件
//
movi r_flash_ptr, 0
nextpc return_address_less_4
br sub_epcs_open_address
//
// 分析器件配置数据顺序读出字节直到下面任一个条件满足
// 1) 我们找到0xA6 （其实应该是0x56，因为我们没有把位序颠倒过来）
// 当我们找到它时表示我们找到配置数据，可以接着算出它的长度。
// 2) 我们找到不是xFF字节，在这种情况我们根本没有在配置数据里查找
// 我们假定我一定是在一个boot loader记录。跳过整个配置数据长度的计算
// 开始装载。
// 3) 我们在任意长的时间内找到的都是0xFF。我们猜测flash是空的没有其它可利用资源
//
// 搜索随意的一大块字节
movi r_findp_count, 0x400
// 我们要找的模板是0x56
movi r_findp_pattern, 0x56
// 在我们找到0x56之前唯一可以接受的字节是0xFF
movi r_findp_temp, 0xFF
fp_look_for_56_loop:
nextpc return_address_less_4
br sub_read_byte_from_flash_epcs
// 我们发现模板了吗？
beq r_read_byte_return_value, r_findp_pattern, fp_found_sync
// 我们发现非0xFF的字节了吗？
bne r_read_byte_return_value, r_findp_temp, fp_short_circuit
// 更新循环计数器开始循环
subi r_findp_count, r_findp_count, 1
bne r_findp_count, r_zero, fp_look_for_56_loop
// 我们没有找到模板或其它匹配的字节，挂起。
// 先关闭EPCS器件
nextpc return_address_less_4
br sub_epcs_close
fp_hang:
br fp_hang
fp_found_sync:
// 同步模板后面紧跟着的4个字节是我们感兴趣
nextpc return_address_less_4
br sub_read_int_from_flash_epcs
// 这4个字节是配置的长度，它们的字节顺序是little-endian，但位序是反的。
nextpc return_address_less_4
br sub_read_int_from_flash_epcs
// 把长度放到r_flash_ptr 中
mov r_flash_ptr, r_read_int_return_value
// 此时我们获得了长度但是在EPCS器件中Quarts
// 以相反的位序存贮字节
//
// 我们先把4位组反过来，再把2位组反过来，然后再把所有的位反过来。
// 就象这样：
//
// 76543210 – 4位组反序--> 32107654 – 两位组反序 --> 10325476 – 位反序 --> 01234567
//
// 下面是整个循环的进行机制
// 你会注意到这个反序过程只展示了一次
// 不用担心，所有的字节都会被反序
//
// ("x" == unknown, "." == zero)
//
// byte temp mask count
// -------- -------- -------- -----
// 初始态 76543210 xxxxxxxx 00001111 4
//
// 1 temp = byte & mask 76543210 ....3210 00001111 4
// 2 temp <<= count 76543210 3210.... 00001111 4
// 3 byte >>= count xxxx7654 3210.... 00001111 4
// 4 byte &= mask ....7654 3210.... 00001111 4
// 5 byte |= temp 32107654 3210.... 00001111 4
// 6 count >>= 1 32107654 3210.... 00001111 2
// 7 temp = mask << count 32107654 00111100 00001111 2
// 8 mask ^= temp 32107654 00111100 00110011 2
//
// loop on (count != 0)
//
// temp = byte & mask 32107654 ..10..54 00110011 2
// temp <<= count 32107654 10..54.. 00110011 2
// byte >>= count xx321076 10..54.. 00110011 2
// byte &= mask ..32..76 10..54.. 00110011 2
// byte |= temp 10325476 10..54.. 00110011 2
// count >>= 1 10325476 10..54.. 00110011 1
// temp = mask << count 10325476 01100110 00110011 1
// mask ^= temp 10325476 01100110 01010101 1
//
// loop on (count != 0)
//
// temp = byte & mask 10325476 .0.2.4.6 01010101 1
// temp <<= count 10325476 0.2.4.6. 01010101 1
// byte >>= count x1032547 0.2.4.6. 01010101 1
// byte &= mask .1.3.5.7 0.2.4.6. 01010101 1
// byte |= temp 01234567 0.2.4.6. 01010101 1
// count >>= 1 01234567 0.2.4.6. 01010101 0
// temp = mask << count 01234567 01010101 01010101 0
// mask ^= temp 01234567 01010101 00000000 0
//
// 初始化mask
movhi r_revbyte_mask, 0x0F0F
addi r_revbyte_mask, r_revbyte_mask, 0x0F0F
// 装入count
movi r_findp_count, 4
fp_reverse_loop:
// 屏蔽高一半的位把结果装入TEMP寄存器
and r_findp_temp, r_flash_ptr, r_revbyte_mask // 1
// 把TEMP中的位左移4位
sll r_findp_temp, r_findp_temp, r_findp_count // 2
// 把PTR中字节右移4位
srl r_flash_ptr, r_flash_ptr, r_findp_count // 3
// 屏蔽掉高4位
and r_flash_ptr, r_flash_ptr, r_revbyte_mask // 4
// 把PTR和TEMP中的位组合起来
or r_flash_ptr, r_flash_ptr, r_findp_temp // 5
// 更新移位计数器
srli r_findp_count, r_findp_count, 1 // 6
// 左移MASK 2位
sll r_findp_temp, r_revbyte_mask, r_findp_count // 7
// 更新MASK
xor r_revbyte_mask, r_revbyte_mask, r_findp_temp // 8
// 循环直到移位计数器为0
bne r_findp_count, r_zero, fp_reverse_loop
//
// 这个长度是以位为单位的长度，把它圆整到以字节为单位的长度。
//
addi r_flash_ptr, r_flash_ptr, 7 // r_flash_ptr += 7
srli r_flash_ptr, r_flash_ptr, 3 // r_flash_ptr /= 8;
fp_short_circuit:
// 关闭EPCS器件
nextpc return_address_less_4
br sub_epcs_close
// 重新打开EPCS器件(at r_flash_ptr)
nextpc return_address_less_4
br sub_epcs_open_address
jmp r_findp_return_address
////////
// EPCS_Open_Address
//
// 打开EPCS器件以便于我们读取给定地址开始的字节流
// 地址在r_flash_ptr给出
//
// 这只是一个sub_tx_rx_int_epcs 子过程的头部
// 没有必要修正返回地址，相反它直接跳转到sub_tx_rx_int_epcs
// 然后让子过程返回到原来的调用者那里。
//
// 寄存器用法：
// 参数： r_flash_ptr
// 临时寄存器： r_eopen_eclose_tmp
// 返回值： --none--
//
sub_epcs_open_address:
// 不需要修正返回地址，这只是一个子过程的头部
// 通过控制寄存器使能EPCS器件的片选
movi r_eopen_eclose_tmp, EPCS_CONTROL_SSO_MASK
stwio r_eopen_eclose_tmp, EPCS_CONTROL_OFFSET (r_epcs_base_address)
// 把读命令送入既定的寄存器中
movhi r_epcs_tx_value, (EPCS_COMMAND_READ << 8)
// 把flash指针送入低24位中
or r_epcs_tx_value, r_epcs_tx_value, r_flash_ptr
// 跳转到sub_tx_rx_int 子过程
br sub_tx_rx_int_epcs
// 现在EPCS器件已经在r_flash_ptr处打开
////////
// 关闭EPCS
//
// 终止当前的EPCS事务
//
sub_epcs_close:
// 修正返回地址
addi return_address_less_4, return_address_less_4, 4
// 等待控制器说发送器空
close_ready_loop:
ldwio r_eopen_eclose_tmp, EPCS_STATUS_OFFSET (r_epcs_base_address)
andi r_eopen_eclose_tmp, r_eopen_eclose_tmp, EPCS_STATUS_TMT_MASK
beq r_eopen_eclose_tmp, r_zero, close_ready_loop
// 清除SSO位释放CS
stwio r_zero, EPCS_CONTROL_OFFSET (r_epcs_base_address)
// 返回
jmp return_address_less_4 // 我们已经修复了返回地址
////////
// sub_read_int_from_flash_epcs
//
// epcs_rx_tx的另外一个入口
//
// 在进入sub_tx_rx_int_epcs先把epcs_tx_value清0
//
sub_read_int_from_flash_epcs:
// 这个子过程读取EPCS器件的下一个32位word，
// 假设一个有效的读命令和地址已经发出去，片选也是使能的
// 给发送的内容清0。
//
mov r_epcs_tx_value, r_zero
//
// 进入sub_tx_rx_int_epcs子过程
//
////////
// sub_tx_rx_int_epcs
//
// 这个子过程往flash写4个字节同时也读回4个字节
// 这4个字节没有什么地址对齐的限制
// 这个子过程写的时候是高位在先，读的时候是低位在先
// 因为EPCS处理命令的时候是高位在先，但是SOF文件的
// 编码却是低位在先
//
// 这个子过程和tx_rx_byte共享输入参数
// 只要tx_rx_byte 不破坏它的输入参数，
// 那这么做就是安全的。
//
// 寄存器用法：
// 入口参数： r_epcs_tx_value
// 局部变量： r_trie_count
// 局部返回指针： r_riff_return_address
// 返回的值： r_read_int_return_value
//
sub_tx_rx_int_epcs:
// 修正返回地址
addi r_riff_return_address, return_address_less_4, 4
//
// 写（高位在先）然后读（低位在先）
//
// 清楚返回的值
mov r_read_int_return_value, r_zero
// 发送/接收的字节数
movi r_trie_count, 4
trie_loop:
// 定位发送字节，使符合参数格式要求
roli r_epcs_tx_value, r_epcs_tx_value, 8
// 发送/接收一个字节
nextpc return_address_less_4
br sub_tx_rx_byte_epcs
// 把它反在结果寄存器的低位字节
or r_read_int_return_value, r_read_int_return_value, r_read_byte_return_value
// 循环移位结果寄存器以便于最后一个字节在高位字节
// 把其它字节移到低位字节
roli r_read_int_return_value, r_read_int_return_value, 24
// 计数器减1，继续循环。
subi r_trie_count, r_trie_count, 1
bne r_trie_count, r_zero, trie_loop
// 返回
jmp r_riff_return_address
////////
// sub_read_byte_from_flash_epcs
//
// epcs_rx_tx.的另一个入口
//
// 在进入epcs_tx_rx 之前把epcs_tx_value清0
//
sub_read_byte_from_flash_epcs:
// 该过程读取EPCS器件的下一个字节，
// 假设一个读命令和地址已经发送，片选也已经使能。
//
// 只要发送0给器件，我们就能收到下一个字节。
//
mov r_epcs_tx_value, r_zero
//
// 进入sub_tx_rx_byte_epcs子过程
//
////////
// sub_tx_rx_byte_epcs
//
// EPCS器件很有趣，每次你发送一些东西，同时也会收到东西。
// 每次你想收到东西，你就必须发送一些东西。
// 这个子过程把它的入口参数内容发送给EPCS, and returns whatever was
// 然后返回它从EPCS获取的值。
//
// 寄存器用法：
// 输入参数： r_epcs_tx_value
// 临时寄存器： rf_temp
// 返回值： r_read_byte_return_value
//
sub_tx_rx_byte_epcs:
// 修正返回地址Fix-up return-address (NOTE: LEAF)
addi return_address_less_4, return_address_less_4, 4
// 等待控制器准备好接收TX字节，然后发送它。
tx_ready_loop:
ldwio rf_temp, EPCS_STATUS_OFFSET (r_epcs_base_address)
andi rf_temp, rf_temp, EPCS_STATUS_TRDY_MASK
beq rf_temp, r_zero, tx_ready_loop
stwio r_epcs_tx_value, EPCS_TXDATA_OFFSET (r_epcs_base_address)
// 等待从EPCS接收的字节有效，然后获取它。
rx_ready_loop:
ldwio rf_temp, EPCS_STATUS_OFFSET (r_epcs_base_address)
andi rf_temp, rf_temp, EPCS_STATUS_RRDY_MASK
beq rf_temp, r_zero, rx_ready_loop
ldbuio r_read_byte_return_value, EPCS_RXDATA_OFFSET (r_epcs_base_address)
// 返回
jmp return_address_less_4 // 返回地址已被修正
////////
// 流拷贝
//
// 拷贝r_data_size字节，从r_flash_ptr到r_dest。
//
// 寄存器用法：
// 参数：r_data_size – 要拷贝的字节数
// 参数：r_dest - 拷贝的目的地址
// 隐含条件： r_flash_ptr – 拷贝的源地址
// 临时寄存器： rf_temp
// 返回值：无
//
// 所有参数在子过程中都会被破坏
//
// Note: we don't keep the flash ptr up to date. Instead
// we just keep streaming from the EPCS device
//
sub_streaming_copy_epcs:
// 修正返回地址 (NOTE: LEAF)
addi return_address_less_4, return_address_less_4, 4
// 为了更好的可读性，给r_data_size再定义一个别名
#define r_dest_end r_data_size
// 通过长度计算结束地址
add r_dest_end, r_data_size, r_dest
subi r_dest_end, r_dest_end, 1
// 等待EPCS控制器准备好接收TX字节
epcs_copy_initial_wait:
ldwio rf_temp, EPCS_STATUS_OFFSET (r_epcs_base_address)
andi rf_temp, rf_temp, EPCS_STATUS_TRDY_MASK
beq rf_temp, r_zero, epcs_copy_initial_wait
// 给EPCS送0
stwio r_zero, EPCS_TXDATA_OFFSET (r_epcs_base_address)
//
// do {
// *r_dest++ = (char*)r_flash_ptr++)
// while (r_dest <= r_dest_end);
//
epcs_copy_loop:
// 等待读取的字节有效
ldwio rf_temp, EPCS_STATUS_OFFSET (r_epcs_base_address)
andi rf_temp, rf_temp, EPCS_STATUS_RRDY_MASK
beq rf_temp, r_zero, epcs_copy_loop
// 读取EPCS的一个字节，并立即要求下一个字节
// 不必等待TX准备好，如果RX准备好了TX也一样。
ldwio rf_temp, EPCS_RXDATA_OFFSET (r_epcs_base_address)
stwio r_zero, EPCS_TXDATA_OFFSET (r_epcs_base_address)
// 存贮读到的字节，并更新目的地址指针
stbio rf_temp, 0(r_dest)
addi r_dest, r_dest, 1
// 循环直到目的地址指针指向结束地址
bne r_dest, r_dest_end, epcs_copy_loop
epcs_copy_last_wait:
// 等待最后读取的字节有效
ldwio rf_temp, EPCS_STATUS_OFFSET (r_epcs_base_address)
andi rf_temp, rf_temp, EPCS_STATUS_RRDY_MASK
beq rf_temp, r_zero, epcs_copy_last_wait
// 读取最后一个字节
ldwio rf_temp, EPCS_RXDATA_OFFSET (r_epcs_base_address)
// 存贮最后一个字节
stbio rf_temp, 0(r_dest)
// 返回
jmp return_address_less_4 // Don't worry--we fixed it.
// 文件结束
5.3 boot_loader_cfi_bits.s解读
#include "boot_loader.h"
.global sub_find_payload_cfi // 查找数据负荷的子程序
.global sub_read_int_from_flash_cfi // 从CFI并行flash中读取32位word的子程序
.global sub_streaming_copy_cfi // 从CFI并行flash中拷贝流的子程序
////////
// Read_Int_From_Flash_CFI
//
// 伪子程序，它从flash中读取4个字节并把它们拼起来形成一个整数
// 这4个字节没有地址对齐的要求
// 寄存器用法:
// 内部变量: r_riff_count
// 内部指针: r_riff_return_address
// 返回值: r_read_int_return_value
//
sub_read_int_from_flash_cfi:
// 修正中断返回地址，即在返回地址寄存器上加4
addi r_riff_return_address, return_address_less_4, 4
//
// 读取字节然后把它们移进返回寄存器中
//
// 先对返回寄存器清0
mov r_read_int_return_value, r_zero
// 返回的字节数
movi r_riff_count, 4
riffc_loop:
// 返回一个字节并泵进一下r_flash_ptr
ldbuio r_read_byte_return_value, 0(r_flash_ptr)
addi r_flash_ptr, r_flash_ptr, 1
// 把它以逻辑或运算的方式送入结果寄存器的低位字节
or r_read_int_return_value, r_read_int_return_value, r_read_byte_return_value
// 循环左移结果寄存器使最后一个字节在高位字节,
// 把其它字节移到低位字节
roli r_read_int_return_value, r_read_int_return_value, 24
// 计数器减1并循环
subi r_riff_count, r_riff_count, 1
bne r_riff_count, r_zero, riffc_loop
// 返回.
jmp r_riff_return_address
////////
// 流拷贝
//
// 拷贝 r_data_size 字节从r_flash_ptr 到 r_dest
//
// 寄存器用法:
// 参数: r_data_size 要拷贝的字节数
// 参数: r_dest 拷贝的目的地址
// 隐含的寄存器参数: r_flash_ptr 拷贝的源地址
// 临时寄存器: rf_temp
// 返回值: 无
//
// 所有的参数寄存器都会在这个子过程中被破坏
//
sub_streaming_copy_cfi:
// 修正返回地址 (NOTE: LEAF)
addi return_address_less_4, return_address_less_4, 4
// 为更好的可读性，给同一个寄存器定义了两个别名。
#define r_dest_end_plus_one r_data_size
// 把长度转化成结束地址加1
add r_dest_end_plus_one, r_data_size, r_dest
//
// do {
// *r_dest++ = (char*)r_flash_ptr++)
// while (r_dest != r_dest_end_plus_one);
//
cfi_copy_loop:
ldbuio rf_temp, 0(r_flash_ptr)
addi r_flash_ptr, r_flash_ptr, 1
stbio rf_temp, 0(r_dest)
addi r_dest, r_dest, 1
// 循环直到目的地址destination == 1 + 结束地址
bne r_dest, r_dest_end_plus_one, cfi_copy_loop
// Return
jmp return_address_less_4 // 不用担心，我们已经修正了它的值。.
////////
// 查找数据负荷
// 把数据负荷的第一个字节的偏移量送到r_flash_ptr返回。
// CFI:
// 数据负荷紧挨着boot-copier的后面存放，使用一些nextpc 这些位置无关
// 的指令来查找。
sub_find_payload_cfi:
// 修正并存贮返回地址
addi r_findp_return_address, return_address_less_4, 4
nextpc r_flash_ptr
payload_offset_base:
addi r_flash_ptr, r_flash_ptr, (end_of_boot_copier - payload_offset_base)
// 找到数据负荷r_flash_ptr现在包含有数据负荷的地址。
jmp r_findp_return_address
//
// 对于一个基于flash的启动代码，我们把它放在
// |reset地址，然后把数据紧挨着它存放，end_of_boot_copier
// 就是数据负荷的地址。
end_of_boot_copier:
// 数据在这里。
.end
6 Crt0.s解读
Nios II c程序在运行之前需要做一些初始化工作。如果程序直接从falsh中运行则Crt0.s是最先执行的代码，如果程序不是直接从flash中运行则Crt0.s是执行完bootloader后最开始执行的代码。
#include "nios2.h"
#include "system.h"
/*
* 宏ALT_LOAD_SECTIONS用于"run from flash"模式。它用于确定
* 是否有section（.RODATA段，.RWDATA段或.EXCEPTIONS段）
* 需要从flash装到RAM中。如果有的话就调用函数alt_load()加以装载。
*/
#define __ALT_LOAD_SECTIONS(res, text, rodata, exc) \
((res##_BASE != rodata##_BASE) || \ // 如果复位地址和.RODATA段，.RWDATA段
(res##_BASE != rwdata##_BASE) || \ // 或.EXCEPTIONS段所在存贮器基地址不同，
(res##_BASE != exc##_BASE)) // 则表明需要装载。符号“＃＃”用于拼接两个名字。
#define _ALT_LOAD_SECTIONS(res, text, rodata, exc) \
__ALT_LOAD_SECTIONS(res, text, rodata, exc)
#define ALT_LOAD_SECTIONS _ALT_LOAD_SECTIONS(ALT_RESET_DEVICE, \
ALT_RODATA_DEVICE, \
ALT_RWDATA_DEVICE, \
ALT_EXCEPTIONS_DEVICE)
/*
* 这是Nios II的入口地址
*
* 复位的时候只有包含有复位向量的cache line是初始化的，
* 所以第一个cache line 的代码要初始化其它的指令cache。
* 一个指令cache line大小是32个字节，所以代码长度不能超过8个指令。
* 注意：自动生成的linker script要求.init section小于0x20个字节
*/
.section .entry, "xa" // .entry段可执行可分配的
.align 5 // 和2^5=32字节边界对齐
/*
* 用户C代码要么在hosted mode 的mainn中，要么在standalone mode的alt_main中
*/
.globl main
.globl alt_main
/*
* 生成一个软件multiply/divide中断处理引用
* 这样一旦有下面的宏定义，它们就会被连入可执行文件中。
*/
#ifndef ALT_NO_INSTRUCTION_EMULATION
.globl alt_exception_muldiv
#endif
#ifdef ALT_TRAP_HANDLER
.globl alt_exception_trap
#endif
/*
* 有些工具需要知道reset vector在哪里
*/
.globl __reset
/*
* 连接器定义的符号，用于初始化.bss
*/
.globl __bss_start // .bss段的开始地址
.globl __bss_end // .bss段的结束地址
/*
* 明确声明可以使用r1 (汇编临时寄存器at)。
* 这个寄存器正常是保留个编译器使用的。
*/
.set noat
.type __reset, @function // 把__reset作为函数符号
__reset:
#ifdef ALT_RUN_FROM_FLASH
/*
* 如果我们在"run from flash"模式，那我们必须把代码放在
* reset 地址，初始化指令cache后跳转到入口(注意：
* 一旦.text段和reset 地址一样的话，"run from flash"就会
* 被设置). 如果我们没有在"run from flash"模式，那
* boot loader就会初始化指令cache就不需要这段代码了。
*/
/*
* 如果定义了ALT_SIM_OPTIMIZE 那这段代码不会在硬件上运行
* 这个定义移去了初始化的指令cache和数据cache。它假设这些在
* 仿真模型中已经做了
*/
#ifndef ALT_SIM_OPTIMIZE
/* 初始化指令cache的所有cache line */
#if NIOS2_ICACHE_SIZE > 0
/*
* 假设指令cache大小是2的幂
*/
#if NIOS2_ICACHE_SIZE > 0x8000
movhi r2, %hi(NIOS2_ICACHE_SIZE) // 2的幂最高位为1，其它都是0，所以只要
#else // 给高位字节赋值，低位字节清0就可以了。
movui r2, NIOS2_ICACHE_SIZE // 小于32k时位长不超过16位，直接赋值就可以。
#endif
0:
initi r2 // Nios II的cache是直接映射型，
addi r2, r2, -NIOS2_ICACHE_LINE_SIZE // 只要对一段和cache大小一样的内存对应的cache，
bgt r2, zero, 0b // 初始化即可以达到初始化整个cache的目的。
1:
/*
* 下面的调试信息块告诉仿真器不用运行上面的循环，
* 而使用内部的快速代码
*/
.pushsection .debug_alt_sim_info
.int 1, 1, 0b, 1b
.popsection
#endif /* NIOS2_ICACHE_SIZE > 0 */
/*
* 初始化cache后调用.text段的入口
*/
#endif /* ALT_SIM_OPTIMIZE */
movhi r1, %hiadj(_start) // 装入_start的高16位
addi r1, r1, %lo(_start) // 装入_start的低16位
jmp r1 // 跳转到.text段入口
.size __reset, . - __reset // 给函数符号__reset设置大小=当前位置-__reset开始的位置
#endif
/*
* .text段的开始，当程序用loader装载运行的时候同时也是代码的入口
*/
.section .text
.align 2 // 4字节对齐
.globl _start
.type _start, @function // 把_start作为函数符号
_start:
/*
* 如果定义了 ALT_SIM_OPTIMIZE那这段代码不会在硬件上运行。
* 这个宏定义移去了指令和数据cache的初始化部分，我们假设仿真
* 模型已经做了这些工作。
*/
#ifndef ALT_SIM_OPTIMIZE
/*
* 在初始化指令cache后我们必须初始化数据cache
*/
#if NIOS2_DCACHE_SIZE > 0
/*
* 假设数据cache大小是2的幂
*/
#if NIOS2_DCACHE_SIZE > 0x8000
movhi r2, %hi(NIOS2_DCACHE_SIZE) // 2的幂只有最高位是1，其它位都是0
#else // 所以大于32k的数，只要存高位字节就可以
movui r2, NIOS2_DCACHE_SIZE // 其它位置为0，小于32k的数，则可以直接
#endif // 赋值。
0:
initd 0(r2) // Nios II的cache是直接映射型的，所以只要
addi r2, r2, -NIOS2_DCACHE_LINE_SIZE // 初始化任何一块和cache一样大小的内存相关
bgt r2, zero, 0b // cache就可以初始化整个cache。
1:
/*
* 下面的调试信息块告诉仿真器不用执行上面的循环，
* 而是执行内部的快速代码。
*/
.pushsection .debug_alt_sim_info
.int 2, 1, 0b, 1b
.popsection
#endif /* NIOS2_DCACHE_SIZE > 0 */
#endif /* ALT_SIM_OPTIMIZE */
/*
* 现在caches已经被初始化，设置栈指针。
* 我们假设由连接器提供的值已经4字节对齐了。
*/
movhi sp, %hiadj(__alt_stack_pointer) // __alt_stack_pointer由连接器脚本定义。
addi sp, sp, %lo(__alt_stack_pointer)
/* 设置global pointer. */
movhi gp, %hiadj(_gp) // _gp由连接器脚本定义。
addi gp, gp, %lo(_gp)
#ifdef ALT_STACK_CHECK
/*
* 如果需要的化就设置栈顶变量。连接器已经在存贮器中设置了该变量的拷贝
*/
ldw et, %gprel(alt_stack_limit_value)(gp)
#endif
#ifndef ALT_SIM_OPTIMIZE
/*
* 给.bss段清0。
*
* 这里使用了符号：__bss_start and __bss_end,，这些在连接器脚本
* 中定义的变量。它们标志了.bss的开始和结束，连接器脚本保证
* 这些值都是32位对齐的。
*/
movhi r2, %hiadj(__bss_start)
addi r2, r2, %lo(__bss_start)
movhi r3, %hiadj(__bss_end)
addi r3, r3, %lo(__bss_end)
beq r2, r3, 1f
0: // 给.bss段清0。
stw zero, (r2)
addi r2, r2, 4
bltu r2, r3, 0b
1:
/*
* 下面的调试信息块告诉仿真器不用执行上面的循环，
* 而执行内部的快速代码。
*/
.pushsection .debug_alt_sim_info
.int 3, 1, 0b, 1b
.popsection
#endif /* ALT_SIM_OPTIMIZE */
/*
* 如果是从flash中运行的就把其它段装入RAM中。
*/
#ifdef ALT_RUN_FROM_FLASH // 如果没有bootloader即从flash直接执行，
#if ALT_LOAD_SECTIONS // 判断是否有段需要从flash中装到RAM中，
call alt_load // 有的话就调用alt_load函数装载。
#endif /* ALT_LOAD_SECTIONS */
#endif /* ALT_RUN_FROM_FLASH */
/* 调用C入口 */
call alt_main
/* alt_main永远都不会返回，所以我们在这里不需要再做任何事情。
*/
.size _start, . - _start // 给函数符号_start赋值大小=当前位置-_start开始的地址
#ifdef ALT_STACK_CHECK
/*
* 如果我们想检查堆栈溢出那我们需要知道堆栈的基地址
*/
.globl alt_stack_limit_value
.section .sdata,"aws",@progbits
.align 2
.type alt_stack_limit_value, @object
.size alt_stack_limit_value, 4
alt_stack_limit_value:
.long __alt_stack_limit
#endif
