Gold Fish 2/goldfish_vol2_cd1.bin/gnu/info/gcc.info-5

GNU Info File | 1994-11-17 | 33KB | 563 lines

This is Info file gcc.info, produced by Makeinfo-1.55 from the input
file gcc.texi.
   This file documents the use and the internals of the GNU compiler.
   Published by the Free Software Foundation 675 Massachusetts Avenue
Cambridge, MA 02139 USA
   Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation,
   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "GNU General Public License," "Funding for
Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are
included exactly as in the original, and provided that the entire
resulting derived work is distributed under the terms of a permission
notice identical to this one.
   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "GNU General Public
License," "Funding for Free Software," and "Protect Your Freedom--Fight
`Look And Feel'", and this permission notice, may be included in
translations approved by the Free Software Foundation instead of in the
original English.
File: gcc.info,  Node: Environment Variables,  Next: Running Protoize,  Prev: Code Gen Options,  Up: Invoking GCC
Environment Variables Affecting GNU CC
======================================
   This section describes several environment variables that affect how
GNU CC operates.  They work by specifying directories or prefixes to use
when searching for various kinds of files.
   Note that you can also specify places to search using options such as
`-B', `-I' and `-L' (*note Directory Options::.).  These take
precedence over places specified using environment variables, which in
turn take precedence over those specified by the configuration of GNU
CC.  *Note Driver::.
`TMPDIR'
     If `TMPDIR' is set, it specifies the directory to use for temporary
     files.  GNU CC uses temporary files to hold the output of one
     stage of compilation which is to be used as input to the next
     stage: for example, the output of the preprocessor, which is the
     input to the compiler proper.
`GCC_EXEC_PREFIX'
     If `GCC_EXEC_PREFIX' is set, it specifies a prefix to use in the
     names of the subprograms executed by the compiler.  No slash is
     added when this prefix is combined with the name of a subprogram,
     but you can specify a prefix that ends with a slash if you wish.
     If GNU CC cannot find the subprogram using the specified prefix, it
     tries looking in the usual places for the subprogram.
     The default value of `GCC_EXEC_PREFIX' is
     `PREFIX/lib/gcc-lib/MACHINE/VERSION/' where PREFIX is the value of
     `prefix' when you ran the `configure' script and MACHINE and
     VERSION are the configuration name and version number of GNU CC,
     respectively.
     Other prefixes specified with `-B' take precedence over this
     prefix.
     This prefix is also used for finding files such as `crt0.o' that
     are used for linking.
     In addition, the prefix is used in an unusual way in finding the
     directories to search for header files.  For each of the standard
     directories whose name normally begins with
     `/usr/local/lib/gcc-lib' (more precisely, with the value of
     `GCC_INCLUDE_DIR'), GNU CC tries replacing that beginning with the
     specified prefix to produce an alternate directory name.  Thus,
     with `-Bfoo/', GNU CC will search `foo/bar' where it would
     normally search `/usr/local/lib/bar'.  These alternate directories
     are searched first; the standard directories come next.
`COMPILER_PATH'
     The value of `COMPILER_PATH' is a colon-separated list of
     directories, much like `PATH'.  GNU CC tries the directories thus
     specified when searching for subprograms, if it can't find the
     subprograms using `GCC_EXEC_PREFIX'.
`LIBRARY_PATH'
     The value of `LIBRARY_PATH' is a colon-separated list of
     directories, much like `PATH'.  GNU CC tries the directories thus
     specified when searching for special linker files, if it can't
     find them using `GCC_EXEC_PREFIX'.  Linking using GNU CC also uses
     these directories when searching for ordinary libraries for the
     `-l' option (but directories specified with `-L' come first).
