GCC Coverage代码分析-GCC插桩前后汇编代码对比分析

本博客（http://blog.csdn.net/livelylittlefish）贴出作者（阿波）相关研究、学习内容所做的笔记，欢迎广大朋友指正！

Content

0. 序

1. 如何编译

1.1 未加入覆盖率测试选项

1.2 加入覆盖率测试选项

1.3 分析

2. 未加入覆盖率测试选项的汇编代码分析

3. 加入覆盖率测试选项的汇编代码分析

3.1 计数桩代码分析

3.2 构造函数桩代码分析

3.3 数据结构分析

3.4 构造函数桩代码小结

4. 说明

5. 小结

 

0.序

 

在"Linux平台代码覆盖率测试-GCC插桩基本概念和原理分析"一文中，我们已经知道，GCC插桩乃汇编级的插桩，那么，本文仍然以test.c为例，来分析加入覆盖率测试选项"-fprofile-arcs -ftest-coverage"前后，即插桩前后汇编代码的变化。本文所用gcc版本为gcc-4.1.2。test.c代码如下。

 /**
  * filename: test.c
  */
 #include <stdio.h>

 int main (void)
 {
     int i, total;

     total = 0;

     for (i = 0; i < 10; i++)
         total += i;

     if (total != 45)
         printf ("Failure\n");
     else
         printf ("Success\n");
     return 0;
 }

1. 如何编译 

1.1未加入覆盖率测试选项

 

# cpp test.c-o test.i  //预处理：生成test.i文件，或者"cpp test.c > test.i"

或者

# gcc -E test.c -o test.i

# gcc-S test.i         //编译：生成test.s文件(未加入覆盖率测试选项)

# as -o test.o test.s   //汇编：生成test.o文件，或者"gcc -c test.s -o test.o"

# gcc -o test test.o    //链接：生成可执行文件test

 

以上过程可参考http://blog.csdn.net/livelylittlefish/archive/2009/12/30/5109300.aspx。

 

查看test.o文件中的符号

# nm test.o

00000000 T main

         U puts

 

1.2加入覆盖率测试选项

 

# cpp test.c-o test.i                         //预处理：生成test.i文件

# gcc-fprofile-arcs -ftest-coverage-S test.i //编译：生成test.s文件(加入覆盖率测试选项)

# as -o test.o test.s                          //汇编：生成test.o文件

# gcc -o test test.o                           //链接：生成可执行文件test

 

查看test.o文件中的符号

# nm test.o

000000eb t _GLOBAL__I_0_main

         U __gcov_init

         U __gcov_merge_add

00000000 T main

         U puts

 

1.3分析

 

从上面nm命令的结果可以看出，加入覆盖率测试选项后的test.o文件，多了3个符号，如上。其中，_GLOBAL__I_0_main就是插入的部分桩代码。section2和section3将对比分析插桩前后汇编代码的变化，section3重点分析插入的桩代码。

 

2.未加入覆盖率测试选项的汇编代码分析

 

采用"# gcc-S test.i"命令得到的test.s汇编代码如下。#后面的注释为笔者所加。

     .file    "test.c"
     .section    .rodata
 .LC0:
     .string    "Failure"
 .LC1:
     .string    "Success"
     .text
 .globl main
     .type    main, @function
 main:
     leal    4(%esp), %ecx    #这几句就是保护现场
     andl    $-16, %esp
     pushl    -4(%ecx)
     pushl    %ebp
     movl    %esp, %ebp
     pushl    %ecx
     subl    $20, %esp

     movl    $0, -8(%ebp)     #初始化total=0,total的值在-8(%ebp)中
     movl    $0, -12(%ebp)    #初始化循环变量i=0,i的值在-12(%ebp)中
     jmp    .L2
 .L3:
     movl    -12(%ebp), %eax  #将i的值移到%eax中，即%eax=i
     addl    %eax, -8(%ebp)   #将%eax的值加到-8(%ebp)，total=total+i
     addl    $1, -12(%ebp)    #循环变量加1，即i++
 .L2:
     cmpl    $9, -12(%ebp)    #比较循环变量i与9的大小
     jle    .L3               #如果i<=9，跳到.L3，继续累加
     cmpl    $45, -8(%ebp)    #否则，比较total的值与45的大小
     je     .L5               #若total=45，跳到.L5
     movl    $.LC0, (%esp)    #否total的值不为45，则将$.LC0放入%esp
     call    puts             #输出Failure
     jmp    .L7               #跳到.L7
 .L5:
     movl    $.LC1, (%esp)    #将$.LC1放入%esp
     call    puts             #输出Success
 .L7:
     movl    $0, %eax         #返回值0放入%eax

     addl    $20, %esp        #这几句恢复现场
     popl    %ecx
     popl    %ebp
     leal    -4(%ecx), %esp
     ret

     .size    main, .-main
     .ident    "GCC: (GNU) 4.1.2 20070925 (Red Hat 4.1.2-33)"
     .section    .note.GNU-stack,"",@progbits

