ARM VFP的一点体会

ARM VFP的一点体会
关键字: VFP arm1136JF-S MCIMX31 gcc linux
参考文献:<>、<>、<>
前言:
MCIMX31 是一款基于ARM1136JF-S的多媒体处理器。他适合用来做智能手机，手持式游戏终端，多媒体播放器等智能手持式设备。有关这款CPU的参数特性可以参考Freescale的DataSheet。
最近使用MCIMX31的VFP有些收获，写出来与大家分享。
调试环境：
成都莱得科技有限公司([url=][/url])的I.MX31开发板。
1. VFP的功能特点
在我看来VFP除了提供浮点数基本运算（加、减、乘、除、开方、比较、取反）提供支持之外，最有特点是它向量（vectors）功能。它同时支持最多8组单精度4组双精度浮点数的运算。有关这部分的叙述请参考<> Chapter C5 VFP Addressing Modes。下面看一个程序实例，程序是用arm-none-linux-gnueabi-gcc 4.1.2编译，运行在MCIMX31 Linux 2.6.24.5平台下。
#include
#include
void vfp_regs_load(float arrays[32])
{
    asm volatile("fldmias %0, {s0-s31}\n"
            :
            :"r"(arrays));
}
void vfp_regs_save(float arrays[32])
{
    asm volatile ("fstmias %0, {s0-s31}"
            :
            :"r"(arrays));
}
void print_array(float array[32])
{
    int i;
    for(i=0; i<32; i++)
    {
        if(i%8==0)
            printf("\n");
        printf("%f ",i, array[i]);
    }
    printf("\n");
}
int main()
{
    unsigned int fpscr;
    float f1=1.0, f2=1.0;
    float farrays[32], farrays2[32];
    int i;
    fpscr = 0x130000;
    asm volatile ("fmxr fpscr, %0\n"
            :
            :"r"(fpscr));
    asm volatile ("fmrx %0, fpscr\n"
            :"=r"(fpscr));
    vfp_regs_save(farrays2);
    for(i=0; i<32; i++)
        farrays[i] = f1+f2*(float) i;
    vfp_regs_load(farrays);
    vfp_regs_save(farrays2);
    printf("\n1:ScalarA op ScalarB->ScalarD");
    vfp_regs_load(farrays);
    asm volatile("fadds s0, s1, s2");
    vfp_regs_save(farrays2);
    print_array(farrays2);
    printf("\n2:VectorA[?] op ScalarB->VectorD[?]");
    vfp_regs_load(farrays);
    asm volatile("fadds s8,  s24, s0");
    vfp_regs_save(farrays2);
    print_array(farrays2);
    printf("\n3:VectorA[?] op VectorB[?]->VectorD[?]");
    vfp_regs_load(farrays);
    asm volatile("fadds s8,  s16, s24");
    vfp_regs_save(farrays2);
    print_array(farrays2);
}

