[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
3.1 Files Created by configure | Files created by running configure . | |
3.2 Configurations Supported by GNU CC | ||
3.3 Compilation in a Separate Directory | Compiling in a separate directory (not where the source is). | |
3.4 Building and Installing a Cross-Compiler | Building and installing a cross-compiler. | |
3.5 Installing GNU CC on the Sun | See below for installation on the Sun. | |
3.6 Installing GNU CC on VMS | See below for installation on VMS. | |
3.7 collect2 | How collect2 works; how it finds ld . | |
3.8 Standard Header File Directories | Understanding the standard header file directories. |
Here is the procedure for installing GNU CC on a GNU or Unix system. See 3.6 Installing GNU CC on VMS, for VMS systems. In this section we assume you compile in the same directory that contains the source files; see 3.3 Compilation in a Separate Directory, 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.
PATH
. The cc
command in
`/usr/ucb' uses libraries which have bugs.
Bison versions older than Sept 8, 1988 will produce incorrect output for `c-parse.c'.
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.
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 `--host' option; the host and target will default to be the same as the host machine. (If you are building a cross-compiler, see 3.4 Building and Installing a Cross-Compiler.)
Here is an example:
./configure --host=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.
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 3.2 Configurations Supported by GNU CC, 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.
configure
, you may also need to specify certain
additional options that describe variant hardware and software
configurations. These are `--with-gnu-as', `--with-gnu-ld',
`--with-stabs' and `--nfp'.
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').
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.
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.
configure
will print out whether the Haifa scheduler is enabled when it is run.
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.
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.
gettext
libraries, and falls back on GCC's copy of the GNU
gettext
library only if the host libraries do not suffice. The
`--with-included-gettext' option causes the build procedure to
prefer its copy of GNU gettext
.
gettext
but has the
inferior catgets
interface, the GCC build procedure normally
ignores catgets
and instead uses GCC's copy of the GNU
gettext
library. The `--with-catgets' option causes the
build procedure to use the host's catgets
in this situation.
configure
.
--with-local-prefix
option below. The directory
you specify need not exist, but its parent directory must exist.
You should specify `--with-local-prefix' only if your site has a different convention (not `/usr/local') for where to put site-specific files.
The default value for `--with-local-prefix' is `/usr/local' regardless of the value of `--prefix'. Specifying `--prefix' has no effect on which directory GNU CC searches for local header files. This may seem counterintuitive, but actually it is logical.
The purpose of `--prefix' is to specify where to install GNU CC. The local header files in `/usr/local/include'---if you put any in that directory--are not part of GNU CC. They are part of other programs--perhaps many others. (GNU CC installs its own header files in another directory which is based on the `--prefix' value.)
Do not specify `/usr' as the `--with-local-prefix'! The
directory you use for `--with-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.
Indications are that people who use this option use it based on mistaken ideas of what it is for. People use it as if it specified where to install part of GNU CC. Perhaps they make this assumption because installing GNU CC creates the 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', a warning about a comparison always being zero in `enquire.o', and warnings about shift counts exceeding type widths in `cexp.y'. Any other compilation errors may represent bugs in the port to your machine or operating system, and should be investigated and reported (see section 8. Reporting Bugs).
Some 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.
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
.
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.
make CC="stage1/xgcc -Bstage1/" CFLAGS="-g -O2" |
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 -O2 -msoft-float" |
make stage2 make CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O2" |
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.
On some systems, meaningful comparison of object files is impossible; they always appear "different." This is currently true on Solaris and some systems that use ELF object file format. On some versions of Irix on SGI machines and DEC Unix (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 (see section 8. Reporting 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.
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 canonicalized form of 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. It also copies the executables for compilers for other languages (e.g., `cc1plus' for C++) to the same directory.
This also copies the driver program `xgcc' into `/usr/local/bin/gcc', so that it appears in typical execution search paths. It also copies `gcc.1' into `/usr/local/man/man1' and info pages into `/usr/local/info'.
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.)
The standard C++ runtime library for GNU CC is called `libstdc++'. An obsolescent library `libg++' may also be available, but it's necessary only for older software that hasn't been converted yet; if you don't know whether you need `libg++' then you probably don't need it.
Here's one way to build and install `libstdc++' for GNU CC:
To summarize, after building and installing GNU CC, invoke the following shell commands in the topmost directory of the C++ library distribution. For configure-options, use the same options that you used to configure GNU CC.
$ CXX=gcc ./configure configure-options $ make $ make install |
When you run `configure', it picks the appropriate Objective-C thread implementation file for the target platform. In some situations, you may wish to choose a different back-end as some platforms support multiple thread implementations or you may wish to disable thread support completely. You do this by specifying a value for the OBJC_THREAD_FILE makefile variable on the command line when you run make, for example:
make CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O2" OBJC_THREAD_FILE=thr-single |
Below is a list of the currently available back-ends.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |