生成可执行文件过程

http://blog.csdn.net/zzjslt/article/details/5973088





C语言编译全过程


    编译的概念：编译程序读取源程序（字符流），对之进行词法和语法的分析，将高级语言指令转换为功能等效的汇编代码，再由汇编程序转换为机器语言，并且按照操作系统对可执行文件格式的要求链接生成可执行程序。
    编译的完整过程：C源程序－－>预编译处理(.c)－－>编译、优化程序（.s、.asm）－－>汇编程序(.obj、.o、.a、.ko)－－>链接程序（.exe、.elf、.axf等）

1. 编译预处理

    读取c源程序，对其中的伪指令（以#开头的指令）和特殊符号进行处理
伪指令主要包括以下四个方面：
 （1）宏定义指令，如#define Name TokenString，#undef等。
对于前一个伪指令，预编译所要做的是将程序中的所有Name用TokenString替换，但作为字符串常量的 Name则不被替换。对于后者，则将取消对某个宏的定义，使以后该串的出现不再被替换。
 （2）条件编译指令，如#ifdef，#ifndef，#else，#elif，#endif等。
这些伪指令的引入使得程序员可以通过定义不同的宏来决定编译程序对哪些代码进行处理。预编译程序将根据有关的文件，将那些不必要的代码过滤掉
 （3） 头文件包含指令，如#include "FileName"或者#include <FileName>等。
在头文件中一般用伪指令#define定义了大量的宏（最常见的是字符常量），同时包含有各种外部符号的声明。
    采用头文件的目的主要是为了使某些定义可以供多个不同的C源程序使用。因为在需要用到这些定义的C源程序中，只需加上一条#include语句即可，而不必再在此文件中将这些定义重复一遍。预编译程序将把头文件中的定义统统都加入到它所产生的输出文件中，以供编译程序对之进行处理。
    包含到c源程序中的头文件可以是系统提供的，这些头文件一般被放在/usr/include目录下。在程序中#include它们要使用尖括号（< >）。另外开发人员也可以定义自己的头文件，这些文件一般与c源程序放在同一目录下，此时在#include中要用双引号（""）。
 （4）特殊符号，预编译程序可以识别一些特殊的符号。
例如在源程序中出现的LINE标识将被解释为当前行号（十进制数），FILE则被解释为当前被编译的C源程序的名称。预编译程序对于在源程序中出现的这些串将用合适的值进行替换。
   预编译程序所完成的基本上是对源程序的“替代”工作。经过此种替代，生成一个没有宏定义、没有条件编译指令、没有特殊符号的输出文件。这个文件的含义同没有经过预处理的源文件是相同的，但内容有所不同。下一步，此输出文件将作为编译程序的输出而被翻译成为机器指令。

 2. 编译、优化阶段

    经过预编译得到的输出文件中，只有常量；如数字、字符串、变量的定义，以及C语言的关键字，如main,if,else,for,while,{,}, +,-,*,/等等。
    编译程序所要作得工作就是通过词法分析和语法分析，在确认所有的指令都符合语法规则之后，将其翻译成等价的中间代码表示或汇编代码。
    优化处理是编译系统中一项比较艰深的技术。它涉及到的问题不仅同编译技术本身有关，而且同机器的硬件环境也有很大的关系。优化一部分是对中间代码的优化。这种优化不依赖于具体的计算机。另一种优化则主要针对目标代码的生成而进行的。
    对于前一种优化，主要的工作是删除公共表达式、循环优化（代码外提、强度削弱、变换循环控制条件、已知量的合并等）、复写传播，以及无用赋值的删除，等等。