注：$9表示常量9，即立即数(Immediate Operand)。-8(%ebp)即为total，-12(%ebp)即是循环变量i。 

3.加入覆盖率测试选项的汇编代码分析

采用"# gcc-fprofile-arcs -ftest-coverage-S test.i"命令得到的test.s汇编代码如下。前面的蓝色部分及后面的.LC2, .LC3, .LPBX0, _GLOBAL__I_0_main等均为插入的桩代码。#后面的注释为笔者所加。

     .file      "test.c"
     .section   .rodata
 .LC0:
     .string    "Failure"
 .LC1:
     .string    "Success"
     .text
 .globl main
     .type    main, @function
 main:
     leal    4(%esp), %ecx    #这几句就是保护现场
     andl    $-16, %esp
     pushl    -4(%ecx)
     pushl    %ebp
     movl    %esp, %ebp
     pushl    %ecx
     subl    $20, %esp

     movl    $0, -8(%ebp)     #初始化total=0,total的值在-8(%ebp)中
     movl    $0, -12(%ebp)    #初始化循环变量i=0,i的值在-12(%ebp)中
     jmp    .L2

 .L3:                         #以下这几句就是插入的桩代码
     movl    .LPBX1, %eax     #将.LPBX1移到%eax，即%eax=.LPBX1
     movl    .LPBX1+4, %edx   #edx=.LPBX1+4
     addl    $1, %eax         #eax=%eax+1
     adcl    $0, %edx         #edx=%edx+0
     movl    %eax, .LPBX1     #将%eax移回.LPBX1
     movl    %edx, .LPBX1+4   #将%edx移回.LPBX1+4

     movl    -12(%ebp), %eax  #将i的值移到%eax中，即%eax=i
     addl    %eax, -8(%ebp)   #将%eax的值加到-8(%ebp)，total=total+i
     addl    $1, -12(%ebp)    #循环变量加1，即i++

 .L2:
     cmpl    $9, -12(%ebp)    #比较循环变量i与9的大小
     jle    .L3               #如果i<=9，跳到.L3，继续累加
     cmpl    $45, -8(%ebp)    #否则，比较total的值与45的大小
     je     .L5               #若total=45，跳到.L5

     #以下也为桩代码
     movl    .LPBX1+8, %eax   #eax=.LPBX1+8
     movl    .LPBX1+12, %edx  #edx=.LPBX1+12
     addl    $1, %eax         #eax=%eax+1
     adcl    $0, %edx         #edx=%edx+0
     movl    %eax, .LPBX1+8   #将%eax移回.LPBX1+8
     movl    %edx, .LPBX1+12  #将%eax移回.LPBX1+12

     movl    $.LC0, (%esp)    #否total的值不为45，则将$.LC0放入%esp
     call    puts             #输出Failure

     #以下也为桩代码，功能同上，不再解释
     movl    .LPBX1+24, %eax
     movl    .LPBX1+28, %edx
     addl    $1, %eax
     adcl    $0, %edx
     movl    %eax, .LPBX1+24
     movl    %edx, .LPBX1+28

     jmp    .L7               #跳到.L7

 .L5:
     #以下也为桩代码，功能同上，不再解释
     movl    .LPBX1+16, %eax
     movl    .LPBX1+20, %edx
     addl    $1, %eax
     adcl    $0, %edx
     movl    %eax, .LPBX1+16
     movl    %edx, .LPBX1+20

     movl    $.LC1, (%esp)    #将$.LC1放入%esp
     call    puts             #输出Success

     #以下也为桩代码，功能同上，不再解释
     movl    .LPBX1+32, %eax
     movl    .LPBX1+36, %edx
     addl    $1, %eax
     adcl    $0, %edx
     movl    %eax, .LPBX1+32
     movl    %edx, .LPBX1+36

 .L7:
     movl    $0, %eax         #返回值0放入%eax
     addl    $20, %esp        #这几句回复现场
     popl    %ecx
     popl    %ebp
     leal    -4(%ecx), %esp
     ret

     .size    main, .-main

     #以下部分均是加入coverage选项后编译器加入的桩代码

     .local   .LPBX1
     .comm    .LPBX1,40,32

     .section .rodata      #只读section
     .align   4
 .LC2:                     #文件名常量，只读
     .string  "/home/zubo/gcc/test/test.gcda"

     .data                 #data数据段
     .align   4
 .LC3:
     .long    3            #ident=3
     .long    -345659544   #即checksum=0xeb65a768
     .long    5            #counters

     .align   32
     .type    .LPBX0, @object #.LPBX0是一个对象
     .size    .LPBX0, 52   #.LPBX0大小为52字节
 .LPBX0:                   #结构的起始地址，即结构名，该结构即为gcov_info结构
     .long    875573616    #即version=0x34303170，即版本为4.1p
     .long    0            #即next指针，为0
     .long    -979544300   #即stamp=0xc59d5714
     .long    .LC2         #filename，值为.LC2的常量
     .long    1            #n_functions=1
     .long    .LC3         #functions指针，指向.LC3
     .long    1            #ctr_mask=1
     .long    5            #以下3个字段构成gcov_ctr_info结构，该字段num=5，即counter的个数
     .long    .LPBX1       #values指针，指向.LPBX1，即5个counter的内容在.LPBX1结构中
     .long    __gcov_merge_add #merge指针，指向__gcov_merge_add函数
     .zero    12           #应该是12个0

     .text                                  #text代码段
     .type    _GLOBAL__I_0_main, @function  #类型是function
 _GLOBAL__I_0_main:                         #以下是函数体
     pushl    %ebp
     movl     %esp, %ebp
     subl     $8, %esp
     movl     $.LPBX0, (%esp)   #将$.LPBX0，即.LPBX0的地址，存入%esp所指单元
                                #实际上是为下面调用__gcov_init准备参数,即gcov_info结构指针
     call     __gcov_init       #调用__gcov_init
     leave
     ret

     .size    _GLOBAL__I_0_main, .-_GLOBAL__I_0_main
     .section    .ctors,"aw",@progbits      #该函数位于ctors段
     .align 4
     .long    _GLOBAL__I_0_main
     .align 4
     .long    _GLOBAL__I_0_main

    .ident    "GCC: (GNU) 4.1.2 20070925 (Red Hat 4.1.2-33)"
    .section    .note.GNU-stack,"",@progbits

