GCC、头文件查找顺序总结

转自:https://blog.csdn.net/benpaobagzb/article/details/51277960

 

--------------------------------------------------------------------------------


1984年,Richard Stallman发起了自由软件运动,GNU (Gnu's Not Unix)项目应运而生,3年后,最初版

的GCC横空出世,成为第一款可移植、可优化、支持ANSI C的开源C编译器。
GCC最初的全名是GNU C Compiler,之后,随着GCC支持的语言越来越多,它的名称变成了GNU Compiler

Collection。
这里介绍的gcc是GCC的前端,C编译器.


警告信息


--------------------------------------------------------------------------------

    -Wall : 显示所有常用的编译警告信息。
    -W    : 显示更多的常用编译警告,如:变量未使用、一些逻辑错误。
    -Wconversion : 警告隐式类型转换。
    -Wshadow : 警告影子变量(在代码块中再次声明已声明的变量)
    -Wcast-qual :警告指针修改了变量的修饰符。如:指针修改const变量。
    -Wwrite-strings : 警告修改const字符串。
    -Wtraditional : 警告ANSI编译器与传统C编译器有不同的解释。
    -Werror : 即使只有警告信息,也不编译。(gcc默认:若只有警告信息,则进行编译,若有错误信

息,则不编译)


C语言标准


--------------------------------------------------------------------------------


你可以在gcc的命令行中通过指定选项来选择相应的C语言标准: 从传统c到最新的GNU扩展C. 默认情况下,

gcc使用最新的GNU C扩展.

    -ansi : 关闭GNU扩展中与ANSI C相抵触的部分。
    -pedantic          : 关闭所有的GNU扩展。
    -std=c89           : 遵循C89标准
    -std=c99           : 遵循C99标准
    -std=traditional : 使用原始C
注意:后4个选项可以与-ansi结合使用,也可以单独使用。

可在gcc中使用大量GNU C扩展.

生成特定格式的文件


--------------------------------------------------------------------------------

以hello.c为例子,可以设置选项生成hello.i, hello.s, hello.o以及最终的hello文件:

    hello.c : 最初的源代码文件;
    hello.i : 经过编译预处理的源代码;
    hello.s : 汇编处理后的汇编代码;
    hello.o : 编译后的目标文件,即含有最终编译出的机器码,但它里面所引用的其他文件中函数的内

存位置尚未定义。
    hello / a.out : 最终的可执行文件
    (还有.a(静态库文件), .so(动态库文件), .s(汇编源文件)留待以后讨论)


如果你不通过-o指定生成可执行文件名,那么会默认生成a.out. 不指定生成文件名肯能覆盖你上次生成

的a.out.


e.g.
$ gcc hello.c
在不给gcc传递任何参数的情况下, gcc执行默认的操作: 将源文件编译为目标文件--> 将目标文件连接为

可执行文件(名为a.out) --> 删除目标文件.


-c生成.o文件时,默认生成与源代码的主干同名的.o文件。比如对应hello.c生成hello.o. 但也可在生成

目标文件时指定目标文件名(注意同时要给出.o后缀): $ gcc -c -o demo.o demo.c


    $ gcc -Wall -c hello.c              : 生成hello.o
    $ gcc -Wall -c -save-temps hello.c : 生成hello.i, hello.s, hello.o
    注意-Wall 选项的使用场合:仅在涉及到编译(即会生成.o文件时,用-Wall)  


多文件编译、连接

--------------------------------------------------------------------------------

如果原文件分布于多个文件中:file1.c, file2,c
    $ gcc -Wall file1.c file2.c -o name

若对其中一个文件作了修改,则可只重新编译该文件,再连接所有文件:
    $ gcc -Wall -c file2.c
    $ gcc file1.c file2.o -c name

注意:若编译器在命令行中从左向右顺序读取.o文件,则它们的出现顺序有限制:含有某函数定义的文件

必须出现在含有调用该函数的文件之后。好在GCC无此限制。


编译预处理


--------------------------------------------------------------------------------
以上述的hello.c为例, 要对它进行编译预备处理, 有两种方法: 在gcc中指定-E选项, 或直接调用

cpp.gcc的编译预处理命令程序为cpp,比较新版本的gcc已经将cpp集成了,但仍提供了cpp命令. 可以直

接调用cpp命令, 也可以在gcc中指定-E选项指定它只进行编译预处理.

$ gcc -E hello.c                            == $ cpp hello.c
上述命令马上将预处理结果显示出来. 不利于观看. 可采用-c将预处理结果保存:
$ gcc -E -c hello.i hello.c              == $ cpp -o hello.i hello.c
注意, -c指定名称要给出".i"后缀.

另外, gcc针对编译预处理提供了一些选项:
(1) 除了直接在源代码中用 #define NAME来定义宏外,gcc可在命令行中定义宏:-DNAME(其中NAME为宏

名), 也可对宏赋值: -DNAME=value 注意等号两边不能有空格! 由于宏扩展只是一个替换过程,也可以

将value换成表达式,但要在两边加上双括号: -DNAME="statement"
e.g. $ gcc -Wall -DVALUE="2+2" tmp.c -o tmp
如果不显示地赋值,如上例子,只给出:-DVALUE,gcc将使用默认值:1.

(2) 除了用户定义的宏外, 有一些宏是编译器自动定义的,它们以__开头,运行: $ cpp -dM /dev/null,

可以看到这些宏. 注意, 其中含有不以__开头的非ANSI宏,它们可以通过-ansi选项被禁止。

查看宏扩展

1, 运行 $ gcc -E test.c ,gcc对test.c进行编译预处理,并立马显示结果. (不执行编译) 2, 运行 $

gcc -c -save-temps test.c ,不光产生test.o,还产生test.i, test.s,前者是编译预处理结果, 后者

是汇编结果.
    
利用Emacs查看编译预处理结果

针对含有编译预处理命令的代码,可以利用emacs方便地查看预处理结果,而不需执行编译,更为方便的

是,可以只选取一段代码,而非整个文件:
1,选择想要查看的代码
2,C-c C-e (M-x c-macro-expand)
这样,就自动在一个名为"Macroexpansion"的buffer中显示pre-processed结果.

生成汇编代码

--------------------------------------------------------------------------------
使用"-S"选项指定gcc生成以".s"为后缀的汇编代码:
$ gcc -S hello.c
$ gcc -S -o hello.s hello.c

生成汇编语言的格式取决于目标平台. 另外, 如果是多个.c文件, 那么针对每一个.c文件生成一个.s文件

.

包含头文件


--------------------------------------------------------------------------------
在程序中包含与连接库对应的头文件是很重要的方面,要使用库,就一定要能正确地引用头文件。一般在

