GCC入门指南：自由软件运动的关键工具

4星 · 超过85%的资源需积分: 9 11 浏览量更新于2024-07-23 收藏 526KB PDF 举报

"An Introduction to GCC 是一本关于GNU Compiler Collection（GCC）的入门指南，由Brian Gough编写，理查德·马修·斯托曼（Richard M. Stallman）作序。本书不仅介绍了如何使用GCC作为编程工具，还探讨了GCC在推广计算机用户自由方面的意义。GCC不仅仅是一个编译器，它是自由软件运动的一部分，强调软件不仅要技术上优秀，还需尊重用户自由。书中的内容可能涵盖以下几个方面： 1. **GCC简介**：GCC是GNU项目的核心组成部分，它是一个集合，包含了针对多种编程语言（如C、C++、Fortran等）的编译器。GCC不仅能够编译源代码，还提供代码优化功能，帮助开发者提升程序性能。 2. **编程基础**：书中可能会介绍如何安装和配置GCC，以及如何编写、编译和调试程序。这包括命令行参数的使用、错误处理和编译选项的详细说明。 3. **高级特性**：可能深入讨论GCC的高级特性，如预处理器宏、模板、异常处理、内联函数等，并指导如何利用这些特性来提高代码质量。 4. **优化技巧**：GCC提供了多种优化级别，书籍会讲解如何通过调整编译器设置来优化代码运行速度和内存使用。 5. **跨平台编译**：由于GCC支持多种操作系统，书里可能涉及如何在不同平台上构建和运行程序，包括Unix、Linux、Windows等。 6. **自由软件理念**：作者强调了软件伦理的重要性，GCC作为自由软件的代表，其发行条款允许用户自由地使用、修改和分发。这部分可能会讨论GNU General Public License (GPL) 和自由软件运动的意义。 7. **社区与支持**：书中可能包含关于如何参与GCC社区、获取帮助和贡献代码的信息，鼓励读者成为开源软件开发的一部分。 8. **实例分析**：通过具体的编程示例，展示如何使用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页未读，继续阅读

Tecn

粉丝: 26
资源: 7

GCC入门指南：自由软件运动的关键工具

An_Introduction_to_GCC_中文版_2.pdf

msys2 无法找到 gcc.exe

xtensa-esp32-elf-gcc.exe 下载

gcc.exe是什么文件

安装gcc出现checking for gcc... no

gcc.exe: error: 1.输出: No such file or directory gcc.exe: error: Hello: No such file or directory gcc.exe: error: World.c: No such file or directory gcc.exe: error: Hello: No such file or directory gcc.exe: error: World: No such file or directory gcc.exe: fatal error: no input files

gcc.exe 生成文件活动已终止

arm-linux-gcc.tar.gz

gcc.exe-y信息的重定向命令是

最新资源