3.1计数桩代码分析

共插入了6段桩代码，前5段桩代码很容易理解。实际上就是一个计数器，只要每次执行到相关代码，即会让该计数器加1。我们以第一处桩代码为例，如下。

 movl    .LPBX1, %eax     #将.LPBX1移到%eax，即%eax=.LPBX1
 movl    .LPBX1+4, %edx   #edx=.LPBX1+4
 addl    $1, %eax         #eax=%eax+1
 adcl    $0, %edx         #edx=%edx+0
 movl    %eax, .LPBX1     #将%eax移回.LPBX1
 movl    %edx, .LPBX1+4   #将%edx移回.LPBX1+4

从该段汇编代码可以看出，这段代码要完成的功能实际上就是让这个计数器加1，但该计数器是谁？

——就是.LPBX1和.LPBX1+4组成的8个字节的长长整数。而前5处桩代码，实际上就是对一个有5个长长整数元素的静态数组的

为什么是静态数组？

 .local   .LPBX1
 .comm    .LPBX1,40,32
 .section .rodata      #只读section
 .align   4

从.LPBX1的section属性可以看出该数组应该是rodata，即只读，其中的40应该就是其长度，即40字节。如下便是LPBX1数组，大小共40字节，以4字节方式对齐。 

+0        +4        +8       +12     +16    +20     +24    +28     +32     +36

