这一期我们概略说一下MIPS架构并了解一下简单的汇编语句。首先推荐大家阅读一下SDK里DataSheet文件夹下的See MIPS Run Linux.pdf和MIPS.Assembly.Language.pdf两个文档。
MIPS的ISA(Instruction Set Architecture)超级精简,现在市面上大多数的路由器都是基于MIPS架构的,因为当年ARM还没有发力网络终端这个领域,所以现在很多的大型交换和路由设备都是采用并行MIPS架构,当然,随着技术的发展,MIPS和ARM这两种RISC架构的差异性会越来越小,将来评论谁优谁劣还是得看各自的市场运营能力了。MIPS的中文资料相比ARM较小,多数都是和龙芯相关的,希望龙芯能扛起MIPS大旗,真心盼望MIPS能在Imagination手里找到市场突破点。
之前看国外大学课程的《微机原理》视频都是拿MIPS作为实例,这真的是个不错的选择,因为MIPS架构的精简非常适合入门,想想现在国内课程大多数人第一次接触的指令往往都是8086或者8051,要把所有的指令分成1,2,3,n,......种字节,光是MOV和LEA就让我绕了一星期,更别提那各种各样的寻址方式,好麻烦的说。
学习一个新的CPU架构首先要抓住两个关键点:寄存器结构和指令集。每个CPU的架构其实都是在讲述指令是如何操作寄存器完成相应运算的故事,所以我们从寄存器和指令两个方面来大略了解MIPS架构。
MIPS有32个通用寄存器($0-$31),各寄存器的功能及汇编程序中使用约定如下:
下面给以详细说明:
$0:即$zero,该寄存器总是返回零,为0这个有用常数提供了一个简洁的编码形式。
move $t0,$t1 实际为 add $t0,$0,$t1 使用伪指令可以简化任务,汇编程序提供了比硬件更丰富的指令集。
$1:即$at,该寄存器为汇编保留,由于I型指令的立即数字段只有16位,在加载大常数时,编译器或汇编程序需要把大常数拆开,然后重新组合到寄存器里。比如加载一个32位立即数需要 lui(装入高位立即数)和addi两条指令。像MIPS程序拆散和重装大常数由汇编程序来完成,汇编程序必需一个临时寄存器来重组大常数,这也是为汇编 保留$at的原因之一。
$2..$3:($v0-$v1)用于子程序的非浮点结果或返回值,对于子程序如何传递参数及如何返回,MIPS范围有一套约定,堆栈中少数几个位置处的内容装入CPU寄存器,其相应内存位置保留未做定义,当这两个寄存器不够存放返回值时,编译器通过内存来完成。
$4..$7:($a0-$a3)用来传递前四个参数给子程序,不够的用堆栈。a0-a3和v0-v1以及ra一起来支持子程序/过程调用,分别用以传递参数,返回结果和存放返回地址。当需要使用更多的寄存器时,就需要堆栈(stack)了,MIPS编译器总是为参数在堆栈中留有空间以防有参数需要存储。
$8..$15:($t0-$t7)临时寄存器,子程序可以使用它们而不用保留。
$16..$23:($s0-$s7)保存寄存器,在过程调用过程中需要保留(被调用者保存和恢复,还包括$fp和$ra),MIPS提供了临时寄存器和保存寄存器,这样就减少了寄存器溢出(spilling,即将不常用的变量放到存储器的过程),编译器在编译一个叶(leaf)过程(不调用其它过程的过程)的时候,总是在临时寄存器分配完了才使用需要保存的寄存器。
$24..$25:($t8-$t9)同($t0-$t7)
$26..$27:($k0,$k1)为操作系统/异常处理保留,至少要预留一个。 异常(或中断)是一种不需要在程序中显示调用的过程。MIPS有个叫异常程序计数器(exception program counter,EPC)的寄存器,属于CP0寄存器,用于保存造成异常的那条指令的地址。查看控制寄存器的唯一方法是把它复制到通用寄存器里,指令mfc0(move from system control)可以将EPC中的地址复制到某个通用寄存器中,通过跳转语句(jr),程序可以返回到造成异常的那条指令处继续执行。MIPS程序员都必须保留两个寄存器$k0和$k1,供操作系统使用。发生异常时,这两个寄存器的值不会被恢复,编译器也不使用k0和k1,异常处理函数可以将返回地址放到这两个中的任何一个,然后使用jr跳转到造成异常的指令处继续执行。
$28:($gp)为了简化静态数据的访问,MIPS软件保留了一个寄存器:全局指针gp(global pointer,$gp),全局指针,静态数据区中的运行时决定的地址,在存取位于gp值上下32KB范围内的数据时,只需要一条以gp为基指针的指令即可。在编译时,数据须在以gp为基指针的64KB范围内。
$29:($sp)MIPS硬件并不直接支持堆栈,你可以把它用于别的目的,但为了使用别人的程序或让别人使用你的程序,还是要遵守这个约定的,但这和硬件没有关系。
$30:($fp)GNU MIPS C编译器使用了帧指针(frame pointer),而SGI的C编译器没有使用,而把这个寄存器当作保存寄存器使用($s8),这节省了调用和返回开销,但增加了代码生成的复杂性。
$31:($ra)存放返回地址,MIPS有个jal(jump-and-link,跳转并 链接)指令,在跳转到某个地址时,把下一条指令的地址放到$ra中。用于支持子程序,例如调用程序把参数放到$a0~$a3,然后jal X跳到X过程,被调过程完成后把结果放到$v0,$v1,然后使用jr $ra返回。
下面列出常见的MIPS指令:
MIPS虽然指令简单,但为了实现一些常用功能而增加了很多宏指令(Macro Instructions)也就是一条宏指令其实在CPU实际运行的是n条指令,这个程序的调试分析带来了一点难度。下面我列出MIPS的常见的宏指令信息:
U-Boot中的入口就是使用MIPS汇编实现的,也就是./cpu/ralink_soc/start.S文件,我们来具体分析一下这个文件,以达到对MIPS架构有一个大体的了解。 Ralink_SDK3.6中的start.S文件中包含很多条件编译信息,所以我做了一些删减,把与rt3052平台无关的信息都删除了,最后缩减成了758行,所以这里提到的行数都以我精简过的start.S文件作为参考。 start.S文件主要实现了4个功能: (1). 寄存器初始化; (2). 堆栈初始化; (3). 将代码导入RAM空间; (4). 跳转到C程序的初始化函数; 寄存器的初始化一般都有统一格式,例如: li t5, 0xa0300674 li t6, 0xffffffff nop sw t6,0(t5) nop 上面这5条语句就是实现了将0xa0300674地址的内存的内容改成0xffffffff的功能,可以对照上面两个表格分析一下。 堆栈的初始化从614行开始:
通过设置gp寄存器的值来实现,在设置好堆栈后就可以跳转执行C函数了,648行就跳转到了board_init_f函数;
relocate_code函数实现将U-Boot代码拷贝到RAM空间,然后跳转到board_init_r函数,此后就脱离start.S文件进行后续的初始化了。
REGISTER | NAME | USAGE |
$0 | $zero | 常量0(constant value 0) |
$1 | $at | 保留给汇编器(Reserved for assembler) |
$2-$3 | $v0-$v1 | 函数调用返回值(values for results and expression evaluation) |
$4-$7 | $a0-$a3 | 函数调用参数(arguments) |
$8-$15 | $t0-$t7 | 暂时的(或随便用的) |
$16-$23 | $s0-$s7 | 保存的(或如果用,需要SAVE/RESTORE的)(saved) |
$24-$25 | $t8-$t9 | 暂时的(或随便用的) |
$28 | $gp | 全局指针(Global Pointer) |
$29 | $sp | 堆栈指针(Stack Pointer) |
$30 | $fp | 帧指针(Frame Pointer) |
$31 | $ra | 返回地址(return address) |
下面列出常见的MIPS指令:
指令 | 功能 | 应用实例 |
LB | 从存储器中读取一个字节的数据到寄存器中 | LB R1, 0(R2) |
LH | 从存储器中读取半个字的数据到寄存器中 | LH R1, 0(R2) |
LW | 从存储器中读取一个字的数据到寄存器中 | LW R1, 0(R2) |
LD | 从存储器中读取双字的数据到寄存器中 | LD R1, 0(R2) |
L.S | 从存储器中读取单精度浮点数到寄存器中 | L.S R1, 0(R2) |
L.D | 从存储器中读取双精度浮点数到寄存器中 | L.D R1, 0(R2) |
LBU | 功能与LB指令相同,但读出的是不带符号的数据 | LBU R1, 0(R2) |
LHU | 功能与LH指令相同,但读出的是不带符号的数据 | LHU R1, 0(R2) |
LWU | 功能与LW指令相同,但读出的是不带符号的数据 | LWU R1, 0(R2) |
SB | 把一个字节的数据从寄存器存储到存储器中 | SB R1, 0(R2) |
SH | 把半个字节的数据从寄存器存储到存储器中 | SH R1,0(R2) |
SW | 把一个字的数据从寄存器存储到存储器中 | SW R1, 0(R2) |
SD | 把两个字节的数据从寄存器存储到存储器中 | SD R1, 0(R2) |
S.S | 把单精度浮点数从寄存器存储到存储器中 | S.S R1, 0(R2) |
S.D | 把双精度数据从存储器存储到存储器中 | S.D R1, 0(R2) |
DADD | 把两个定点寄存器的内容相加,也就是定点加 | DADD R1,R2,R3 |
DADDI | 把一个寄存器的内容加上一个立即数 | DADDI R1,R2,#3 |
DADDU | 不带符号的加 | DADDU R1,R2,R3 |
DADDIU | 把一个寄存器的内容加上一个无符号的立即数 | DADDIU R1,R2,#3 |
ADD.S | 把一个单精度浮点数加上一个双精度浮点数,结果是单精度浮点数 | ADD.S F0,F1,F2 |
ADD.D | 把一个双精度浮点数加上一个单精度浮点数,结果是双精度浮点数 | ADD.D F0,F1,F2 |
ADD.PS | 两个单精度浮点数相加,结果是单精度浮点数 | ADD.PS F0,F1,F2 |
DSUB | 两个寄存器的内容相减,也就是定点数的减 | DSUB R1,R2,R3 |
DSUBU | 不带符号的减 | DSUBU R1,R2,R3 |
SUB.S | 一个双精度浮点数减去一个单精度浮点数,结果为单精度 | SUB.S F1,F2,F3 |
SUB.D | 一个双精度浮点数减去一个单精度浮点数,结果为双精度浮点数 | SUB.D F1,F2,F3 |
SUB.PS | 两个单精度浮点数相减 | SUB.SP F1,F2,F3 |
DDIV | 两个定点寄存器的内容相除,也就是定点除 | DDIV R1,R2,R3 |
DDIVU | 不带符号的除法运算 | DDIVU R1,R2,R3 |
DIV.S | 一个双精度浮点数除以一个单精度浮点数,结果为单精度浮点数 | DIV.S F1,F2,F3 |
DIV.D | 一个双精度浮点数除以一个单精度浮点数,结果为双精度浮点数 | DIV.D F1,F2,F3 |
DIV.PS | 两个单精度浮点数相除,结果为单精度 | DIV.PS F1,F2,F3 |
DMUL | 两个定点寄存器的内容相乘,也就是定点乘 | DMUL R1,R2,R3 |
DMULU | 不带符号的乘法运算 | DMULU R1,R2,R3 |
MUL.S | 一个双精度浮点数乘以一个单精度浮点数,结果为单精度浮点数 | DMUL.S F1,F2,F3 |
MUL.D | 一个双精度浮点数乘以一个单精度浮点数,结果为双精度浮点数 | DMUL.D F1,F2,F3 |
MUL.PS | 两个单精度浮点数相乘,结果为单精度浮点数 | DMUL.PS F1,F2,F3 |
AND | 与运算,两个寄存器中的内容相与 | AND R1,R2,R3 |
ANDI | 一个寄存器中的内容与一个立即数相与 | ANDI R1,R2,#3 |
OR | 或运算,两个寄存器中的内容相或 | OR R1,R2,R3 |
ORI | 一个寄存器中的内容与一个立即数相或 | ORI R1,R2,#3 |
XOR | 异或运算,两个寄存器中的内容相异或 | XOR R1,R2,R3 |
XORI | 一个寄存器中的内容与一个立即数异或 | XORI R1,R2,#3 |
BEQZ | 条件转移指令,当寄存器中内容为0时转移发生 | BEQZ R1,0 |
BENZ | 条件转移指令,当寄存器中内容不为0时转移发生 | BNEZ R1,0 |
BEQ | 条件转移指令,当两个寄存器内容相等时转移发生 | BEQ R1,R2 |
BNE | 条件转移指令,当两个寄存器中内容不等时转移发生 | BNE R1,R2 |
J | 直接跳转指令,跳转的地址在指令中 | J name |
JR | 使用寄存器的跳转指令,跳转地址在寄存器中 | JR R1 |
JAL | 直接跳转指令,并带有链接功能,指令的跳转地址在指令中,跳转发生时要把返回地址存放到R31这个寄存器中 | JAL R1 name |
JALR | 使用寄存器的跳转指令,并且带有链接功能,指令的跳转地址在寄存器中,跳转发生时指令的放回地址放在R31这个寄存器中 | JALR R1 |
MOV.S | 把一个单精度浮点数从一个浮点寄存器复制到另一个浮点寄存器 | MOV.S F0,F1 |
MOV.D | 把一个双精度浮点数从一个浮点寄存器复制到另一个浮点寄存器 | MOV.D F0,F1 |
MFC0 | 把一个数据从通用寄存器复制到特殊寄存器 Move from coprocessor 0 | MFC0 R1,R2 |
MTC0 | 把一个数据从特殊寄存器复制到通用寄存器 Move to coprocessor 0 | MTC0 R1,R2 |
MFC1 | 把一个数据从定点寄存器复制到浮点寄存器 | MFC1 R1,F1 |
MTC1 | 把一个数据从浮点寄存器复制到定点寄存器 | MTC1 R1,F1 |
LUI | 把一个16位的立即数填入到寄存器的高16位,低16位补零 | LUI R1,#42 |
DSLL | 双字逻辑左移 | DSLL R1,R2,#2 |
DSRL | 双字逻辑右移 | DSRL R1,R2,#2 |
DSRA | 双字算术右移 | DSRA R1,R2,#2 |
DSLLV | 可变的双字逻辑左移 | DSLLV R1,R2,#2 |
DSRLV | 可变的双字罗伊右移 | DSRLV R1,R2,#2 |
DSRAV | 可变的双字算术右移 | DSRAV R1,R2,#2 |
SLT | 如果R2的值小于R3,那么设置R1的值为1,否则设置R1的值为0 | SLT R1,R2,R3 |
SLTI | 如果寄存器R2的值小于立即数,那么设置R1的值为1,否则设置寄存器R1的值为0 | SLTI R1,R2,#23 |
SLTU | 功能与SLT一致,但是带符号的 | SLTU R1,R2,R3 |
SLTUI | 功能与SLT一致,但不带符号 | SLTUI R1,R2,R3 |
MOVN | 如果第三个寄存器的内容为负,那么复制一个寄存器的内容到另外一个寄存器 | MOVN R1,R2,R3 |
MOVZ | 如果第三个寄存器的内容为0,那么复制一个寄存器的内容到另外一个寄存器 | MOVZ R1,R2,R3 |
TRAP | 根据地址向量转入管态 | |
ERET | 从异常中返回到用户态 | |
MADD.S | 一个双精度浮点数与单精度浮点数相乘加,结果为单精度 | |
MADD.D | 一个双精度浮点数与单精度浮点数相乘加,结果为双精度 | |
MADD.PS | 两个单精度浮点数相乘加,结果为单精度 |
eq. | Name | Brief | Actual Code | Space/Time | Description |
1 | abs Rd, Rs | Absolute Value | addu Rd, $0, Rs bgez Rs, 1 sub Rd, $0, Rs | 3/3 | |
2 | beqz Rs, Label | Branch if Equal to Zero | beq Rs, $0, Label | 1/1 | |
3 | bge Rs, Rt, Label | Branch if Greater than or Equal | slt $at, Rs, Rt 2/2 beq $at, $0, Label | 2/2 | If Reg.File[Rs] > = Reg.File[Rt] branch to Label Used to compare values represented in the two's complement number system. |
4 | bgeu Rs, Rt, Label | Branch if Greater than or Equal Unsigned | sltu $at, Rs, Rt beq $at, $0, Label | 2/2 | If Reg.File[Rs] > = Reg.File[Rt] branch to Label Used to compare addresses (unsigned values). |
5 | bgt Rs, Rt, Label | Branch if Greater Than | slt $at, Rt, Rs bne $at, $0, Label | 2/2 | If Reg.File[Rs] > Reg.File[Rt] branch to Label Used to compare values represented in the two's complement number system. |
6 | bgtu Rs, Rt, Label | Branch if Greater Than Unsigned | sltu $at, Rt, Rs bne $at, $0, Label | 2/2 | If Reg.File[Rs] > Reg.File[Rt] branch to Label Used to compare addresses (unsigned values). |
7 | ble Rs, Rt, Label | Branch if Less Than or Equal | slt $at, Rt, Rs beq $at, $0, Label | 2/2 | If Reg.File[Rs] < = Reg.File[Rt] branch to Label Used to compare values represented in the two's complement number system. |
8 | bleu Rs, Rt, Label | Branch if Less Than or Equal Unsigned | sltu $at, Rt, Rs beq $at, $0, Label | 2/2 | If Reg.File[Rs] < = Reg.File[Rt] branch to Label Used to compare addresses (unsigned values). |
9 | blt Rs, Rt, Label | Branch if Less Than | slt $at, Rs, Rt bne $at, $0, Label | 2/2 | If Reg.File[Rs] < Reg.File[Rt] branch to Label Used to compare values represented in the two's complement number system |
10 | bltu Rs, Rt, Label | Branch if Less Than Unsigned | sltu $at, Rs, Rt bne $at, $0, Label | 2/2 | If Reg.File[Rs] < Reg.File[Rt] branch to Label Used to compare addresses (unsigned values). |
11 | bnez Rs, Label | Branch if Not Equal to Zero | bne Rs, $0, Label | 1/1 | |
12 | b Label | Branch Unconditional | bgez $0, Label | 1/1 | |
13 | div Rd, Rs, Rt | Divide | bne Rt, $0, ok break $0 ok: div Rs, Rt mflo Rd | 4/41 | |
14 | divu Rd, Rs, Rt | Divide Unsigned | bne Rt, $0, ok break $0 ok: divu Rs, Rt mflo Rd | 4/41 | |
15 | la Rd, Label | Load Address | lui $at, Upper 16-bits of Label ori Rd, $at, Lower 16-bits of Label | 2/2 | Used to initialize pointers |
16 | li Rd, value | Load Immediate | lui $at, Upper 16-bits of value ori Rd, $at, Lower 16-bits of value | 2/2 | Initialize registers with negative constants and values greater than 32767. |
17 | li Rd, value | Load Immediate | ori Rt, $0, value | 1/1 | Initialize registers with positive constants less than 32768. |
18 | move Rd, Rs | Move | addu Rd, $0, Rs | 1/1 | |
19 | mul Rd, Rs, Rt | Multiply | mult Rs, Rt mflo Rd | 2/33 | |
20 | mulo Rd, Rs, Rt | Multiply (with overflow exception) | mult Rs, Rt mfhi $at mflo Rd sra Rd, Rd, 31 beq $at, Rd, ok break $0 ok: mflo Rd | 7/37 | |
21 | mulou Rd, Rs, Rt | Multiply Unsigned (with overflow exception) | multu Rs, Rt mfhi $at beq $at, $0, ok ok: break $0 mflo Rd | 5/35 | |
22 | neg Rd, Rs | Negate | sub Rd, $0, Rs | 1/1 | Two's complement negation. An exception is generated when there is an attempt to negate the most negative value: 2,147,483,648. |
23 | negu Rd, Rs | Negate Unsigned | subu Rd, $0, Rs | 1/1 | |
24 | nop | Nop | or $0, $0, $0 | 1/1 | |
25 | not Rd, Rs | Not | nor Rd, Rs, $0 | 1/1 | A bit-wise Boolean complement. |
26 | rem Rd, Rs, Rt | Remainder | bne Rt, $0, 8 break $0 div Rs, Rt mfhi Rd | 4/40 | |
27 | remu Rd, Rs, Rt | Remainder Unsigned | bne Rt, $0, ok break $0 ok: divu Rs, Rt mfhi Rd | 4/40 | |
28 | rol Rd, Rs, Rt | Rotate Left Variable | subu $at, $0, Rt srlv $at, Rs, $at sllv Rd, Rs, Rt or Rd, Rd, $at | 4/4 | The lower 5-bits in Rt specifys the shift amount. |
29 | ror Rd, Rs, Rt | Rotate Right Variable | subu $at, $0, Rt sllv $at, Rs, $at srlv Rd, Rs, Rt or Rd, Rd, $at | 4/4 | |
30 | rol Rd, Rs, sa | Rotate Left Constant | srl $at, Rs, 32-sa sll Rd, Rs, sa or Rd, Rd, $at | 3/3 | |
31 | ror Rd, Rs, sa | Rotate Right Constant | sll $at, Rs, 32-sa srl Rd, Rs, sa or Rd, Rd, $at | 3/3 | |
32 | seq Rd, Rs, Rt | Set if Equal | beq Rt, Rs, yes ori Rd, $0, 0 beq $0, $0, skip yes: ori Rd, $0, 1 skip: | 4/4 | |
33 | sge Rd, Rs, Rt | Set if Greater Than or Equal | bne Rt, Rs, yes ori Rd, $0, 1 beq $0, $0, skip yes: slt Rd, Rt, Rs skip: | 4/4 | |
34 | sgeu Rd, Rs, Rt | Set if Greater Than or Equal Unsigned | bne Rt, Rs, yes ori Rd, $0, 1 beq $0, $0, skip yes: sltu Rd, Rt, Rs skip: | 4/4 | |
35 | sgt Rd, Rs, Rt | Set if Greater Than | slt Rd, Rt, Rs | 1/1 | |
36 | sgtu Rd, Rs, Rt | Set if Greater Than Unsigned | sltu Rd, Rt, Rs | 1/1 | |
37 | sle Rd, Rs, Rt | Set if Less Than or Equal | bne Rt, Rs, yes ori Rd, $0, 1 beq $0, $0, skip yes: slt Rd, Rs, Rt skip: | 4/4 | |
38 | sleu Rd, Rs, Rt | Set if Less Than or Equal Unsigned | bne Rt, Rs, yes ori Rd, $0, 1 beq $0, $0, skip yes: sltu Rd, Rs, Rt skip: | 4/4 | |
39 | sne Rd, Rs, Rt | Set if Not Equal | beq Rt, Rs, yes ori Rd, $0, 1 beq $0, $0, skip yes: ori Rd, $0, 0 skip: | 4/4 | |
40 | ulh Rd, 3(Rs) | Unaligned Load Halfword Unsigned | lb Rd, 4(Rs) lbu $at, 3(Rs) sll Rd, Rd, 8 or Rd, Rd, $at | 4/4 | |
41 | ulhu Rd, 3(Rs) | Unaligned Load Halfword | lbu Rd, 4(Rs) lbu $at, 3(Rs) sll Rd, Rd, 8 or Rd, Rd, $at | 4/4 | |
42 | ulw Rd, 3(Rs) | Unaligned Load Word | lwl Rd, 6(Rs) lwr Rd, 3(Rs) | 2/2 | |
43 | ush Rd, 3(Rs) | Unaligned Store Halfword | sb Rd, 3(Rs) srl $at, Rd, 8 sb $at, 4(Rs) | 3/3 | |
44 | usw Rd, 3(Rs) | Unaligned Store Word | swl Rd, 6(Rs) swr Rd, 3(Rs) | 2/2 |
U-Boot中的入口就是使用MIPS汇编实现的,也就是./cpu/ralink_soc/start.S文件,我们来具体分析一下这个文件,以达到对MIPS架构有一个大体的了解。 Ralink_SDK3.6中的start.S文件中包含很多条件编译信息,所以我做了一些删减,把与rt3052平台无关的信息都删除了,最后缩减成了758行,所以这里提到的行数都以我精简过的start.S文件作为参考。 start.S文件主要实现了4个功能: (1). 寄存器初始化; (2). 堆栈初始化; (3). 将代码导入RAM空间; (4). 跳转到C程序的初始化函数; 寄存器的初始化一般都有统一格式,例如: li t5, 0xa0300674 li t6, 0xffffffff nop sw t6,0(t5) nop 上面这5条语句就是实现了将0xa0300674地址的内存的内容改成0xffffffff的功能,可以对照上面两个表格分析一下。 堆栈的初始化从614行开始:
/*
********************************************************************
* Set up temporary stack.
********************************************************************
*/
li a0, CFG_INIT_SP_OFFSET
//bal mips_cache_lock
nop
li t0, CFG_SDRAM_BASE + CFG_INIT_SP_OFFSET
la sp, 0(t0)
/* Initialize GOT pointer.
*/
#if 0
bal 1f
nop
.word _GLOBAL_OFFSET_TABLE_ - 1f + 4
1:
move gp, ra
lw t1, 0(ra)
add gp, t1
#else
/* winfred: a easier way to get gp value so that mipsel-linux-as can
* assemble correctly without -mips_allow_branch_to_undefined flag
*/
bal 1f
nop
.word _GLOBAL_OFFSET_TABLE_
1:
lw gp, 0(ra)
#endif
la t9, board_init_f
j t9
nop
通过设置gp寄存器的值来实现,在设置好堆栈后就可以跳转执行C函数了,648行就跳转到了board_init_f函数;
/*
************************************************************************
* void relocate_code (addr_sp, gd, addr_moni)
*
* This "function" does not return, instead it continues in RAM
* after relocating the monitor code.
*
* a0 = addr_sp
* a1 = gd
* a2 = destination address
************************************************************************
*/
.globl relocate_code
.ent relocate_code
relocate_code:
move sp, a0 /* Set new stack pointer */
li t0, CFG_MONITOR_BASE
la t3, in_ram
lw t2, -12(t3) /* t2 <-- uboot_end_data */
move t1, a2
/*
* Fix GOT pointer:
*
* New GOT-PTR = (old GOT-PTR - CFG_MONITOR_BASE) + Destination Address
*/
move t6, gp
sub gp, CFG_MONITOR_BASE
add gp, a2 /* gp now adjusted */
sub t6, gp, t6 /* t6 <-- relocation offset */
/*
* t0 = source address
* t1 = target address
* t2 = source end address
*/
/* On the purple board we copy the code earlier in a special way
* in order to solve flash problems
*/
#ifndef CONFIG_PURPLE
1:
lw t3, 0(t0)
sw t3, 0(t1)
addu t0, 4
ble t0, t2, 1b
addu t1, 4 /* delay slot */
#endif
/* If caches were enabled, we would have to flush them here.
*/
/* Jump to where we've relocated ourselves.
*/
addi t0, a2, in_ram - _start
j t0
nop
.word uboot_end_data
.word uboot_end
.word num_got_entries
in_ram:
/* Now we want to update GOT.
*/
lw t3, -4(t0) /* t3 <-- num_got_entries */
addi t4, gp, 8 /* Skipping first two entries. */
li t2, 2
1:
lw t1, 0(t4)
beqz t1, 2f
add t1, t6
sw t1, 0(t4)
2:
addi t2, 1
blt t2, t3, 1b
addi t4, 4 /* delay slot */
/* Clear BSS.
*/
lw t1, -12(t0) /* t1 <-- uboot_end_data */
lw t2, -8(t0) /* t2 <-- uboot_end */
add t1, t6 /* adjust pointers */
add t2, t6
sub t1, 4
1: addi t1, 4
bltl t1, t2, 1b
sw zero, 0(t1) /* delay slot */
move a0, a1
la t9, board_init_r
j t9
move a1, a2 /* delay slot */
.end relocate_code
relocate_code函数实现将U-Boot代码拷贝到RAM空间,然后跳转到board_init_r函数,此后就脱离start.S文件进行后续的初始化了。
MIPS架构的汇编我就简单的说这些,我个人大约用了3个月的时间才勉强入门,希望大家看过这一期可以对MIPS进行架构进行更深入的学习。
----------------------------------------------------
SDK下载地址: https://github/aggresss/RFDemo更多推荐
第十五期 MIPS汇编U-Boot从start.S开始《路由器就是开发板》
发布评论