运行结果：
1:ScalarA op ScalarB->ScalarD
5.000000 2.000000 3.000000 4.000000 5.000000 6.000000 7.000000 8.000000
9.000000 10.000000 11.000000 12.000000 13.000000 14.000000 15.000000 16.000000
17.000000 18.000000 19.000000 20.000000 21.000000 22.000000 23.000000 24.000000
25.000000 26.000000 27.000000 28.000000 29.000000 30.000000 31.000000 32.000000
2:VectorA[?] op ScalarB->VectorD[?]
1.000000 2.000000 3.000000 4.000000 5.000000 6.000000 7.000000 8.000000
26.000000 10.000000 28.000000 12.000000 30.000000 14.000000 32.000000 16.000000
17.000000 18.000000 19.000000 20.000000 21.000000 22.000000 23.000000 24.000000
25.000000 26.000000 27.000000 28.000000 29.000000 30.000000 31.000000 32.000000
3:VectorA[?] op VectorB[?]->VectorD[?]
1.000000 2.000000 3.000000 4.000000 5.000000 6.000000 7.000000 8.000000
42.000000 10.000000 46.000000 12.000000 50.000000 14.000000 54.000000 16.000000
17.000000 18.000000 19.000000 20.000000 21.000000 22.000000 23.000000 24.000000
25.000000 26.000000 27.000000 28.000000 29.000000 30.000000 31.000000 32.000000
第一种情况是最简单的两个浮点数相加(fadds s0, s1, s2) 我们看到的结果是s0(5.00)=s1(2.00)+s2(3.00)。
第二种情况是一组Vector和一个Scalar相加(fadds s8,  s24, s0),我们看到的结果就是：
S8(26.00)=S24(25.00)+S0(1.00)
S10(28.00)=S26(27.00)+S0(1.00)
S12(30.00)=S28(29.00)+S0(1.00)
S14(32.00)=S30(31.00)+S0(1.00)
第三种情况是两组Vectors相加(fadds s8,  s16, s24),我们看到的结果就是：
S8(42.00)=S24(25.00)+S16(17.00)
S10(46.00)=S26(27.00)+S18(19.00)
S12(50.00)=S28(29.00)+S20(21.00)
S14(54.00)=S30(31.00)+S22(23.00)
至于为什么是有4组结果，并且相邻结果间隔一个。有兴趣的可以参考<>有关FPSCR的叙述。
2. 硬件支持
ARM1136JF-S通过两个协处理器CP10和CP11来实现VFP。其中CP10支持单精度浮点操作，CP11支持双精度浮点操作。所以所有的VFP指令其实就是一些协处理器的指令比如FADDS其实就是一个CDP指令，一个FLDS就是一个LDC指令。理论上讲只要采用了ARM1136JF-S的CPU就应该能够支持VFP。

3. 编译器对VFP的支持
一个浮点数操作最后是翻译成VFP指令，还是翻译成fpa，或者是softfloat是编译器决定的。实例：
[sjl@sjl vfp]$ cat f.c
int main()
{
    float f1=1.2,f2=1.3;
    f1 = f2*f1;
}
[sjl@sjl vfp]$ arm-linux-gcc -v
....
gcc version 3.4.4
[sjl@sjl vfp]$ arm-linux-gcc -c f.c
[sjl@sjl vfp]$ arm-linux-objdump -d f.o
f.o:     file format elf32-littlearm
Disassembly of section .text:
00000000

