1 @c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
2 @c This is part of the GCC manual.
3 @c For copying conditions, see the file install.texi.
6 @comment node-name, next, previous, up
7 @node Old, GNU Free Documentation License, Specific, Top
10 <h1 align="center">Old installation documentation</h1>
13 @chapter Old installation documentation
16 Note most of this information is out of date and superseded by the
17 previous chapters of this manual. It is provided for historical
18 reference only, because of a lack of volunteers to merge it into the
23 * Configurations:: Configurations Supported by GNU CC.
24 * Cross-Compiler:: Building and installing a cross-compiler.
25 * VMS Install:: See below for installation on VMS.
29 Here is the procedure for installing GNU CC on a GNU or Unix system.
30 See @ref{VMS Install}, for VMS systems.
34 If you have chosen a configuration for GNU CC which requires other GNU
35 tools (such as GAS or the GNU linker) instead of the standard system
36 tools, install the required tools in the build directory under the names
37 @file{as}, @file{ld} or whatever is appropriate.
39 Alternatively, you can do subsequent compilation using a value of the
40 @code{PATH} environment variable such that the necessary GNU tools come
41 before the standard system tools.
44 Specify the host, build and target machine configurations. You do this
45 when you run the @file{configure} script.
47 The @dfn{build} machine is the system which you are using, the
48 @dfn{host} machine is the system where you want to run the resulting
49 compiler (normally the build machine), and the @dfn{target} machine is
50 the system for which you want the compiler to generate code.
52 If you are building a compiler to produce code for the machine it runs
53 on (a native compiler), you normally do not need to specify any operands
54 to @file{configure}; it will try to guess the type of machine you are on
55 and use that as the build, host and target machines. So you don't need
56 to specify a configuration when building a native compiler unless
57 @file{configure} cannot figure out what your configuration is or guesses
60 In those cases, specify the build machine's @dfn{configuration name}
61 with the @option{--host} option; the host and target will default to be
62 the same as the host machine. (If you are building a cross-compiler,
63 see @ref{Cross-Compiler}.)
68 ./configure --host=sparc-sun-sunos4.1
71 A configuration name may be canonical or it may be more or less
74 A canonical configuration name has three parts, separated by dashes.
75 It looks like this: @samp{@var{cpu}-@var{company}-@var{system}}.
76 (The three parts may themselves contain dashes; @file{configure}
77 can figure out which dashes serve which purpose.) For example,
78 @samp{m68k-sun-sunos4.1} specifies a Sun 3.
80 You can also replace parts of the configuration by nicknames or aliases.
81 For example, @samp{sun3} stands for @samp{m68k-sun}, so
82 @samp{sun3-sunos4.1} is another way to specify a Sun 3.
84 You can specify a version number after any of the system types, and some
85 of the CPU types. In most cases, the version is irrelevant, and will be
86 ignored. So you might as well specify the version if you know it.
88 See @ref{Configurations}, for a list of supported configuration names and
89 notes on many of the configurations. You should check the notes in that
90 section before proceeding any further with the installation of GNU CC@.
95 @node Configurations, Cross-Compiler, , Old
96 @section Configurations Supported by GNU CC
99 <h2>@anchor{Configurations}Configurations Supported by GNU CC</h2>
101 @cindex configurations supported by GNU CC
103 Here are the possible CPU types:
106 @c gmicro, fx80, spur and tahoe omitted since they don't work.
107 1750a, a29k, alpha, arm, avr, c@var{n}, clipper, dsp16xx, elxsi, fr30, h8300,
108 hppa1.0, hppa1.1, i370, i386, i486, i586, i686, i786, i860, i960, ip2k, m32r,
109 m68000, m68k, m6811, m6812, m88k, mcore, mips, mipsel, mips64, mips64el,
110 mn10200, mn10300, ns32k, pdp11, powerpc, powerpcle, romp, rs6000, sh, sparc,
111 sparclite, sparc64, v850, vax, we32k.
114 Here are the recognized company names. As you can see, customary
115 abbreviations are used rather than the longer official names.
117 @c What should be done about merlin, tek*, dolphin?
119 acorn, alliant, altos, apollo, apple, att, bull,
120 cbm, convergent, convex, crds, dec, dg, dolphin,
121 elxsi, encore, harris, hitachi, hp, ibm, intergraph, isi,
122 mips, motorola, ncr, next, ns, omron, plexus,
123 sequent, sgi, sony, sun, tti, unicom, wrs.
126 The company name is meaningful only to disambiguate when the rest of
127 the information supplied is insufficient. You can omit it, writing
128 just @samp{@var{cpu}-@var{system}}, if it is not needed. For example,
129 @samp{vax-ultrix4.2} is equivalent to @samp{vax-dec-ultrix4.2}.
131 Here is a list of system types:
134 386bsd, aix, acis, amigaos, aos, aout, aux, bosx, bsd, clix, coff, ctix, cxux,
135 dgux, dynix, ebmon, ecoff, elf, esix, freebsd, hms, genix, gnu, linux,
136 linux-gnu, hiux, hpux, iris, irix, isc, luna, lynxos, mach, minix, msdos, mvs,
137 netbsd, newsos, nindy, ns, osf, osfrose, ptx, riscix, riscos, rtu, sco, sim,
138 solaris, sunos, sym, sysv, udi, ultrix, unicos, uniplus, unos, vms, vsta,
139 vxworks, winnt, xenix.
143 You can omit the system type; then @file{configure} guesses the
144 operating system from the CPU and company.
146 You can add a version number to the system type; this may or may not
147 make a difference. For example, you can write @samp{bsd4.3} or
148 @samp{bsd4.4} to distinguish versions of BSD@. In practice, the version
149 number is most needed for @samp{sysv3} and @samp{sysv4}, which are often
152 @samp{linux-gnu} is the canonical name for the GNU/Linux target; however
153 GNU CC will also accept @samp{linux}. The version of the kernel in use is
154 not relevant on these systems. A suffix such as @samp{libc1} or @samp{aout}
155 distinguishes major versions of the C library; all of the suffixed versions
158 If you specify an impossible combination such as @samp{i860-dg-vms},
159 then you may get an error message from @file{configure}, or it may
160 ignore part of the information and do the best it can with the rest.
161 @file{configure} always prints the canonical name for the alternative
162 that it used. GNU CC does not support all possible alternatives.
164 Often a particular model of machine has a name. Many machine names are
165 recognized as aliases for CPU/company combinations. Thus, the machine
166 name @samp{sun3}, mentioned above, is an alias for @samp{m68k-sun}.
167 Sometimes we accept a company name as a machine name, when the name is
168 popularly used for a particular machine. Here is a table of the known
172 3300, 3b1, 3b@var{n}, 7300, altos3068, altos,
173 apollo68, att-7300, balance,
174 convex-c@var{n}, crds, decstation-3100,
175 decstation, delta, encore,
176 fx2800, gmicro, hp7@var{nn}, hp8@var{nn},
177 hp9k2@var{nn}, hp9k3@var{nn}, hp9k7@var{nn},
178 hp9k8@var{nn}, iris4d, iris, isi68,
179 m3230, magnum, merlin, miniframe,
180 mmax, news-3600, news800, news, next,
181 pbd, pc532, pmax, powerpc, powerpcle, ps2, risc-news,
182 rtpc, sun2, sun386i, sun386, sun3,
183 sun4, symmetry, tower-32, tower.
187 Remember that a machine name specifies both the cpu type and the company
189 If you want to install your own homemade configuration files, you can
190 use @samp{local} as the company name to access them. If you use
191 configuration @samp{@var{cpu}-local}, the configuration name
192 without the cpu prefix
193 is used to form the configuration file names.
195 Thus, if you specify @samp{m68k-local}, configuration uses
196 files @file{m68k.md}, @file{local.h}, @file{m68k.c},
197 @file{xm-local.h}, @file{t-local}, and @file{x-local}, all in the
198 directory @file{config/m68k}.
200 Here is a list of configurations that have special treatment or special
201 things you must know:
205 See @ref{VMS Install}, for details on how to install GNU CC on VMS@.
209 @node Cross-Compiler, VMS Install, Configurations, Old
210 @section Building and Installing a Cross-Compiler
213 <h2>@anchor{Cross-Compiler}Building and Installing a Cross-Compiler</h2>
215 @cindex cross-compiler, installation
217 GNU CC can function as a cross-compiler for many machines, but not all.
221 Cross-compilers for the Mips as target using the Mips assembler
222 currently do not work, because the auxiliary programs
223 @file{mips-tdump.c} and @file{mips-tfile.c} can't be compiled on
224 anything but a Mips. It does work to cross compile for a Mips
225 if you use the GNU assembler and linker.
228 Cross-compilers between machines with different floating point formats
229 have not all been made to work. GNU CC now has a floating point
230 emulator with which these can work, but each target machine description
231 needs to be updated to take advantage of it.
234 Cross-compilation between machines of different word sizes is
235 somewhat problematic and sometimes does not work.
238 Since GNU CC generates assembler code, you probably need a
239 cross-assembler that GNU CC can run, in order to produce object files.
240 If you want to link on other than the target machine, you need a
241 cross-linker as well. You also need header files and libraries suitable
242 for the target machine that you can install on the host machine.
246 * Steps of Cross:: Using a cross-compiler involves several steps
247 that may be carried out on different machines.
248 * Configure Cross:: Configuring a cross-compiler.
249 * Tools and Libraries:: Where to put the linker and assembler, and the C library.
250 * Cross Headers:: Finding and installing header files
251 for a cross-compiler.
252 * Build Cross:: Actually compiling the cross-compiler.
257 @node Steps of Cross, Configure Cross, , Cross-Compiler
258 @subsection Steps of Cross-Compilation
261 <h2>Steps of Cross-Compilation</h2>
264 To compile and run a program using a cross-compiler involves several
269 Run the cross-compiler on the host machine to produce assembler files
270 for the target machine. This requires header files for the target
274 Assemble the files produced by the cross-compiler. You can do this
275 either with an assembler on the target machine, or with a
276 cross-assembler on the host machine.
279 Link those files to make an executable. You can do this either with a
280 linker on the target machine, or with a cross-linker on the host
281 machine. Whichever machine you use, you need libraries and certain
282 startup files (typically @file{crt@dots{}.o}) for the target machine.
285 It is most convenient to do all of these steps on the same host machine,
286 since then you can do it all with a single invocation of GNU CC@. This
287 requires a suitable cross-assembler and cross-linker. For some targets,
288 the GNU assembler and linker are available.
291 @node Configure Cross, Tools and Libraries, Steps of Cross, Cross-Compiler
292 @subsection Configuring a Cross-Compiler
295 <h2>Configuring a Cross-Compiler</h2>
298 To build GNU CC as a cross-compiler, you start out by running
299 @file{configure}. Use the @option{--target=@var{target}} to specify the
300 target type. If @file{configure} was unable to correctly identify the
301 system you are running on, also specify the @option{--build=@var{build}}
302 option. For example, here is how to configure for a cross-compiler that
303 produces code for an HP 68030 system running BSD on a system that
304 @file{configure} can correctly identify:
307 ./configure --target=m68k-hp-bsd4.3
311 @node Tools and Libraries, Cross Headers, Configure Cross, Cross-Compiler
312 @subsection Tools and Libraries for a Cross-Compiler
315 <h2>Tools and Libraries for a Cross-Compiler</h2>
318 If you have a cross-assembler and cross-linker available, you should
319 install them now. Put them in the directory
320 @file{/usr/local/@var{target}/bin}. Here is a table of the tools
321 you should put in this directory:
325 This should be the cross-assembler.
328 This should be the cross-linker.
331 This should be the cross-archiver: a program which can manipulate
332 archive files (linker libraries) in the target machine's format.
335 This should be a program to construct a symbol table in an archive file.
338 The installation of GNU CC will find these programs in that directory,
339 and copy or link them to the proper place to for the cross-compiler to
340 find them when run later.
342 The easiest way to provide these files is to build the Binutils package
343 and GAS@. Configure them with the same @option{--host} and @option{--target}
344 options that you use for configuring GNU CC, then build and install
345 them. They install their executables automatically into the proper
346 directory. Alas, they do not support all the targets that GNU CC
349 If you want to install libraries to use with the cross-compiler, such as
350 a standard C library, put them in the directory
351 @file{/usr/local/@var{target}/lib}; installation of GNU CC copies
352 all the files in that subdirectory into the proper place for GNU CC to
353 find them and link with them. Here's an example of copying some
354 libraries from a target machine:
357 ftp @var{target-machine}
358 lcd /usr/local/@var{target}/lib
368 The precise set of libraries you'll need, and their locations on
369 the target machine, vary depending on its operating system.
372 Many targets require ``start files'' such as @file{crt0.o} and
373 @file{crtn.o} which are linked into each executable; these too should be
374 placed in @file{/usr/local/@var{target}/lib}. There may be several
375 alternatives for @file{crt0.o}, for use with profiling or other
376 compilation options. Check your target's definition of
377 @code{STARTFILE_SPEC} to find out what start files it uses.
378 Here's an example of copying these files from a target machine:
381 ftp @var{target-machine}
382 lcd /usr/local/@var{target}/lib
392 @node Cross Headers, Build Cross, Tools and Libraries, Cross-Compiler
393 @subsection Cross-Compilers and Header Files
396 <h2>Cross-Compilers and Header Files</h2>
399 If you are cross-compiling a standalone program or a program for an
400 embedded system, then you may not need any header files except the few
401 that are part of GNU CC (and those of your program). However, if you
402 intend to link your program with a standard C library such as
403 @file{libc.a}, then you probably need to compile with the header files
404 that go with the library you use.
406 The GNU C compiler does not come with these files, because (1) they are
407 system-specific, and (2) they belong in a C library, not in a compiler.
409 If the GNU C library supports your target machine, then you can get the
410 header files from there (assuming you actually use the GNU library when
411 you link your program).
413 If your target machine comes with a C compiler, it probably comes with
414 suitable header files also. If you make these files accessible from the host
415 machine, the cross-compiler can use them also.
417 Otherwise, you're on your own in finding header files to use when
420 When you have found suitable header files, you should put them in the
421 directory @file{/usr/local/@var{target}/include}, before building the
422 cross compiler. Then installation will run fixincludes properly and
423 install the corrected versions of the header files where the compiler
426 Provide the header files before you build the cross-compiler, because
427 the build stage actually runs the cross-compiler to produce parts of
428 @file{libgcc.a}. (These are the parts that @emph{can} be compiled with
429 GNU CC@.) Some of them need suitable header files.
431 Here's an example showing how to copy the header files from a target
432 machine. On the target machine, do this:
435 (cd /usr/include; tar cf - .) > tarfile
438 Then, on the host machine, do this:
441 ftp @var{target-machine}
442 lcd /usr/local/@var{target}/include
449 @node Build Cross, , Cross Headers, Cross-Compiler
450 @subsection Actually Building the Cross-Compiler
453 <h2>Actually Building the Cross-Compiler</h2>
456 Now you can proceed just as for compiling a single-machine compiler
457 through the step of building stage 1.
459 Do not try to build stage 2 for a cross-compiler. It doesn't work to
460 rebuild GNU CC as a cross-compiler using the cross-compiler, because
461 that would produce a program that runs on the target machine, not on the
462 host. For example, if you compile a 386-to-68030 cross-compiler with
463 itself, the result will not be right either for the 386 (because it was
464 compiled into 68030 code) or for the 68030 (because it was configured
465 for a 386 as the host). If you want to compile GNU CC into 68030 code,
466 whether you compile it on a 68030 or with a cross-compiler on a 386, you
467 must specify a 68030 as the host when you configure it.
469 To install the cross-compiler, use @samp{make install}, as usual.
472 @node VMS Install, , Cross-Compiler, Old
473 @section Installing GNU CC on VMS
476 <h2>@anchor{VMS Install}Installing GNU CC on VMS</h2>
478 @cindex VMS installation
479 @cindex installing GNU CC on VMS
481 The VMS version of GNU CC is distributed in a backup saveset containing
482 both source code and precompiled binaries.
484 To install the @file{gcc} command so you can use the compiler easily, in
485 the same manner as you use the VMS C compiler, you must install the VMS CLD
486 file for GNU CC as follows:
490 Define the VMS logical names @samp{GNU_CC} and @samp{GNU_CC_INCLUDE}
491 to point to the directories where the GNU CC executables
492 (@file{gcc-cpp.exe}, @file{gcc-cc1.exe}, etc.) and the C include files are
493 kept respectively. This should be done with the commands:
496 $ assign /system /translation=concealed -
498 $ assign /system /translation=concealed -
499 disk:[gcc.include.] gnu_cc_include
503 with the appropriate disk and directory names. These commands can be
504 placed in your system startup file so they will be executed whenever
505 the machine is rebooted. You may, if you choose, do this via the
506 @file{GCC_INSTALL.COM} script in the @file{[GCC]} directory.
509 Install the @file{GCC} command with the command line:
512 $ set command /table=sys$common:[syslib]dcltables -
513 /output=sys$common:[syslib]dcltables gnu_cc:[000000]gcc
514 $ install replace sys$common:[syslib]dcltables
518 To install the help file, do the following:
521 $ library/help sys$library:helplib.hlb gcc.hlp
525 Now you can invoke the compiler with a command like @samp{gcc /verbose
526 file.c}, which is equivalent to the command @samp{gcc -v -c file.c} in
530 If you wish to use GNU C++ you must first install GNU CC, and then
531 perform the following steps:
535 Define the VMS logical name @samp{GNU_GXX_INCLUDE} to point to the
536 directory where the preprocessor will search for the C++ header files.
537 This can be done with the command:
540 $ assign /system /translation=concealed -
541 disk:[gcc.gxx_include.] gnu_gxx_include
545 with the appropriate disk and directory name. If you are going to be
546 using a C++ runtime library, this is where its install procedure will install
550 Obtain the file @file{gcc-cc1plus.exe}, and place this in the same
551 directory that @file{gcc-cc1.exe} is kept.
553 The GNU C++ compiler can be invoked with a command like @samp{gcc /plus
554 /verbose file.cc}, which is equivalent to the command @samp{g++ -v -c
558 We try to put corresponding binaries and sources on the VMS distribution
559 tape. But sometimes the binaries will be from an older version than the
560 sources, because we don't always have time to update them. (Use the
561 @samp{/version} option to determine the version number of the binaries and
562 compare it with the source file @file{version.c} to tell whether this is
563 so.) In this case, you should use the binaries you get to recompile the
564 sources. If you must recompile, here is how:
568 Execute the command procedure @file{vmsconfig.com} to set up the files
569 @file{tm.h}, @file{config.h}, @file{aux-output.c}, and @file{md.}, and
570 to create files @file{tconfig.h} and @file{bconfig.h}. This procedure
571 also creates several linker option files used by @file{make-cc1.com} and
572 a data file used by @file{make-l2.com}.
579 Setup the logical names and command tables as defined above. In
580 addition, define the VMS logical name @samp{GNU_BISON} to point at the
581 to the directories where the Bison executable is kept. This should be
582 done with the command:
585 $ assign /system /translation=concealed -
586 disk:[bison.] gnu_bison
589 You may, if you choose, use the @file{INSTALL_BISON.COM} script in the
590 @file{[BISON]} directory.
593 Install the @samp{BISON} command with the command line:
596 $ set command /table=sys$common:[syslib]dcltables -
597 /output=sys$common:[syslib]dcltables -
598 gnu_bison:[000000]bison
599 $ install replace sys$common:[syslib]dcltables
603 Type @samp{@@make-gcc} to recompile everything, or submit the file
604 @file{make-gcc.com} to a batch queue. If you wish to build the GNU C++
605 compiler as well as the GNU CC compiler, you must first edit
606 @file{make-gcc.com} and follow the instructions that appear in the
610 In order to use GCC, you need a library of functions which GCC compiled code
611 will call to perform certain tasks, and these functions are defined in the
612 file @file{libgcc2.c}. To compile this you should use the command procedure
613 @file{make-l2.com}, which will generate the library @file{libgcc2.olb}.
614 @file{libgcc2.olb} should be built using the compiler built from
615 the same distribution that @file{libgcc2.c} came from, and
616 @file{make-gcc.com} will automatically do all of this for you.
618 To install the library, use the following commands:
621 $ library gnu_cc:[000000]gcclib/delete=(new,eprintf)
622 $ library gnu_cc:[000000]gcclib/delete=L_*
623 $ library libgcc2/extract=*/output=libgcc2.obj
624 $ library gnu_cc:[000000]gcclib libgcc2.obj
627 The first command simply removes old modules that will be replaced with
628 modules from @file{libgcc2} under different module names. The modules
629 @code{new} and @code{eprintf} may not actually be present in your
630 @file{gcclib.olb}---if the VMS librarian complains about those modules
631 not being present, simply ignore the message and continue on with the
632 next command. The second command removes the modules that came from the
633 previous version of the library @file{libgcc2.c}.
635 Whenever you update the compiler on your system, you should also update the
636 library with the above procedure.
639 You may wish to build GCC in such a way that no files are written to the
640 directory where the source files reside. An example would be the when
641 the source files are on a read-only disk. In these cases, execute the
642 following DCL commands (substituting your actual path names):
645 $ assign dua0:[gcc.build_dir.]/translation=concealed, -
646 dua1:[gcc.source_dir.]/translation=concealed gcc_build
647 $ set default gcc_build:[000000]
651 where the directory @file{dua1:[gcc.source_dir]} contains the source
652 code, and the directory @file{dua0:[gcc.build_dir]} is meant to contain
653 all of the generated object files and executables. Once you have done
654 this, you can proceed building GCC as described above. (Keep in mind
655 that @file{gcc_build} is a rooted logical name, and thus the device
656 names in each element of the search list must be an actual physical
657 device name rather than another rooted logical name).
660 @strong{If you are building GNU CC with a previous version of GNU CC,
661 you also should check to see that you have the newest version of the
662 assembler}. In particular, GNU CC version 2 treats global constant
663 variables slightly differently from GNU CC version 1, and GAS version
664 1.38.1 does not have the patches required to work with GCC version 2.
665 If you use GAS 1.38.1, then @code{extern const} variables will not have
666 the read-only bit set, and the linker will generate warning messages
667 about mismatched psect attributes for these variables. These warning
668 messages are merely a nuisance, and can safely be ignored.
671 If you want to build GNU CC with the VAX C compiler, you will need to
672 make minor changes in @file{make-cccp.com} and @file{make-cc1.com}
673 to choose alternate definitions of @code{CC}, @code{CFLAGS}, and
674 @code{LIBS}. See comments in those files. However, you must
675 also have a working version of the GNU assembler (GNU as, aka GAS) as
676 it is used as the back end for GNU CC to produce binary object modules
677 and is not included in the GNU CC sources. GAS is also needed to
678 compile @file{libgcc2} in order to build @file{gcclib} (see above);
679 @file{make-l2.com} expects to be able to find it operational in
680 @file{gnu_cc:[000000]gnu-as.exe}.
682 To use GNU CC on VMS, you need the VMS driver programs
683 @file{gcc.exe}, @file{gcc.com}, and @file{gcc.cld}. They are
684 distributed with the VMS binaries (@file{gcc-vms}) rather than the
685 GNU CC sources. GAS is also included in @file{gcc-vms}, as is Bison.
687 Once you have successfully built GNU CC with VAX C, you should use the
688 resulting compiler to rebuild itself. Before doing this, be sure to
689 restore the @code{CC}, @code{CFLAGS}, and @code{LIBS} definitions in
690 @file{make-cccp.com} and @file{make-cc1.com}. The second generation
691 compiler will be able to take advantage of many optimizations that must
692 be suppressed when building with other compilers.
695 Under previous versions of GNU CC, the generated code would occasionally
696 give strange results when linked with the sharable @file{VAXCRTL} library.
697 Now this should work.
699 Even with this version, however, GNU CC itself should not be linked with
700 the sharable @file{VAXCRTL}. The version of @code{qsort} in
701 @file{VAXCRTL} has a bug (known to be present in VMS versions V4.6
702 through V5.5) which causes the compiler to fail.
704 The executables are generated by @file{make-cc1.com} and
705 @file{make-cccp.com} use the object library version of @file{VAXCRTL} in
706 order to make use of the @code{qsort} routine in @file{gcclib.olb}. If
707 you wish to link the compiler executables with the shareable image
708 version of @file{VAXCRTL}, you should edit the file @file{tm.h} (created
709 by @file{vmsconfig.com}) to define the macro @code{QSORT_WORKAROUND}.
711 @code{QSORT_WORKAROUND} is always defined when GNU CC is compiled with
712 VAX C, to avoid a problem in case @file{gcclib.olb} is not yet