10

0

0

0

1

0

0

0

1

0

代码运行后，该数组的值就记录了桩代码被执行的次数，也即其后的代码块被执行的次数，如上所示。

3.2构造函数桩代码分析

 

插入的第6段桩代码，先不管他的功能，先分析一下以下代码。

     .text                                  #text代码段
     .type    _GLOBAL__I_0_main, @function  #类型是function
 _GLOBAL__I_0_main:                         #以下是函数体
     pushl    %ebp
     movl     %esp, %ebp
     subl     $8, %esp
     movl     $.LPBX0, (%esp)   #将$.LPBX0，即.LPBX0的地址，存入%esp所指单元
                                #实际上是为下面调用__gcov_init准备参数,即gcov_info结构指针
     call     __gcov_init       #调用__gcov_init
     leave
     ret

可以看出，这是一个函数，函数名为_GLOBAL__I_0_main，该函数的主要目的是调用__gcov_init函数，调用参数就是.LPBX0结构。

将可执行文件test通过objdump命令dump出来，查看该符号，也一目了然。

 0804891b <_GLOBAL__I_0_main>:
  804891b:       55                      push   %ebp
  804891c:       89 e5                   mov    %esp,%ebp
  804891e:       83 ec 08                sub    $0x8,%esp
                                         //将$.LPBX0，即.LPBX0的地址，存入%esp所指单元
                                         //实际上是为下面调用__gcov_init准备参数,即gcov_info结构指针
                                         //此处gcov_info的地址即为0x804b7a0，当然这是一个虚拟地址
  8048921:       c7 04 24 a0 b7 04 08    movl   $0x804b7a0,(%esp)
  8048928:       e8 93 01 00 00          call   8048ac0 <__gcov_init>    //调用__gcov_init
  804892d:       c9                      leave
  804892e:       c3                      ret
  804892f:       90                      nop

接下来，看看__gcov_init函数，定义如下。

 void __gcov_init (struct gcov_info *info)
 {
     if (! info- >version)
         return;

     if (gcov_version (info, info->version, 0))
     {
         const char *ptr = info- >filename;
         gcov_unsigned_t crc32 = gcov_crc32;
         size_t filename_length = strlen(info- >filename);

         /* Refresh the longest file name information */
         if (filename_length > gcov_max_filename)
             gcov_max_filename = filename_length;

         do
         {
             unsigned ix;
             gcov_unsigned_t value = *ptr << 24;

             for (ix = 8; ix-- ; value <<= 1)
             {
                 gcov_unsigned_t feedback;
                 feedback = (value ^ crc32) & 0x80000000 ? 0x04c11db7 : 0;
                 crc32 <<= 1;
                 crc32 ^= feedback;
             }
         }while (*ptr++);

         gcov_crc32 = crc32;

         if (! gcov_list)
             atexit (gcov_exit);

         info- >next = gcov_list; /* Insert info into list gcov_list */
         gcov_list = info;        /* gcov_list is the list head */
     }
     info->version = 0;
 }

由此，我们得到两个结论：

(1).LPBX0结构就是gcov_info结构，二者相同。

(2) __gcov_init的功能：将.LPBX0结构，即gcov_info结构，串成一个链表，该链表指针就是gcov_list。 

我们先看看这些数据结构。

3.3数据结构分析

.LPBX0结构即为gcov_info结构，定义如下。

 /* Type of function used to merge counters. */
 typedef void (*gcov_merge_fn) (gcov_type *, gcov_unsigned_t);

 /* Information about counters. */
 struct gcov_ctr_info
 {
     gcov_unsigned_t num;    /* number of counters. */
     gcov_type *values;      /* their values. */
     gcov_merge_fn merge;    /* The function used to merge them. */
 };

 /* Information about a single object file. */
 struct gcov_info
 {
     gcov_unsigned_t version; /* expected version number */
     struct gcov_info *next;  /* link to next, used by libgcov */

     gcov_unsigned_t stamp;   /* uniquifying time stamp */
     const char *filename;    /* output file name */

     unsigned n_functions;                 /* number of functions */
     const struct gcov_fn_info *functions; /* table of functions */

     unsigned ctr_mask;                    /* mask of counters instrumented. */
     struct gcov_ctr_info counts[0];       /* count data. The number of bits
                                             set in the ctr_mask field
                                             determines how big this array is. */
 };

