GCC编译器详解：GNU世界的编程利器

GCC

需积分: 10 24 浏览量更新于2024-07-18 2 收藏 522KB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

"GCC编程简介，GCC（GNU Compiler Collection）是GNU开发的多语言编译器套件，广泛应用于各种类Unix操作系统以及Windows系统。它最初是GNU操作系统的官方编译器，支持GPL许可证，是自由软件基金会的重要项目。本书《An Introduction to GCC》由Brian Gough撰写，Richard M. Stallman作序，详细介绍了GCC的使用，特别是对于gcc和g++这两个GNU编译器的使用。" GCC，全称GNU Compiler Collection，是开源社区GNU开发的一个强大且多功能的编译器集合，支持多种编程语言，包括C、C++、Fortran、Objective-C、Ada、Go等。其核心任务是将源代码转换为机器可执行的代码，使得程序员可以编写一次代码，然后在多个平台上运行。GCC不仅提供了编译器，还包括预处理器、汇编器和链接器，形成了完整的编译流程。 GCC的出现极大地推动了自由软件的发展，因为它允许开发者自由地使用、修改和分发代码，这符合GPL（GNU General Public License）的精神。在类Unix系统如Linux和BSD中，GCC通常是默认的编译工具链。而在苹果的Mac OS X系统中，GCC也曾被广泛使用，尽管后来Apple推出了自家的Clang编译器。在《An Introduction to GCC》一书中，作者Brian Gough深入浅出地讲解了如何使用GCC进行编程，包括如何配置编译选项、调试代码、优化性能等方面的内容。这本书对于初学者和经验丰富的开发者来说都是一份宝贵的资源，可以帮助他们更好地理解和利用GCC的强大功能。书中的内容可能涵盖以下几个方面： 1. **GCC的安装与配置**：介绍如何在不同平台上安装GCC，以及如何设置编译环境。 2. **编译过程**：解释预处理、编译、汇编和链接四个步骤，以及它们在GCC中的实现。 3. **命令行选项**：详细列举并解释gcc和g++的常用编译选项，如`-Wall`用于开启警告，`-O2`用于优化等。 4. **调试工具GDB**：说明如何结合GCC的调试信息和GDB进行程序调试。 5. **多文件项目**：指导如何编译和管理包含多个源文件的项目。 6. **代码优化**：讨论GCC提供的各种优化级别和特定优化选项，如`-Os`针对小体积优化，`-O3`针对性能优化。 7. **跨平台编译**：介绍如何使用GCC编译目标平台不同的代码，如从x86编译到ARM架构。通过阅读这本书，读者能够掌握GCC的基本用法，理解编译过程的细节，从而更高效地进行软件开发。同时，GCC的自由软件特性也鼓励读者参与到GCC的改进和扩展中，为开源社区贡献自己的力量。

资源详情

资源推荐

10 An Intro duction to GCC

longer need to include the system header ﬁle ‘stdio.h’ in ‘main.c’ to

declare the function printf, since the ﬁle ‘main.c’ does not call printf

directly.

The declaration in ‘hello.h’ is a single line specifying the prototype

of the function hello:

void hello (const char * name);

The deﬁnition of the function hello itself is contained in the ﬁle

‘hello_fn.c’:

#include <stdio.h>

#include "hello.h"

void

hello (const char * name)

{

printf ("Hello, %s!\n", name);

}

This function prints the message “Hello, name!” using its argument as

the value of name.

Incidentally, the diﬀerence between the two forms of the include state-

ment #include "FILE.h" and #include <FILE.h> is that the former

searches for ‘FILE.h’ in the current directory before looking in the sys-

tem header ﬁle directories. The include statement #include <FILE.h>

searches the s ystem header ﬁles, but do es not look in the current direc-

tory by default.

To compile these source ﬁles with gcc, use the following command:

$ gcc -Wall main.c hello_fn.c -o newhello

In this case, we use the ‘-o’ option to specify a diﬀerent output ﬁle for

the executable, ‘newhello’. Note that the header ﬁle ‘hello.h’ is not

speciﬁed in the list of ﬁles on the command line. The directive #include

"hello.h" in the source ﬁles instructs the compiler to include it auto-

matically at the appropriate points.

To run the program, type the path name of the executable:

$ ./newhello

Hello, world!

All the parts of the program have been combined into a single executable

ﬁle, which produces the same result as the executable created from the

single source ﬁle used earlier.

Chapter 2: Compiling a C program 11

2.4 Compiling ﬁles independently

If a program is stored in a single ﬁle then any change to an individual

function requires the whole program to be recompiled to produce a new

executable. The recompilation of large source ﬁles can be very time-

consuming.

When programs are stored in independent source ﬁles, only the ﬁles

which have changed need to be recompiled after the source code has been

modiﬁed. In this approach, the source ﬁles are compiled separately and

then linked together—a two stage process. In the ﬁrst stage, a ﬁle is

compiled without creating an executable. The result is referred to as an

object ﬁle, and has the extension ‘.o’ when using GCC.

In the second stage, the object ﬁles are merged together by a separate

program called the linker. The linker combines all the object ﬁles together

to create a single executable.

An object ﬁle contains machine code where any references to the mem-

ory addresses of functions (or variables) in other ﬁles are left undeﬁned.

This allows source ﬁles to be compiled without direct reference to each

other. The linker ﬁlls in these missing addresses when it produces the

executable.

2.4.1 Creating object ﬁles from source ﬁles

The command-line option ‘-c’ is used to compile a source ﬁle to an object

ﬁle. For example, the following command will compile the source ﬁle

‘main.c’ to an object ﬁle:

