GNU內嵌彙編資料

一、格式
    asm volatile (“asm code”：output：input：changed);    //必須以‘;’結尾，不管有多長對C都只是一條語句
   
    asm                 內嵌彙編關鍵字
   
    volatile            告訴編譯器不要優化內嵌彙編，如果想優化可以不加
   
    ANSI C規範的關鍵字：    （ANSI C把asm用於其它用途，不能用於內嵌彙編語句，GCC可以）
        __asm__
        __volatile__        //前面和後面都有兩個下劃線，它們之間沒有空格
       
    如果後面部分沒有內容，‘：’可以省略，前面或中間的不能省略‘：’
    沒有asm code也不可以省略‘“”’，沒有changed必須省略‘：’
   
二、asm code
   
    asm code必須放在一個字符串內，但是字符串中間是不能直接按回車鍵換行的
    可以寫成多個字符串，只要字符串之間不加任何符號編譯完後就會變成一個字符串
        
         "mov r0,r0/n/t"        //指令之間必須要換行，/t可以不加，只是爲了在彙編文件中的指令格式對齊
        "mov r1,r1/n/t"
        "mov r2,r2"
   
    字符串內不是隻能放指令，可以放一些標籤、變量、循環、宏等等
   
    還可以把內嵌彙編放在C函數外面，用內嵌彙編定義函數、變量、段等彙編有的東東，總之就跟直接在寫彙編文件一樣
   
    在C函數外面定義內嵌彙編時不能加volatile：output：input：changed
   
    注意：編譯器不檢查asm code的內容是否合法，直接交給彙編器
   
三、output（ASM --> C）和input（C --> ASM）
    1、    指定輸出值
            __asm__ __volatile__ (
                    "asm code"
                    :“constraint”（variable）
            );
   
            constraint定義variable的存放位置：
                                r            使用任何可用的通用寄存器
                                m            使用變量的內存地址

            output修飾符：
                                +            可讀可寫
                                =            只寫
                                &            該輸出操作數不能使用輸入部分使用過的寄存器，只能 +& 或 =& 方式使用
                               
    2、    指定輸入值
            __asm__ __volatile__ (
                    "asm code"
                    :
                    :“constraint”（variable / immediate）
            );
   
            constraint定義variable / immediate的存放位置：
                                r            使用任何可用的通用寄存器（變量和立即數都可以）
                                m            使用變量的內存地址（不能用立即數）
                                i             使用立即數（不能用變量）
                   
    3、    使用佔位符
            int a = 100,b = 200;
            int result;
            __asm__ __volatile__ (
                    “mov    %0,%3/n/t”        //mov     r3,#123                %0代表result，%3代表123（編譯器會自動加 # 號）
                    “ldr    r0,%1/n/t”        //ldr     r0,[fp, #-12]        %1代表 a 的地址
                    “ldr    r1,%2/n/t”        //ldr     r1,[fp, #-16]        %2代表 b 的地址
                    “str    r0,%2/n/t”        //str     r0,[fp, #-16]        因爲%1和%2是地址所以只能用ldr或str指令
                    “str    r1,%1/n/t”        //str     r1,[fp, #-12]        如果用錯指令編譯時不會報錯，要到彙編時纔會
                    ：“=r”(result),“+m”(a),“+m”(b)                            out1是%0，out2是%1，...，outN是%N-1
                    ：“i”(123)                                                    in1是%N，in2是%N+1，...
            );
   
    4、引用佔位符
            int num = 100;
          __asm__ __volatile__ (
                "add    %0,%1,#100/n/t"
                : "=r"(a)
                : "0"(a)                        //"0"是零，即%0，引用時不可以加 %，只能input引用output,
                );                                            //引用是爲了更能分清輸出輸入部分
   
    5、    & 修飾符
            int num;
          __asm__ __volatile__ (                //mov     r3, #123            //編譯器自動加的指令
                "mov    %0,%1/n/t"            //mov     r3,r3                //輸入和輸出使用相同的寄存器
                : "=r"(num)
                : "r"(123)
             );
             
             int num;
          __asm__ __volatile__ (                //mov     r3, #123
                "mov    %0,%1/n/t"            //mov     r2,r3                //加了&後輸入和輸出的寄存器不一樣了
                : "=&r"(num)                    //mov     r3, r2                //編譯器自動加的指令
                : "r"(123)
             );
   
四、changed
   
    告訴編譯器你修改過的寄存器，編譯器會自動把保存這些寄存器值的指令加在內嵌彙編之前，再把恢復寄存器值的指令加在內嵌彙編之後
   
        1    void test()                                                        test:
        2    {                                                                            str     fp, [sp, #-4]!
        3        __asm__ __volatile__ (                                        add     fp, sp, #0
       4             "mov    r4,#123"                                        mov     r4,#123
        5          );                                                                    add     sp, fp, #0
        6    }                                                                            ldmfd   sp!, {fp}
        7                                                                                bx      lr
        8                                                                               
        9    void test()                                                        test:
        10    {                                                                            stmfd   sp!, {r4, fp}
        11        __asm__ __volatile__ (                                        add     fp, sp, #0
       12             "mov    r4,#123"                                        mov     r4,#123
        13                :                                                            add     sp, fp, #0
        14                  :                                                            ldmfd   sp!, {r4, fp}
        15                  :"r4"                                                        bx            lr
        16            );
        17    }
                           
    彙編的第 2 行與第 6 行沒有保存和恢復 R4（R4是通用寄存器變量必須保護，見APCS），第 10 行與第 14 行有保存和恢復 R4
   
    如果修改了沒有在輸入或輸出中定義的任何內存位置，必須在changed列表里加上“memory”