探索GNU GCC编程指南：自由与效率的编译工具

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

"《An Introduction to GCC》是由Brian Gough撰写的一本指南，专为初学者介绍GNU Compiler Collection (GCC)。该书旨在教授读者如何有效地利用GCC作为编程工具，并深入探讨其在自由计算机用户运动中的角色。GCC不仅仅是一款编译器，它更是GNU项目的一部分，这场长达20年的运动旨在赋予计算机用户自由。书中首先由Richard Stallman作序，强调了GCC在开源软件世界中的重要性。出版日期为2004年3月，由Network Theory Limited出版，地址位于英国布里斯托尔。此外，读者可以访问info@network-theory.co.uk获取更多关于本书的信息，或者通过网址http://www.network-theory.co.uk/gcc/intro/查找额外资料。封面设计灵感来源于一个高效、节能的硬件栈，这体现了GCC在现代电子设计中的应用与效率。作者引用了Steven Rubin的免费电子VLSI设计系统Static Free Software（www.staticfreesoft.com）的作品，反映了软件开源社区的支持与合作精神。版权方面，这本书遵循GNU自由文档许可证（GNU FDL, Version 1.2或后续版本），允许在特定条件下复制、分发和修改文档，包括前封面文本“一本Network Theory手册”和后封面文本，这些都体现了尊重和保护创作者权益的同时，推动知识的共享与传播。《An Introduction to 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页未读，继续阅读

金爽Carol

粉丝: 0
资源: 1

探索GNU GCC编程指南：自由与效率的编译工具

An_Introduction_to_GCC_中文版_2.pdf

An_Introduction_to_GCC_中文__入门全局观书籍

An Introduction to GCC（含中文翻译）

introduction to gcc 下载

VScode gcc not exist

Unable to locate package gcc-11

gcc: fatal error: no input files compilation terminated.

Unable to locate package gcc

gcc -o program program.c sdl2-config --cflags --libs give an examplt

unable to locate package gcc

最新资源