后一种类型的优化同机器的硬件结构密切相关，最主要的是考虑是如何充分利用机器的各个硬件寄存器存放的有关变量的值，以减少对于内存的访问次数。另外，如何根据机器硬件执行指令的特点（如流水线、RISC、CISC、VLIW等）而对指令进行一些调整使目标代码比较短，执行的效率比较高，也是一个重要的研究课题。
    经过优化得到的汇编代码必须经过汇编程序的汇编转换成相应的机器指令，方可能被机器执行。

  3. 汇编过程

    汇编过程实际上指把汇编语言代码翻译成目标机器指令的过程。对于被翻译系统处理的每一个C语言源程序，都将最终经过这一处理而得到相应的目标文件。目标文件中所存放的也就是与源程序等效的目标的机器语言代码。
 目标文件由段组成。通常一个目标文件中至少有两个段：
    代码段：该段中所包含的主要是程序的指令。该段一般是可读和可执行的，但一般却不可写。
    数据段：主要存放程序中要用到的各种全局变量或静态的数据。一般数据段都是可读，可写，可执行的。
 UNIX环境下主要有三种类型的目标文件：
 （1）可重定位文件
其中包含有适合于其它目标文件链接来创建一个可执行的或者共享的目标文件的代码和数据。
 （2）共享的目标文件
   这种文件存放了适合于在两种上下文里链接的代码和数据。
   第一种是链接程序可把它与其它可重定位文件及共享的目标文件一起处理来创建另一个 目标文件；
  第二种是动态链接程序将它与另一个可执行文件及其它的共享目标文件结合到一起，创建一个进程映象。
（3）可执行文件
    它包含了一个可以被操作系统创建一个进程来执行之的文件。
汇编程序生成的实际上是第一种类型的目标文件。对于后两种还需要其他的一些处理方能得到，这个就是链接程序的工作了。

  4. 链接程序

 

    由汇编程序生成的目标文件并不能立即就被执行，其中可能还有许多没有解决
的问题。
    例如，某个源文件中的函数可能引用了另一个源文件中定义的某个符号（如变量或者函数调用等）；在程序中可能调用了某个库文件中的函数，等等。所有的这些问题，都需要经链接程序的处理方能得以解决。
    链接程序的主要工作就是将有关的目标文件彼此相连接，也即将在一个文件中引用的符号同该符号在另外一个文件中的定义连接起来，使得所有的这些目标文件成为一个能够诶操作系统装入执行的统一整体。
    根据开发人员指定的同库函数的链接方式的不同，链接处理可分为两种：
 （1）静态链接
    在这种链接方式下，函数的代码将从其所在地静态链接库中被拷贝到最终的可执行程序中。这样该程序在被执行时这些代码将被装入到该进程的虚拟地址空间中。静态链接库实际上是一个目标文件的集合，其中的每个文件含有库中的一个或者一组相关函数的代码。
 （2） 动态链接
    在此种方式下，函数的代码被放到称作是动态链接库或共享对象的某个目标文件中。链接程序此时所作的只是在最终的可执行程序中记录下共享对象的名字以及其它少量的登记信息。在此可执行文件被执行时，动态链接库的全部内容将被映射到运行时相应进程的虚地址空间。动态链接程序将根据可执行程序中记录的信息找到相应的函数代码。
    对于可执行文件中的函数调用，可分别采用动态链接或静态链接的方法。使用动态链接能够使最终的可执行文件比较短小，并且当共享对象被多个进程使用时能节约一些内存，因为在内存中只需要保存一份此共享对象的代码。但并不是使用动态链接就一定比使用静态链接要优越。在某些情况下动态链接可能带来一些性能上损害。

总结：
    C语言编译的整个过程是非常复杂的，里面涉及到的编译器知识、硬件知识、工具链知识都是非常多的，深入了解整个编译过程对工程师理解应用程序的编写是有很大帮助的，希望大家可以多了解一些，在遇到问题时多思考、多实践。
    一般情况下，我们只需要知道分成编译和连接两个阶段，编译阶段将源程序（*.c)转换成为目标代码（，一般是obj文件，至于具体过程就是上面说的那些阶段），连接阶段是把源程序转换成的目标代码（obj文件）与你程序里面调用的库函数对应的代码连接起来形成对应的可执行文件（exe文件）就可以了，其他的都需要在实践中多多体会才能有更深的理解。

 

 

 

