• 10.5汇编语言整理

    【汇编语言相关语法】

    1.汇编语言的组成部分

            1.伪操作：不参与程序的执行，但是用于告诉编译器程序该怎么编译 .text .global .end .if .else .endif .data

            2.汇编指令 编译器将一条汇编指令编译成一条机器码，在内存里一条指令占4字节内存，一条指令可以实现一个特定的功能

            3.伪指令 不是指令，看起来像是一条指令，可以实现和指令类似的功能。一条伪指令实际上可能是由多条指令共同实现

            4.注释 单行注释： @ 多行注释 /* */ 条件编译 .if 0 指令段 .else 指令段 .endif

    2.汇编指令的介绍

            1.基本数据操作指令 数据搬移指令 = 数据移位指令 << >> 数据算数运算指令 + - * / 位运算指令 & | ~ ^ 数据比较指令

            2.跳转指令

             3.内存读写指令

            4.状态寄存器读写指令

            5.软中断指令

    3.汇编指令的基本语法格式

    指令的基本格式： {}{s} , ,

    解释：

            ：指令码

            {}：条件码

            {s}：状态位，如果在指令后面加上s，则运算的结果会影响CPSR的条件位

             ：目标寄存器

            ：第一操作寄存器 只能是寄存器

            ：第二操作数，可以是寄存器，也可以是立即数 按照指令码将第一操作寄存器和第二操作数进行运算，将运算后的结果保存在目标寄存器

            注意： 1.一条汇编指令一般占一行 2.汇编不区分大写小写

    【汇编指令】

    1.数据搬移指令

    1.1 格式

    {}{s} ,

    解释：

            ：指令码

            {}：条件码

            {s}：状态位，如果在指令后面加上s，则运算的结果会影响CPSR的条件位

            ：目标寄存器 ：第一操作数，可以是寄存器，也可以是立即数 按照指令码将第一操作数运算后的结果保存在目标寄存器

    指令码功能： mov:将第一操作数的值保存在目标寄存器

                            mvn:将第一操作数的值按位取反，将结果保存在目标寄存器

    1.2 示例

    1.3 立即数的概念

    定义：能够直接当作指令的一部分参与到指令的执行过程中的数据就是立即数.立即数由一个0-255范围内的数循环右移偶数位获得。

    在指令的32为中将低12位预留保存立即数的数据

    如何判断一个数据是不是立即数： 在0-255范围内找一个数，让它循环右移偶数位（一个0-15范围内的数*2得到），如果能够得到这个数据，则这个数就是一个立即数。

    循环右移：最低位移出去的数补到最高位 0000 0000 0000 0000 0000 0000 0000 1010

    右移两位： 0000 0000 0000 0000 0000 0000 0000 0010

    循环右移两位： 100000 0000 0000 0000 0000 0000 0000 10 ex: 0X104： 0000 0000 0000 0000 0000 0001 0000 0100

    循环右移2位-》000000 0000 0000 0000 000000 0100 0001 -》0x41 换句话说，将0x41循环右移30位得到0X104,所以，0X104是一个立即数 0X101:0000 0000 0000 0000 0000 0001 0000 0001 0X101找不到一个0-255范围内的数循环右移得到它，所以0X101不是立即数

    1.4 将非立即数保存至寄存器中

    伪指令： LDR 目标寄存器,=数值 将指定的数据放在目标寄存器中 ex:LDR r1,=0X12345678

    2.移位指令

    2.1 格式以及指令码

    格式：{}{s} , ,

    解释：将第一操作寄存器的数值移位第二操作数指定的位数，将结果保存在目标寄存器中

    指令码： LSL：左移运算 低位补0

                     LSR:右移运算 高位补0

                    ROR:循环右移：低位移出的值补到高位

    2.2 示例

    1. 1.左移
    2.         mov r0,#0XFF
    3.     lsl r1,r0,#0X4  @将R0的值左移4位保存在r1寄存器  R1结果：0XFF0
    4.  2.右移
    5.  mov r0,#0XFF
    6. lsr r1,r0,#0X4  @将R0的值右移4位保存在r1寄存器  R1结果：0XF
    7. 3.循环右移
    8. mov r0,#0XFF
    9. ror r1,r0,#0X4  @将R0的值循环右移4位保存在r1寄存器  R1结果：0XF000000F
    10. 4.c风格写法
    11. mov r0,#0XFF
    12. ror r1,r0,#(0X1<<2)  @将R0的值循环右移4位保存在r1寄存器  R1结果：0XF000000F

    3.位运算指令

    3.1 格式以及功能码

    格式：{}{s} , ,

    解释：将第一操作寄存器和第二操作数进行位运算，将结果保存在目标寄存器中

    指令码： and:与 与0清0 与1不变

                    orr:或 或1置1 或0不变

                    eor:异或 相同为0 不同为1

                    bic:按位清零指令，想将哪一位设置为0，只需要用bic指令给这一位运算一个1即可

    3.2 示例

    1. 1.and:
    2. mov r0,#0XFF
    3.     and r1,r0,#0XF0  @R1结果为0XF0
    4.  2.ORR:
    5.      mov r0,#0XFF
    6.     orr r1,r0,#0XF000  @R1结果为0XF0FF
    7. 3.EOR:
    8.     ldr r0,=0xf0f0
    9.     EOr r1,r0,#0XFF  @R1结果为0XF00F
    10. 0000 0000 0000 0000 0000 0000 1111 1111
    11. 0000 0000 0000 0000 1111 0000 1111 0000
    12. 结果：0000 0000 0000 0000 1111 0000 0000 1111 -》0XF00F
    13.  
    14. 4.BIC
    15.  ldr r0,=0xFF
    16.     BIC r0,r0,#(0x1<<5)  @将R0的值第5位清0 @R0结果为0XDF

    3.3 练习

    1. LDR r1,=0X12345678  @将0X12345678存放在r1寄存器
    2. 0001 0010 0011 0100 0101 0110 0111 1000
    3. 1.将R1寄存器的第4位清0，其他位不变
    4.         and r1,r1,#(~(0X1<<4))
    5.     或者BIC R1,R1,#(0x1<<4)
    6. 2.将r1寄存器第7位置1，其他位不变
    7. orr r1,r1,#(0X1<<7)
    8. 3.将r1寄存器[31：28]清0，其他位不变
    9. and r1,r1,#(~(0Xf<<28))
    10.     或者BIC R1,R1,#(0xF<<28)
    11. 4.将r1寄存器[7:4]置1，其他位不变
    12. orr r1,r1,#(0XF<<4)
    13. 5.将r1寄存器[15:11]设置为10101，其他位不变 
    14.     @先清0
    15.     BIC R1,R1,#(0X1F<<11)
    16.     @再置位
    17.     orr r1,r1,#(0X15<<11)

    4.算数运算指令

    4.1 格式以及指令码

    格式：{}{s} , ,

    解释：将第一操作寄存器的值和第二操作数进行算数运算，结果保存在目标寄存器中

            add:加法运算

            adc:进行加法运算时需要考虑CPSR的条件位

            sub:减法运算

            sbc:进行减法运算时需要考虑CPSR的条件位

            mul:乘法运算

    4.2 示例

    1. 1.ADD：加法
    2.   ex1:  mov r1,#1
    3.       mov r2,#2
    4.      add r3,r1,r2@r3=r1+r2
    5.   ex:
    6.       mov r1,#0XFFFFFFFE
    7.     mov r2,#2
    8.     addS r3,r1,r2@r3=r1+r2  @运算的结果影响到条件位
    9. 2.SUB
    10.         mov r1,#0XFFFFFFFE
    11.     mov r2,#2
    12.     sub r3,r1,r2@r3=r1-r2
    13.  ex2:
    14.          mov r1,#0XFFFFFFFE
    15.     mov r2,#2
    16.     subs r3,r2,r1@r3=r2-r1 
    17. 3.ADC
    18. mov r1,#0XFFFFFFFE
    19. mov r2,#2
    20.     ADDS r3,r2,r1 @r3=r1+r2 
    21.     ADC R4,R2,#3  @R4=R2+3+cpsr(C位)  6 
    22.  
    23. 4.sbc:减法运算考虑条件位
    24. mov r1,#0XFFFFFFFE
    25.     mov r2,#2
    26.       SUBS r3,r2,r1 @r3=R2-R1    4
    27.     sbC R4,R1,#3  @R4=R1-3-CPSR(C位取反)

    4.3 64位数据进行算数运算

    原则： 一个 64位数保存在两个寄存器

                    高32位运算，低32位运算

                    mov r1,#0XFFFFFFFE @保存第一个数据的低32位

                    mov r2,#2@保存第一个数据的高32位

                    mov r3,#3 @保存第二个数据的低32位

                    mov r4,#4 @保存第2数据的高32位 @低32位运算要求影响条件位

                    ADDS R5,R1,R3@R5保存运算后结果的低32位

                    ADC R6,R2,R4@R6寄存器保存运算结果的高32位，需要考虑条件位

    5.比较指令

    格式： cmp 第一操作数，第二操作寄存器 比较两个数据

    cmp命令本质：实际上就是比较的两个数进行减法运算，并且减法运算的结果会影响到CPSR寄存器的条件位 通常比较指令完毕之后会使用条件码进行判断，根据判断的结果做不同的逻辑

    条件码

    在一个指令后面加上条件码的助记词后缀，如果满足条件码对应的条件，我们就会进行对应的指令操作，否则不进行操作

    mov r1,#3 mov r2,#4 cmp r1,r2 @比较两个数

    SUBHI r3,r1,r2 @如果r1>r2 进行减法运算

    MULEQ r3,r1,r2@如果两数相等，进行乘法运算

    ADDCC R3,R1,R2@如果r1

    6. 跳转指令

    1. 格式：
    2. <opcode>{<cond>} 标签
    3. 功能：跳转到指定的标签下
    4.  
    5. 指令码：
    6. b:跳转时不影响LR寄存器的值
    7.  
    8. ex:.text
    9. .global  _start
    10.     
    11. _start:
    12.         mov r1,#3
    13.         mov r2,#4
    14.         b fun1 @程序跳转
    15.         mul r5,r1,r2
    16.     
    17. stop:
    18.     b stop  
    19.  
    20. fun1:
    21.     add r4,r1,r2
    22.  
    23.     
    24.     
    25. .end
    26.     
    27.  
    28. bl:跳转时影响LR寄存器的值
    29.  
    30. .text
    31. .global  _start
    32.     
    33. _start:
    34.         mov r1,#3
    35.         mov r2,#4
    36.         bl fun1 @程序跳转
    37.         mul r5,r1,r2
    38.     
    39. stop:
    40.     b stop  
    41.  
    42. fun1:
    43.     add r4,r1,r2
    44.     mov pc,lr @程序返回
    45.  
    46.     
    47.     
    48. .end

    【内存读写指令】

    int *p=0X12345678

    *p=100;//向内存中写入数据

    int a= *p;//从内存读取

    1.单寄存器内存读写指令

    讨论如何将单个寄存器的数据向内存中读写

    1.1 指令码以及功能

    1. 向内存中写：
    2. str:向内存中写一个字(4字节)的数据
    3. strh:向内存写半个字（2字节）的数据
    4. strb:向内存写一个字节的数据
    5. 从内存读：
    6. ldr:从内存读取一个字的数据
    7. ldrh:从内存读取半个字的数据
    8. ldrb:从内存读取一个字节的数据

    1.2 格式

    1. 指令码{条件码} 目标寄存器 [目标地址]
    2. str 目标寄存器 ,[目标地址]：将目标寄存器的数据写入到以目标地址为起始的内存中
    3. ldr 目标寄存器 ,[目标地址]：从以目标地址为起始的内存中读一个字的数据到目标寄存器

    1.3 示例

    1.  mov r1,#0XFFFFFFFF
    2.     ldr r2,=0X40000000
    3.     @向内存写入
    4.     str r1,[r2]
    5.     @从内存读
    6.     ldr r3,[r2]

    1.4 单寄存器读写的地址索引方式

    1. 1.前索引
    2.    mov r1,#0XFFFFFFFF
    3.     ldr r2,=0X40000000
    4.         str r1,[r2,#8]@将r1寄存器的值保存到r2+8为起始地址的内存中
    5.     ldr r3,[r2,#8]@从r2+8为起始地址的内存中读
    6.  2.后索引
    7.       mov r1,#0XFFFFFFFF
    8.     ldr r2,=0X40000000
    9.      str r1,[r2],#8  @将r1寄存器的值保存到r2为起始地址的内存中，r2值=让r2+8
    10.   3.自动索引
    11.   mov r1,#0XFFFFFFFF
    12.   ldr r2,=0X40000000
    13.      str r1,[r2,#8]!  @将r1寄存器的值保存到r2+8w为起始地址的内存中，r2=r2+8

    2.批量寄存器的内存读写方式

    2.1 指令码以及格式

    向内存写：

             stm 目标地址，{寄存器列表} 将寄存器列表中每一个寄存器的值都写道目标地址指向的连续空间之中 从内存读

            ldm 目标地址，{寄存器列表} 将目标地址指向的连续内存中的数据读到寄存器列表中的寄存器中

    注意事项： 1.如果寄存器列表中寄存器的编号连续，可以用-表示列表，如果不连续，用,分割寄存器 {r1-r5,r7}

                            2.无论寄存器列表中如何表示，我们在读写内存的时候始终是低地址 对应低寄存器编号

    2.2 示例代码

    1. mov r1,#1
    2.     mov r2,#2
    3.     mov r3,#3
    4.     mov r4,#4
    5.     mov r5,#5
    6.     ldr r6,=0X40000000
    7.     stm r6,{r1,r2,r3,r4,r5}  @将r1-r6寄存器的值写道r6指向的连续内存中
    8.     ldm r6,{r7,r8,r9,r10,r11}@从r6指向的连续内存中读取数据保存到r7-r11寄存器中

    2.3 批量寄存器的地址增长方式

    每次向指定寄存器保存的地址中写入一个数据，保存地址的寄存器保存的地址也会发生相应的改变

    1.  mov r1,#1
    2.     mov r2,#2
    3.     mov r3,#3
    4.     mov r4,#4
    5.     mov r5,#5
    6.     ldr r6,=0X40000000
    7.     stm r6!,{r1-r5}
    8.     先向r6指向的内存中写一个数据，然后r6保存的地址向地址大的方向增长

    ia后缀

    1.  mov r1,#1
    2.     mov r2,#2
    3.     mov r3,#3
    4.     mov r4,#4
    5.     mov r5,#5
    6.     ldr r6,=0X40000000
    7.     stmia r6!,{r1-r5}
    8.     先向r6指向的内存中写一个数据，然后r6保存的地址向地址大的方向增长

    ib后缀

    1. mov r1,#1
    2.     mov r2,#2
    3.     mov r3,#3
    4.     mov r4,#4
    5.     mov r5,#5
    6.     ldr r6,=0X40000000
    7.     stmib r6!,{r1-r5}
    8.  
    9.  先让R6寄存器保存的地址往地址大的方向增长，再向R6寄存器保存的地址中写入数据

    da后缀

    1. mov r1,#1
    2.     mov r2,#2
    3.     mov r3,#3
    4.     mov r4,#4
    5.     mov r5,#5
    6.     ldr r6,=0X40000800
    7.     stmda r6!,{r1-r5}
    8.  先向R6指向的内存中存数据，然后R6寄存器保存的地址往地址小的方向增长

    DB后缀

    1.   mov r1,#1
    2.     mov r2,#2
    3.     mov r3,#3
    4.     mov r4,#4
    5.     mov r5,#5
    6.     ldr r6,=0X40000800
    7.     stmdb r6!,{r1-r5}
    8.  先将R6寄存器保存的地址往地址小的方向增长，再往R6寄存器保存的地址内存中存入数据

    1.  mov r1,#1
    2.     mov r2,#2
    3.     mov r3,#3
    4.     mov r4,#4
    5.     mov r5,#5
    6.     ldr r6,=0X40000000
    7.     stmia r6!,{r1-r5}   @ia存，db取
    8.     ldmdb  r6!,{r7-r11}

    3.栈内存读写

    栈指针寄存器：R13/SP

    栈：栈本质上就是一段内存，我们在内存中指定一片区域用于保存一些临时数据，这片区域就是栈区

    3.1 栈的类型

    增栈：压栈结束后，栈顶往地址大的方向增长

    减栈：压栈结束后，栈顶往地址小的方向增长

    空栈：压栈结束后，栈顶区域没有有效数据

    满栈：压栈结束后，栈顶区域存放有效数据 空增栈（EA）/空减栈(ED)/满增栈(FA)/满减栈(FD) ARM使用的栈是满减栈

    3.2 满减栈压栈出栈操作

    1. ex1：
    2.   ldr sp,=0X40000020 @指定顶地址
    3.     mov r1,#1
    4.     mov r2,#2
    5.     mov r3,#3
    6.     mov r4,#4
    7.     mov r5,#5
    8.     push {r1-r5} @压栈
    9.     pop {r6-r10}  @将栈顶元素数值出栈
    10. ex2:
    11.     ldr sp,=0X40000020 @指定顶地址
    12.     mov r1,#1
    13.     mov r2,#2
    14.     mov r3,#3
    15.     mov r4,#4
    16.     mov r5,#5
    17.     STMDB sp!,{r1-r5} @压栈
    18.     LDMIA sp!,{r6-r10}  @将栈顶元素数值出栈
    19. EX3:
    20.     ldr sp,=0X40000020 @指定顶地址
    21.     mov r1,#1
    22.     mov r2,#2
    23.     mov r3,#3
    24.     mov r4,#4
    25.     mov r5,#5
    26.     STMfd sp!,{r1-r5} @压栈
    27.     LDMfd sp!,{r6-r10}  @出栈

    4.栈实例---叶子函数的调用过程

    1. .text  
    2. .global _start 
    3.             
    4.  
    5. _start:
    6.     ldr sp,=0X40000020 @初始化栈
    7.     b main
    8. main:
    9.     mov r1,#1
    10.     mov r2,#2
    11.     bl func
    12.     add r3,r1,r2
    13.     b main
    14.  
    15. func:
    16. @压栈保护现场
    17.     stmfd sp!,{r1,r2}
    18.     mov r1,#3
    19.     mov r2,#4
    20.     sub r4,r2,r1
    21.     @出栈恢复现场
    22.     ldmfd sp!,{r1,r2}
    23.     mov pc,lr  @返回main函数
    24.     
    25.     
    26. wh: 
    27.     b wh  
    28.     
    29. .end

    5.栈实例---非叶子函数的调用过程

    1. .text  
    2. .global _start 
    3.             
    4.  
    5. _start:
    6.     ldr sp,=0X40000020 @初始化栈
    7.     b main
    8. main:
    9.     mov r1,#1
    10.     mov r2,#2
    11.     bl func
    12.     add r3,r1,r2
    13.     b main
    14.  
    15. func:
    16. @压栈保护现场
    17.     stmfd sp!,{r1,r2,lr}
    18.     mov r1,#3
    19.     mov r2,#4
    20.     bl fun1
    21.     sub r4,r2,r1
    22.     @出栈恢复现场
    23.     ldmfd sp!,{r1,r2,lr}
    24.     mov pc,lr  @返回main函数
    25. fun1:
    26. @压栈保护现场
    27.     stmfd sp!,{r1,r2}
    28.     mov r1,#4
    29.     mov r2,#5
    30.     mul r5,r1,r2
    31.     @出栈恢复现场
    32.     ldmfd sp!,{r1,r2}
    33.     mov pc,lr
    34.     
    35.     
    36. wh: 
    37.     b wh  
    38.     
    39. .end

  • 相关阅读:
    [思维]Ironforge 2022杭电多校第8场 1005
    Windows编程技术之运行单一实例
    掌握数据仓库建模和元数据备份的方法
    5.Vue中的计算属性（compute）监视属性（watch），二者优点和对比
    概率深度学习建模数据不确定性
    springboot打war包
    电脑工作者缓解眼部疲劳问题的工具分享
    TiDB 悲观事务模式
    GPTs 今日上线：OpenAI杀死了初创公司
    3、构建实时数据仓库-ods和dim层构建
  • 原文地址：https://blog.csdn.net/sy311SB/article/details/133619441