代码中通过#include引入头文件, 如果头文件位于系统默认的包含路径(/usr/includes), 则只需在

#include中给出头文件的名字, 不需指定完整路径. 但若要包含的头文件位于系统默认包含路径之外,

则有其它的工作要做: 可以(在源文件中)同时指定头文件的全路径. 但考虑到可移植性,最好通过-I在调

用gcc的编译命令中指定。


下面看这个求立方的小程序(阴影语句表示刚开始不存在):

#include <stdio.h>
#include <math.h>
int main(int argc, char *argv[])
{
double x = pow (2.0, 3.0);
printf("The cube of 2.0 is %f\n", x);
return 0;
}


使用gcc-2.95来编译它(-lm选项在后面的连接选项中有介绍, 这里只讨论头文件的包含问题):
$ gcc-2.95 -Wall pow.c -lm -o pow_2.95
pow.c: In function `main':
pow.c:5: warning: implicit declaration of function `pow'

程序编译成功,但gcc给出警告: pow函数隐式声明。
$ ./pow_2.95
The cube of 2.0 is 1.000000

明显执行结果是错误的,在源程序中引入头文件(#include <math.h>),消除了错误。

不要忽略Warning信息!它可能预示着,程序虽然编译成功,但运行结果可能有错。故,起码加上"-Wall"

编译选项!并尽量修正Warning警告。


搜索路径

首先要理解 #include<file.h>和#include"file.h"的区别:
#include<file.h>只在默认的系统包含路径搜索头文件
#include"file.h"首先在当前目录搜索头文件, 若头文件不位于当前目录, 则到系统默认的包含路径搜索

头文件.


UNIX类系统默认的系统路径为:

头文件,包含路径: /usr/local/include/ or /usr/include/
库文件,连接路径: /usr/local/lib/          or /usr/lib/   

对于标准c库(glibc或其它c库)的头文件, 我们可以直接在源文件中使用#include <file.h>来引入头文件

.


如果要在源文件中引入自己的头文件, 就需要考虑下面的问题:


1, 如果使用非系统头文件, 头文件和源文件位于同一个目录, 如何引用头文件呢?
——我们可以简单地在源文件中使用 #include "file.h", gcc将当前目录的file.h引入到源文件. 如果

你很固执, 仍想使用#include <file.h>语句, 可以在调用gcc时添加"-I."来将当前目录添加到系统包含

路径. 细心的朋友可能会想到: 这样对引用其它头文件会不会有影响? 比如, #include<file.h>之后紧接

着一个#include<math.h>, 它能正确引入math.h吗? 答案是: 没有影响. 仍然能正确引用math.h. 我的理

解是: "-I."将当前目录作为包含路径的第一选择, 若在当前目录找不到头文件, 则在默认路径搜索头文

件. 这实际上和#include"file.h"是一个意思.


2, 对于比较大型的工程, 会有许多用户自定义的头文件, 并且头文件和.c文件会位于不同的目录. 又该

如何在.c文件中引用头文件呢?
—— 可以直接在.c文件中利用#include“/path/file.h", 通过指定头文件的路径(可以是绝对路径, 也

可以是相对路径)来包含头文件. 但这明显降低了程序的可移植性. 在别的系统环境下编译可能会出现问

题. 所以还是利用"-I"选项指定头文件完整的包含路径.


针对头文件比较多的情况, 最好把它们统一放在一个目录中, 比如~/project/include. 这样就不需为不

同的头文件指定不同的路径. 如果你嫌每次输入这么多选项太麻烦, 你可以通过设置环境变量来添加路径

:
$ C_INCLUDE_PATH=/opt/gdbm-1.8.3/include
$ export C_INCLUDE_PATH
$ LIBRART_PATH=/opt/gdbm-1.8.3/lib
$ export LIBRART_PATH

可一次指定多个搜索路径,":"用于分隔它们,"."表示当前路径,如:
$ C_INCLUDE_PATH=.:/opt/gdbm-1.8.3/include:/net/include
$ LIBRARY_PATH=.:/opt/gdbm-1.8.3/lib:/net/lib
(可以添加多个路径,路径之间用:相隔,.代表当前目录,若.在最前头,也可省略)

当然,若想永久地添加这些路径,可以在.bash_profile中添加上述语句.

3, 还有一个比较猥琐的办法: 系统默认的包含路径不是/usr/include或/usr/local/include么? 我把自

己的头文件拷贝到其中的一个目录, 不就可以了么? 的确可以这样, 如果你只想在你自己的机器上编译运

行这个程序的话.


前面介绍了三种添加搜索路径的方法,如果这三种方法一起使用,优先级如何呢?
命令行设置 > 环境变量设置 > 系统默认


与外部库连接

--------------------------------------------------------------------------------
前面介绍了如何包含头文件. 而头文件和库是息息相关的, 使用库时, 要在源代码中包含适当的头文件,

这样才能声明库中函数的原型(发布库时, 就需要给出相应的头文件).

和包含路径一样, 系统也有默认的连接路径:
头文件,包含路径: /usr/local/include/ or /usr/include/
库文件,连接路径: /usr/local/lib/          or /usr/lib/  

同样地, 我们想要使用某个库里的函数, 必须将这个库连接到使用那些函数的程序中.

有一个例外: libc.a或libc.so (C标准库,它包含了ANSI C所定义的C函数)是不需要你显式连接的, 所有

的C程序在运行时都会自动加载c标准库.

除了C标准库之外的库称之为"外部库", 它可能是别人提供给你的, 也可能是你自己创建的(后面有介绍如

何创建库的内容).

外部库有两种:(1)静态连接库lib.a
                     (2)共享连接库lib.so 
两者的共同点:
    .a, .so都是.o目标文件的集合,这些目标文件中含有一些函数的定义(机器码),而这些函数将在

连接时会被最终的可执行文件用到。

两者的区别:
    静态库.a : 当程序与静态库连接时,库中目标文件所含的所有将被程序使用的函数的机器码被copy

到最终的可执行文件中. 静态库有个缺点: 占用磁盘和内存空间. 静态库会被添加到和它连接的每个程序

中, 而且这些程序运行时, 都会被加载到内存中. 无形中又多消耗了更多的内存空间.


    共享库.so : 与共享库连接的可执行文件只包含它需要的函数的引用表,而不是所有的函数代码,只

有在程序执行时, 那些需要的函数代码才被拷贝到内存中, 这样就使可执行文件比较小, 节省磁盘空间(

更进一步,操作系统使用虚拟内存,使得一份共享库驻留在内存中被多个程序使用).共享库还有个优点:

若库本身被更新, 不需要重新编译与它连接的源程序。

静态库

下面我们来看一个简单的例子,计算2.0的平方根(假设文件名为sqrt.c):

