CodeViz 原本是作者用来分析 Linux virtual memory 的源码时写的一个小工具，现在已经基本支持 C++ 语言，最新的 1.0.9 版能在 Windows + Cygwin 下顺利地编译使用:)。需要注意的是：1) 下载 GCC 3.4.1 的源码 gcc-3.4.1.tar.gz 放到 codeviz-1.0.9/compilers，2) 安装 patch 程序（属于Utils类），3) 从 http://www.graphviz.org 下载并安装 Graphviz 2.6。

我用 CodeViz 分析《嵌入式实时操作系统 uC/OS-II (第二版)》中的第一个范例程序，步骤如下：

1. 想办法让 gcc 能编译uC/OS 2.52和范例程序的源码，每个C源文件生成对于的.c.cdepn文件。只要编译(参数 -c)就行，无需连接。

2. 调用genfull生成full.graph，这个文件记录了所有函数在源码中的位置和它们之间的调用关系。

3. 使用gengraph生成我关心的函数的调用关系。

首先分析main()：

1. gengraph --output-type gif -f main
分析main()的call graph，得到的图如下，看不出要领：

2. gengraph --output-type gif -f main -s OSInit
暂时不关心OSInit()的内部实现细节(参数 -s)，让它显示为一个节点。得到的图如下，有点乱，不过好多了：

3. gengraph --output-type gif -f main -s OSInit -i "OSCPUSaveSR;OSCPURestoreSR"
基本上每个函数都会有进入/退出临界区的代码，忽略之(参数 -i)。得到的图如下，基本清楚了：

4. gengraph --output-type gif -f main -s "OSInit;OSSemCreate" -i "OSCPUSaveSR;OSCPURestoreSR" -k
OSSemCreate()的内部细节似乎也不用关心，不过保留中间文件sub.graph(参数 -k)，得到的图如下，

5. dot -Tgif -o main.gif sub.graph
修改sub.graph，使图形符合函数调用顺序，最后得到的图如下，有了这个都不用看代码了:)

接着分析OSTimeDly()的被调用关系：

gengraph --output-type gif -r -f OSTimeDly

看看哪些函数调用了OSTimeDly()，参数 -r ，Task()和TaskStart()都是用户编写的函数：

最后看看Task()直接调用了哪些函数：

gengraph --output-type gif -d 1 -f Task

只看从Task出发的第一层调用（参数 -d 1）：

在分析源码的时候，把这些图形打印在手边，在上面做笔记，实在方便得很。

函数调用关系图（call graph）是图（graph），而且是有向图，多半还是无环图（无圈图）——如果代码中没有直接或间接的递归的话。Graphviz是专门绘制有向图和无向图的工具，所以很多call graph分析工具都以它为后端(back end)。那么前端呢？就看各家各显神通了。

调用图的分析分析大致可分为“静态”和“动态”两种，所谓静态分析是指在不运行待分析的程序的前提下进行分析，那么动态分析自然就是记录程序实际运行时的函数调用情况了。

静态分析又有两种方法，一是分析源码，二是分析编译后的目标文件。

分析源码获得的调用图的质量取决于分析工具对编程语言的理解程度，比如能不能找出正确的C++重载函数。Doxygen是源码文档化工具，也能绘制调用图，它似乎是自己分析源码获得函数调用关系的。GNU cflow也是类似的工具，不过它似乎偏重分析流程图（flowchart）。

对编程语言的理解程度最好的当然是编译器了，所以有人想出给编译器打补丁，让它在编译时顺便记录函数调用关系。CodeViz（其灵感来自Martin Devera (Devik) 的工具）就属于此类，它（1.0.9版）给GCC 3.4.1打了个补丁。另外一个工具egypt的思路更巧妙，不用大动干戈地给编译器打补丁，而是让编译器自己dump出调用关系，然后分析分析，交给Graphviz去绘图。不过也有人另起炉灶，自己写个C语言编译器（ncc），专门分析调用图，勇气可嘉。不如要是对C++语言也这么干，成本不免太高了。分析C++的调用图，还是借助编译器比较实在。

分析目标文件听起来挺高深，其实不然，反汇编的工作交给binutils的objdump去做，只要分析一下反汇编出来的文本文件就行了。下面是Cygwin下objdump -d a.exe的部分结果：

00401050 <_main>:
  401050:       55                      push   %ebp
  401051:       89 e5                   mov    %esp,%ebp
  401053:       83 ec 18                sub    $0x18,%esp
   ......
 40107a:       c7 44 24 04 00 20 40    movl   $0x402000,0x4(%esp)
  401081:       00
  401082:       c7 04 24 02 20 40 00    movl   $0x402002,(%esp)
  401089:       e8 f2 00 00 00          call   401180 <_fopen>

