install

gcc库的原代码,对编程有很大帮助.

This file documents the installation of the GNU compiler.  Copyright
(C) 1988, 1989, 1992, 1994, 1995 Free Software Foundation, Inc.  You
may copy, distribute, and modify it freely as long as you preserve this
copyright notice and permission notice.

Installing GNU CC
*****************

   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 proceeding 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',
          `ANY-lynx-lynxos', 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 file named `config.h' is created that contains a `#include'
          of the top-level config file for the machine you will run the
          compiler on (*note The Configuration File:
          (gcc.info)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 file named `tconfig.h' is created which includes the
          top-level config file for your target machine.  This is used
          for compiling certain programs to run on that machine.

        * A file named `tm.h' is created which includes the
          machine-description macro file for your target machine.  It
          should be in the subdirectory `config' and its name is often
          `MACHINE.h'.

        * 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' and a warning about a comparison always being zero
     in `enquire.o'.  Any other compilation errors may represent bugs in
     the port to your machine or operating system, and should be
     investigated and reported.

     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