#include <math.h>
#include <stdio.h>
int
main (void)
{
double x = sqrt (2.0);
printf ("The square root of 2.0 is %f\n", x);
return 0;
}

用gcc将它编译为可执行文件:
$ gcc -Wall sqrt.c -o sqrt
编译成功,没有任何警告或错误信息。执行结果也正确。
$ ./sqrt
The square root of 2.0 is 1.414214
    
下面我们来看看刚才使用的gcc版本:
$ gcc --version
gcc (GCC) 4.0.2 20050808 (prerelease) (Ubuntu 4.0.1-4ubuntu9)

现在我用2.95版的gcc把sqrt.c再编译一次:
$ gcc-2.95 -Wall sqrt.c -o sqrt_2.95
/tmp/ccVBJd2H.o: In function `main':
sqrt.c:(.text+0x16): undefined reference to `sqrt'
     collect2: ld returned 1 exit status
    
编译器会给出上述错误信息,这是因为sqrt函数不能与外部数学库"libm.a"相连。sqrt函数没有在程序中

定义,也不存在于默认C库 "libc.a"中,如果用gcc-2.95,应该显式地选择连接库。上述出错信息中

的"/tmp/ccVBJd2H.o"是gcc创造的临时目标文件,用作连接时用。

使用下列的命令可以成功编译:
$ gcc-2.95 -Wall sqrt.c /usr/lib/libm.a -o sqrt_2.95
它告知gcc:在编译sqrt.c时,加入位于/usr/lib中的libm.a库(C数学库)。

C库文件默认位于/usr/lib, /usr/local/lib系统目录中; gcc默认地从/usr/local/lib, /usr/lib中搜

索库文件。(在我的Ubuntu系统中,C库文件位于/urs/lib中。

这里还要注意连接顺序的问题,比如上述命令,如果我改成:
$ gcc-2.95 -Wall /usr/lib/libm.a sqrt.c -o sqrt_2.95
gcc会给出出错信息:
/tmp/cc6b3bIa.o: In function `main':
sqrt.c:(.text+0x16): undefined reference to `sqrt'
collect2: ld returned 1 exit status

正如读取目标文件的顺序,gcc也在命令行中从左向右读取库文件——任何包含某函数定义的库文件必须

位于调用该函数的目标文件之后!

指定库文件的绝对路径比较繁琐,有一种简化方法,相对于上述命令,可以用下面的命令来替代:
$ gcc-2.95 -Wall sqrt.c -lm -o sqrt_2.95
其中的"-l"表示与库文件连接,"m"代表"libm.a"中的m。一般而言,"-lNAME"选项会使gcc将目标文件与

名为"libNAME.a"的库文件相连。(这里假设使用默认目录中的库,对于其他目录中的库文件,参考后面

的“搜索路径”。)


上面所提到的"libm.a"就是静态库文件,所有静态库文件的扩展名都是.a!
$ whereis libm.a
libm: /usr/lib/libm.a /usr/lib/libm.so

正如前面所说,默认的库文件位于/usr/lib/或/usr/local/lib/目录中。其中,libm.a是静态库文件,

libm.so是后面会介绍的动态共享库文件。

如果调用的函数都包含在libc.a中(C标准库被包含在/usr/lib/libc.a中,它包含了ANSI C所定义的C函

数)。那么没有必要显式指定libc.a:所有的C程序运行时都自动包含了C标准库!(试试 $ gcc-2.95 -

Wall hello.c -o hello)。

共享库

正因为共享库的优点,如果系统中存在.so库,gcc默认使用共享库(在/usr/lib/目录中,库文件以共享

和静态两种版本存在)。

运行:$ gcc -Wall -L. hello.c -lNAME -o hello
gcc先检查是否有替代的libNAME.so库可用。   

正如前面所说,共享库以.so为扩展名(so == shared object)。

那么,如果不想用共享库,而只用静态库呢?可以加上 -static选项
$ gcc -Wall -static hello.c -lNAME -o hello
它等价于:
$ gcc -Wall hello.c libNAME.a -o hello

$ gcc-2.95 -Wall sqrt.c -static -lm -o sqrt_2.95_static
$ gcc-2.95 -Wall sqrt.c -lm -o sqrt_2.95_default
$ gcc-2.95 -Wall sqrt.c /usr/lib/libm.a -o sqrt_2.95_a
$ gcc-2.95 -Wall sqrt.c /usr/lib/libm.so -o sqrt_2.95_so

$ ls -l sqrt*
-rwxr-xr-x 1 zp zp 21076 2006-04-25 14:52 sqrt_2.95_a
-rwxr-xr-x 1 zp zp   7604 2006-04-25 14:52 sqrt_2.95_default
-rwxr-xr-x 1 zp zp   7604 2006-04-25 14:52 sqrt_2.95_so
-rwxr-xr-x 1 zp zp 487393 2006-04-25 14:52 sqrt_2.95_static

上述用四种方式编译sqrt.c,并比较了可执行文件的大小。奇怪的是,-static -lm 和 /lib/libm.a为什

么有区别?有知其原因着,恳请指明,在此谢谢了! :)

如果libNAME.a在当前目录,应执行下面的命令:
$ gcc -Wall -L. hello.c -lNAME -o hello
-L.表示将当前目录加到连接路径。

利用GNU archiver创建库

$ ar cr libhello.a hello_fn.o by_fn.o
从hello_fn.o和by_fn.o创建libihello.a,其中cr表示:creat & replace
$ ar t libhello.a
列出libhello.a中的内容,t == table
(也可创建libhello.so)

关于创建库的详细介绍,可参考本blog的GNU binutils笔记

http://www.cublog.cn/u/13991/showart.php?id=104690

调试


--------------------------------------------------------------------------------
一般地,可执行文件中是不包含任何对源代码的参考的,而debugger要工作,就要知道目标文件/可执行

文件中的机器码对应的源代码的信息(如:哪条语句、函数名、变量名...). debugger工作原理:将函数

名、变量名,对它们的引用,将所有这些对象对应的代码行号储存到目标文件或可执行文件的符号表中。

GCC提供-g选项,将调试信息加入到目标文件或可执行文件中。
$ gcc -Wall -g hello.c -o hello

注意:若发生了段错误,但没有core dump,是由于系统禁止core文件的生成!
$ ulimit -c  ,若显示为0,则系统禁止了core dump


解决方法:
$ ulimit -c unlimited  (只对当前shell进程有效)
或在~/.bashrc 的最后加入: ulimit -c unlimited (一劳永逸)


优化


--------------------------------------------------------------------------------
GCC具有优化代码的功能,代码的优化是一项比较复杂的工作,它可归为:源代码级优化、速度与空间的

权衡、执行代码的调度。