`C_INCLUDE_PATH'
`CPLUS_INCLUDE_PATH'
`OBJC_INCLUDE_PATH'
     These environment variables pertain to particular languages.  Each
     variable's value is a colon-separated list of directories, much
     like `PATH'.  When GNU CC searches for header files, it tries the
     directories listed in the variable for the language you are using,
     after the directories specified with `-I' but before the standard
     header file directories.
`DEPENDENCIES_OUTPUT'
     If this variable is set, its value specifies how to output
     dependencies for Make based on the header files processed by the
     compiler.  This output looks much like the output from the `-M'
     option (*note Preprocessor Options::.), but it goes to a separate
     file, and is in addition to the usual results of compilation.
     The value of `DEPENDENCIES_OUTPUT' can be just a file name, in
     which case the Make rules are written to that file, guessing the
     target name from the source file name.  Or the value can have the
     form `FILE TARGET', in which case the rules are written to file
     FILE using TARGET as the target name.
File: gcc.info,  Node: Running Protoize,  Prev: Environment Variables,  Up: Invoking GCC
Running Protoize
================
   The program `protoize' is an optional part of GNU C.  You can use it
to add prototypes to a program, thus converting the program to ANSI C
in one respect.  The companion program `unprotoize' does the reverse:
it removes argument types from any prototypes that are found.
   When you run these programs, you must specify a set of source files
as command line arguments.  The conversion programs start out by
compiling these files to see what functions they define.  The
information gathered about a file FOO is saved in a file named `FOO.X'.
   After scanning comes actual conversion.  The specified files are all
eligible to be converted; any files they include (whether sources or
just headers) are eligible as well.
   But not all the eligible files are converted.  By default,
`protoize' and `unprotoize' convert only source and header files in the
current directory.  You can specify additional directories whose files
should be converted with the `-d DIRECTORY' option.  You can also
specify particular files to exclude with the `-x FILE' option.  A file
is converted if it is eligible, its directory name matches one of the
specified directory names, and its name within the directory has not
been excluded.
   Basic conversion with `protoize' consists of rewriting most function
definitions and function declarations to specify the types of the
arguments.  The only ones not rewritten are those for varargs functions.
   `protoize' optionally inserts prototype declarations at the
beginning of the source file, to make them available for any calls that
precede the function's definition.  Or it can insert prototype
declarations with block scope in the blocks where undeclared functions
are called.
   Basic conversion with `unprotoize' consists of rewriting most
function declarations to remove any argument types, and rewriting
function definitions to the old-style pre-ANSI form.
   Both conversion programs print a warning for any function
declaration or definition that they can't convert.  You can suppress
these warnings with `-q'.
   The output from `protoize' or `unprotoize' replaces the original
source file.  The original file is renamed to a name ending with
`.save'.  If the `.save' file already exists, then the source file is
simply discarded.
   `protoize' and `unprotoize' both depend on GNU CC itself to scan the