自动生成 Makefile 的全过程详解！ automake/autoconf 入门

automake/autoconf 入门
作为Linux 下的程序开发人员，大家一定都遇到过Makefile ，用make 命令来编译自己写的程序确实是很方便。一般情况下，大家都是手工写一个简单Makefile ，如果要想写出一个符合自由软件惯例的Makefile 就不那么容易了。

在本文中，将给大家介绍如何使用autoconf 和automake 两个工具来帮助我们自动地生成符合自由软件惯例的Makefile ，这样就可以象常 见的GNU 程序一样，只要使用“./configure” ，“make” ，“make instal” 就可以把程序安装到Linux 系统中去了。这将特别适合想做开放源代码软件的程序开发人员，又或如果你只是自己写些小的Toy 程序，那么这 个文章对你也会有很大的帮助。

一、Makefile 介绍

Makefile 是用于自动编译和链接的，一个工程有很多文件组成，每一个文件的改变都会导致工程的重新链接，但是不是所有的文件都需要重新编译，Makefile 中纪录有文件的信息，在make 时会决定在链接的时候需要重新编译哪些文件。

Makefile 的宗旨就是：让编译器知道要编译一个文件需要依赖其他的哪些文件。当那些依赖文件有了改变，编译器会自动的发现最终的生成文件已经过时，而重新编译相应的模块。

Makefile 的基本结构不是很复杂，但当一个程序开发人员开始写Makefile 时，经常会怀疑自己写的是否符合惯例，而且自己写的 Makefile 经常和自己的开发环境相关联，当系统环境变量或路径发生了变化后，Makefile 可能还要跟着修改。这样就造成了手工书写 Makefile 的诸多问题，automake 恰好能很好地帮助我们解决这些问题。

使用automake ，程序开发人员只需要写一些 简单的含有预定义宏的文件，由autoconf 根据一个宏文件生成configure ，由automake 根据另一个宏文件生成Makefile.in ， 再使用configure 依据Makefile.in 来生成一个符合惯例的Makefile 。下面我们将详细介绍Makefile 的automake 生成 方法。

二、使用的环境

本文所提到的程序是基于Linux 发行版本：Fedora Core release 1 ，它包含了我们要用到的autoconf ，automake 。

三、从helloworld 入手

我们从大家最常使用的例子程序helloworld 开始。

下面的过程如果简单地说来就是：

新建三个文件：

helloworld.c
configure.in
Makefile.am

然后执行：

aclocal; autoconf; automake --add-missing; ./configure; make; ./helloworld

就可以看到Makefile 被产生出来，而且可以将helloworld.c 编译通过。

很简单吧，几条命令就可以做出一个符合惯例的Makefile ，感觉如何呀。

现在开始介绍详细的过程：

1 、建目录

在你的工作目录下建一个helloworld 目录，我们用它来存放helloworld 程序及相关文件，如在/home/my/build 下：

$ mkdir helloword
$ cd helloworld

2 、 helloworld.c

然后用你自己最喜欢的编辑器写一个hellowrold.c 文件，如命令：vi helloworld.c 。使用下面的代码作为helloworld.c 的内容。

int main(int argc, char** argv)
{
printf("Hello, Linux World!/n");
return 0;
}

完成后保存退出。

现在在helloworld 目录下就应该有一个你自己写的helloworld.c 了。

3 、生成configure

我们使用autoscan 命令来帮助我们根据目录下的源代码生成一个configure.in 的模板文件。

命令：

$ autoscan
$ ls
configure.scan helloworld.c

执行后在hellowrold 目录下会生成一个文件：configure.scan ，我们可以拿它作为configure.in 的蓝本。

现在将configure.scan 改名为configure.in ，并且编辑它，按下面的内容修改，去掉无关的语句：

============================configure.in 内容开始=========================================
# -*- Autoconf -*-
# Process this file with autoconf to produce a configure script.