$ gcc -Wall -c main.c

This produces an object ﬁle ‘main.o’ containing the machine code for the

main function. It contains a reference to the external function hello, but

the corresponding memory address is left undeﬁned in the object ﬁle at

this stage (it will be ﬁlled in later by linking).

The corresponding command for compiling the hello function in the

source ﬁle ‘hello_fn.c’ is:

$ gcc -Wall -c hello_fn.c

This produces the object ﬁle ‘hello_fn.o’.

Note that there is no need to use the option ‘-o’ to specify the name

of the output ﬁle in this case. When compiling with ‘-c’ the compiler

automatically creates an object ﬁle whose name is the same as the source

ﬁle, with ‘.o’ instead of the original extension.

There is no need to put the header ﬁle ‘hello.h’ on the command line,

since it is automatically included by the #include statements in ‘main.c’

and ‘hello_fn.c’.

12 An Intro duction to GCC

2.4.2 Creating executables from object ﬁles

The ﬁnal step in creating an executable ﬁle is to use gcc to link the object

ﬁles together and ﬁll in the missing addresses of external functions. To

link object ﬁles together, they are simply listed on the command line:

$ gcc main.o hello_fn.o -o hello

This is one of the few occasions where there is no need to use the ‘-Wall’

warning option, since the individual source ﬁles have already been success-

fully compiled to object code. Once the source ﬁles have been compiled,

linking is an unambiguous process which either succeeds or fails (it fails

only if there are references which cannot be resolved).

To perform the linking step gcc uses the linker ld, which is a separate

program. On GNU systems the GNU linker, GNU ld, is used. Other

systems may use the GNU linker with GCC, or may have their own linkers.

The linker itself will be discussed later (see Chapter 11 [How the compiler

works], page 81). By running the linker, gcc creates an executable ﬁle

from the object ﬁles.

The resulting executable ﬁle can now be run:

$ ./hello

Hello, world!

It pro duces the same output as the version of the program using a single

source ﬁle in the previous section.

2.4.3 Link order of object ﬁles

On Unix-like systems, the traditional behavior of compilers and linkers

is to search for external functions fr om left to right in the object ﬁles

speciﬁed on the command line. This means that the object ﬁle which

contains the deﬁnition of a function should appear after any ﬁles which

call that function.

In this case, the ﬁle ‘hello_fn.o’ containing the function hello should

be speciﬁed after ‘main.o’ itself, since main calls hello:

$ gcc main.o hello_fn.o -o hello (correct order)

With some compilers or linkers the opposite ordering would result in an

error,

$ cc hello_fn.o main.o -o hello (incorrect order)

main.o: In function ‘main’:

main.o(.text+0xf): undefined reference to ‘hello’

because there is no object ﬁle containing hello after ‘main.o’.

Most current compilers and linker s will search all object ﬁles, regard-

less of order, but since not all compilers do this it is best to follow the

convention of ordering object ﬁles from left to right.

14 An Intro duction to GCC

ﬁles in a project can be automated using GNU Make (see [Further read-

ing], page 91).

2.6 Linking with external libraries

A library is a collection of precompiled object ﬁles which can be linked

into programs. The most common use of libraries is to provide system

functions, such as the square root function sqrt found in the C math

library.

Libraries are typically stored in special archive ﬁles with the extension

‘.a’, referred to as static libraries. They are created from object ﬁles with

a separate tool, the GNU archiver ar, and used by the linker to resolve

references to functions at compile-time. We will see later how to create

libraries using the ar command (see Chapter 10 [Compiler-related tools],

page 73). For simplicity, only static libraries are covered in this section—

dynamic linking at runtime using shared libraries will be described in the

next chapter.

The standard system libraries are usually found in the directories

‘/usr/lib’ and ‘/lib’.

(2)

For example, the C math library is typically

stored in the ﬁle ‘/usr/lib/libm.a’ on Unix-like systems. The corre-

sponding prototype declarations for the functions in this library are given

in the header ﬁle ‘/usr/include/math.h’. The C standard library itself

is stored in ‘/usr/lib/libc.a’ and contains functions speciﬁed in the

ANSI/ISO C standard, such as ‘printf’—this library is linked by default

for every C program.

Here is an example program which makes a call to the external function

sqrt in the math library ‘libm.a’:

#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;

}

Trying to create an executable from this source ﬁle alone causes the com-

piler to give an error at the link stage:

(2)

On systems supporting both 64 and 32-bit executables the 64-bit versions

of the libraries will often be stored in ‘/usr/lib64’ and ‘/lib64’, with the

32-bit versions in ‘/usr/lib’ and ‘/lib’.

剩余123页未读，继续阅读

qq_37832837

粉丝: 2
资源: 9

GCC编译器详解：GNU世界的编程利器

GCC_编程简介 （中文版）

gcc编程

齿轮曲柄摆块机构拼接Jfeand gcc 编程

linux gcc编程

虚拟机gcc编程步骤

使用gcc编程编写冒泡排序

齿轮曲柄摆块机构 gcc 编程代码

ubantu gcc编程

gcc8.4.0 gcc8.3.0

gcc99 gcc88区别

深入分析gcc pdf

yum -y install gcc+ gcc-c++

gcc -> gcc-4.9

cross gcc cygwin gcc 区别

gcc 进行 Windows 编程时，如何链接 Windows API 库

gcc 和gcc-9

学习gcc有什么好书可以看？

gcc10-gcc-c++.x86_64

gcc是什么？tdm-gcc和别的gcc有什么不同？

gcc-c++源码包

最新资源

GCC_编程简介（中文版）