对应于上述代码中的解释，便一目了然。此处再重复一下对该结构的解释。

 .align   32
 .type    .LPBX0, @object  #.LPBX0是一个对象
 .size    .LPBX0, 52       #.LPBX0大小为52字节
 X0:                       #结构的起始地址，即结构名，该结构即为gcov_info结构
 .long    875573616        #即version=0x34303170，即版本为4.1p
 .long    0                #即next指针，为0，next为空
 .long    -979544300       #即stamp=0xc59d5714
 .long    .LC2             #filename，值为.LC2的常量
 .long    1                #n_functions=1，1个函数
 .long    .LC3             #functions指针，指向.LC3
 .long    1                #ctr_mask=1
 .long    5                #以下3个字段构成gcov_ctr_info结构，该字段num=5，即counter的个数
 .long    .LPBX1           #values指针，指向.LPBX1，即5个counter的内容在.LPBX1结构中
 .long    __gcov_merge_add #merge指针，指向__gcov_merge_add函数
 .zero    12               #应该是12个0

上述的.LC2即为文件名，如下。

     .section .rodata          #只读section
     .align   4
 .LC2:                         #文件名常量，只读
     .string  "/home/zubo/gcc/test/test.gcda"

然后就是functions结构，1个函数，函数结构就是.LC3的内容。

 .LC3:
     .long    3            #ident=3
     .long    -345659544   #即checksum=0xeb65a768
     .long    5            #counters

其对应的结构为gcov_fn_info，定义如下。

 / * Information about a single function. This uses the trailing array idiom. The number of
     counters is determined from the counter_mask in gcov_info. We hold an array of function
     info, so have to explicitly calculate the correct array stride. */
 struct gcov_fn_info
 {
     gcov_unsigned_t ident;    /* unique ident of function */
     gcov_unsigned_t checksum; /* function checksum */
     unsigned n_ctrs[0];       /* instrumented counters */
 };

3.4构造函数桩代码小结

 

gcov_init函数中的gcov_list是一个全局指针，指向gcov_info结构的链表，定义如下。

 / * Chain of per- object gcov structures. */
 staticstructgcov_info *gcov_list;

因此，被测文件在进入main之前，所有文件的.LPBX0结构就被组织成一个链表，链表头就是gcov_list。被测程序运行完之后，在__gcov_init()中通过atexit()注册的函数gcov_exit()就被调用。该函数将从gcov_list的第一个.LPBX0结构开始，为每个被测文件生成一个.gcda文件。.gcda文件的主要内容就是.LPBX0结构的内容。

至此，我们可以做这样的总结：将.LPBX0结构串成链表的目的是在被测程序运行结束时统一写入计数信息到.gcda文件。

因此，为了将LPBX0结构链成一条链，GCC要为每个被测试源文件中插入一个构造函数_GLOBAL__I_0_main的桩代码，该函数名根据当前被测文件中的第一个全局函数的名字生成，其中main即为test.c中的第一个全局函数名，防止重名。

而之所以称为构造函数，是因为该函数类似C++的构造函数，在调用main函数之前就会被调用。

 

4.说明

 

本文参考文献中实际分析的gcc代码应该是gcc-2.95版本，而本文分析的gcc代码是gcc-4.1.2版本。可以发现这两个版本间变化非常非常大。

gcc-2.95版本中有__bb_init_func()函数和__bb_exit_func()函数，并且其中的结构为bb结构。

但在gcc-4.1.2版本中，就变为__gcov_init()函数和gcov_exit()函数，对应的结构为gcov_info结构。

 

5.小结

 

本文详细叙述了Linux平台代码覆盖率测试插桩前后汇编代码的变化及分析，对于分析gcc插桩、gcov原理有很大的帮助。

 

Reference
费训,罗蕾.利用GNU工具实现汇编程序覆盖测试,计算机应用, 24卷, 2004.

吴康.面向多语言混合编程的嵌入式测试软件设计与实现(硕士论文).电子科技大学, 2007.

http://gcc.parentingamerica.com/releases/gcc-2.95.3

http://gcc.parentingamerica.com/releases/gcc-4.1.2