AC_INIT(helloworld.c)
AM_INIT_AUTOMAKE(helloworld, 1.0)

# Checks for programs.
AC_PROG_CC

# Checks for libraries.

# Checks for header files.

# Checks for typedefs, structures, and compiler characteristics.

# Checks for library functions.
AC_OUTPUT(Makefile)
============================configure.in 内容结束=========================================

然后执行命令aclocal 和autoconf ，分别会产生aclocal.m4 及configure 两个文件：

$ aclocal
$ls
aclocal.m4 configure.in helloworld.c
$ autoconf
$ ls
aclocal.m4 autom4te.cache configure configure.in helloworld.c


大家可以看到configure.in 内容是一些宏定义，这些宏经autoconf 处理后会变成检查系统特性、环境变量、软件必须的参数的shell 脚本。

autoconf 是用来生成自动配置软件源代码脚本（configure ）的工具。configure 脚本能独立于autoconf 运行，且在运行的过程中，不需要用户的干预。

要生成configure 文件，你必须告诉autoconf 如何找到你所用的宏。方式是使用aclocal 程序来生成你的aclocal.m4 。

aclocal 根据configure.in 文件的内容，自动生成aclocal.m4 文件。aclocal 是一个perl 脚本程序，它的定义是：“aclocal - create aclocal.m4 by scanning configure.ac” 。

autoconf 从configure.in 这个列举编译软件时所需要各种参数的模板文件中创建configure 。

autoconf 需要GNU m4 宏处理器来处理aclocal.m4 ，生成configure 脚本。

m4 是一个宏处理器。将输入拷贝到输出，同时将宏展开。宏可以是内嵌的，也可以是用户定义的。除了可以展开宏，m4 还有一些内建的函数，用来引用文件，执行命令，整数运算，文本操作，循环等。m4 既可以作为编译器的前端，也可以单独作为一个宏处理器。

4 、新建Makefile.am

新建Makefile.am 文件，命令：


$ vi Makefile.am


内容如下:


AUTOMAKE_OPTIONS=foreign
bin_PROGRAMS=helloworld
helloworld_SOURCES=helloworld.c


automake 会根据你写的Makefile.am 来自动生成Makefile.in 。

Makefile.am 中定义的宏和目标, 会指导automake 生成指定的代码。例如，宏bin_PROGRAMS 将导致编译和连接的目标被生成。

5 、运行automake

命令：


$ automake --add-missing
configure.in: installing `./install-sh'
configure.in: installing `./mkinstalldirs'
configure.in: installing `./missing'
Makefile.am: installing `./depcomp'


automake 会根据Makefile.am 文件产生一些文件，包含最重要的Makefile.in 。

6 、执行configure 生成Makefile


$ ./configure
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for gawk... gawk
checking whether make sets $(MAKE)... yes
checking for gcc... gcc
checking for C compiler default output... a.out
checking whether the C compiler works... yes
checking whether we are cross compiling... no
checking for suffix of executables...
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ANSI C... none needed
checking for style of include used by make... GNU
checking dependency style of gcc... gcc3
configure: creating ./config.status
config.status: creating Makefile
config.status: executing depfiles commands
$ ls -l Makefile
-rw-rw-r-- 1 yutao yutao 15035 Oct 15 10:40 Makefile


你可以看到，此时Makefile 已经产生出来了。

7 、使用Makefile 编译代码



$ make
if gcc -DPACKAGE_NAME="" -DPACKAGE_TARNAME="" -DPACKAGE_VERSION="" -

DPACKAGE_STRING="" -DPACKAGE_BUGREPORT="" -DPACKAGE="helloworld" -DVERSION="1.0"

-I. -I. -g -O2 -MT helloworld.o -MD -MP -MF ".deps/helloworld.Tpo" /
-c -o helloworld.o `test -f 'helloworld.c' || echo './'`helloworld.c; /
then mv -f ".deps/helloworld.Tpo" ".deps/helloworld.Po"; /
else rm -f ".deps/helloworld.Tpo"; exit 1; /
fi
gcc -g -O2 -o helloworld helloworld.o


