gcc.texinfo

这是完整的gcc源代码

@var{one line to give the program's name and a brief idea of what it does.}
Copyright (C) 19@var{yy}  @var{name of author}

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
@end smallexample

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:

@smallexample
Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author}
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
@end smallexample

The hypothetical commands `show w' and `show c' should show the
appropriate parts of the General Public License.  Of course, the
commands you use may be called something other than `show w' and `show
c'; they could even be mouse-clicks or menu items---whatever suits your
program.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a ``copyright disclaimer'' for the program, if
necessary.  Here a sample; alter the names:

@example
Yoyodyne, Inc., hereby disclaims all copyright interest in the
program `Gnomovision' (a program to direct compilers to make passes
at assemblers) written by James Hacker.

@var{signature of Ty Coon}, 1 April 1989
Ty Coon, President of Vice
@end example

That's all there is to it!

@node Contributors, Boycott, Copying, Top
@unnumbered Contributors to GNU CC

In addition to Richard Stallman, several people have written parts
of GNU CC.

@itemize @bullet
@item
The idea of using RTL and some of the optimization ideas came from the
U. of Arizona Portable Optimizer, written by Jack Davidson and
Christopher Fraser.  See ``Register Allocation and Exhaustive Peephole
Optimization'', Software Practice and Experience 14 (9), Sept. 1984,
857-866.

@item
Paul Rubin wrote most of the preprocessor.

@item
Leonard Tower wrote parts of the parser, RTL generator, and RTL
definitions, and of the Vax machine description.

@item
Ted Lemon wrote parts of the RTL reader and printer.

@item
Jim Wilson implemented loop strength reduction and some other
loop optimizations.

@item
Nobuyuki Hikichi of Software Research Associates, Tokyo, contributed
the support for the Sony NEWS machine.

@item
Charles LaBrec contributed the support for the Integrated Solutions
68020 system.

@item
Michael Tiemann of MCC wrote most of the description of the National
Semiconductor 32000 series cpu.  He also wrote the code for inline
function integration and for the SPARC cpu and Motorola 88000 cpu
and part of the Sun FPA support.

@item
Jan Stein of the Chalmers Computer Society provided support for
Genix, as well as part of the 32000 machine description.

@item
Randy Smith finished the Sun FPA support.

@item
Robert Brown implemented the support for Encore 32000 systems.

@item
David Kashtan of SRI adapted GNU CC to the Vomit-Making System.

@item
Alex Crain provided changes for the 3b1.

@item
Greg Satz and Chris Hanson assisted in making GNU CC work on HP-UX for
the 9000 series 300.

@item
William Schelter did most of the work on the Intel 80386 support.

@item
Christopher Smith did the port for Convex machines.

@item
Paul Petersen wrote the machine description for the Alliant FX/8.

@item
Alain Lichnewsky ported GNU CC to the Mips cpu.

@item
Devon Bowen, Dale Wiles and Kevin Zachmann ported GNU CC to the Tahoe.

@item
Jonathan Stone wrote the machine description for the Pyramid computer.
@end itemize

@node Boycott, Options, Contributors, Top
@chapter Protect Your Freedom---Fight ``Look And Feel''

@quotation
@i{This section is a political message from the League for Programming
Freedom to the users of GNU CC.  It is included here as an expression
of support for the League on the part of the Free Software Foundation
and Richard Stallman.}
@end quotation

Ashton-Tate, Apple, Lotus and Xerox are trying to create a new form of
legal monopoly: a copyright on a class of user interfaces.  These
monopolies would cause serious problems for users and developers of
computer software and systems.

Until a few years ago, the law seemed clear: no one could restrict
others from using a user interface; programmers were free to implement
any interface they chose.  Imitating interfaces, sometimes with changes,
was standard practice in the computer field.  The interfaces we know
evolved gradually in this way; for example, the Macintosh user interface
drew ideas from the Xerox interface, which in turn drew on work done at
Stanford and SRI.  1-2-3 imitated VisiCalc, and dBase imitated a
database program from JPL.

Most computer companies, and nearly all computer users, were happy with
this state of affairs.  The companies that are suing say it does not
offer ``enough incentive'' to develop their products, but they must have
considered it ``enough'' when they made their decision to do so.  It
seems they are not satisfied with the opportunity to continue to compete
in the marketplace---not even with a head start.

If Xerox, Lotus, Apple and Ashton-Tate are permitted to make law through
the courts, the precedent will hobble the software industry:

@itemize @bullet
@item
Gratuitous incompatibilities will burden users.  Imagine if each
car manufacturer had to arrange the pedals in a different order.

@item
Software will become and remain more expensive.  Users will be
``locked in'' to proprietary interfaces, for which there is no real
competition.

@item
Large companies have an unfair advantage wherever lawsuits become
commonplace.  Since they can easily afford to sue, they can intimidate
small companies with threats even when they don't really have a case.

@item
User interface improvements will come slower, since incremental
evolution through creative imitation will no longer be permitted.

@item
Even Apple, etc., will find it harder to make improvements if
they can no longer adapt the good ideas that others introduce, for
fear of weakening their own legal positions.  Some users suggest that
this stagnation may already have started.

@item
If you use GNU software, you might find it of some concern that user
interface copyright will make it hard for the Free Software Foundation
to develop programs compatible with the interfaces that you already
know.
@end itemize

To protect our freedom from lawsuits like these, a group of programmers
and users have formed a new grass-roots political organization, the
League for Programming Freedom.

The purpose of the League is to oppose new monopolistic practices such
as user-interface copyright and software patents; it calls for a return
to the legal policies of the recent past, in which these practices were
not allowed.  The League is not concerned with free software as an
issue, and not affiliated with the Free Software Foundation.

The League's membership rolls include John McCarthy, inventor of Lisp,
Marvin Minsky, founder of the Artificial Intelligence lab, Guy L.
Steele, Jr., author of well-known books on Lisp and C, as well as
Richard Stallman, the developer of GNU CC.  Please join and add your
name to the list.  Membership dues in the League are $42 per year for
programmers, managers and professionals; $10.50 for students; $21 for
others.

The League needs both activist members and members who only pay their
dues.

To join, or for more information, phone [phone] or write to:

@example
League for Programming Freedom
1 Kendall Square #143
P.O. Box 9171
Cambridge, MA 02139       league@@prep.ai.mit.edu
@end example

Here are some suggestions from the League for how you can protect your
freedom to write programs:

@itemize @bullet
@item
Don't buy from Xerox, Lotus, Apple or Ashton-Tate.  Buy from their
competitors or from the defendants they are suing.

@item
Don't develop software to work with the systems made by these companies.

@item
Port your existing software to competing systems, so that you encourage
users to switch.

@item
Write letters to company presidents to let them know their conduct
is unacceptable.

@item
Tell your friends and colleagues about this issue and how it threatens
to ruin the computer industry.

@item
Above all, don't work for the look-and-feel plaintiffs, and don't
accept contracts from them.

@item
Write to Congress to explain the importance of this issue.

@example
House Subcommittee on Intellectual Property
2137 Rayburn Bldg
Washington, DC 20515

Senate Subcommittee on Patents, Trademarks and Copyrights
United States Senate
Washington, DC 20510
@end example
@end itemize

Express your opinion!  You can make a difference.

@node Options, Installation, Boycott, Top
@chapter GNU CC Command Options

The GNU C compiler uses a command syntax much like the Unix C compiler.
The @code{gcc} program accepts options and file names as operands.
Multiple single-letter options may @emph{not} be grouped: @samp{-dr} is
very different from @w{@samp{-d -r}}.

When you invoke GNU CC, it normally does preprocessing, compilation,
assembly and linking.  File names which end in @samp{.c} are taken as C
source to be preprocessed and compiled; file names ending in @samp{.i}
are taken as preprocessor output to be compiled; compiler output files
plus any input files with names ending in @samp{.s} are assembled; then
the resulting object files, plus any other input files, are linked
together to produce an executable.

Command options allow you to stop this process at an intermediate stage.
For example, the @samp{-c} option says not to run the linker.  Then the
output consists of object files output by the assembler.

Other command options are passed on to one stage of processing.  Some
options control the preprocessor and others the compiler itself.  Yet
other options control the assembler and linker; these are not documented
here, but you rarely need to use any of them.

Here are the options to control the overall compilation process, including
those that say whether to link, whether to assemble, and so on.

@table @samp
@item -o @var{file}
Place output in file @var{file}.  This applies regardless to whatever
sort of output is being produced, whether it be an executable file,
an object file, an assembler file or preprocessed C code.

If @samp{-o} is not specified, the default is to put an executable file
in @file{a.out}, the object file @file{@var{source}.c} in
@file{@var{source}.o}, an assembler file in @file{@var{source}.s}, and
preprocessed C on standard output.@refill

@item -c
Compile or assemble the source files, but do not link.  Produce object
files with names made by replacing @samp{.c} or @samp{.s} with
@samp{.o} at the end of the input file names.  Do nothing at all for
object files specified as input.

@item -S
Compile into assembler code but do not assemble.  The assembler output
file name is made by replacing @samp{.c} with @samp{.s} at the end of
the input file name.  Do nothing at all for assembler source files or
object files specified as input.

@item -E
Run only the C preprocessor.  Preprocess all the C source files
specified and output the results to standard output.

@item -v
Compiler driver program prints the commands it executes as it runs
the preprocessor, compiler proper, assembler and linker.  Some of
these are directed to print their own version numbers.

@item -pipe
Use pipes rather than temporary files for communication between the
various stages of compilation.  This fails to work on some systems
where the assembler is unable to read from a pipe; but the GNU
assembler has no trouble.

@item -B@var{prefix}
Compiler driver program tries @var{prefix} as a prefix for each
program it tries to run.  These programs are @file{cpp}, @file{cc1},
@file{as} and @file{ld}.

For each subprogram to be run, the compiler driver first tries the
@samp{-B} prefix, if any.  If that name is not found, or if @samp{-B}
was not specified, the driver tries two standard prefixes, which are
@file{/usr/lib/gcc-} and @file{/usr/local/lib/gcc-}.  If neither of
those results in a file name that is found, the unmodified program
name is searched for using the directories specified in your