什么是报告的gcov析构函数的分支？-c++,gcc,代码覆盖率code-coverage,gcov-CodeGo.net
什么是报告的gcov析构函数的分支？
当GCOV的C ++代码的测试覆盖率报告它在析构函数的分支。
struct Foo
virtual ~Foo()
int main (int argc, char* argv[])
当我运行的gcov启用（-B）分支概率我得到以下输出。
$ gcov /home/epronk/src/lcov-1.9/example/example.gcda -o /home/epronk/src/lcov-1.9/example -b
File 'example.cpp'
Lines executed:100.00% of 6
Branches executed:100.00% of 2
Taken at least once:50.00% of 2
Calls executed:40.00% of 5
example.cpp:creating 'example.cpp.gcov'
的一部分，这是“至少执行一次：2 50.00％”。
生成的。gcov的文件提供了更多的细节。
$ cat example.cpp.gcov | c++filt
-: 0:Source:example.cpp
-: 0:Graph:/home/epronk/src/lcov-1.9/example/example.gcno
-: 0:Data:/home/epronk/src/lcov-1.9/example/example.gcda
-: 0:Runs:1
-: 0:Programs:1
-: 1:struct Foo
function Foo::Foo() called 1 returned 100% blocks executed 100%
function Foo::~Foo() called 1 returned 100% blocks executed 75%
function Foo::~Foo() called 0 returned 0% blocks executed 0%
1: 3: virtual ~Foo()
branch 0 taken 0% (fallthrough)
branch 1 taken 100%
call 2 never executed
call 3 never executed
call 4 never executed
function main called 1 returned 100% blocks executed 100%
1: 8:int main (int argc, char* argv[])
call 0 returned 100%
call 1 returned 100%
注意行“分支取0 0％（fallthrough）”。
什么我需要这个分支是什么做的，代码在这里得到一个100％？
G++（的Ubuntu / Linaro的4.5.2-8ubuntu4）4.5.2
gcov的（Ubuntu的/ Linaro的4.5.2-8ubuntu4）4.5.2
本文地址 ：CodeGo.net/346954/
-------------------------------------------------------------------------------------------------------------------------
1. 在一个典型的有两个分支：一个用于非动态对象的破坏，另一种为动态对象的破坏.a个特定分支的选择是通过调用者传递到析构函数隐藏的布尔值。它通过一个寄存器作为0或1。
我猜，因为你的情况的破坏是一个非动态对象，动态不转移。尝试添加new-海关，然后delete-海关类的对象Foo和第二分支应视为良好。
究其原因这个分支是必要的植根于C ++语言的规范。当类定义它自己operator delete，特定的选择operator delete调用完成后，就好像它是抬头从类的析构函数里面。这从字面上：正确operator delete是从字面上的析构函数 CodeGo.net，当然里面叫，operator delete销毁动态分配的对象时，应该只被调用。为了实现这一目标，该呼叫到operator delete被放置到由隐性控制的分支
在你的榜样事情看起来很琐碎。我expect的优化器删除所有不必要的分支。然而，看来它设法生存优化。
这里有更多的研究的一点点。考虑下面的代码
#include &stdio.h&
struct A {
void operator delete(void *) { scanf("11"); }
virtual ~A() { printf("22"); }
struct B : A {
void operator delete(void *) { scanf("33"); }
virtual ~B() { printf("44"); }
int main() {
A *a = new B;
这是怎样的的析构函数的代码A看起来像下默认优化设置GCC 4.3.4
__ZN1AD2Ev: destructor A::~A
pushl %ebp
movl %esp, %ebp
subl $8, %esp
movl 8(%ebp), %eax
movl $__ZTV1A+8, (%eax)
movl $LC1, (%esp) LC1 is "22"
call _printf
movl $0, % &------ Note this
testb %al, % &------
L10 &------
movl 8(%ebp), % &------
movl %eax, (%esp) &------
call __ZN1AdlEP &------ calling `A::operator delete`
（的析构函数B将是一个位，这是为什么A做为一个例子。但据有关分支来讲，析构函数B做它的方式）。
然而，这种析构函数之后生成的代码将包含另一个版本的析构函数的类非常A，这看起来完全，除movl $0, %eax指令被替换movl $1, %eax指令。
__ZN1AD0Ev: another destructor A::~A
pushl %ebp
movl %esp, %ebp
subl $8, %esp
movl 8(%ebp), %eax
movl $__ZTV1A+8, (%eax)
movl $LC1, (%esp) LC1 is "22"
call _printf
movl $1, % &------ See the difference?
testb %al, % &------
L14 &------
movl 8(%ebp), % &------
movl %eax, (%esp) &------
call __ZN1AdlEP &------ calling `A::operator delete`
注意代码块我用箭头标记。这正是我在说什么。这种“伪分支”是应该要么调用或跳过该呼叫到operator delete按照价值al。然而，在析构函数的优先个版本，这是硬编码到身体一如既往0，而在第二个它是硬编码一如既往1。
类B也有两个版本，它产生的析构函数。因此，我们最终与4unique的析构函数在程序：双析构函数为每个类。
那么，是什么发生在这种情况下是在内部开始认为在一个单一的“析构函数（其中工程完全按照我上面描述的突破），然后决定析构函数分成两个独立的非版本方面：一个是的硬编码值0（非动态的析构函数），另一个的硬编码值1（动态析构函数）。在非优化模式，它确实是从字面上看，通过分配函数体内部的实际值和使所有的分支完全完好。这是在非优化代码可以接受的，我猜。这就是你正在处理什么。
换句话说，在回答你的问题是：这是不可能做出拿在这种情况下所有分支。有没有办法做到100％的覆盖率。这些分支是“死”。它就是这样的方法来生成非优化代码是相当“懒”和“松”在这个版本的GCC。
有可能是一个办法，以防止splitting的非优化模式，我想。我只是还没有找到它。或者，很可能，它不能这样做。旧版本的真析构函数。也许在这个版本的GCC，他们决定改用两个析构函数的方法，并在做的，他们“现有的代码生成器在这样一个快速和肮脏的方式，expect优化清理树枝。
当你启用了优化GCC不会允许自己这样的奢侈品分支的最终代码。你应该尝试去分析优化的代码。非优化的GCC生成的代码有许多分支赞一个。
在析构函数，GCC生成conditial跳跃的条件而不可能是真实的（％人不为零，因为这只是一个分配1）：
29: b8 01 00 00 00
mov $0x1,%eax
test %al,%al
62 &_ZN3FooD0Ev+0x62&
本文标题 ：什么是报告的gcov析构函数的分支？
本文地址 ：CodeGo.net/346954/
Copyright (C) 2017 CodeGo.netgcov是gcc工具链内含的一个选项，用于测试Code Coverage，包含代码行，函数及分支的覆盖率测试。&
lcov是LTP对gcov扩展的可视化工具，debian系可直接通过apt-get安装，用于生成html格式的详细报告。&
本文仅对gcov+lcov的使用及常用技巧作一个简单介绍。
编译目标代码
测试用户空间代码
在编译时加上两个选项-fprofile-arcs和-ftest-coverage，如下
gcc -fprofile-arcs -ftest-coverage -o test test.c
编译生成两个文件，可执行目标文件test和test.gcno，可以看到test文件明显大了许多，在此不论述编译器具体做了什么，有兴趣的可以查看gcov的原理。
root:~# gcc -o test test.croot:~# ls -l test-rwxr-xr-x 1 root root 7335 Dec 19 23:12 testroot:~# gcc -fprofile-arcs -ftest-coverage -o test test.croot:~# ls -l test-rwxr-xr-x 1 root root 22016 Dec 19 23:12 test
测试内核空间代码
打开kernel gcov选项
# 在.config中添加CONFIG_DEBUG_FS=yCONFIG_GCOV_KERNEL=y
设置测试目标代码
#若测试整个内核，在.config中添加CONFIG_GCOV_PROFILE_ALL=y#若测试某一个目录下所有文件，在目录Makefile中添加GCOV_PROFILE=y#若测试目录下某几个文件，在目录Makefile中添加GCOV_PROFILE_file1_name.o=yGCOV_PROFILE_file2_name.o=y
生成的gcno文件位置为out/target/***/obj/kernel/***
测试过程会生成 &*.gcda& 文件，对于内核代码，gcda文件的位置为/sys/kernel/debug/gcov/$KERNEL_PATH/
lcov生成文本格式报告
#将gcda和gcno文件放在同一目录下，在该目录下执行lcov -b &测试代码路径& -d . -c -o result.info --rc lcov_branch_coverage=1
--rc lcov_branch_coverage=1表示包含分支数据，lcov支持很多选项，具体可参考其&
生成的info文件格式如下，包含了代码路径及每一行的调用次数，希望大家不要直接修改这个文件来伪造测试结果
SF:[测试代码路径]FN:[行号],[函数名]DA:[行号],[执行次数]LF:被统计的总行数LH:被执行的行数end_of_record
genhtml生成html报告
# 会生成result文件夹，可通过index.html进行查看genhtml -o result result.info --rc lcov_branch_coverage=1
整合测试结果
将多个测试阶段的报告进行整合，这个功能在测试内核驱动时特别有用，因为有时需要重启进行第二阶段测试，但重启后覆盖率信息将会被重置，就需要将coverage info先保存下来，然后将多个info整合生成最终的报告，如：
#测试阶段1完成，pull出gcda文件，生成#重启#测试阶段2完成，pull出gcda文件，生成#整合和lcov -a phase1.info -a phase2.info -o out.info#生成html报告，为两次测试结果汇总genhtml -o result out.info
在添加新的测试后，之前的测试不用重新跑过，只需要得到新的测试报告，将报告进行叠加即可。
在使用lcov生成.info文件时，有时会报match错误，这种情况一般有两种原因
gcda与gcno对应的不是同一次build的镜像，可通过如下命令查看，两次tag相同则为同一次编译的，否则只能重新编译测试
$ hexdump -e '&%x\n&' -s8 -n4 usb.gcno6f88d714$ hexdump -e '&%x\n&' -s8 -n4 usb.gcda6f88d714
编译代码的主机与生成报告的主机源码绝对路径不同
修改阈值
genhtml默认：90%+为绿色，75%~90%为黄色，75%以下为红色&
我们也可以根据项目要求自定义阈值，lcov/genhtml支持通过 –rc 传输一些配置参数。&
其中与阈值相关设置项：
genhtml_hi_limit -& 全局genhtml_med_limit -& 全局genhtml_branch_hi_limit -& 分支genhtml_branch_med_limit -& 分支genhtml_function_hi_limit -& 函数genhtml_function_med_limit -& 函数
包含了全局，分支及函数的阈值设置，以单独设置为准。如果你定义了genhtml_hi_limit和genhtml_branch_hi_limit，对branch来说还是以genhtml_branch_hi_limit为准，而line和function则使用全局的设置。所以虽然没有line的单独设置项，也是可以分别设置line，function和branch的阈值。
注意链接时需要加上选项&-lgcov，否则会报如下类似错误
undefined reference to `__gcov_init'
有兴趣的查看lcov/genhtml的源码，就是两个perl脚本，一般位置在 /user/local/bin/lcov /user/local/bin/genhtml
相关链接：
，此博主有一系列gcov相关的博文，且比较详细
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1052次
排名：千里之外下次自动登录
现在的位置:
& 综合 & 正文
代码覆盖率——gcov lcov的使用
1.GCOV查看arm-linux覆盖率
关于gcov工具
gcov伴随gcc 发布。gcc编译加入-fprofile-arcs -ftest-coverage 参数生成二进制，执行测试用例生成代码覆盖率信息。
1、如何使用gcov
用GCC编译的时候加上-fprofile-arcs -ftest-coverage选项，链接的时候也加上。
fprofile-arcs参数使gcc创建一个程序的流图，之后找到适合图的生成树。只有不在生成树中的弧被操纵（instrumented）：gcc添加了代码来清点这些弧执行的次数。当这段弧是一个块的唯一出口或入口时，操纵工具代码（instrumentation code)将会添加到块中，否则创建一个基础块来包含操纵工具代码。
gcov主要使用.gcno和.gcda两个文件。
.gcno是由-ftest-coverage产生的，它包含了重建基本块图和相应的块的源码的行号的信息。
.gcda是由加了-fprofile-arcs编译参数的编译后的文件运行所产生的，它包含了弧跳变的次数和其他的概要信息（而gcda只能在程序运行完毕后才能产生的）。
Gcov执行函数覆盖、语句覆盖和分支覆盖。
举个例子,程序代码由main.c和tmp.c两个文件组成，编译、链接、运行程序
编译：gcc -fprofile-arcs -ftest-coverage -o myapp main.c tmp.c
运行：./myapp
命令： gcov main.c,gcov tmp.c
这个时候当前目录下有了新的文档main.c.gcov,和tmp.c.gcov
若想保存覆盖率文件，上述命令修改为：
命令：gcov main.c &&yourfilename,gcov tmp.c &&yourfilename
而这时候的main.c.gcov,和tmp.c.gcov就包含了函数和代码执行次数的信息，我们可以查看结果：
65:/***************************************************************************************
66: * name
67: * return
other ERROR
69: * history
70:****************************************************************************************/
71:int main( int argc, char *argv[] )
/* the entrance for program
function main called 4 returned 100% blocks executed 81%
int loop = 0 ;
int ret = OK ;
int empty_line = 0 ;
int code_line = 0 ;
int annotation_line = 0 ;
struct stat file_
/* use for file state */
char recu_name[256] ;
char *pwd = NULL ;
char *tmp = NULL ;
if( argc = MAX_FILE ){
/* file size larger than max size */
printf( "file [%s] size is over 64K! /ncontinue..../n", argv[loop] ) ;
##### 这就是表示没跑到的
各个参数使用如下：
gcov [-b] [-c] [-v] [-n] [-l] [-f] [-o directory] sourcefile
Write branch frequencies to the output file, and write branch summary info to the standard output. This option allows you to
see how often each branch in your program was taken.
//b(ranch),分支测试
Write branch frequencies as the number of branches taken, rather than the percentage of branches taken.
Display the gcov version number (on the standard error stream).
//太简单了吧,我上面用了
Do not create the gcov output file.
Create long file names for included source files. For example, if the header file `x.h' contains code, and was included in the
file `a.c', then running gcov on the file `a.c' will produce an output file called `a.c.x.h.gcov' instead of `x.h.gcov'. This can
be useful if `x.h' is included in multiple source files.
Output summaries for each function in addition to the file level summary.
The directory where the object files live. Gcov will search for `.bb', `.bbg', and `.da' files in this directory.
新版的是这么说的
-o directory│file
--object-directory directory
--object-file file
Specify either the directory containing the gcov data files, or the
object path name. The .gcno, and .gcda data files are searched for
using this option. If a directory is specified, the data files are
in that directory and named after the source file name, without its
extension. If a file is specified here, the data files are named
after that file, without its extension. If this option is not sup-
plied, it defaults to the current directory.
其他的更有新版的-u,
--unconditional-branches
When branch counts are given, include those of unconditional
branches. Unconditional branches are normally not interesting.
--preserve-paths
Preserve complete path information in the names of generated .gcov
files. Without this option, just the filename component is used.
With this option, all directories are used, with ’/’ characters
translated to ’#’ characters, ’.’ directory components removed and
’..’ components renamed to ’^’. This is useful if sourcefiles are
in several different directories. It also affects the -l option.
二、关于lcov
Lcov则是上的gcov 结果展现的一个前端，可以将覆盖率信息转换成html展现。
1. 如何访问用户空间应用程序代码覆盖数据的示例
---------------------------------------------------------------------
前提条件：使用 GCC 以 -fprofile-arcs 和-ftest-coverage 选项编译程序。假设编译目录名称为 "/root/test/code_cover/"，然后执行：
以我的一个实例/root/test/code_cover/下的fork.c为例看代码的覆盖率：
首先进入/root/test/code_cover/目录
a) 重置计数器
lcov --directory . --zerocounters
b) 收集当前代码覆盖状态到一个文件（应用程序启动和停止至少一次后，该命令才能正常工作）
lcov --directory . --capture --output-
Capturing coverage data from .
Found gcov version: 3.4.6
Scanning . for .gcda files ...
Found 1 data files in .
Processing ./TestQuery.gcda
Finished .info-file creation
c) 获取 HTML 输出
genhtml -o
其中的“-o results”是指示结果存放在什么位置的。
Reading data
Found 18 entries.
Found common filename prefix "/home/search/isearch_yb/src"
Writing .css and .png files.
Generating output.
Processing file cpp/core/basis/GlobalDef.h
Processing file cpp/core/search/QueryCache.h
Writing directory view page.
Overall coverage rate: 117 of 514 lines (22.8%)
使用 web 浏览器打开 index.html 文件查看代码覆盖结果。
三、Linux内核覆盖率测试：
将最终的 gcov 内核模块文件复制到 system wide modules 目录或者 PERL 脚本所在目录。以 root 身份， 执行：
Gcov：在对Linux内核程序进行代码覆盖率测试时，同样可以采用gcov，但是需要对kernel打一个补丁。Gcov的内核补丁下载地址：。下载gcov内核补丁（wget http://downloads.sourceforge.net/ltp/gcov-kernel-2.tar.gz），解压补丁，然后为一个kernel打补丁（patch
–p1 & /home/linux-v3.4-mem/gcov-kernel-2/linux-2.6.18-gcov.patch）注意打补丁时应该处于内核的主目录下也即/home/linux-v3.4-mem，打完补丁之后，通过make menuconfig配置gcov，配置页面显示如下：
配置完毕之后，重新编译内核，将编译成功的gcov这个内核模块/home/linux-v3.4-mem /kernel/gcov/gcov-proc.ko拷贝到网络文件系统下面，arm linux系统启动后加载这个模块
（1）/insmod gcov-proc.ko
然后再跑其他测试程序，跑了一段时间，你会发现在/proc/gcov目录下有各种gcov的统计文件：
/proc/gcov # ls
把这整个目录拷贝到fedora虚拟机下的一个目录，我是拷贝到/nfs/kernel_test/gcov目录下，然后
（2）收集当前代码覆盖状态到一个文件
lcov --directory . --output-
（3） 获取 HTML 输出
使用 web 浏览器打开 index.html 文件查看代码覆盖结果。
上面是怎样获取内核运行代码覆盖率的一般方法及流程。
但如果我们只想获取一个程序运行时的内核代码覆盖率，改怎么办呢？？？
这里先说几个gcov-proc模块的特性：
（1）模块属性：
我们发现/sys/module/gcov_proc下有parameters文件夹，进去我们发现有两个属性文件：
/sys/module/gcov_proc/parameters # ls
gcov_persist
这两个属性是控制什么的呢？？？看看官方表述：
- gcov_link=0/1 (default is 1): When set to non-zero, symbolic links to
source and gcov graph files are created in /proc/gcov along with the data
- gcov_persist=0/1 (default is 0): When set to non-zero, gcov data for
kernel modules is kept even after those modules are unloaded so that
coverage measurements can be extended to module cleanup code. To clear
this persistent data, write to /proc/vmlinux.
（2）重启内核覆盖率采集的数据
To reset coverage data for a specific file, simply write to the associated data
file in the /proc/gcov hierarchy:
echo 0 & /proc/gcov/kernel/signal.da
To reset all coverage data, write to the extra file '/proc/gcov/vmlinux':
echo 0 & /proc/gcov/vmlinux
四、获取程序运行时段的内核覆盖率
我的方法是在运行应用程序（这里面是以我的/nfs/memtest/timetest下的timetest应用程序为例）的开始先用“echo 0 & /proc/gcov/vmlinux”指令将我们的/proc/gcov下的统计信息全部清空让它重新计数的，下面说下我们的方法和步骤：
先获得一个含义gcov信息的内核和gcov-proc.ko，这个上面已经说过了；
启动linux内核，然后安装gcov-proc.ko
/memtest # insmod gcov-proc.ko
gcov-proc: initializing proc module: persist=0 link=1 format=gcc 3.4
gcov-proc: init done
/memtest # cd timetest/
/memtest/timetest # ls
timetest.c
timetest.gcno
timetest-lcov
timetest.gcda
这时先用“echo 0 & /proc/gcov/vmlinux”指令清空gcov，然后运行timetest，然后将
/proc/gcov拷贝到/tmp下面，这是防止直接拷到虚拟机下会产生大量的网络函数调用，增加统计误差。
/memtest/timetest # echo 0 & /proc/gcov/vmlinux && ./timetest && cp -r /proc/gcov/ /tmp
game over count1 is 0xc9413e40,count2 is 0x0,count3 is 0x3c8b1e45,count4 is 0x0
/memtest/timetest # ls /tmp
现在统计的数据是放在/tp/gcov下面的，我们需要将之拷贝到上位机的虚拟机中才能分析，因为我们的lcov只能在虚拟机中才能运行的。
/memtest/timetest # cp -r /tmp/gcov/ ./
/memtest/timetest #
现在需要转到虚拟机下接着运行lcov来产生最后的html页面了。
[root@localhost timetest]# cd gcov/
[root@localhost gcov]# lcov --directory . --capture --output-
[root@localhost gcov]# genhtml -o
这样就生成了最后基本上只运行在timetest时间段的内核代码覆盖率了。
2.gcov使用实例
使用GCOV进行代码覆盖率统计，需要注意：
在编译时不要加优化选项，因为加编译选项后，代码会发生变化，这样就找不到哪些是自己写的热点代码。
如果代码中使用复杂的宏，比如说这个宏展开后是循环或者控制结构， gcov只在宏调用出现的那一行报告 ，如果复杂的宏看起来像函数，可以用内联函数来代替。
代码在编写时要注意，每一行最好只有一条语句。
可以用gcov,lcov测试linux内核覆盖率，参考
这里只讨论应用程序的覆盖率。
使用主要有三个步骤：
编译阶段：加入编译选项gcc –o hello –fprofile-arcs –ftest-coverage hello，生成记录程序流程图等信息
数据收集与提取阶段：./hello.，生成具体的运行信息
这一阶段生成的数据信息自动保存到。o文件所在的目录，也就是说如果存在/usr/build/hello.o，则生成/usr/build/hello.gcda,但是如果前边目录不存在就会出错。
生成数据报告: gcov
以下给出gcov针对c++项目nmap的应用过程
Nmap是一个强大的端口扫描程序，同时Nmap也是著名安全工具Nessus所依赖工具。代码行数在3万行以上。
CXXFLAGS=”-fprofile-arcs -ftest-coverage” LIBS=-lgcov ./configure
èmakefile
è 每个源文件产生一个.gcno文件
è每个源文件生成一个.gcda文件
è每个源文件生成一个.gcov文件
步骤一：检测代码
按照nmap项目readme文档编译运行一遍，保证代码正确性
步骤二：增加使用gcov的编译选项：-fprofile-arcs -ftest-coverage，链接选项-lgcov或者-coverage
对于手动写的Makefile代码，直接增加编译选项即可
对一些自动生成的Makefile文件，运行./configure –h 查看增加Makefile编译连接选项的方法，增加编译选项：-fprofile-arcs -ftest-coverage ，通过一些环境变量设置即可，比如本程序设置为 CXXFLAGS=”-fprofile-arcs -ftest-coverage” LIBS=-lgcov ./configure
步骤三：编译连接
修改Makefile文件后，执行make, 针对每个源文件会生成.gcno文件
步骤四：测试
运行单个测试用例或测试用例组，生成.gcda文件，如下运行./nmap 127.0.0.1后，结果如下
步骤五：运行gcov生成覆盖测试信息
如下所示，分析其中的一个源文件及其相关联文件的测试覆盖率情况，默认情况下会生成sourefilename.c.gcov文件，可以添加-l，-p选项生成具体的目录及长文件名。如下所示，分别对main.cc与output.cc的进行覆盖率统计。这里查看的是行覆盖率，也可以添加-b,-f给出分支覆盖率信息，具体可以通过man gcov查看
下边是给出的生成行覆盖率的信息：
步骤六：查看.gcov文件
显示的执行情况，如下所示，查看output.cc的执行情况，以下分别是output.cc.gcov文件的头与部分信息，其中红框部分标注该行代码的执行次数，-表示没有被插桩到的代码行。
下图是分支覆盖率信息：
函数开始前给出整体信息：
一些分支情况：
步骤七： 用lcov查看整体代码覆盖情况
使用lcov前对覆盖率数据清空，lcov –z –d ./
在源码路径下运行lcov –b ./
-c -，-b指示以当前目录作为相对路径，-d表示统计目录中的覆盖数据文件而不是内核数据，并将生成的信息存于-o所示文件，具体参数参考：lcov –h 查看
最后，可以合并多个覆盖率信息，用-a 选项
–add-tracefile . –a ./ –a ./
步骤八：用genhtml查看总体视图与网页视图
如下，可以看出本次覆盖测试成功instrument的行数有近两万行，执行的行数却只有三千多行，可以反复的增加测试用例，提高覆盖测试率。下图分别给出了整体覆盖率和各个源文件的覆盖情况。
.gcda文件目录出错，找不到要创建的目录，这种主要用于跨平台情况。
这个是由于.gcda文件的生成默认保存到.o所在的目录，但是如果.o所在目录不存在，就会出现错误。
设置环境变量可以解决这个问题。
设置GCOV_PREFIX=/target/run’同GCOV_PREFIX_STRIP=1
则生成的.gcda文件 将会保存到 /target/run/build/foo.gcda。
the gcov message “Merge mismatch for summaries”
可以将.gcda全部删除或者对整个文件全部编译，而不是单个改变的文件，这个是由于gcda与gcno不相配导致的，因为两者之间都有个时间戳用来记录是不是相同的。
&&&&推荐文章:
【上篇】【下篇】}