:
   0:   e1a0c00d        mov     ip, sp
   4:   e92dd800        stmdb   sp!, {fp, ip, lr, pc}
   8:   e24cb004        sub     fp, ip, #4      ; 0x4
   c:   e24dd008        sub     sp, sp, #8      ; 0x8
  10:   e59f3024        ldr     r3, [pc, #36]   ; 3c <.text+0x3c>
  14:   e50b3010        str     r3, [fp, #-16]
  18:   e59f3020        ldr     r3, [pc, #32]   ; 40 <.text+0x40>
  1c:   e50b3014        str     r3, [fp, #-20]
  20:   ed1b1104        ldfs    f1, [fp, #-16]
  24:   ed1b0105        ldfs    f0, [fp, #-20]
  28:   ee910100        fmls    f0, f1, f0
  2c:   ed0b0104        stfs    f0, [fp, #-16]
  30:   e1a00003        mov     r0, r3
  34:   e24bd00c        sub     sp, fp, #12     ; 0xc
  38:   e89da800        ldmia   sp, {fp, sp, pc}
  3c:   3f99999a        swicc   0x0099999a
  40:   3fa66666        swicc   0x00a66666
我们用arm-linux-gcc 3.4.4编译明显，生成的不是VFP指令。

[sjl@sjl vfp]$ arm-none-linux-gnueabi-gcc -v
....
gcc version 4.1.2
[sjl@sjl vfp]$ arm-none-linux-gnueabi-gcc -c f.c
[sjl@sjl vfp]$ arm-none-linux-gnueabi-objdump -d f.o
f.o:     file format elf32-littlearm
Disassembly of section .text:
00000000

:
   0:   e1a0c00d        mov     ip, sp
   4:   e92dd800        stmdb   sp!, {fp, ip, lr, pc}
   8:   e24cb004        sub     fp, ip, #4      ; 0x4
   c:   e24dd008        sub     sp, sp, #8      ; 0x8
  10:   e59f3024        ldr     r3, [pc, #36]   ; 3c <.text+0x3c>
  14:   e50b3014        str     r3, [fp, #-20]
  18:   e59f3020        ldr     r3, [pc, #32]   ; 40 <.text+0x40>
  1c:   e50b3010        str     r3, [fp, #-16]
  20:   e51b0014        ldr     r0, [fp, #-20]
  24:   e51b1010        ldr     r1, [fp, #-16]
  28:   ebfffffe        bl      0 <__aeabi_fmul>
  2c:   e1a03000        mov     r3, r0
  30:   e50b3014        str     r3, [fp, #-20]
  34:   e24bd00c        sub     sp, fp, #12     ; 0xc
  38:   e89da800        ldmia   sp, {fp, sp, pc}
  3c:   3f99999a        svccc   0x0099999a
  40:   3fa66666        svccc   0x00a66666
我们用arm-none-linux-gnueabi-gcc 4.1.2 默认也不是生成VFP指令。
[sjl@sjl vfp]$ arm-none-linux-gnueabi-gcc -mfpu=vfp -mfloat-abi=softfp -c f.c
[sjl@sjl vfp]$ arm-none-linux-gnueabi-objdump -d f.o
f.o:     file format elf32-littlearm
Disassembly of section .text:
00000000

:
   0:   e1a0c00d        mov     ip, sp
   4:   e92dd800        stmdb   sp!, {fp, ip, lr, pc}
   8:   e24cb004        sub     fp, ip, #4      ; 0x4
   c:   e24dd008        sub     sp, sp, #8      ; 0x8
  10:   e59f3020        ldr     r3, [pc, #32]   ; 38 <.text+0x38>
  14:   e50b3014        str     r3, [fp, #-20]
  18:   e59f301c        ldr     r3, [pc, #28]   ; 3c <.text+0x3c>
  1c:   e50b3010        str     r3, [fp, #-16]
  20:   ed1b7a05        flds    s14, [fp, #-20]
  24:   ed5b7a04        flds    s15, [fp, #-16]
  28:   ee677a27        fmuls   s15, s14, s15
  2c:   ed4b7a05        fsts    s15, [fp, #-20]
  30:   e24bd00c        sub     sp, fp, #12     ; 0xc
  34:   e89da800        ldmia   sp, {fp, sp, pc}
  38:   3f99999a        svccc   0x0099999a
  3c:   3fa66666        svccc   0x00a66666
用arm-none-linux-gnueabi-gcc 4.1.2指定-mfpu=vfp -mfloat-abi=softfp参数之后生成VFP指令。
好像是从GCC 4之后才支持VFP，如果你要在原有GCC 3里面使用VFP，如何解决，大家可以一起思考这个问题。

4. 操作系统对VFP的支持
应用程序要使用VFP指令，还需要操作系统配合。
在ARM1136JF-S里面有几个重要的协处理器与VFP有关。
CP15 c1 协处理器访问控制寄存器，这个寄存器规定了用户模式和特权对协处理器的访问权限。我们要使用VFP当然要运行用户模式访问CP10和CP11。
另外一个寄存器是VFP的FPEXC Bit30这是VFP功能的使用位。
其实操作系统在做了这两件事情之后，用户程序就可以使用VFP了。
例子：
编译内核取消VFP的支持，编写一个内核驱动，加入以下代码：
void enable_vfp(void)
{
    int ret = 0;
    unsigned int value;
    asm  volatile ("mrc p15, 0, %0, c1, c0, 2"
            :"=r"(value)
            :);
    value |= 0xf00000;/*enable CP10, CP11 user access*/
    asm volatile("mcr p15, 0, %0, c1, c0, 2"
            :
            :"r"(value));
    asm volatile("fmrx %0, fpexc"
               :"=r"(value));
    value |=(1<<30);
    asm volatile("fmxr fpexc, %0"
               :
               :"r"(value));
}
编写一个应用程序：
int main()
{
    float f1=1.2,f2=1.3;
    f1 = f2*f1;
    printf("%f\n", f1);
}
adsdebian:/dev/shm# ./a.out
1.560000
看见了吧，结果正确。
但，我们看内核的VFP支持代码，还是干了很多其他的事情。
让我们来想想这个问题：
    8374:       ed1b7a05        flds    s14, [fp, #-20]
    8378:       ed5b7a04        flds    s15, [fp, #-16]
    837c:       ee677a27        fmuls   s15, s14, s15
    8380:       ed4b7a05        fsts    s15, [fp, #-20]
    8384:       ed5b7a05        flds    s15, [fp, #-20]
我们知道s14,s15这些是协处理器的寄存器，属于所有进程共有的资源。所以当上述例子执行到0x8378时程序切换到其他进程，恰好这个其他进程也访问了s14那结果就可想而知了。
实例：
加载上面我们提到的禁用VFP的Linux kernel并且加载一个驱动修改对应的协处理器寄存器运行用户程序执行VFP指令。
[sjl@sjl vfp]$ cat fork.c
#include
#include
int main()
{
    float f1=1.0,f2=1.0;
    pid_t pid;
    fork();
    pid = getpid();
    while(1)
    {
        f1 +=f2;
        printf("%d %f\n", pid, f1);
    }
}
[sjl@sjl vfp]$ arm-none-linux-gnueabi-gcc -O2 -mfpu=vfp -mfloat-abi=softfp fork.c
[sjl@sjl vfp]$ arm-none-linux-gnueabi-objdump -d a.out|less
...
000083b4

:
    83b4:       e92d4010        stmdb   sp!, {r4, lr}
    83b8:       ed2d8b03        fstmdbx sp!, {d8}
    83bc:       e24dd004        sub     sp, sp, #4      ; 0x4
    83c0:       ebffffc7        bl      82e4 <.text-0x18>
    83c4:       ebffffc3        bl      82d8 <.text-0x24>
    83c8:       ed9f8a08        flds    s16, [pc, #32]
    83cc:       eef08a48        fcpys   s17, s16
    83d0:       e1a04000        mov     r4, r0
    83d4:       ee388a28        fadds   s16, s16, s17
    83d8:       eeb77ac8        fcvtds  d7, s16
    83dc:       e1a01004        mov     r1, r4
    83e0:       ec532b17        fmrrd   r2, r3, d7
    83e4:       e59f0008        ldr     r0, [pc, #8]    ; 83f4 <.text+0xf8>
    83e8:       ebffffc0        bl      82f0 <.text-0xc>
    83ec:       eafffff8        b       83d4
    83f0:       3f800000        svccc   0x00800000
    83f4:       0000847c        andeq   r8, r0, ip, ror r4
...
执行结果：
.....
1382 915.000000
1382 916.000000
1381 2.000000
1381 917.000000
1381 918.000000
....
我们看到进程1381的执行结果与我们程序设计的意图不同。
经过我们上面的例子，我们知道为了让应用程序能够正常的执行，操作系统要保存进程的VFP现场，当然为支持VFP操作系统还要做不少其他的事情。
看来操作系统至少要在进程切换的时候保存应用程序保存VFP的寄存器值。来看看Linux是怎么做的。
5、VFP代码情景
进程在切换的时候，内核的函数调用过程是这样的(ARM Arch)：
__schedule()->context_switch()->switch_to()->__switch_to()
__switch_to()在Arch/arm/kernel/entry-armv.S中实现，这段代码不长，这里我比较关心的是
...
mov r5, r0
add r4, r2, #TI_CPU_SAVE
ldr r0, =thread_notify_head
mov r1, #THREAD_NOTIFY_SWITCH
bl atomic_notifier_call_chain
mov r0, r5
...
翻译成C就是atomic_notifier_call_chain(thread_notify_head,THREAD_NOTIFY_SWITCH,next->cpu_context);
到我们的VFP代码中去看,
static struct notifier_block vfp_notifier_block = {
.notifier_call = vfp_notifier,
};
vfp_init()
{
...
thread_register_notifier(&vfp_notifier_block);
...
}
很明显进程在切换的时候会执行到vfp_notifier()中去。仔细研究vfp_notifier()的代码，没有发现保存VFP寄存器的代码。倒是这段代码比较可疑：
...
fmxr(FPEXC, fpexc & ~FPEXC_EN);
...
FPEXC的FPEXC_EN是VFP功能的使能位，如果这位未被设置，CPU在执行到VFP指令时会产生“未定义指令”中断。好了，每次一个新进程被切换到CPU的时候FPEXC_EN总是未被设置，此时一个VFP指令就产生了一个“未定义指令”中断。
好了。程序这下跑到__und_usr()->call_fpe()->do_vfp()，这个过程其实还是很复杂的，有兴趣可以仔细阅读代码。
do_vfp:
...
  ldr r4, .LCvfp
ldr r11, [r10, #TI_CPU] @ CPU number
add r10, r10, #TI_VFPSTATE @ r10 = workspace
ldr pc, [r4]  @ call VFP entry point
...
.LCvfp:
.word vfp_vector
好吗跑到vfp_vector，vfp_vector这个函数指针在vfp_init()里面赋值 vfp_vector = vfp_support_entry;
关键就在vfp_support_entry里面。vfp_support_entry不仅负责保存/恢复进程的VFP寄存器值，还负责处理VFP的异常(例如除0等等)。
具体的实现过程有兴趣的可以慢慢的看了。[/i][/i]

 

 

 

作者: Sam(甄峰) 

 

一：早期ARM上的浮点模拟器：

早期的ARM没有协处理器，所以浮点运算是由CPU来模拟的，即所需浮点运算均在浮点运算模拟器（float math emulation）上进行，需要的浮点运算，常要耗费数千个循环才能执行完毕，因此特别缓慢。

直到今天，在ARM Kernel配置时，都有如下选项：

Floating point emulation  --->

[ ] NWFPE math emulation

[ ] FastFPE math emulation (EXPERIMENTAL) 

在这里，可以配置ARM 浮点模拟器。

 

浮点模拟器 模拟浮点是利用了undefined instrction handler，这么做带来的后果是带来极频繁的exception，大大增加中断延迟，降低系统实时性。

 

二：软浮点技术：

软浮点支持是由交叉工具链提供的功能，与Linux内核无关。当使用软浮点工具链编译浮点操作时，编译器会用内联的浮点库替换掉浮点操作，使得生成的机器码完全不含浮点指令，但是又能够完成正确的浮点操作。

 

三：浮点协处理器：

在较新版本的ARM中，可以添加协处理器。 一些ARM CPU为了更好的处理浮点计算的需要，添加了浮点协处理器。

并定义了浮点指令集。 如果不存在实际的硬件，则这些指令被截获并由浮点模拟器模块(FPEmulator)来执行。

 

 

四: 硬件浮点协处理器以及对应指令集的使用:

这里Sam是这样理解的：

想要使用硬件浮点协处理器来帮助运算Application中的浮点运算。需要以下几个前提条件：

1. Kernel中设置支持 硬件协处理器。

2. 编译器支持将浮点运算翻译成硬件浮点运算指令。

 

1. Kernle的支持：

如果Kernel不支持浮点协处理器，则因为协处理器寄存器等使用权限等问题，协处理器对应指令无法运行。

网络上有位高手指出：

CP15 c1 协处理器访问控制寄存器，这个寄存器规定了用户模式和特权对协处理器的访问权限。我们要使用VFP当然要运行用户模式访问CP10和CP11。
另外一个寄存器是VFP的FPEXC Bit30这是VFP功能的使用位。
其实操作系统在做了这两件事情之后，用户程序就可以使用VFP了。当然，Kernel 除了这2件事外，还处理了其他一些事情。

 

Sam看了看Kernel中对应代码，发现是汇编后就放弃继续研究了。

Floating point emulation  --->
[*] VFP-format floating point maths

Include VFP support code in the kernel. This is needed IF your hardware includes a VFP unit.

 

2. 编译器指定浮点指令：

编译器可以显式指定将浮点运算翻译成何种浮点指令。

 

如果编译器支持软浮点，则其可能会将浮点运算翻译成编译器中自带的浮点库。则不会有真正的浮点运算。

否则，可以翻译成FPA(Floating Point Accelerator)指令。 FPA指令再去查看是否有浮点模拟器。

还可以将浮点运算指定为VFP（vector floating point）指令。

 

 

五. 编译器指定编译硬浮点指令:

Sam有个测试程序，测试CPU浮点性能。例如：浮点加减乘除等运算的时间长度：

 

float src_mem_32[1024] = {1.024};

float dst_mem_32[1024] = {0.933};

 

for(j = 0; j < 1024; j++)
{
     for(i = 0; i < 1024; i++)
     {
          src_32 = src_mem_32[i] + dst_mem_32[i];
     }
}

通过printf 计算前后毫秒数的差值来看计算能力。

 

编译：

arm-hisiv200-linux-gcc -c   -Wall fcpu.c -o fcpu.o

arm-hisiv200-linux-gcc fcpu.o -o FCPU -L./

运行，则得到32位浮点数加1024次所需要时间。

 

如果要使用VFP呢？

arm-hisiv200-linux-gcc -c   -Wall -mfpu=vfp -mfloat-abi=softfp  fcpu.c -o fcpu.o

arm-hisiv200-linux-gcc -Wall -mfpu=vfp -mfloat-abi=softfp   fcpu.o -o FCPU -L./

则运行后发现，所需要时间几乎减小了一半。 说明还是非常有效果的。

关于-mfpu   -mfloat-abi讲解：见附录2。 

 

另外，如何才能在直观的检查出是否使用VFP呢？

可以通过察看编译出的ASM程序得到结论。

 

#arm-hisiv200-linux-objdump -d fcpu.o

00000000 :
   0:   e52db004        push    {fp}            ; (str fp, [sp, #-4]!)
   4:   e28db000        add     fp, sp, #0
   8:   e24dd00c        sub     sp, sp, #12
   c:   e3a03000        mov     r3, #0
  10:   e50b300c        str     r3, [fp, #-12]
  14:   e3a03000        mov     r3, #0
  18:   e50b3008        str     r3, [fp, #-8]
  1c:   e3a03000        mov     r3, #0
  20:   e50b3008        str     r3, [fp, #-8]
  24:   ea000017        b       88
  28:   e3a03000        mov     r3, #0
  2c:   e50b300c        str     r3, [fp, #-12]
  30:   ea00000d        b       6c
  34:   e51b200c        ldr     r2, [fp, #-12]
  38:   e59f3064        ldr     r3, [pc, #100]  ; a4
  3c:   e0831102        add     r1, r3, r2, lsl #2
  40:   ed917a00        vldr    s14, [r1]
  44:   e51b200c        ldr     r2, [fp, #-12]
  48:   e59f3058        ldr     r3, [pc, #88]   ; a8
  4c:   e0831102        add     r1, r3, r2, lsl #2
  50:   edd17a00        vldr    s15, [r1]
  54:   ee777a27        vadd.f32        s15, s14, s15
  58:   e59f304c        ldr     r3, [pc, #76]   ; ac
  5c:   edc37a00        vstr    s15, [r3]
  60:   e51b300c        ldr     r3, [fp, #-12]
  64:   e2833001        add     r3, r3, #1
  68:   e50b300c        str     r3, [fp, #-12]
  6c:   e51b200c        ldr     r2, [fp, #-12]
  70:   e59f3038        ldr     r3, [pc, #56]   ; b0
  74:   e1520003        cmp     r2, r3
  78:   daffffed        ble     34
  7c:   e51b3008        ldr     r3, [fp, #-8]
  80:   e2833001        add     r3, r3, #1
  84:   e50b3008        str     r3, [fp, #-8]
  88:   e51b2008        ldr     r2, [fp, #-8]
  8c:   e59f301c        ldr     r3, [pc, #28]   ; b0
  90:   e1520003        cmp     r2, r3
  94:   daffffe3        ble     28
  98:   e28bd000        add     sp, fp, #0
  9c:   e49db004        pop     {fp}            ; (ldr fp, [sp], #4)
  a0:   e12fff1e        bx      lr

 

这里明显包含vfp指令。 所以是使用vfp指令的：

arm-hisiv200-linux-gcc -c   -Wall -mfpu=vfp -mfloat-abi=softfp  fcpu.c -o fcpu.o

注意：VFP 指令指令在附录1中。

 

 

如果使用：

arm-hisiv200-linux-gcc -c   -Wall fcpu.c -o fcpu.o

 

#arm-hisiv200-linux-objdump -d fcpu.o

00000000 :
   0:   e92d4800        push    {fp, lr}
   4:   e28db004        add     fp, sp, #4
   8:   e24dd008        sub     sp, sp, #8
   c:   e3a03000        mov     r3, #0
  10:   e50b300c        str     r3, [fp, #-12]
  14:   e3a03000        mov     r3, #0
  18:   e50b3008        str     r3, [fp, #-8]
  1c:   e3a03000        mov     r3, #0
  20:   e50b3008        str     r3, [fp, #-8]
  24:   ea000019        b       90
  28:   e3a03000        mov     r3, #0
  2c:   e50b300c        str     r3, [fp, #-12]
  30:   ea00000f        b       74
  34:   e51b200c        ldr     r2, [fp, #-12]
  38:   e59f3068        ldr     r3, [pc, #104]  ; a8
  3c:   e7932102        ldr     r2, [r3, r2, lsl #2]
  40:   e51b100c        ldr     r1, [fp, #-12]
  44:   e59f3060        ldr     r3, [pc, #96]   ; ac
  48:   e7933101        ldr     r3, [r3, r1, lsl #2]
  4c:   e1a00002        mov     r0, r2
  50:   e1a01003        mov     r1, r3
  54:   ebfffffe        bl      0 <__aeabi_fadd>
  58:   e1a03000        mov     r3, r0
  5c:   e1a02003        mov     r2, r3
  60:   e59f3048        ldr     r3, [pc, #72]   ; b0
  64:   e5832000        str     r2, [r3]
  68:   e51b300c        ldr     r3, [fp, #-12]
  6c:   e2833001        add     r3, r3, #1
  70:   e50b300c        str     r3, [fp, #-12]
  74:   e51b200c        ldr     r2, [fp, #-12]
  78:   e59f3034        ldr     r3, [pc, #52]   ; b4
  7c:   e1520003        cmp     r2, r3
  80:   daffffeb        ble     34
  84:   e51b3008        ldr     r3, [fp, #-8]
  88:   e2833001        add     r3, r3, #1
  8c:   e50b3008        str     r3, [fp, #-8]
  90:   e51b2008        ldr     r2, [fp, #-8]
  94:   e59f3018        ldr     r3, [pc, #24]   ; b4
  98:   e1520003        cmp     r2, r3
  9c:   daffffe1        ble     28
  a0:   e24bd004        sub     sp, fp, #4
  a4:   e8bd8800        pop     {fp, pc}

则不包含VFP指令。

且去调用 __aeabi_fadd

 

 

 

 

 ARM的GCC 编译选项：

 

 

 

 

附录1 ：VFP 指令

• VABS、VNEG 和 VSQRT

  浮点绝对值、求反和平方根。

• VADD、VSUB 和 VDIV

  浮点加法、减法和除法。

• VMUL、VMLA、VMLS、VNMUL、VNMLA 和 VNMLS

  浮点乘法和乘加，包含可选求反。

• VCMP

  浮点数比较。

• VCVT（在单精度数和双精度数之间）

  在单精度数和双精度数之间转换。

• VCVT（在浮点数和整数之间）

  在浮点数和整数之间转换。

• VCVT（在浮点数和定点数之间）

  在浮点数和定点数之间转换。

• VCVTB，VCVTT（半精度扩展）

  在半精度和单精度浮点数之间转换。

• VMOV

  将浮点常数插入单精度或双精度寄存器。

 

 

附录2：

       -mfpu=name
       -mfpe=number
       -mfp=number
           This specifies what floating point hardware (or hardware emulation) is available on the target.  Permissible names are: fpa, fpe2, fpe3, maverick, vfp.  -mfp and -mfpe are synonyms for -mfpu=fpenumber, for compatibility with older versions of GCC.

 

 

 

-mfloat-abi=name
           Specifies which ABI to use for floating point values.  Permissible values are: soft, softfp and hard.

           soft and hard are equivalent to -msoft-float and -mhard-float respectively.  softfp allows the generation of floating point instructions, but still uses the soft-float calling conventions.

Sam不明白为什么 hard不能使用。只好使用softfp