从中可以看出，main()调用了fopen()。CodeViz带有分析目标文件的功能。

动态分析是在程序运行时记录函数的调用，然后整理成调用图。与静态分析相比，它能获得更多的信息，比如函数调用的先后顺序和次数；不过也有一定的缺点，比如程序中语句的某些分支可能没有执行到，这些分支中调用的函数自然就没有记录下来。

动态分析也有两种方法，一是借助gprof的call graph功能（参数-q），二是利用GCC的 -finstrument-functions 参数。

gprof生成的输出如下：

index % time    self  children    called     name
                0.00    0.00       4/4           foo [4]
[3]      0.0    0.00    0.00       4         bar [3]
-----------------------------------------------
                0.00    0.00       1/2           init [5]
                0.00    0.00       1/2           main [45]
[4]      0.0    0.00    0.00       2         foo [4]
                0.00    0.00       4/4           bar [3]
-----------------------------------------------
                0.00    0.00       1/1           main [45]
[5]      0.0    0.00    0.00       1         init [5]
                0.00    0.00       1/2           foo [4]
-----------------------------------------------

从中可以看出，bar()被foo()调用了4次，foo()被init()和main()各调用了一次，init()被main()调用了一次。用Perl脚本分析gprof的输出，生成Graphviz的dot输入，就能绘制call graph了。这样的脚本不止一个人写过：http://www.graphviz.org/Resources.php，http://www.ioplex.com/~miallen/。

GCC的-finstrument-functions 参数的作用是在程序中加入hook，让它在每次进入和退出函数的时候分别调用下面这两个函数：

void __cyg_profile_func_enter( void *func_address, void *call_site )
                                __attribute__ ((no_instrument_function));

void __cyg_profile_func_exit ( void *func_address, void *call_site )
                                __attribute__ ((no_instrument_function));

当然，这两个函数本身不能被钩住（使用no_instrument_function这个__attribute__），不然就反反复复万世不竭了:) 这里获得的是函数地址，需要用binutils中的addr2line这个小工具转换为函数名，如果是C++函数，还要用c++filt进行name demangle。具体方法在《 用Graphviz 可视化函数调用》中有详细介绍，这里不再赘述。

从适应能力上看，源码分析法是最强的，即便源码中有语法错，头文件不全也没关系，它照样能分析个八九不离十。而基于编译器的分析法对源码的要求要高一些，至少能编译通过（gcc 参数 -c）——能产生object file，不一定要链接得到可执行文件。这至少要求源码没有语法错，其中调用的函数不一定有定义(definition)，但要有声明(declaration)，也就是说头文件要齐全。当然，真的不全也没关系，自己放几个函数声明在前面就能糊弄编译器:) 至于动态分析，要求最高——程序需得运行起来。如果你要分析的是操作系统中某一部分，比如内存管理或网络协议栈，那么这里提到的两种动态分析法恐怕都不适用了。

我发现前面列举的所有免费工具几乎都和GCC、GNU Binutils脱不了干系。这里在把它们整理一下，用Graphviz绘成图：

举例来说，有如下 Makefile:

# start of Makefile

all: foo1.obj foo2.obj foo3.obj foo4.obj

.cpp.obj:
    cl /nologo /c $<

# end of Makefile

那么执行 nmake 得到的输出是

Microsoft (R) Program Maintenance Utility Version 8.00.50727.762
Copyright (C) Microsoft Corporation.  All rights reserved.

        cl /nologo /c foo1.cpp
foo1.cpp
        cl /nologo /c foo2.cpp
foo2.cpp
        cl /nologo /c foo3.cpp
foo3.cpp
        cl /nologo /c foo4.cpp
foo4.cpp

可见期间调用了 4 次 CL。如果把上述 Makefile 中的“.cpp.obj:”替换为“.cpp.obj::”，注意多了一个冒号，再调用 nmake 得到的输出是

Microsoft (R) Program Maintenance Utility Version 8.00.50727.762
Copyright (C) Microsoft Corporation.  All rights reserved.

        cl /nologo /c foo1.cpp foo2.cpp foo3.cpp foo4.cpp
foo1.cpp
foo2.cpp
foo3.cpp
foo4.cpp
Generating Code...

可见这样一次就把 4 个文件都编译出来了。只要多加一个冒号，就能节省反复启动编译器的时间，加快编译速度。

在预定义的规则中，nmake 是开启批模式的，可以用命令行参数 /Y 来禁用它。

http://msdn2.microsoft.com/zh-cn/library/f2x0zs74(VS.80).aspx （批模式规则）

http://msdn2.microsoft.com/zh-cn/library/cx06ysxh(VS.80).aspx （预定义的规则）