GCC提供了下列优化选项:
    -O0 : 默认不优化(若要生成调试信息,最好不优化)
    -O1 : 简单优化,不进行速度与空间的权衡优化;    
    -O2 : 进一步的优化,包括了调度。(若要优化,该选项最适合,它是GNU发布软件的默认优化级别


    -O3 : 鸡肋,兴许使程序速度更慢;
    -funroll-loops : 展开循环,会使可执行文件增大,而速度是否增加取决于特定环境;
    -Os : 生成最小执行文件;

一般来说,调试时不优化,一般的优化选项用-O2(gcc允许-g与-O2联用,这也是GNU软件包发布的默认选

项),embedded可以考虑-Os。

注意:此处为O!(非0或小写的o,-o是指定可执行文件名)。

检验优化结果的方法:$ time ./prog

time测量指定程序的执行时间,结果由三部分组成: 
    real : 进程总的执行时间, 它和系统负载有关(包括了进程调度,切换的时间)
    user: 被测量进程中用户指令的执行时间
    sys : 被测量进程中内核代用户指令执行的时间

user和sys的和被称为CPU时间.

注意:对代码的优化可能会引发警告信息,移出警告的办法不是关闭优化,而是调整代码。


Windows/Unix/Linux编译C/C++添加头文件与库的搜索路径

环境变量设置
/etc/profile:在登录时,操作系统定制用户环境时使用的第一个文件,此文件为系统的每个用户设置环境信息,当用户第一次登录时,该文件被执行。并从/etc/profile.d目录的配置文件中搜集shell的设置。

/etc/bashrc:为每一个运行bash shell的用户执行此文件.当bash shell被打开时,该文件被读取。

~/.bash_profile:每个用户都可使用该文件输入专用于自己使用的shell信息,当用户登录时,该文件仅仅执行一次!默认情况下,他设置一些环境变量,执行用户的.bashrc文件.每个用户都可使用该文件输入专用于自己使用的shell信息,当用户登录时,该文件仅仅执行一次!默认情况下,他设置一些环境变量,执行用户的.bashrc文件.

/etc/environment :在登录时操作系统使用的第二个文件,系统在读取你自己的profile前,设置文件的环境变量。

~/.profile:在登录时用到的第三个文件。profile文件,每个用户都可使用该文件输入专用于自己使用的shell信息,当用户登录时,该文件仅仅执行一次!默认情况下,他设置一些环境变量,执行用户的.bashrc文件。

/etc/bashrc:为每一个运行bash shell的用户执行此文件。当bash shell被打开时,该文件被读取。

~/.bashrc:该文件包含专用于你的bash shell的bash信息,当登录时以及每次打开新的shell时,该该文件被读取。

Ubuntu
在bash配置文件中添加环境变量

对所有用户有效修改/etc/profile
对个人有效则修改~/.bashrc

#在PATH中找到可执行文件程序的路径。

[plain] view plain copy
export PATH =$PATH:$HOME/bin  
#gcc找到头文件的路径
[plain] view plain copy
C_INCLUDE_PATH=/usr/include/libxml2:/MyLib  
export C_INCLUDE_PATH  
#g++找到头文件的路径
[plain] view plain copy
CPLUS_INCLUDE_PATH=$CPLUS_INCLUDE_PATH:/usr/include/libxml2:/MyLib  
export CPLUS_INCLUDE_PATH  
#找到动态链接库的路径
[plain] view plain copy
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/MyLib  
export LD_LIBRARY_PATH  
#找到静态库的路径
[plain] view plain copy
LIBRARY_PATH=$LIBRARY_PATH:/MyLib  
export LIBRARY_PATH  
下面是在gcc命令中手动设置搜索路径:
#添加头文件搜索路径
[plain] view plain copy
# gcc foo.c -I /home/xiaowp/include -o foo  
 #添加动态库搜索路径
[plain] view plain copy
# gcc foo.c -L /home/xiaowp/lib -lfoo -o foo  
#添加静态库搜索路径
[plain] view plain copy
# gcc foo.c -L /home/xiaowp/lib -static -lfoo -o foo  

Linux C语言头文件搜索路径  (2012-10-25 08:56:38)
转载▼
标签:  杂谈    分类: Linux

    本文介绍在linux中头文件的搜索路径,也就是说你通过include指定的头文件,linux下的gcc编译器它是怎么找到它的呢。在此之前,先了解一个基本概念。

    头文件是一种文本文件,使用文本编辑器将代码编写好之后,以扩展名.h保存就行了。头文件中一般放一些重复使用的代码,例如函数声明、变量声明、常数定义、宏的定义等等。当使用#include语句将头文件引用时,相当于将头文件中所有内容,复制到#include处。#include有两种写法形式,分别是:

#include <> : 直接到系统指定的某些目录中去找某些头文件。

#include “” : 先到源文件所在文件夹去找,然后再到系统指定的某些目录中去找某些头文件。

    

    #include文件可能会带来一个问题就是重复应用,如a.h引用的一个函数是某种实现,而b.h引用的这个函数却是另外一种实现,这样在编译的时候将会出现错误。所以,为了避免因为重复引用而导致的编译错误,头文件常具有:

#ifndef    LABEL

#define    LABEL

    //代码部分

#endif

的格式。其中LABEL为一个唯一的标号,命名规则跟变量的命名规则一样。常根据它所在的头文件名来命名,例如,如果头文件的文件名叫做hardware.h,那么可以这样使用:

#ifndef    __HARDWARE_H__

#define    __HARDWARE_H__

  //代码部分

#endif

这样写的意思就是,如果没有定义__HARDWARE_H__,则定义__HARDWARE_H__,并编译下面的代码部分,直到遇到#endif。这样当重复引用时,由于__HARDWARE_H__已经被定义,则下面的代码部分就不会被编译了,这样就避免了重复定义。

 

    一句话,头文件事实上只是把一些常用的命令集成在里面,你要用到哪方面的命令就载入哪个头文件就可以了。

 

    gcc寻找头文件的路径(按照1->2->3的顺序)

    1. 在gcc编译源文件的时候,通过参数-I指定头文件的搜索路径,如果指定路径有多个路径时,则按照指定路径的顺序搜索头文件。命令形式如:“gcc -I /path/where/theheadfile/in sourcefile.c“,这里源文件的路径可以是绝对路径,也可以是相对路径。eg:

设当前路径为/root/test,include_test.c如果要包含头文件“include/include_test.h“,有两种方法:

1) include_test.c中#include “include/include_test.h”或者#include "/root/test/include/include_test.h",然后gcc include_test.c即可

2) include_test.c中#include 或者#include ,然后gcc –I include include_test.c也可

 

    2. 通过查找gcc的环境变量C_INCLUDE_PATH/CPLUS_INCLUDE_PATH/OBJC_INCLUDE_PATH来搜索头文件位置。

 

    3. 再找内定目录搜索,分别是

/usr/include

/usr/local/include

/usr/lib/gcc-lib/i386-linux/2.95.2/include

最后一行是gcc程序的库文件地址,各个用户的系统上可能不一样。

    gcc在默认情况下,都会指定到/usr/include文件夹寻找头文件。

    gcc还有一个参数:-nostdinc,它使编译器不再系统缺省的头文件目录里面找头文件,一般和-I联合使用,明确限定头文件的位置。在编译驱动模块时,由于非凡的需求必须强制GCC不搜索系统默认路径,也就是不搜索/usr/include要用参数-nostdinc,还要自己用-I参数来指定内核头文件路径,这个时候必须在Makefile中指定。

    4. 当#include使用相对路径的时候,gcc最终会根据上面这些路径,来最终构建出头文件的位置。如#include 就是包含文件/usr/include/sys/types.h

http://hi.baidu.com/ilonng/item/4095d08cee970e844414cf16

Linux下gcc编译中关于头文件与库文件搜索路径相关问题 2009-10-14 13:38:59
分类: C/C++
如何指定GCC的默认头文件路径
网上偶搜得之,以之为宝:)
原地址:http://blog.chinaunix.net/u/28781/showart.php?id=401631
===============================================================================


在交叉编译的时候我们需要用到其他的库,在config时候可以通过“-I”来指定头文件目录,但是每次都需要设置的话难免有些麻烦,找到一个简单的方法。看下文的红色部分。


有大量的环境变量可供设置以影响 GCC 编译程序的方式。利用这些变量的控制也可使用合适的命令行选项。一些环境变量设置在目录名列表中。这些名字和 PATH 环境变量使用的格式相同。特殊字符 PATH_SEPARATOR (安装编译程序的时候定义)用在目录名之间。在 UNIX 系统中,分隔符是冒号,而 Windows 系统中为分号。 


C_INCLUDE_PATH 
编译 C 程序时使用该环境变量。该环境变量指定一个或多个目录名列表,查找头文件,就好像在命令行中指定 -isystem 选项一样。会首先查找 -isystem 指定的所有目录。 
==>也见 CPATH 、 CPLUS_INCLUDE_PATH 和 OBJC_INCLUDE_PATH 。 


COMPILER_PATH 
该环境变量指定一个或多个目录名列表,如果没有指定 GCC_EXEC_PREFIX 定位子程序,编译程序会在此查找它的子程序。 
==>也见 LIBRARY_PATH 、 GCC_EXEC_PREFIX 和 -B 命令行选项。 


CPATH 
编译 C 、 C++ 和 Objective-C 程序时使用该环境变量。该环境变量指定一个或多个目录名列表,查找头文件,就好像在命令行中指定 -l 选项一样。会首先查找 -l 指定的所有目录。 
==>也见 C_INCLUDE_PATH 、 CPLUS_INCLUDE_PATH 和 OBJC_INCLUDE_PATH 。 


CPLUS_INCLUDE_PATH 
编译 C++ 程序时使用该环境变量。该环境变量指定一个或多个目录名列表,查找头文件,就好像在命令行中指定 -isystem 选项一样。会首先查找 -isystem 指定的所有目录。 
==>也见 CPATH 、 C_INCLUDE_PATH 和 OBJC_INCLUDE_PATH 。 


DEPENDENCIES_OUTPUT 
为文件名设置该环境变量会让预处理程序将基于依赖关系的 makefile 规则写入文件。不会包括系统头文件名字。 
如果环境变量设置为单名,被看作是文件名字,而依赖关系规则的名字来自源文件名字。如果定义中有两个名字,则第二个名字是用作依赖关系规则的目标名。 设置该环境变量的结果和使用命令行选项 -MM 、 -MF 和 -MT 的组合是一样的。
==>也见 SUNPRO_DEPENDENCIES 。 


GCC_EXEC_PREFIX 
如果定义了该环境变量,它会作为编译程序执行的所有子程序名字的前缀。例如,如果将变量设置为 testver 而不是查找 as ,汇编器首先会在名字testveras 下查找。如果在此没有找到,编译程序会继续根据它的普通名进行查找。可在前缀名中使用斜线指出路径名。 


GCC_EXEC_PREFIX 的默认设置为 prefix /lib/gcc-lib/ ,这里的 prefix 是安装编译程序时 configure 脚本指定的名字。该前缀也用于定位标准连接程序文件,包含进来作为可执行程序的一部分。 
如果使用 -B 命令行选项,会重写该设置。
==>也见 COMPILER_PATH 。


LANG 该环境变量用于指出编译程序使用的字符集,可创建宽字符文字、串文字和注释。 
定义 LANG 为 C-JIS ,指出预处理程序将多字节字符按照 JIS (日语工业标准)字符进行解释。 C-SJIS 可用来指出 Shift -JIS 字符而 C-EUCJP 指出日文 EUC 。 
如果没有定义 LANG ,或定义为不可识别,函数 mblen() 被用来确定字符宽度,而 mbtowc() 用来将多字节序列转换为宽字符。 
LC_ALL 如果设置,该环境变量的值重写 LC_MESSAGES 和 LC_CTYPE 的所有设置。 
LC_CTYPE 该环境变量指出引用串中定义的多字节字符的字符分类。主要用于确定字符串的字符边界,字符编码需要用引号或转义符,可被错误地解释为字符串的结尾或特殊字 符串。对 Australian English ,可将它设置为 en_AU ; 对 Mexican Spanish ,可将它设置为 es_MX。如果没有设置该变量,默认为 LANG 变量的值,或如果没有设置 LANG ,那就使用 C 英语行为。也见 LC_ALL 。 
LC_MESSAGES 该环境变量指出编译程序使用何种语言发出诊断消息。对 Australian English ,可设置为 en_AU ; 对 MexicanSpanish ,可设置为 es_MX 。如果变量没有设置,使用 LANG 变量的默认值,或如果没有设置 LANG ,那就使用 C英语行为。也见 LC_ALL 。 
LD_LIBRARY_PATH 该环境变量不会影响编译程序,但程序运行的时候会有影响。变量指定一个目录列表,程序会查找该列表定位共享库。只有当未在编译程序的目录中找到共享库的时候,执行程序必须设置该变量。 
LD_RUN_PATH 该环境变量不会影响编译程序,但程序运行的时候会有影响。该变量在运行时指出文件的名字,运行的程序可由此得到它的符号名字和地址。地址不会重新载入,因而可能符号引用其他文件中的绝对地址。这和 ld 工具使用 -R 选项完全一样。 


LIBRARY_PATH 
该环境变量可设置为一个或多个目录名字列表,连接程序会搜寻该目录,以查找特殊连接程序文件,和由 -l (字母 l )命令行选项指定名字的库。 由 -L 命令行选项指定的目录在环境变量的前面,首先被查找。
==>也见 COMPILER_PATH 。 


OBJC_INCLUDE_PATH 
在编译 Objective-C 程序的时候使用该环境变量。一个或多个目录名的列表由环境变量指定,用来查找头文件,就好像在命令行中指定 -isystem 选项一样。所有由 -isystem 选项指定的目录会首先被查找。 
==>也见 CPATH 、 CPLUS_INCLUDE_PATH 和 C_INCLUDE_PATH 。 


SUNPRO_OUTPUT 
为文件名设置该环境变量会令预处理程序将基于依赖关系的 makefile 规则写入文件。会包含系统头文件名。 如果环境变量被设置为单个名字,它将会被当作文件名,依赖关系规则中的名字将由源文件的名字中获得。如果定义中有两个名字,第二个名字就是依赖关系规则中的目标名。 设置该环境变量的结果与在命令行中使用参数 -M 、 -MF 和 -MT 的效果一样。
==>参见 DEPENDENCIES_OUTPUT 。 


TMPDIR 
这个变量包含了供编译程序存放临时工作文件的目录的路径名。这些文件通常在编译过程结束时被删除。这种文件的一个例子就是由预处理程序输出并输入给编译程序的文件。
 
linux 默认的include在哪?
#include 中的module.h默认是在哪个目录下呢?我在/usr/include/linux下并没有找到这个文件。
另外想问一下,不同内核版本的linux头文件是不是一样的。比如:我在2.6.20内核的系统上,用2.6.10的头文件会不会有问题。
 
网友回复:
1
我的 module.h是在 内核编译好了的目录下的,不是在/usr/include/linux下,
2
在2.6.20内核的系统上,用2.6.10的头文件应该会有问题,内核的头文件和 当前系统运行的内核不一致。
 
网友回复:你引用的是内核下的头文件.
不在/usr/include下.
在: /usr/src/kernels/2.6.18-8.el5-x86_64/include/linux/module.h 下面... 中间的版本号是不一样的...你选你的就行了..
 
网友回复:请问楼上为什么是在/usr/src/kernels/2.6.18-8.el5-x86_64/include/linux/module.h呢?我查了一下环境变量,没有看到关于头文件的环境变量。gcc是如何知道头文件的位置的?
 
网友回复:这个问题很好,
你需要看看linux kernel的Makefile文件了。在什么地方找头文件,它说了算。:)
 
网友回复:你的程序是驱动之类的内核层的吧?
它调用的头文件就应该是内核源码里面的include了。一般的系统都把内核源码放在/usr/src下面,假如是自己编译的内核的话,也可以放在别处的。 至于gcc到哪里去找头文件,就看makefile了,或者直接用gcc命令的话,要加上-I来指定目录。
 
网友回复:楼上,可是我的makefile里没有指定include呀,gcc是怎么找到头文件的?
 
网友回复:gcc是怎么找到头文件的?
================================
回答了这个问题,LZ就明白了一切了,GCC找头文件有三种策略:
1.会在默认情况下指定到/usr/include文件夹(更深层次的是一个相对路径,GCC可执行程序的路径是/usr/bin,那么它在实际工作时指定头文件头径是一种相对路径方法,换算成绝对路径就是/usr/include)
2.GCC还使用了-I指定路径的方式,这一点大家都知道
3.还可以使用一个参数来指示GCC不搜索系统默认路径,这个参数我忘了,你搜一下就知道了
 
在编译驱动模块时,由于非凡的需求必须强制GCC不搜索系统默认路径,也就是不搜索/usr/include,要自己用-I参数来指定内核头文件路径,这个时候必须在Makefile中指定两个参数,一个是内核头文件路径,一个是强制GCC不搜索系统默认路径。在编译内核时,必须使用一个参数(强制GCC不搜索系统默认路径),否则就会引起混乱。
 
明白了上面的原理,LZ自己应该可以找到答案了吧????
来自:http://www.itzhe.cn/news/20071216/31985.html
 
Linux指定动态库路径
 
众所周知,Linux动态库的默认搜索路径是/lib和/usr/lib。动态库被创建后,一般都复制到这两个目录中。当程序执行时需要某动态库, 并且该动态库还未加载到内存中,则系统会自动到这两个默认搜索路径中去查找相应的动态库文件,然后加载该文件到内存中,这样程序就可以使用该动态库中的函 数,以及该动态库的其它资源了。在Linux 中,动态库的搜索路径除了默认的搜索路径外,还可以通过以下三种方法来指定。
 
方法一:在配置文件/etc/ld.so.conf中指定动态库搜索路径。
 
可以通过编辑配置文件/etc/ld.so.conf来指定动态库的搜索路径,该文件中每行为一个动态库搜索路径。每次编辑完该文件后,都必须运行命令ldconfig使修改后的配置生效。我们通过例1来说明该方法。
例1:
我们通过以下命令用源程序pos_conf.c(见程序1)来创建动态库 libpos.so,详细创建过程请参考文[1]。
# gcc -c pos_conf.c
         # gcc -shared -fPCI -o libpos.so pos_conf.o
         #
 
#include 
         void pos()
         {
                 printf("/root/test/conf/lib\n");
          }
          程序1: pos_conf.c
 
接着通过以下命令编译main.c(见程序2)生成目标程序pos。
# gcc -o pos main.c -L. -lpos
  #
void pos();
        int main()
        {
             pos();
              return 0;
         }
        程序2: main.c
然后把库文件移动到目录/root/test/conf/lib中。
# mkdir -p /root/test/conf/lib
         # mv libpos.so /root/test/conf/lib
          #
最后编辑配置文件/etc/ld.so.conf,在该文件中追加一行"/root/test/conf/lib"。
运行程序pos试试。
# ./pos
         ./pos: error while loading shared libraries: libpos.so: cannot open shared object file: No such file or directory
          #
出错了,系统未找到动态库libpos.so。找找原因,原来在编辑完配置文件/etc/ld.so.conf后,没有运行命令ldconfig,所以刚才的修改还未生效。我们运行ldconfig后再试试。
# ldconfig
         # ./pos
          /root/test/conf/lib 
           #
程序pos运行成功,并且打印出正确结果。
 
方法二:通过环境变量LD_LIBRARY_PATH指定动态库搜索路径。
 
通过设定环境变量LD_LIBRARY_PATH也可以指定动态库搜索路径。当通过该环境变量指定多个动态库搜索路径时,路径之间用冒号":"分隔。下面通过例2来说明本方法。
例2:
我们通过以下命令用源程序pos_env.c(见程序3)来创建动态库libpos.so。
# gcc -c pos_env.c
         # gcc -shared -fPCI -o libpos.so pos_env.o
          #
#include 
        void pos()
         {
               printf("/root/test/env/lib\n");
          }
        程序3: pos_env.c
测试用的可执行文件pos可以使用例1中的得到的目标程序pos,不需要再次编译。因为pos_conf.c中的函数pos和pos_env.c中的函数pos 函数原型一致,且动态库名相同,这就好比修改动态库pos后重新创建该库一样。这也是使用动态库的优点之一。
然后把动态库libpos.so移动到目录/root/test/conf/lib中。
# mkdir -p /root/test/env/lib
         # mv libpos.so /root/test/env/lib
          #
我们可以使用export来设置该环境变量,在设置该环境变量后所有的命令中,该环境变量都有效。
例如:
# export LD_LIBRARY_PATH=/root/test/env/lib
         #
但本文为了举例方便,使用另一种设置环境变量的方法,既在命令前加环境变量设置,该环境变量只对该命令有效,当该命令执行完成后,该环境变量就无效了。如下述命令:
# LD_LIBRARY_PATH=/root/test/env/lib ./pos
        /root/test/env/lib
         #
程序pos运行成功,并且打印的结果是"/root/test/env/lib",正是程序pos_env.c中的函数pos的运行结果。因此程序pos搜索到的动态库是/root/test/env/lib/libpos.so。
 
方法三:在编译目标代码时指定该程序的动态库搜索路径。
 
还可以在编译目标代码时指定程序的动态库搜索路径。-Wl,表示后面的参数将传给link程序ld(因为gcc可能会自动调用ld)。这里通过gcc 的参数"-Wl,-rpath,"指定(如例3所示)。当指定多个动态库搜索路径时,路径之间用冒号":"分隔。
例3:
我们通过以下命令用源程序pos.c(见程序4)来创建动态库libpos.so。
# gcc -c pos.c
         # gcc -shared -fPCI -o libpos.so pos.o
          #
#include 
        void pos()
         {
               printf("./\n");
         }
         程序4: pos.c
因为我们需要在编译目标代码时指定可执行文件的动态库搜索路径,所以需要用gcc命令重新编译源程序main.c(见程序2)来生成可执行文件pos。
# gcc -o pos main.c -L. -lpos -Wl,-rpath,./
         #
再运行程序pos试试。
# ./pos
         ./
          #
程序pos运行成功,输出的结果正是pos.c中的函数pos的运行结果。因此程序pos搜索到的动态库是./libpos.so。
example:
gcc -Wl,-rpath,/home/arc/test,-rpath,/lib/,-rpath,/usr/lib/,-rpath,/usr/local/lib test.c
以上介绍了三种指定动态库搜索路径的方法,加上默认的动态库搜索路径/lib和/usr/lib,共五种动态库的搜索路径,那么它们搜索的先后顺序是什么呢?
在介绍上述三种方法时,分别创建了动态库./libpos.so、 /root/test/env/lib/libpos.so和/root/test/conf/lib/libpos.so。我们再用源程序 pos_lib.c(见程序5)来创建动态库/lib/libpos.so,用源程序pos_usrlib.c(见程序6)来创建动态库 /usr/lib/libpos.so。
#include 
         void pos()
          {
                 printf("/lib\n");
           }
          程序5: pos_lib.c
#include 
        void pos()
         {
                printf("/usr/lib\n");
         }
        程序6: pos_usrlib.c
这 样我们得到五个动态库libpos.so,这些动态库的名字相同,且都包含相同函数原型 的公用函数pos。但存储的位置不同和公用函数pos 打印的结果不同。每个动态库中的公用函数pos都输出该动态库所存放的位置。这样我们可以通过执行例3中的可执行文件pos得到的结果不同获知其搜索到了 哪个动态库,从而获得第1个动态库搜索顺序,然后删除该动态库,再执行程序pos,获得第2个动态库搜索路径,再删除第2个被搜索到的动态库,如此往复, 将可得到Linux搜索动态库的先后顺序。程序pos执行的输出结果和搜索到的动态库的对应关系如表1所示:
程序pos输出结果
使用的动态库
对应的动态库搜索路径指定方式
./
./libpos.so
编译目标代码时指定的动态库搜索路径
/root/test/env/lib
/root/test/env/lib/libpos.so
环境变量LD_LIBRARY_PATH指定的动态库搜索路径
/root/test/conf/lib
/root/test/conf/lib/libpos.so
配置文件/etc/ld.so.conf中指定的动态库搜索路径
/lib
/lib/libpos.so
默认的动态库搜索路径/lib
/usr/lib
/usr/lib/libpos.so
默认的动态库搜索路径/usr/lib
表1: 程序pos输出结果和动态库的对应关系
创建各个动态库,并放置在相应的目录中。测试环境就准备好了。执行程序pos,并在该命令行中设置环境变量LD_LIBRARY_PATH。
# LD_LIBRARY_PATH=/root/test/env/lib ./pos
          ./
          #
根据程序pos的输出结果可知,最先搜索的是编译目标代码时指定的动态库搜索路径。然后我们把动态库./libpos.so删除了,再运行上述命令试试。
# rm libpos.so
        rm: remove regular file `libpos.so'? y
        # LD_LIBRARY_PATH=/root/test/env/lib ./pos
        /root/test/env/lib
        #
根据程序pos的输出结果可知,第2个动态库搜索的路径是环境变量LD_LIBRARY_PATH指定的。我们再把/root/test/env/lib/libpos.so删除,运行上述命令。
# rm /root/test/env/lib/libpos.so
         rm: remove regular file `/root/test/env/lib/libpos.so'? y
        # LD_LIBRARY_PATH=/root/test/env/lib ./pos
        /root/test/conf/lib
        #
第3个动态库的搜索路径是配置文件/etc/ld.so.conf指定的路径。删除动态库/root/test/conf/lib/libpos.so后再运行上述命令。
# rm /root/test/conf/lib/libpos.so
        rm: remove regular file `/root/test/conf/lib/libpos.so'? y
        # LD_LIBRARY_PATH=/root/test/env/lib ./pos
        /lib
        #
第4个动态库的搜索路径是默认搜索路径/lib。我们再删除动态库/lib/libpos.so,运行上述命令。
# rm /lib/libpos.so
        rm: remove regular file `/lib/libpos.so'? y
        # LD_LIBRARY_PATH=/root/test/env/lib ./pos
        /usr/lib
        #
最后的动态库搜索路径是默认搜索路径/usr/lib。
综合以上结果可知,动态库的搜索路径搜索的先后顺序是:
1.编译目标代码时指定的动态库搜索路径;
2.环境变量LD_LIBRARY_PATH指定的动态库搜索路径;
3.配置文件/etc/ld.so.conf中指定的动态库搜索路径;
4.默认的动态库搜索路径/lib;
5.默认的动态库搜索路径/usr/lib。
在上述1、2、3指定动态库搜索路径时,都可指定多个动态库搜索路径,其搜索的先后顺序是按指定路径的先后顺序搜索的。对此本文不再举例说明,有兴趣的读者可以参照本文的方法验证。
 
来源:http://hi.baidu.com/kkernel/blog/item/ce31bb34a07e6b46251f14cf.html
 
下面的文章为对上篇文章的总结
Linux操作系统的头文件和库文件搜索路径
Include的header文件,动态链接库,系统定义,总共有下列来源指定gcc去那里找。
当初在编译时指定的(在~gcc/gcc/collect2.c:locatelib()
写在specs内的 ,内定的,这是当初compile gcc时写在程序内的。
后来用-D -I -L指定的
gcc环境变量设定(编译的时候)
ld.so的环境变量(这是run time的时候)
 
一、头文件
gcc 在编译时如何去寻找所需要的头文件:
※所以header file的搜寻会从-I开始
※然后找gcc的环境变量 C_INCLUDE_PATH,CPLUS_INCLUDE_PATH,OBJC_INCLUDE_PATH
※再找内定目录
/usr/include
/usr/local/include
/usr/lib/gcc-lib/i386-linux/2.95.2/include
/usr/lib/gcc-lib/i386-linux/2.95.2/../../../../include/g++-3
/usr/lib/gcc-lib/i386-linux/2.95.2/../../../../i386-linux/include
 
库文件,但是如果装gcc的时候,是有给定的prefix的话,那么就是
/usr/include
prefix/include
prefix/xxx-xxx-xxx-gnulibc/include
prefix/lib/gcc-lib/xxxx-xxx-xxx-gnulibc/2.8.1/include
 
二、库文件
cos()等函式库的选项要多加 -lm
编译的时候:
※gcc会去找-L
※再找gcc的环境变量LIBRARY_PATH
※再找内定目录 /lib /usr/lib /usr/local/lib 这是当初compile gcc时写在程序内的
 
三、运行时动态库的搜索路径
1、在配置文件/etc/ld.so.conf中指定动态库搜索路径
2、通过环境变量LD_LIBRARY_PATH指定动态库搜索路径(当通过该环境变量指定多个动态库搜索路径时,路径之间用冒号":"分隔)
3、在编译目标代码时指定该程序的动态库搜索路径(还可以在编译目标代码时指定程序的动态库搜索路径。
这是通过gcc 的参数"-Wl,-rpath,"指定(如例3所示)。当指定多个动态库搜索路径时,路径之间用冒号":"分隔)
4、默认的动态库搜索路径/lib
5、默认的动态库搜索路径/usr/lib
可以通过执行可执行文件pos得到的结果不同获知其搜索到了哪个动态库,从而获得第1个动态库搜索顺序,然后删除该动态库,
再执行程序pos,获得第2个动态库搜索路径,再删除第2个被搜索到的动态库,
如此往复,将可得到Linux搜索动态库的先后顺序。
程序pos执行的输出结果和搜索到的动态库的对应关系如表1所示
程序pos输出结果 使用的动态库 对应的动态库搜索路径指定方式
./ ./libpos.so 编译目标代码时指定的动态库搜索路径
/root/test/env/lib /root/test/env/lib/libpos.so 环境变量LD_LIBRARY_PATH指定的动态库搜索路径
/root/test/conf/lib /root/test/conf/lib/libpos.so 配置文件/etc/ld.so.conf中指定的动态库搜索路径
/lib /lib/libpos.so 默认的动态库搜索路径/lib
/usr/lib /usr/lib/libpos.so 默认的动态库搜索路径/usr/lib
综合以上结果可知,动态库的搜索路径搜索的先后顺序是:
1.编译目标代码时指定的动态库搜索路径;
2.环境变量LD_LIBRARY_PATH指定的动态库搜索路径;
3.配置文件/etc/ld.so.conf中指定的动态库搜索路径;
4.默认的动态库搜索路径/lib;
5.默认的动态库搜索路径/usr/lib。


 gcc编译过程概述 2009-09-25 09:21:45
分类: C/C++

本文对gcc编译器如何工作做一个概要描述.更为详细的信息请参考编译器手册。

当我们进行编译的时候,要使用一系列的工具,我们称之为工具链.其中包括:预处理器CPP,编译器前端gcc/g++,汇编器as,连接器ld.一个编译过程包括下面几个阶段:
(1)预处理。预处理器CPP将对源文件中的宏进行展开。
(2)编译。gcc将c文件编译成汇编文件。
(3)汇编。as将汇编文件编译成机器码。
(4)连接。ld将目标文件和外部符号进行连接,得到一个可执行二进制文件。

下面以一个很简单的test.c来探讨这个过程。
        #defineNUMBER(1+2)
        int main()
        {
                int  x = NUMBER;
                return  0;
        }

(1)预处理:
        gcc会首先调用CPP进行预处理:CPP test.c > test.i
        预处理的输出为文件test.i。
        我们用cat test.i查看test.i的内容如下:
        int main()
        {
                int x = (1+2);
                return  0;
        }
        我们可以看到,文件中宏定义NUMBER出现的位置被(1+2)替换掉了,其它的内容保持不变。

(2)gcc将c文件编译成汇编文件。
        接下来gcc会执行gcc -S test.i得到的输出文件为test.s.

(3)as将汇编文件编译成机器码。
        as test.s -o test.o
        得到输出文件为test.o.
        test.o中为目标机器上的二进制文件.
        用nm查看文件中的符号:nm test.o
        输出如下:
                00000000 b .bss
                00000000 d .data
                00000000 t .text
                U ___main
                U __alloca
                00000000 T _main

        既然已经是二进制目标文件了,能不能执行呢?试一下./test.o,提示cannot execute binaryfile.
        原来___main前面的U表示这个符号的地址还没有定下来,T表示这个符号属于代码段。ld连接的时候会为这些带U的符号确定地址。

(4)连接。
        连接需要指定库的位置。通常程序中会有很多的外部符号,因此需要指定的位置就会很多。
        不过,我们之需要调用gcc即可,ld会自己去找这些库的位置。
        gcc test.o > test
        就得到了最终的可执行程序了。


--------------------- 
作者:benpaobagzb 
来源:CSDN 
原文:https://blog.csdn.net/benpaobagzb/article/details/51277960 
版权声明:本文为博主原创文章,转载请附上博文链接!

展开阅读全文

没有更多推荐了,返回首页