运行helloworld



$ ./helloworld
Hello, Linux World!


这样helloworld 就编译出来了，你如果按上面的步骤来做的话，应该也会很容易地编译出正确的helloworld 文件。你还可以试着使用一些其 他的make 命令，如make clean ，make install ，make dist ，看看它们会给你什么样的效果。感觉如何？自己也能写出这么专业的Makefile ，老板一定会对你刮目相看。

四、深入浅出

针对上面提到的各个命令，我们再做些详细的介绍。

1 、 autoscan

autoscan 是用来扫描源代码目录生成configure.scan 文件的。autoscan 可以用目录名做为参数，但如果你不使用参数的话，那么 autoscan 将认为使用的是当前目录。autoscan 将扫描你所指定目录中的源文件，并创建configure.scan 文件。

2 、 configure.scan

configure.scan 包含了系统配置的基本选项，里面都是一些宏定义。我们需要将它改名为configure.in

3 、 aclocal

aclocal 是一个perl 脚本程序。aclocal 根据configure.in 文件的内容，自动生成aclocal.m4 文件。aclocal 的定义是：“aclocal - create aclocal.m4 by scanning configure.ac” 。

4 、 autoconf

autoconf 是用来产生configure 文件的。configure 是一个脚本，它能设置源程序来适应各种不同的操作系统平台，并且根据不同的系统来产生合适的Makefile ，从而可以使你的源代码能在不同的操作系统平台上被编译出来。

configure.in 文件的内容是一些宏，这些宏经过autoconf 处理后会变成检查系统特性、环境变量、软件必须的参数的shell 脚本。configure.in 文件中的宏的顺序并没有规定，但是你必须在所有宏的最前面和最后面分别加上AC_INIT 宏和AC_OUTPUT 宏。

在configure.ini 中：

# 号表示注释，这个宏后面的内容将被忽略。

AC_INIT(FILE)

这个宏用来检查源代码所在的路径。

AM_INIT_AUTOMAKE(PACKAGE, VERSION)

这个宏是必须的，它描述了我们将要生成的软件包的名字及其版本号：PACKAGE 是软件包的名字，VERSION 是版本号。当你使用make dist 命令时，它会给你生成一个类似helloworld-1.0.tar.gz 的软件发行包，其中就有对应的软件包的名字和版本号。

AC_PROG_CC

这个宏将检查系统所用的C 编译器。

AC_OUTPUT(FILE)

这个宏是我们要输出的Makefile 的名字。

我们在使用automake 时，实际上还需要用到其他的一些宏，但我们可以用aclocal 来帮我们自动产生。执行aclocal 后我们会得到aclocal.m4 文件。

产生了configure.in 和aclocal.m4 两个宏文件后，我们就可以使用autoconf 来产生configure 文件了。

5 、 Makefile.am

Makefile.am 是用来生成Makefile.in 的，需要你手工书写。Makefile.am 中定义了一些内容：

AUTOMAKE_OPTIONS

这个是automake 的选项。在执行automake 时，它会检查目录下是否存在标准GNU 软件包中应具备的各种文件，例如AUTHORS 、ChangeLog 、NEWS 等文件。我们将其设置成foreign 时，automake 会改用一般软件包的标准来检查。

bin_PROGRAMS

这个是指定我们所要产生的可执行文件的文件名。如果你要产生多个可执行文件，那么在各个名字间用空格隔开。

helloworld_SOURCES

这个是指定产生“helloworld” 时所需要的源代码。如果它用到了多个源文件，那么请使用空格符号将它们隔开。比如需要 helloworld.h ，helloworld.c 那么请写成helloworld_SOURCES= helloworld.h helloworld.c 。

如果你在bin_PROGRAMS 定义了多个可执行文件，则对应每个可执行文件都要定义相对的filename_SOURCES 。