program and collect information about the functions it uses.  So
neither of these programs will work until GNU CC is installed.
   Here is a table of the options you can use with `protoize' and
`unprotoize'.  Each option works with both programs unless otherwise
stated.
`-B DIRECTORY'
     Look for the file `SYSCALLS.c.X' in DIRECTORY, instead of the
     usual directory (normally `/usr/local/lib').  This file contains
     prototype information about standard system functions.  This option
     applies only to `protoize'.
`-c COMPILATION-OPTIONS'
     Use  COMPILATION-OPTIONS as the options when running `gcc' to
     produce the `.X' files.  The special option `-aux-info' is always
     passed in addition, to tell `gcc' to write a `.X' file.
     Note that the compilation options must be given as a single
     argument to `protoize' or `unprotoize'.  If you want to specify
     several `gcc' options, you must quote the entire set of
     compilation options to make them a single word in the shell.
     There are certain `gcc' arguments that you cannot use, because they
     would produce the wrong kind of output.  These include `-g', `-O',
     `-c', `-S', and `-o' If you include these in the
     COMPILATION-OPTIONS, they are ignored.
     Rename files to end in `.C' instead of `.c'.  This is convenient
     if you are converting a C program to C++.  This option applies
     only to `protoize'.
     Add explicit global declarations.  This means inserting explicit
     declarations at the beginning of each source file for each function
     that is called in the file and was not declared.  These
     declarations precede the first function definition that contains a
     call to an undeclared function.  This option applies only to
     `protoize'.
`-i STRING'
     Indent old-style parameter declarations with the string STRING.
     This option applies only to `protoize'.
     `unprotoize' converts prototyped function definitions to old-style
     function definitions, where the arguments are declared between the
     argument list and the initial `{'.  By default, `unprotoize' uses
     five spaces as the indentation.  If you want to indent with just
     one space instead, use `-i " "'.
     Keep the `.X' files.  Normally, they are deleted after conversion
     is finished.
     Add explicit local declarations.  `protoize' with `-l' inserts a
     prototype declaration for each function in each block which calls
     the function without any declaration.  This option applies only to
     `protoize'.
     Make no real changes.  This mode just prints information about the
     conversions that would have been done without `-n'.
     Make no `.save' files.  The original files are simply deleted.
     Use this option with caution.
`-p PROGRAM'
     Use the program PROGRAM as the compiler.  Normally, the name `gcc'
     is used.
     Work quietly.  Most warnings are suppressed.
     Print the version number, just like `-v' for `gcc'.
   If you need special compiler options to compile one of your program's
source files, then you should generate that file's `.X' file specially,
by running `gcc' on that source file with the appropriate options and
the option `-aux-info'.  Then run `protoize' on the entire set of
files.  `protoize' will use the existing `.X' file because it is newer
than the source file.  For example:
     gcc -Dfoo=bar file1.c -aux-info
     protoize *.c
You need to include the special files along with the rest in the
`protoize' command, even though their `.X' files already exist, because
otherwise they won't get converted.
   *Note Protoize Caveats::, for more information on how to use
`protoize' successfully.
File: gcc.info,  Node: Installation,  Next: C Extensions,  Prev: Invoking GCC,  Up: Top
Installing GNU CC
*****************
* Menu:
* Configurations::    Configurations Supported by GNU CC.
* Other Dir::     Compiling in a separate directory (not where the source is).
* Cross-Compiler::   Building and installing a cross-compiler.
* Sun Install::   See below for installation on the Sun.
* VMS Install::   See below for installation on VMS.
* Collect2::      How `collect2' works; how it finds `ld'.
* Header Dirs::   Understanding the standard header file directories.
   Here is the procedure for installing GNU CC on a Unix system.  See
*Note VMS Install::, for VMS systems.  In this section we assume you
compile in the same directory that contains the source files; see *Note
Other Dir::, to find out how to compile in a separate directory on Unix
systems.
   You cannot install GNU C by itself on MSDOS; it will not compile
under any MSDOS compiler except itself.  You need to get the complete
compilation package DJGPP, which includes binaries as well as sources,
and includes all the necessary compilation tools and libraries.
  1. If you have built GNU CC previously in the same directory for a
     different target machine, do `make distclean' to delete all files
     that might be invalid.  One of the files this deletes is
     `Makefile'; if `make distclean' complains that `Makefile' does not
     exist, it probably means that the directory is already suitably
     clean.
  2. On a System V release 4 system, make sure `/usr/bin' precedes
     `/usr/ucb' in `PATH'.  The `cc' command in `/usr/ucb' uses
     libraries which have bugs.
  3. Specify the host, build and target machine configurations.  You do
     this by running the file `configure'.
     The "build" machine is the system which you are using, the "host"
     machine is the system where you want to run the resulting compiler
     (normally the build machine), and the "target" machine is the
     system for which you want the compiler to generate code.
     If you are building a compiler to produce code for the machine it
     runs on (a native compiler), you normally do not need to specify
     any operands to `configure'; it will try to guess the type of
     machine you are on and use that as the build, host and target
     machines.  So you don't need to specify a configuration when
     building a native compiler unless `configure' cannot figure out
     what your configuration is or guesses wrong.
     In those cases, specify the build machine's "configuration name"
     with the `--build' option; the host and target will default to be
     the same as the build machine.  (If you are building a
     cross-compiler, see *Note Cross-Compiler::.)
     Here is an example:
          ./configure --build=sparc-sun-sunos4.1
     A configuration name may be canonical or it may be more or less
     abbreviated.
     A canonical configuration name has three parts, separated by
     dashes.  It looks like this: `CPU-COMPANY-SYSTEM'.  (The three
     parts may themselves contain dashes; `configure' can figure out
     which dashes serve which purpose.)  For example,
     `m68k-sun-sunos4.1' specifies a Sun 3.
     You can also replace parts of the configuration by nicknames or
     aliases.  For example, `sun3' stands for `m68k-sun', so
     `sun3-sunos4.1' is another way to specify a Sun 3.  You can also
     use simply `sun3-sunos', since the version of SunOS is assumed by
     default to be version 4.  `sun3-bsd' also works, since `configure'
     knows that the only BSD variant on a Sun 3 is SunOS.
     You can specify a version number after any of the system types,
     and some of the CPU types.  In most cases, the version is
     irrelevant, and will be ignored.  So you might as well specify the
     version if you know it.
     See *Note Configurations::, for a list of supported configuration
     names and notes on many of the configurations.  You should check
     the notes in that section before proceding any further with the
     installation of GNU CC.
     There are four additional options you can specify independently to
     describe variant hardware and software configurations.  These are
     `--with-gnu-as', `--with-gnu-ld', `--with-stabs' and `--nfp'.
    `--with-gnu-as'
          If you will use GNU CC with the GNU assembler (GAS), you
          should declare this by using the `--with-gnu-as' option when
          you run `configure'.
          Using this option does not install GAS.  It only modifies the
          output of GNU CC to work with GAS.  Building and installing
          GAS is up to you.
          Conversely, if you *do not* wish to use GAS and do not specify
          `--with-gnu-as' when building GNU CC, it is up to you to make
          sure that GAS is not installed.  GNU CC searches for a
          program named `as' in various directories; if the program it
          finds is GAS, then it runs GAS.  If you are not sure where
          GNU CC finds the assembler it is using, try specifying `-v'
          when you run it.
          The systems where it makes a difference whether you use GAS
          are
          `hppa1.0-ANY-ANY', `hppa1.1-ANY-ANY', `i386-ANY-sysv',
          `i386-ANY-isc',
          `i860-ANY-bsd', `m68k-bull-sysv', `m68k-hp-hpux',
          `m68k-sony-bsd',
          `m68k-altos-sysv', `m68000-hp-hpux', `m68000-att-sysv', and
          `mips-ANY').  On any other system, `--with-gnu-as' has no
          effect.
          On the systems listed above (except for the HP-PA, for ISC on
          the 386, and for `mips-sgi-irix5.*'), if you use GAS, you
          should also use the GNU linker (and specify `--with-gnu-ld').
    `--with-gnu-ld'
          Specify the option `--with-gnu-ld' if you plan to use the GNU
          linker with GNU CC.
          This option does not cause the GNU linker to be installed; it
          just modifies the behavior of GNU CC to work with the GNU
          linker.  Specifically, it inhibits the installation of
          `collect2', a program which otherwise serves as a front-end
          for the system's linker on most configurations.
    `--with-stabs'
          On MIPS based systems and on Alphas, you must specify whether
          you want GNU CC to create the normal ECOFF debugging format,
          or to use BSD-style stabs passed through the ECOFF symbol
          table.  The normal ECOFF debug format cannot fully handle
          languages other than C.  BSD stabs format can handle other
          languages, but it only works with the GNU debugger GDB.
          Normally, GNU CC uses the ECOFF debugging format by default;
          if you prefer BSD stabs, specify `--with-stabs' when you
          configure GNU CC.
          No matter which default you choose when you configure GNU CC,
          the user can use the `-gcoff' and `-gstabs+' options to
          specify explicitly the debug format for a particular
          compilation.
          `--with-stabs' is meaningful on the ISC system on the 386,
          also, if `--with-gas' is used.  It selects use of stabs
          debugging information embedded in COFF output.  This kind of
          debugging information supports C++ well; ordinary COFF
          debugging information does not.
          `--with-stabs' is also meaningful on 386 systems running
          SVR4.  It selects use of stabs debugging information embedded
          in ELF output.  The C++ compiler currently (2.6.0) does not
          support the DWARF debugging information normally used on 386
          SVR4 platforms; stabs provide a workable alternative.  This
          requires gas and gdb, as the normal SVR4 tools can not
          generate or interpret stabs.
    `--nfp'
          On certain systems, you must specify whether the machine has
          a floating point unit.  These systems include
          `m68k-sun-sunosN' and `m68k-isi-bsd'.  On any other system,
          `--nfp' currently has no effect, though perhaps there are
          other systems where it could usefully make a difference.
     The `configure' script searches subdirectories of the source
     directory for other compilers that are to be integrated into GNU
     CC.  The GNU compiler for C++, called G++ is in a subdirectory
     named `cp'.  `configure' inserts rules into `Makefile' to build
     all of those compilers.
     Here we spell out what files will be set up by `configure'.
     Normally you need not be concerned with these files.
        * A symbolic link named `config.h' is made to the top-level
          config file for the machine you will run the compiler on
          (*note Config::.).  This file is responsible for defining
          information about the host machine.  It includes `tm.h'.
          The top-level config file is located in the subdirectory
          `config'.  Its name is always `xm-SOMETHING.h'; usually
          `xm-MACHINE.h', but there are some exceptions.
          If your system does not support symbolic links, you might
          want to set up `config.h' to contain a `#include' command
          which refers to the appropriate file.
        * A symbolic link named `tconfig.h' is made to the top-level
          config file for your target machine.  This is used for
          compiling certain programs to run on that machine.
        * A symbolic link named `tm.h' is made to the
          machine-description macro file for your target machine.  It
          should be in the subdirectory `config' and its name is often
          `MACHINE.h'.
        * A symbolic link named `md' will be made to the machine
          description pattern file.  It should be in the `config'
          subdirectory and its name should be `MACHINE.md'; but MACHINE
          is often not the same as the name used in the `tm.h' file
          because the `md' files are more general.
        * A symbolic link named `aux-output.c' will be made to the
          output subroutine file for your machine.  It should be in the
          `config' subdirectory and its name should be `MACHINE.c'.
        * The command file `configure' also constructs the file
          `Makefile' by adding some text to the template file
          `Makefile.in'.  The additional text comes from files in the
          `config' directory, named `t-TARGET' and `x-HOST'.  If these
          files do not exist, it means nothing needs to be added for a
          given target or host.
  4. The standard directory for installing GNU CC is `/usr/local/lib'.
     If you want to install its files somewhere else, specify
     `--prefix=DIR' when you run `configure'.  Here DIR is a directory
     name to use instead of `/usr/local' for all purposes with one
     exception: the directory `/usr/local/include' is searched for
     header files no matter where you install the compiler.  To override
     this name, use the `--local-prefix' option below.
  5. Specify `--local-prefix=DIR' if you want the compiler to search
     directory `DIR/include' for locally installed header files
     *instead* of `/usr/local/include'.
     You should specify `--local-prefix' *only* if your site has a
     different convention (not `/usr/local') for where to put
     site-specific files.
     *Do not* specify `/usr' as the `--local-prefix'!  The directory
     you use for `--local-prefix' *must not* contain any of the
     system's standard header files.  If it did contain them, certain
     programs would be miscompiled (including GNU Emacs, on certain
     targets), because this would override and nullify the header file
     corrections made by the `fixincludes' script.
  6. Make sure the Bison parser generator is installed.  (This is
     unnecessary if the Bison output files `c-parse.c' and `cexp.c' are
     more recent than `c-parse.y' and `cexp.y' and you do not plan to
     change the `.y' files.)
     Bison versions older than Sept 8, 1988 will produce incorrect
     output for `c-parse.c'.
  7. If you have chosen a configuration for GNU CC which requires other
     GNU tools (such as GAS or the GNU linker) instead of the standard
     system tools, install the required tools in the build directory
     under the names `as', `ld' or whatever is appropriate.  This will
     enable the compiler to find the proper tools for compilation of
     the program `enquire'.
     Alternatively, you can do subsequent compilation using a value of
     the `PATH' environment variable such that the necessary GNU tools
     come before the standard system tools.
  8. Build the compiler.  Just type `make LANGUAGES=c' in the compiler
     directory.
     `LANGUAGES=c' specifies that only the C compiler should be
     compiled.  The makefile normally builds compilers for all the
     supported languages; currently, C, C++ and Objective C.  However,
     C is the only language that is sure to work when you build with
     other non-GNU C compilers.  In addition, building anything but C
     at this stage is a waste of time.
     In general, you can specify the languages to build by typing the
     argument `LANGUAGES="LIST"', where LIST is one or more words from
     the list `c', `c++', and `objective-c'.  If you have any
     additional GNU compilers as subdirectories of the GNU CC source
     directory, you may also specify their names in this list.
     Ignore any warnings you may see about "statement not reached" in
     `insn-emit.c'; they are normal.  Also, warnings about "unknown
     escape sequence" are normal in `genopinit.c' and perhaps some
     other files.  Likewise, you should ignore warnings about "constant
     is so large that it is unsigned" in `insn-emit.c' and
     `insn-recog.c'.  Any other compilation errors may represent bugs in
     the port to your machine or operating system, and should be
     investigated and reported (*note Bugs::.).
     Some commercial compilers fail to compile GNU CC because they have
     bugs or limitations.  For example, the Microsoft compiler is said
     to run out of macro space.  Some Ultrix compilers run out of
     expression space; then you need to break up the statement where
     the problem happens.
  9. If you are building a cross-compiler, stop here.  *Note
     Cross-Compiler::.
 10. Move the first-stage object files and executables into a
     subdirectory with this command:
          make stage1
     The files are moved into a subdirectory named `stage1'.  Once
     installation is complete, you may wish to delete these files with
     `rm -r stage1'.
 11. If you have chosen a configuration for GNU CC which requires other
     GNU tools (such as GAS or the GNU linker) instead of the standard
     system tools, install the required tools in the `stage1'
     subdirectory under the names `as', `ld' or whatever is
     appropriate.  This will enable the stage 1 compiler to find the
     proper tools in the following stage.
     Alternatively, you can do subsequent compilation using a value of
     the `PATH' environment variable such that the necessary GNU tools
     come before the standard system tools.
 12. Recompile the compiler with itself, with this command:
          make CC="stage1/xgcc -Bstage1/" CFLAGS="-g -O"
     This is called making the stage 2 compiler.
     The command shown above builds compilers for all the supported
     languages.  If you don't want them all, you can specify the
     languages to build by typing the argument `LANGUAGES="LIST"'.  LIST
     should contain one or more words from the list `c', `c++',
     `objective-c', and `proto'.  Separate the words with spaces.
     `proto' stands for the programs `protoize' and `unprotoize'; they
     are not a separate language, but you use `LANGUAGES' to enable or
     disable their installation.
     If you are going to build the stage 3 compiler, then you might
     want to build only the C language in stage 2.
     Once you have built the stage 2 compiler, if you are short of disk
     space, you can delete the subdirectory `stage1'.
     On a 68000 or 68020 system lacking floating point hardware, unless
     you have selected a `tm.h' file that expects by default that there
     is no such hardware, do this instead:
          make CC="stage1/xgcc -Bstage1/" CFLAGS="-g -O -msoft-float"
 13. If you wish to test the compiler by compiling it with itself one
     more time, install any other necessary GNU tools (such as GAS or
     the GNU linker) in the `stage2' subdirectory as you did in the
     `stage1' subdirectory, then do this:
          make stage2
          make CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O"
     This is called making the stage 3 compiler.  Aside from the `-B'
     option, the compiler options should be the same as when you made
     the stage 2 compiler.  But the `LANGUAGES' option need not be the
     same.  The command shown above builds compilers for all the
     supported languages; if you don't want them all, you can specify
     the languages to build by typing the argument `LANGUAGES="LIST"',
     as described above.
     If you do not have to install any additional GNU tools, you may
     use the command
          make bootstrap LANGUAGES=LANGUAGE-LIST BOOT_CFLAGS=OPTION-LIST
     instead of making `stage1', `stage2', and performing the two
     compiler builds.
 14. Then compare the latest object files with the stage 2 object
     files--they ought to be identical, aside from time stamps (if any).
     On some systems, meaningful comparison of object files is
     impossible; they always appear "different."  This is currently
     true on Solaris and probably on all systems that use ELF object
     file format.  On some versions of Irix on SGI machines and OSF/1
     on Alpha systems, you will not be able to compare the files
     without specifying `-save-temps'; see the description of
     individual systems above to see if you get comparison failures.
     You may have similar problems on other systems.
     Use this command to compare the files:
          make compare
     This will mention any object files that differ between stage 2 and
     stage 3.  Any difference, no matter how innocuous, indicates that
     the stage 2 compiler has compiled GNU CC incorrectly, and is
     therefore a potentially serious bug which you should investigate
     and report (*note Bugs::.).
     If your system does not put time stamps in the object files, then
     this is a faster way to compare them (using the Bourne shell):
          for file in *.o; do
          cmp $file stage2/$file
          done
     If you have built the compiler with the `-mno-mips-tfile' option on
     MIPS machines, you will not be able to compare the files.
 15. Build the Objective C library (if you have built the Objective C
     compiler).  Here is the command to do this:
          make objc-runtime CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O"
 16. Install the compiler driver, the compiler's passes and run-time
     support with `make install'.  Use the same value for `CC',
     `CFLAGS' and `LANGUAGES' that you used when compiling the files
     that are being installed.  One reason this is necessary is that
     some versions of Make have bugs and recompile files gratuitously
     when you do this step.  If you use the same variable values, those
     files will be recompiled properly.
     For example, if you have built the stage 2 compiler, you can use
     the following command:
          make install CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O" LANGUAGES="LIST"
     This copies the files `cc1', `cpp' and `libgcc.a' to files `cc1',
     `cpp' and `libgcc.a' in the directory
     `/usr/local/lib/gcc-lib/TARGET/VERSION', which is where the
     compiler driver program looks for them.  Here TARGET is the target
     machine type specified when you ran `configure', and VERSION is
     the version number of GNU CC.  This naming scheme permits various
     versions and/or cross-compilers to coexist.
     This also copies the driver program `xgcc' into
     `/usr/local/bin/gcc', so that it appears in typical execution
     search paths.
     On some systems, this command causes recompilation of some files.
     This is usually due to bugs in `make'.  You should either ignore
     this problem, or use GNU Make.
     *Warning: there is a bug in `alloca' in the Sun library.  To avoid
     this bug, be sure to install the executables of GNU CC that were
     compiled by GNU CC.  (That is, the executables from stage 2 or 3,
     not stage 1.)  They use `alloca' as a built-in function and never
     the one in the library.*
     (It is usually better to install GNU CC executables from stage 2
     or 3, since they usually run faster than the ones compiled with
     some other compiler.)
 17. Install the Objective C library (if you are installing the
     Objective C compiler).  Here is the command to do this:
          make install-libobjc CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O"
 18. If you're going to use C++, it's likely that you need to also
     install the libg++ distribution.  It should be available from the
     same place where you got the GNU C distribution.  Just as GNU C
     does not distribute a C runtime library, it also does not include
     a C++ run-time library.  All I/O functionality, special class
     libraries, etc., are available in the libg++ distribution.