My Blog

/* 不同数据类型的 Load （Store 类型） */
ldr         // load word
ldrh        // load unsigned half word
ldrsh       // load signed half word
ldrb        // load unsigned byte
ldrsb       // load signed byte

/* 将 list 的地址存入 r0，即 r0 = &list[0] */
ldr r0, =list   

/* 将 r0 值对应的地址的数据存入 r1，即 r1 = list[0] */
ldr r1, [r0]

/* 将 r0 值加 4 对应地址的数据存入 r2，即 r2 = list[1] 
   另外，加数必须为 4 的倍数，一个地址占 4 字节 */
ldr r2, [r0, #4]

/* 将 r0 值对应地址的数据存入 r3，然后 r0 再加 4，
   即 r3 = list[0], r0 += 4 */
ldr r3, [r0], #4

/* 多数据加载，将 r2 对应地址的值加载到 r0，然后再将地址+1的值
   加载到 r4，依次类推加载到 r6 为止 */
ldm r2, {r0, r4-r6}

/* ！表示将最后的地址写回到 r2 */
ldm r2!, {r0, r4-r6}

/* Store 存数据也是类似情形 */

/* 加减乘 */
add r2, r1, r0      // r2 = r1 + r0
sub r2, r1, r0      // r2 = r1 - r0
mul r2, r1, r0      // r2 = r1 * r0

/* 注意：普通的算数运算指令不会设置 CPSR 的标志位，所以当一些算数产生进位、借位
  溢出时我们就无法得知，所以就有了下面这些拓展指令 */
adds r2, r1, r0
subs r2, r1, r0
muls r2, r1, r0

/* 带进位借位运算 */
ADC r2, r1, r0      // r2 = r1 + r0 + carry_bit
SBC r2, r1, r0      // r2 = r1 - r0 - carry_bit

/* 与、或、异或 */
and r1, r0, #0xf    // r1 = r0 & (0xf)
orr r1, r0, #0xf    // r1 = r0 | (0xf)
eor r1, r0, #0xf    // r1 = r0 ^ (0xf) 

/* 赋值与取反 */
mov r0, #0xf        // r0 = 0xf
mvn r0, #0xf        // r0 = ~(0xf)

/* 左移 */
lsl r0, #1      // 对 r0 的值左移 1 位，立即数范围：0-31
lsl r1, r0      // 对 r1 的值左移 r0 值个位
lsl r1, r0, #1  // 将 r0 值左移移位存入 r1 中

/* 右移 */
lsr r0, #1      // r0 值右移 1 位，立即数范围：1-32

/* 循环右移 */
ror r0，#1      // r0 值向右循环移 1 位
ror r1, r0, #1

/* 注意：参与移位的寄存器必须为 r0-r7 */

/* 比较 - 即计算 r1 - r0 的差值，若为 +，CSPR N 位置 0，
   为 -，CPSR N 位置 1，为 0，CPSR Z 位置 1 */
cmp r1, r0

/* 通过 cmp 指令设置 CPSR 标志位，即可判断大小 */
BGT label   // 若 N=0,Z=0, 跳至 label 执行
BLT label   // 若 N=1,Z=0, 跳至 label 执行
BEQ label   // 若 N=0,Z=1, 跳至 label 执行
BGE(≥), BLE(≤), BNE(!=)
B label     // 跳转到 label

/* 条件跳转示例--遍历数组 */
.data
list:   // 定义数组，并获取数组长度
	.word 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
	.equ listend,(.-list)/4

.global _start
_start:     // 初始化寄存器
	ldr r0, =list   // r0 作数组下标
    mov r2, #0
    mov r3, #0
    
sum:        // 遍历数组求和
	ldr r3, [r0], #4    // 取出数组当前下标值，下标向后移
    add r2, r3          // r2 += r3
    cmp r3, #listend    // 判断下标是否超出数组长度
    blt sum             // 未超出跳至 sum 循环遍历
    
.end


/* 除了跳转可与条件结合使用外，算数运算也行，并组合成新指令 */
movlt r0, #1    // 若条件满足，r0=1
addgt r1, #2    // 若条件满足，r1+=2

/* 函数调用与返回 */
bl label       // 跳转 label 处执行，同时 LR 存入 bl 指令下条指令地址
bx lr          // 常用于子函数结尾，表示跳至 LR 所存地址处执行，即回到主函数

/* 栈--保护/恢复现场 */
push {r0, r1}  // 将当前寄存器的值压栈
mov r0, #0     // 执行一些语句，可能会改变寄存器值
pop {r0, r1}   // 出栈恢复寄存器值

/* 栈的一些用法： 
   1. 在调用函数前，将 reg 值压栈，防止子函数覆盖掉 reg 值，返回后再出栈
   2. 在子函数中压栈，在主函数中出栈，可获取子函数的返回值*/

/* C - 找出两数的最大值 */
int main(void)
{
   int a = 1, b = 2, res = 0;
   res = max(a, b);

   return 0;
}

int max(int a, int b) 
{
   return (a > b) ? a : b;
}


/* arm asm */
main:
        stmfd   sp!, {fp, lr}
        add     fp, sp, #4       // 创建 fp
        sub     sp, sp, #16      // 分配栈帧内存
        mov     r3, #1           // 向栈帧中存数据
        str     r3, [fp, #-8]
        mov     r3, #2
        str     r3, [fp, #-12]
        mov     r3, #0
        str     r3, [fp, #-16]
        ldr     r0, [fp, #-8]    // 取数据
        ldr     r1, [fp, #-12]
        bl      max
        str     r0, [fp, #-16]
        mov     r3, #0
        mov     r0, r3
        sub     sp, fp, #4       // 释放栈帧
        ldmfd   sp!, {fp, pc}
max:
        str     fp, [sp, #-4]!
        add     fp, sp, #0
        sub     sp, sp, #12
        str     r0, [fp, #-8]
        str     r1, [fp, #-12]
        ldr     r2, [fp, #-12]
        ldr     r3, [fp, #-8]
        cmp     r2, r3
        movge   r3, r2
        movlt   r3, r3
        mov     r0, r3
        add     sp, fp, #0
        ldmfd   sp!, {fp}
        bx      lr

/* Prologue - 保护前一程序的状态，并创建栈帧 */
str     fp, [sp, #-4]!
add     fp, sp, #0
sub     sp, sp, #12

/* Body - 完成函数功能，初始化参数、比较数值大小 */
str     r0, [fp, #-8]
str     r1, [fp, #-12]
ldr     r2, [fp, #-12]
ldr     r3, [fp, #-8]
cmp     r2, r3
movge   r3, r2
movlt   r3, r3
mov     r0, r3

/* Epilogue - 销毁栈帧，恢复现场，返回到主函数 */
add     sp, fp, #0
ldmfd   sp!, {fp}
bx      lr

/* Prologue */
main:
   stmfd   sp!, {fp, lr}
   add     fp, sp, #4      
   sub     sp, sp, #16      
max:
   str     fp, [sp, #-4]!
   add     fp, sp, #0
   sub     sp, sp, #12
/* no-leaf 在保护现场时还将 lr 寄存器压栈 */

/* Epilogue */
main:
   sub     sp, fp, #4       // 释放栈帧
   ldmfd   sp!, {fp, pc}
max:
   add     sp, fp, #0
   ldmfd   sp!, {fp}
   bx      lr
/* leaf 在函数结尾时跳至 lr 以返回到主函数 */

/* 汇编程序-在控制台打印 Hello world */
.global _start
_start:
         mov r0, #1        // 设置 file description 为 1，即 stdout
         ldr r1, =message  // 取字符串地址到 r1
         ldr r2, =len      // 取字符串长度到 r2
         mov r7, #4        // syscall-write
         swi 0             // 软中断

         mov r7, #1        // syscall-exit
         swi 0

.data
message:    // 以 ASCII 码形式存储字符串，message 指向该字符串
         .asciz "hello world!\n"
len = .-message   // 获取字符串长度

gdb test       // 使用 gdb 调试 test
gdb test -q    // -q(quite) 关闭 gdb test 的免责申明
break(b) _start       // b/break 在 _start 处打断点
run            // 运行程序到断点处

layout         // 查看布局
layout regs    // 查看所有寄存器
info register r0     // 查看单个寄存器
layout prev/next     // 布局窗口切换

stepi(s)       // 执行一条程序，若有函数调用则进入
next(n)        // 执行一条程序，不进入调用函数内部

x/10x $r1         // 从 r1 值开始以 hex 形式查看 10 个内存地址
x/10d $r1         // 从 r1 值开始以 decimal 形式查看 10 个内存地址
x/10c $r1         // 从 r1 值开始以 char 形式查看 10 个内存地址