6 、 automake

我们使用automake --add-missing 来产生Makefile.in 。

选项--add-missing 的定义是“add missing standard files to package” ，它会让automake 加入一个标准的软件包所必须的一些文件。

我们用automake 产生出来的Makefile.in 文件是符合GNU Makefile 惯例的，接下来我们只要执行configure 这个shell 脚本就可以产生合适的 Makefile 文件了。

7 、 Makefile

在符合GNU Makefiel 惯例的Makefile 中，包含了一些基本的预先定义的操作：

make

根据Makefile 编译源代码，连接，生成目标文件，可执行文件。

make clean

清除上次的make 命令所产生的object 文件（后缀为“.o” 的文件）及可执行文件。

make install

将编译成功的可执行文件安装到系统目录中，一般为/usr/local/bin 目录。

make dist

产生发布软件包文件（即distribution package ）。这个命令将会将可执行文件及相关文件打包成一个tar.gz 压缩的文件用来作为发布软件的软件包。

它会在当前目录下生成一个名字类似“PACKAGE-VERSION.tar.gz” 的文件。PACKAGE 和VERSION ，是我们在configure.in 中定义的AM_INIT_AUTOMAKE(PACKAGE, VERSION) 。

make distcheck

生成发布软件包并对其进行测试检查，以确定发布包的正确性。这个操作将自动把压缩包文件解开，然后执行configure 命令，并且执行make ，来确认编译不出现错误，最后提示你软件包已经准备好，可以发布了。

===============================================
helloworld-1.0.tar.gz is ready for distribution
===============================================
make distclean

类似make clean ，但同时也将configure 生成的文件全部删除掉，包括Makefile 。

五、结束语

通过上面的介绍，你应该可以很容易地生成一个你自己的符合GNU 惯例的Makefile 文件及对应的项目文件。

如果你想写出更复杂的且符合惯例的Makefile ，你可以参考一些开放代码的项目中的configure.in 和Makefile.am 文件，比如：嵌入式数据库sqlite ，单元测试cppunit 。

 

 

 

 

 

 

 

 

gcc 从语言编译全过程 预处理---->编译---->汇编----->链接

文章分类:C++编程

在Linux下进行C语言编程，必然要采用GNU GCC来编译C源代码生成可执行程序。

一、GCC快速入门

Gcc指令的一般格式为：Gcc [选项] 要编译的文件 [选项] [目标文件]

其中，目标文件可缺省，Gcc默认生成可执行的文件名为：编译文件.out

我们来看一下经典入门程序"Hello World！"

# vi hello.c

#include <stdlib.h>
#include <stdio.h>
void main(void)
{
printf("hello world!/r/n");
}

用gcc编译成执行程序。

#gcc hello.c

该命令将hello.c直接生成最终二进制可执行程序a.out

这条命令隐含执行了（1）预处理、（2）汇编、(3)编译并(4)链接形成最终的二进制可执行程序。这里未指定输出文件，默认输出为a.out。

如何要指定最终二进制可执行程序名，那么用-o选项来指定名称。比如需要生成执行程序hello.exe

那么

#gcc hello.c -o hello.exe

二、GCC的命令剖析--四步走

从上面我们知道GCC编译源代码生成最终可执行的二进制程序，GCC后台隐含执行了四个阶段步骤。

GCC编译C源码有四个步骤：

预处理-----> 编译 ----> 汇编 ----> 链接

现在我们就用GCC的命令选项来逐个剖析GCC过程。

1）预处理(Pre-processing)

在该阶段，编译器将C源代码中的包含的头文件如stdio.h编译进来，用户可以使用gcc的选项”-E”进行查看。

用法：#gcc -E hello.c -o hello.i

作用：将hello.c预处理输出hello.i文件。

