falso
/
c-intro-and-ref
mirror of git://git.savannah.gnu.org/c-intro-and-ref.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

(Compilation): Substantial rewrite and reordering, for clarity.

This commit is contained in:
Richard Stallman 2022-09-09 07:36:18 -04:00
parent a50f6f1177
commit f7b79b82cf
1 changed files with 37 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
c.texi
View File

@ -12126,20 +12126,29 @@ that value. Its definition is written to avoid overflow.
@cindex object file @cindex object file
@cindex compilation module @cindex compilation module
@cindex make rules @cindex make rules
@cindex link
Early in the manual we explained how to compile a simple C program Early in the manual we explained how to compile a simple C program
that consists of a single source file (@pxref{Compile Example}). that consists of a single source file (@pxref{Compile Example}).
However, we handle only short programs that way. A typical C program However, we handle only short programs that way. A typical C program
consists of many source files, each of which is a separate consists of many source files, each of which is usually a separate
@dfn{compilation module}---meaning that it has to be compiled @dfn{compilation module}---meaning that it has to be compiled
separately. separately. (The source files that are not separate compilation
modules are those that are used via @code{#include}; see @ref{Header
Files}.)
The full details of how to compile with GCC are documented in xxxx. To compile a multi-module program, you compile each of the program's
compilation modules, making an @dfn{object file} for that module. The
last step is to @dfn{link} the many object files together into a
single executable for the whole program.
The full details of how to compile C programs (and other programs)
with GCC are documented in xxxx.
@c ??? ref @c ??? ref
Here we give only a simple introduction. Here we give only a simple introduction.
These are the commands to compile two compilation modules, These commands compile two compilation modules, @file{foo.c} and
@file{foo.c} and @file{bar.c}, with a command for each module: @file{bar.c}, running the compiler for each module:
@example @example
gcc -c -O -g foo.c gcc -c -O -g foo.c
@ -12149,28 +12158,17 @@ gcc -c -O -g bar.c
@noindent @noindent
In these commands, @option{-g} says to generate debugging information, In these commands, @option{-g} says to generate debugging information,
@option{-O} says to do some optimization, and @option{-c} says to put @option{-O} says to do some optimization, and @option{-c} says to put
the compiled code for that module into a corresponding @dfn{object the compiled code for that module into a corresponding object file and
file} and go no further. The object file for @file{foo.c} is called go no further. The object file for @file{foo.c} is automatically
@file{foo.o}, and so on. called @file{foo.o}, and so on.
If you wish, you can specify the additional options @option{-Wformat If you wish, you can specify the additional compilation options. For
-Wparenthesis -Wstrict-prototypes}, which request additional warnings. instance, @option{-Wformat -Wparenthesis -Wstrict-prototypes} request
additional warnings.
One reason to divide a large program into multiple compilation modules
is to control how each module can access the internals of the others.
When a module declares a function or variable @code{extern}, other
modules can access it. The other functions and variables in
a module can't be accessed from outside that module.
The other reason for using multiple modules is so that changing
one source file does not require recompiling all of them in order
to try the modified program. Dividing a large program into many
substantial modules in this way typically makes recompilation much faster.
@cindex linking object files @cindex linking object files
After you compile all the program's modules, in order to run the After you compile all the program's modules, you link the object files
program you must @dfn{link} the object files into a combined into a combined executable, like this:
executable, like this:
@example @example
gcc -o foo foo.o bar.o gcc -o foo foo.o bar.o
@ -12182,12 +12180,24 @@ executable file, and the other arguments are the object files to link.
Always specify the executable file name in a command that generates Always specify the executable file name in a command that generates
one. one.
One reason to divide a large program into multiple compilation modules
is to control how each module can access the internals of the others.
When a module declares a function or variable @code{extern}, other
modules can access it. The other functions and variables defined in a
module can't be accessed from outside that module.
The other reason for using multiple modules is so that changing one
source file does not require recompiling all of them in order to try
the modified program. It is sufficient to recompile the source file
that you changed, then link them all again. Dividing a large program
into many substantial modules in this way typically makes
recompilation much faster.
Normally we don't run any of these commands directly. Instead we Normally we don't run any of these commands directly. Instead we
write a set of @dfn{make rules} for the program, then use the write a set of @dfn{make rules} for the program, then use the
@command{make} program to recompile only the source files that need to @command{make} program to recompile only the source files that need to
be recompiled. be recompiled, by following those rules. @xref{Top, The GNU Make
Mamual, , Make, The GNU Make Manual}).
@c ??? ref to make manual
@node Directing Compilation @node Directing Compilation
@chapter Directing Compilation @chapter Directing Compilation