本篇通過拆解一段很簡單的匯編代碼來快速認識匯編,為讀懂鴻蒙匯編打基礎.系列篇后續將逐個剖析鴻蒙的匯編文件.

匯編很簡單

第一： 要認定匯編語言一定是簡單的，沒有高深的東西，無非就是數據的搬來搬去，運行時數據主要待在兩個地方：內存和寄存器。寄存器是CPU內部存儲器,離運算器最近,所以最快.

第二： 運行空間(棧空間)就是CPU打卡上班的地方，內核設計者規定誰請CPU上班由誰提供場地，用戶程序提供的場地叫用戶棧，敏感工作CPU要帶回公司做，公司提供的場地叫內核棧，敏感工作叫系統調用，系統調用的本質理解是CPU要切換工作模式即切換辦公場地。

第三：CPU的工作順序是流水線的，它只認指令，而且只去一個地方（指向代碼段的PC寄存器）拿指令運算消化。指令集是告訴外界我CPU能干什么活并提供對話指令，匯編語言是人和CPU能愉快溝通不擰巴的共識語言。一一對應了CPU指令，又能確保記性不好的人類能模塊化的設計idea, 先看一段C編譯成匯編代碼再來說模塊化。

square(c -> 匯編)

//編譯器: armv7-a clang (trunk)
//++++++++++++ square(c -> 匯編)++++++++++++++++++++++++
int square(int a,int b){
    return a*b;
}
square(int, int):
        sub     sp, sp, #8     @sp減去8,意思為給square分配棧空間,只用2個棧空間完成計算
        str     r0, [sp, #4]   @第一個參數入棧
        str     r1, [sp]       @第二個參數入棧
        ldr     r1, [sp, #4]   @取出第一個參數給r1
        ldr     r2, [sp]       @取出第二個參數給r2
        mul     r0, r1, r2     @執行a*b給R0,返回值的工作一直是交給R0的
        add     sp, sp, #8     @函數執行完了,要釋放申請的棧空間
        bx      lr             @子程序返回,等同于mov pc,lr,即跳到調用處

fp(c -> 匯編)

//++++++++++++ fp(c -> 匯編)++++++++++++++++++++++++
int fp(int b)
{
    int a = 1;
    return square(a+b,a+b);
}
fp(int):
        push    {r11, lr}      @r11(fp)/lr入棧,保存調用者main的位置
        mov     r11, sp        @r11用于保存sp值,函數棧開始位置 
        sub     sp, sp, #8     @sp減去8,意思為給fp分配棧空間,只用2個棧空間完成計算
        str     r0, [sp, #4]   @先保存參數值,放在SP+4,此時r0中存放的是參數
        mov     r0, #1         @r0=1
        str     r0, [sp]       @再把1也保存在SP的位置
        ldr     r0, [sp]       @把SP的值給R0
        ldr     r1, [sp, #4]   @把SP+4的值給R1
        add     r1, r0, r1     @執行r1=a+b
        mov     r0, r1         @r0=r1,用r0,r1傳參
        bl      square(int, int)@先mov lr, pc 再mov pc square(int, int)   
        mov     sp, r11        @函數執行完了,要釋放申請的棧空間 
        pop     {r11, lr}      @彈出r11和lr,lr是專用標簽,彈出就自動復制給lr寄存器
        bx      lr             @子程序返回,等同于mov pc,lr,即跳到調用處

main(c -> 匯編)

//++++++++++++ main(c -> 匯編)++++++++++++++++++++++++
int main()
{
    int sum = 0;
    for(int a = 0;a < 100; a++){
        sum = sum + fp(a);
    }
    return sum;
}
main:
        push    {r11, lr}      @r11(fp)/lr入棧,保存調用者的位置
        mov     r11, sp        @r11用于保存sp值,函數棧開始位置
        sub     sp, sp, #16    @sp減去16,意思為給main分配棧空間,只用4個棧空間完成計算
        mov     r0, #0         @初始化r0
        str     r0, [r11, #-4] @執行sum = 0
        str     r0, [sp, #8]   @sum將始終占用SP+8的位置
        str     r0, [sp, #4]   @a將始終占用SP+4的位置
        b       .LBB1_1        @跳到循環開始位置
.LBB1_1:                       @循環開始位置入口
        ldr     r0, [sp, #4]   @取出a的值給r0
        cmp     r0, #99        @跟99比較
        bgt     .LBB1_4        @大于99,跳出循環 mov pc .LBB1_4
        b       .LBB1_2        @繼續循環,直接 mov pc .LBB1_2
.LBB1_2:                       @符合循環條件入口
        ldr     r0, [sp, #8]   @取出sum的值給r0,sp+8用于寫SUM的值
        str     r0, [sp]       @先保存SUM的值,SP的位置用于讀SUM值
        ldr     r0, [sp, #4]   @r0用于傳參,取出A的值給r0作為fp的參數
        bl      fp(int)        @先mov lr, pc再mov pc fp(int)
        mov     r1, r0         @fp的返回值為r0,保存到r1
        ldr     r0, [sp]       @取出SUM的值
        add     r0, r0, r1     @計算新sum的值,由R0保存
        str     r0, [sp, #8]   @將新sum保存到SP+8的位置
        b       .LBB1_3        @無條件跳轉,直接 mov pc .LBB1_3
.LBB1_3:                       @完成a++操作入口
        ldr     r0, [sp, #4]   @SP+4中記錄是a的值,賦給r0
        add     r0, r0, #1     @r0增加1
        str     r0, [sp, #4]   @把新的a值放回SP+4里去
        b       .LBB1_1        @跳轉到比較 a < 100 處
.LBB1_4:                       @循環結束入口
        ldr     r0, [sp, #8]   @最后SUM的結果給R0,返回值的工作一直是交給R0的
        mov     sp, r11        @函數執行完了,要釋放申請的棧空間
        pop     {r11, lr}      @彈出r11和lr,lr是專用標簽,彈出就自動復制給lr寄存器
        bx      lr             @子程序返回,跳轉到lr處等同于 MOV PC, LR

代碼有點長，都加了注釋，如果能直接看懂那么恭喜你，鴻蒙內核的6個匯編文件基于也就懂了。這是以下C文件全貌

文件全貌

#include 
#include 

int square(int a,int b){
    return a*b;
}

int fp(int b)
{
    int a = 1;
    return square(a+b,a+b);
}

int main()
{
    int sum = 0;
    for(int a = 0;a < 100; a++){
        sum = sum + fp(a);
    }
    return sum;
}

代碼很簡單誰都能看懂，代碼很典型，具有代表性，有循環，有判斷，有運算，有多級函數調用。編譯后的匯編代碼基本和C語言的結構差不太多, 區別是對循環的實現用了四個模塊,四個模塊也好理解: 一個是開始塊(LBB1_1), 一個符合條件的處理塊(LBB1_2),一個條件發生變化塊(LBB1_3),最后收尾塊(LBB1_4).

按塊逐一剖析.

先看最短的那個

int square(int a,int b){
    return a*b;
}
//編譯成
square(int, int):
        sub     sp, sp, #8     @sp減去8,意思為給square分配棧空間,只用2個棧空間完成計算
        str     r0, [sp, #4]   @第一個參數入棧
        str     r1, [sp]       @第二個參數入棧
        ldr     r1, [sp, #4]   @取出第一個參數給r1
        ldr     r2, [sp]       @取出第二個參數給r2
        mul     r0, r1, r2     @執行a*b給R0,返回值的工作一直是交給R0的
        add     sp, sp, #8     @函數執行完了,要釋放申請的棧空間
        bx      lr             @子程序返回,等同于mov pc,lr,即跳到調用處

首先上來一句 sub sp, sp, #8 等同于 sp = sp - 8 ,CPU運行需要場地,這個場地就是棧 ,SP是指向棧的指針,表示此時用棧的刻度. 代碼和鴻蒙內核用棧方式一樣,都采用了遞減滿棧的方式(FD). 什么是遞減滿棧? 遞減指的是棧底地址高于棧頂地址,棧的生長方向是遞減的, 滿棧指的是SP指針永遠指向棧頂. 每個函數都有自己獨立的棧底和棧頂,之間的空間統稱棧幀.可以理解為分配了一塊 區域給函數運行,sub sp, sp, #8 代表申請2個棧空間,一個棧空間按四個字節算. 用完要不要釋放?當然要,add sp, sp, #8 就是釋放棧空間. 是一對的,減了又加回去,空間就歸還了. ldr r1, [sp, #4] 的意思是取出SP+4這個虛擬地址的值給r1寄存器,而SP的指向并沒有改變的,還是在棧頂, 為什么要+呢, +就是往回數, 定位到分配的棧空間上.
一定要理解遞減滿棧,這是關鍵! 否則讀不懂內核匯編代碼.

入參方式

一般都是通過寄存器(r0..r10)傳參,fp調用square之前會先將參數給(r0..r10)

        add     r1, r0, r1     @執行r1=a+b
        mov     r0, r1         @r0=r1,用r0,r1傳參
        bl      square(int, int)@先mov lr, pc 再mov pc square(int, int) 

到了square中后,先讓 r0,r1入棧,目的是保存參數值, 因為 square中要用r0,r1 ,

        str     r0, [sp, #4]   @先入棧保存第一個參數
        str     r1, [sp]       @再入棧保存第二個參數
        ldr     r1, [sp, #4]   @再取出第一個參數給r1,(a*b)中a值
        ldr     r2, [sp]       @再取出第二個參數給r2,用于計算 (a*b)中b值

是不是感覺這段匯編很傻,直接不保存計算不就完了嗎,這個是流程問題,編譯器統一先保存參數,至于你想怎么用它不管,也管不了. 另外返回值都是默認統一給r0保存. square中將(a*b)的結果給了r0,回到fp中取出R0對fp來說這就是square的返回值,這是規定.

函數調用main 和 fp 中都需要調用其他函數,所以都出現了

        push    {r11, lr}
        //....
        pop     {r11, lr}

這哥倆也是成對出現的,這是函數調用的必備裝備,作用是保存和恢復調用者的現場,例如 main -> fp, fp要保存main的棧幀范圍和指令位置, lr保存的是main函數執行到哪個指令的位置, r11的作用是指向main的棧頂位置,如此fp執行完后return回main的時候,先mov pc,lr, PC寄存器的值一變, 表示執行的代碼就變了,又回到了main的指令和棧幀繼續未完成的事業.

內存和寄存器數據怎么搬?

數據主要待在兩個地方：內存和寄存器. 寄存器<->寄存器 , 內存<->寄存器 , 內存<->內存 搬運指令都不一樣.

        str     r1, [sp]       @ 寄存器->內存
        ldr     r1, [sp, #4]   @ 內存->寄存器

這又是一對,用于 內存<->寄存器之間,熟知的 mov r0, r1 用于 寄存器<->寄存器

編輯：hfy