[root]# gcc -E hello.c -o hello.i
[root]# ls
hello.c  hello.i
[root]# vi hello.i
# 1 "hello.c"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "hello.c"
# 1 "/usr/include/stdlib.h" 1 3
# 25 "/usr/include/stdlib.h" 3
# 1 "/usr/include/features.h" 1 3
# 291 "/usr/include/features.h" 3
# 1 "/usr/include/sys/cdefs.h" 1 3
# 292 "/usr/include/features.h" 2 3
# 314 "/usr/include/features.h" 3
# 1 "/usr/include/gnu/stubs.h" 1 3
# 315 "/usr/include/features.h" 2 3
# 26 "/usr/include/stdlib.h" 2 3
# 3 "hello.c" 2
void main(void)
{
printf("hello world!/r/n");
}


2)编译阶段(Compiling)

第二步进行的是编译阶段，在这个阶段中，Gcc首先要检查代码的规范性、是否有语法错误等，以确定代码的实际要做的工作，在检查无误后，Gcc把代码翻译成汇编语言。用户可以使用”-S”选项来进行查看，该选项只进行编译而不进行汇编，生成汇编代码。

选项 -S

用法：[root]# gcc –S hello.i –o hello.s

作用：将预处理输出文件hello.i汇编成hello.s文件。

[root@richard hello-gcc]# ls

hello.c  hello.i  hello.s

如下为hello.s汇编代码

[root@richard hello-gcc]# vi hello.s
.file   "hello.c"
.section    .rodata
.LC0:
.string "hello world!/r/n"
.text
.globl main
.type   main,@function
main:
pushl   %ebp
movl    %esp, %ebp
subl    $8, %esp
andl    $-16, %esp
movl    $0, %eax
subl    %eax, %esp
subl    $12, %esp
pushl   $.LC0
call    printf
addl    $16, %esp
movl    $0, %eax
leave
ret
.Lfe1:
.size   main,.Lfe1-main
.ident  "GCC: (GNU) 3.2.2 20030222 (Red Hat Linux 3.2.2-5)"

3)汇编阶段(Assembling)

汇编阶段是把编译阶段生成的”.s”文件转成二进制目标代码.

选项 -c

用法：[root]# gcc –c hello.s –o hello.o

作用：将汇编输出文件test.s编译输出test.o文件。

[root]# gcc -c hello.s -o hello.o

[root]# ls

hello.c  hello.i  hello.o  hello.s


4）链接阶段(Link)

在成功编译之后，就进入了链接阶段。

无选项链接

用法：[root]# gcc hello.o –o hello.exe

作用：将编译输出文件hello.o链接成最终可执行文件hello.exe。

[root]# ls

hello.c  hello.exe  hello.i  hello.o  hello.s

运行该可执行文件，出现正确的结果如下。

[root@localhost Gcc]# ./hello

Hello World!

在这里涉及到一个重要的概念：函数库。

读者可以重新查看这个小程序，在这个程序中并没有定义”printf”的函数实现，且在预编译中包含进的”stdio.h”中也只有该函数的声明，而没有定义函数的实现，那么，是在哪里实现”printf”函数的呢？最后的答案是：系统把这些函数实现都被做到名为libc.so.6的库文件中去了，在没有特别指定时，gcc会到系统默认的搜索路径”/usr/lib”下进行查找，也就是链接到libc.so.6库函数中去，这样就能实现函数”printf” 了，而这也就是链接的作用。

你可以用ldd命令查看动态库加载情况：

[root]# ldd hello.exe

libc.so.6 => /lib/tls/libc.so.6 (0x42000000)

/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)

函数库一般分为静态库和动态库两种。静态库是指编译链接时，把库文件的代码全部加入到可执行文件中，因此生成的文件比较大，但在运行时也就不再需要库文件了。其后缀名一般为”.a”。动态库与之相反，在编译链接时并没有把库文件的代码加入到可执行文件中，而是在程序执行时由运行时链接文件加载库，这样可以节省系统的开销。动态库一般后缀名为”.so”，如前面所述的libc.so.6就是动态库。gcc在编译时默认使用动态库。