source: trunk/third/gcc/INSTALL @ 8834

Revision 8834, 82.4 KB checked in by ghudson, 28 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r8833, which included commits to RCS files with non-trunk default branches.
Line 
1This file documents the installation of the GNU compiler.  Copyright
2(C) 1988, 1989, 1992, 1994, 1995 Free Software Foundation, Inc.  You
3may copy, distribute, and modify it freely as long as you preserve this
4copyright notice and permission notice.
5
6Installing GNU CC
7*****************
8
9   Here is the procedure for installing GNU CC on a Unix system.  See
10*Note VMS Install::, for VMS systems.  In this section we assume you
11compile in the same directory that contains the source files; see *Note
12Other Dir::, to find out how to compile in a separate directory on Unix
13systems.
14
15   You cannot install GNU C by itself on MSDOS; it will not compile
16under any MSDOS compiler except itself.  You need to get the complete
17compilation package DJGPP, which includes binaries as well as sources,
18and includes all the necessary compilation tools and libraries.
19
20  1. If you have built GNU CC previously in the same directory for a
21     different target machine, do `make distclean' to delete all files
22     that might be invalid.  One of the files this deletes is
23     `Makefile'; if `make distclean' complains that `Makefile' does not
24     exist, it probably means that the directory is already suitably
25     clean.
26
27  2. On a System V release 4 system, make sure `/usr/bin' precedes
28     `/usr/ucb' in `PATH'.  The `cc' command in `/usr/ucb' uses
29     libraries which have bugs.
30
31  3. Specify the host, build and target machine configurations.  You do
32     this by running the file `configure'.
33
34     The "build" machine is the system which you are using, the "host"
35     machine is the system where you want to run the resulting compiler
36     (normally the build machine), and the "target" machine is the
37     system for which you want the compiler to generate code.
38
39     If you are building a compiler to produce code for the machine it
40     runs on (a native compiler), you normally do not need to specify
41     any operands to `configure'; it will try to guess the type of
42     machine you are on and use that as the build, host and target
43     machines.  So you don't need to specify a configuration when
44     building a native compiler unless `configure' cannot figure out
45     what your configuration is or guesses wrong.
46
47     In those cases, specify the build machine's "configuration name"
48     with the `--build' option; the host and target will default to be
49     the same as the build machine.  (If you are building a
50     cross-compiler, see *Note Cross-Compiler::.)
51
52     Here is an example:
53
54          ./configure --build=sparc-sun-sunos4.1
55
56     A configuration name may be canonical or it may be more or less
57     abbreviated.
58
59     A canonical configuration name has three parts, separated by
60     dashes.  It looks like this: `CPU-COMPANY-SYSTEM'.  (The three
61     parts may themselves contain dashes; `configure' can figure out
62     which dashes serve which purpose.)  For example,
63     `m68k-sun-sunos4.1' specifies a Sun 3.
64
65     You can also replace parts of the configuration by nicknames or
66     aliases.  For example, `sun3' stands for `m68k-sun', so
67     `sun3-sunos4.1' is another way to specify a Sun 3.  You can also
68     use simply `sun3-sunos', since the version of SunOS is assumed by
69     default to be version 4.  `sun3-bsd' also works, since `configure'
70     knows that the only BSD variant on a Sun 3 is SunOS.
71
72     You can specify a version number after any of the system types,
73     and some of the CPU types.  In most cases, the version is
74     irrelevant, and will be ignored.  So you might as well specify the
75     version if you know it.
76
77     See *Note Configurations::, for a list of supported configuration
78     names and notes on many of the configurations.  You should check
79     the notes in that section before proceeding any further with the
80     installation of GNU CC.
81
82     There are four additional options you can specify independently to
83     describe variant hardware and software configurations.  These are
84     `--with-gnu-as', `--with-gnu-ld', `--with-stabs' and `--nfp'.
85
86    `--with-gnu-as'
87          If you will use GNU CC with the GNU assembler (GAS), you
88          should declare this by using the `--with-gnu-as' option when
89          you run `configure'.
90
91          Using this option does not install GAS.  It only modifies the
92          output of GNU CC to work with GAS.  Building and installing
93          GAS is up to you.
94
95          Conversely, if you *do not* wish to use GAS and do not specify
96          `--with-gnu-as' when building GNU CC, it is up to you to make
97          sure that GAS is not installed.  GNU CC searches for a
98          program named `as' in various directories; if the program it
99          finds is GAS, then it runs GAS.  If you are not sure where
100          GNU CC finds the assembler it is using, try specifying `-v'
101          when you run it.
102
103          The systems where it makes a difference whether you use GAS
104          are
105          `hppa1.0-ANY-ANY', `hppa1.1-ANY-ANY', `i386-ANY-sysv',
106          `i386-ANY-isc',
107          `i860-ANY-bsd', `m68k-bull-sysv', `m68k-hp-hpux',
108          `m68k-sony-bsd',
109          `m68k-altos-sysv', `m68000-hp-hpux', `m68000-att-sysv',
110          `ANY-lynx-lynxos', and `mips-ANY').  On any other system,
111          `--with-gnu-as' has no effect.
112
113          On the systems listed above (except for the HP-PA, for ISC on
114          the 386, and for `mips-sgi-irix5.*'), if you use GAS, you
115          should also use the GNU linker (and specify `--with-gnu-ld').
116
117    `--with-gnu-ld'
118          Specify the option `--with-gnu-ld' if you plan to use the GNU
119          linker with GNU CC.
120
121          This option does not cause the GNU linker to be installed; it
122          just modifies the behavior of GNU CC to work with the GNU
123          linker.  Specifically, it inhibits the installation of
124          `collect2', a program which otherwise serves as a front-end
125          for the system's linker on most configurations.
126
127    `--with-stabs'
128          On MIPS based systems and on Alphas, you must specify whether
129          you want GNU CC to create the normal ECOFF debugging format,
130          or to use BSD-style stabs passed through the ECOFF symbol
131          table.  The normal ECOFF debug format cannot fully handle
132          languages other than C.  BSD stabs format can handle other
133          languages, but it only works with the GNU debugger GDB.
134
135          Normally, GNU CC uses the ECOFF debugging format by default;
136          if you prefer BSD stabs, specify `--with-stabs' when you
137          configure GNU CC.
138
139          No matter which default you choose when you configure GNU CC,
140          the user can use the `-gcoff' and `-gstabs+' options to
141          specify explicitly the debug format for a particular
142          compilation.
143
144          `--with-stabs' is meaningful on the ISC system on the 386,
145          also, if `--with-gas' is used.  It selects use of stabs
146          debugging information embedded in COFF output.  This kind of
147          debugging information supports C++ well; ordinary COFF
148          debugging information does not.
149
150          `--with-stabs' is also meaningful on 386 systems running
151          SVR4.  It selects use of stabs debugging information embedded
152          in ELF output.  The C++ compiler currently (2.6.0) does not
153          support the DWARF debugging information normally used on 386
154          SVR4 platforms; stabs provide a workable alternative.  This
155          requires gas and gdb, as the normal SVR4 tools can not
156          generate or interpret stabs.
157
158    `--nfp'
159          On certain systems, you must specify whether the machine has
160          a floating point unit.  These systems include
161          `m68k-sun-sunosN' and `m68k-isi-bsd'.  On any other system,
162          `--nfp' currently has no effect, though perhaps there are
163          other systems where it could usefully make a difference.
164
165     The `configure' script searches subdirectories of the source
166     directory for other compilers that are to be integrated into GNU
167     CC.  The GNU compiler for C++, called G++ is in a subdirectory
168     named `cp'.  `configure' inserts rules into `Makefile' to build
169     all of those compilers.
170
171     Here we spell out what files will be set up by `configure'.
172     Normally you need not be concerned with these files.
173
174        * A file named `config.h' is created that contains a `#include'
175          of the top-level config file for the machine you will run the
176          compiler on (*note The Configuration File:
177          (gcc.info)Config.).  This file is responsible for defining
178          information about the host machine.  It includes `tm.h'.
179
180          The top-level config file is located in the subdirectory
181          `config'.  Its name is always `xm-SOMETHING.h'; usually
182          `xm-MACHINE.h', but there are some exceptions.
183
184          If your system does not support symbolic links, you might
185          want to set up `config.h' to contain a `#include' command
186          which refers to the appropriate file.
187
188        * A file named `tconfig.h' is created which includes the
189          top-level config file for your target machine.  This is used
190          for compiling certain programs to run on that machine.
191
192        * A file named `tm.h' is created which includes the
193          machine-description macro file for your target machine.  It
194          should be in the subdirectory `config' and its name is often
195          `MACHINE.h'.
196
197        * The command file `configure' also constructs the file
198          `Makefile' by adding some text to the template file
199          `Makefile.in'.  The additional text comes from files in the
200          `config' directory, named `t-TARGET' and `x-HOST'.  If these
201          files do not exist, it means nothing needs to be added for a
202          given target or host.
203
204  4. The standard directory for installing GNU CC is `/usr/local/lib'.
205     If you want to install its files somewhere else, specify
206     `--prefix=DIR' when you run `configure'.  Here DIR is a directory
207     name to use instead of `/usr/local' for all purposes with one
208     exception: the directory `/usr/local/include' is searched for
209     header files no matter where you install the compiler.  To override
210     this name, use the `--local-prefix' option below.
211
212  5. Specify `--local-prefix=DIR' if you want the compiler to search
213     directory `DIR/include' for locally installed header files
214     *instead* of `/usr/local/include'.
215
216     You should specify `--local-prefix' *only* if your site has a
217     different convention (not `/usr/local') for where to put
218     site-specific files.
219
220     *Do not* specify `/usr' as the `--local-prefix'!  The directory
221     you use for `--local-prefix' *must not* contain any of the
222     system's standard header files.  If it did contain them, certain
223     programs would be miscompiled (including GNU Emacs, on certain
224     targets), because this would override and nullify the header file
225     corrections made by the `fixincludes' script.
226
227  6. Make sure the Bison parser generator is installed.  (This is
228     unnecessary if the Bison output files `c-parse.c' and `cexp.c' are
229     more recent than `c-parse.y' and `cexp.y' and you do not plan to
230     change the `.y' files.)
231
232     Bison versions older than Sept 8, 1988 will produce incorrect
233     output for `c-parse.c'.
234
235  7. If you have chosen a configuration for GNU CC which requires other
236     GNU tools (such as GAS or the GNU linker) instead of the standard
237     system tools, install the required tools in the build directory
238     under the names `as', `ld' or whatever is appropriate.  This will
239     enable the compiler to find the proper tools for compilation of
240     the program `enquire'.
241
242     Alternatively, you can do subsequent compilation using a value of
243     the `PATH' environment variable such that the necessary GNU tools
244     come before the standard system tools.
245
246  8. Build the compiler.  Just type `make LANGUAGES=c' in the compiler
247     directory.
248
249     `LANGUAGES=c' specifies that only the C compiler should be
250     compiled.  The makefile normally builds compilers for all the
251     supported languages; currently, C, C++ and Objective C.  However,
252     C is the only language that is sure to work when you build with
253     other non-GNU C compilers.  In addition, building anything but C
254     at this stage is a waste of time.
255
256     In general, you can specify the languages to build by typing the
257     argument `LANGUAGES="LIST"', where LIST is one or more words from
258     the list `c', `c++', and `objective-c'.  If you have any
259     additional GNU compilers as subdirectories of the GNU CC source
260     directory, you may also specify their names in this list.
261
262     Ignore any warnings you may see about "statement not reached" in
263     `insn-emit.c'; they are normal.  Also, warnings about "unknown
264     escape sequence" are normal in `genopinit.c' and perhaps some
265     other files.  Likewise, you should ignore warnings about "constant
266     is so large that it is unsigned" in `insn-emit.c' and
267     `insn-recog.c' and a warning about a comparison always being zero
268     in `enquire.o'.  Any other compilation errors may represent bugs in
269     the port to your machine or operating system, and should be
270     investigated and reported.
271
272     Some commercial compilers fail to compile GNU CC because they have
273     bugs or limitations.  For example, the Microsoft compiler is said
274     to run out of macro space.  Some Ultrix compilers run out of
275     expression space; then you need to break up the statement where
276     the problem happens.
277
278  9. If you are building a cross-compiler, stop here.  *Note
279     Cross-Compiler::.
280
281 10. Move the first-stage object files and executables into a
282     subdirectory with this command:
283
284          make stage1
285
286     The files are moved into a subdirectory named `stage1'.  Once
287     installation is complete, you may wish to delete these files with
288     `rm -r stage1'.
289
290 11. If you have chosen a configuration for GNU CC which requires other
291     GNU tools (such as GAS or the GNU linker) instead of the standard
292     system tools, install the required tools in the `stage1'
293     subdirectory under the names `as', `ld' or whatever is
294     appropriate.  This will enable the stage 1 compiler to find the
295     proper tools in the following stage.
296
297     Alternatively, you can do subsequent compilation using a value of
298     the `PATH' environment variable such that the necessary GNU tools
299     come before the standard system tools.
300
301 12. Recompile the compiler with itself, with this command:
302
303          make CC="stage1/xgcc -Bstage1/" CFLAGS="-g -O2"
304
305     This is called making the stage 2 compiler.
306
307     The command shown above builds compilers for all the supported
308     languages.  If you don't want them all, you can specify the
309     languages to build by typing the argument `LANGUAGES="LIST"'.  LIST
310     should contain one or more words from the list `c', `c++',
311     `objective-c', and `proto'.  Separate the words with spaces.
312     `proto' stands for the programs `protoize' and `unprotoize'; they
313     are not a separate language, but you use `LANGUAGES' to enable or
314     disable their installation.
315
316     If you are going to build the stage 3 compiler, then you might
317     want to build only the C language in stage 2.
318
319     Once you have built the stage 2 compiler, if you are short of disk
320     space, you can delete the subdirectory `stage1'.
321
322     On a 68000 or 68020 system lacking floating point hardware, unless
323     you have selected a `tm.h' file that expects by default that there
324     is no such hardware, do this instead:
325
326          make CC="stage1/xgcc -Bstage1/" CFLAGS="-g -O2 -msoft-float"
327
328 13. If you wish to test the compiler by compiling it with itself one
329     more time, install any other necessary GNU tools (such as GAS or
330     the GNU linker) in the `stage2' subdirectory as you did in the
331     `stage1' subdirectory, then do this:
332
333          make stage2
334          make CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O2"
335
336     This is called making the stage 3 compiler.  Aside from the `-B'
337     option, the compiler options should be the same as when you made
338     the stage 2 compiler.  But the `LANGUAGES' option need not be the
339     same.  The command shown above builds compilers for all the
340     supported languages; if you don't want them all, you can specify
341     the languages to build by typing the argument `LANGUAGES="LIST"',
342     as described above.
343
344     If you do not have to install any additional GNU tools, you may
345     use the command
346
347          make bootstrap LANGUAGES=LANGUAGE-LIST BOOT_CFLAGS=OPTION-LIST
348
349     instead of making `stage1', `stage2', and performing the two
350     compiler builds.
351
352 14. Then compare the latest object files with the stage 2 object
353     files--they ought to be identical, aside from time stamps (if any).
354
355     On some systems, meaningful comparison of object files is
356     impossible; they always appear "different."  This is currently
357     true on Solaris and some systems that use ELF object file format.
358     On some versions of Irix on SGI machines and DEC Unix (OSF/1) on
359     Alpha systems, you will not be able to compare the files without
360     specifying `-save-temps'; see the description of individual
361     systems above to see if you get comparison failures.  You may have
362     similar problems on other systems.
363
364     Use this command to compare the files:
365
366          make compare
367
368     This will mention any object files that differ between stage 2 and
369     stage 3.  Any difference, no matter how innocuous, indicates that
370     the stage 2 compiler has compiled GNU CC incorrectly, and is
371     therefore a potentially serious bug which you should investigate
372     and report.
373
374     If your system does not put time stamps in the object files, then
375     this is a faster way to compare them (using the Bourne shell):
376
377          for file in *.o; do
378          cmp $file stage2/$file
379          done
380
381     If you have built the compiler with the `-mno-mips-tfile' option on
382     MIPS machines, you will not be able to compare the files.
383
384 15. Install the compiler driver, the compiler's passes and run-time
385     support with `make install'.  Use the same value for `CC',
386     `CFLAGS' and `LANGUAGES' that you used when compiling the files
387     that are being installed.  One reason this is necessary is that
388     some versions of Make have bugs and recompile files gratuitously
389     when you do this step.  If you use the same variable values, those
390     files will be recompiled properly.
391
392     For example, if you have built the stage 2 compiler, you can use
393     the following command:
394
395          make install CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O" LANGUAGES="LIST"
396
397     This copies the files `cc1', `cpp' and `libgcc.a' to files `cc1',
398     `cpp' and `libgcc.a' in the directory
399     `/usr/local/lib/gcc-lib/TARGET/VERSION', which is where the
400     compiler driver program looks for them.  Here TARGET is the target
401     machine type specified when you ran `configure', and VERSION is
402     the version number of GNU CC.  This naming scheme permits various
403     versions and/or cross-compilers to coexist.
404
405     This also copies the driver program `xgcc' into
406     `/usr/local/bin/gcc', so that it appears in typical execution
407     search paths.
408
409     On some systems, this command causes recompilation of some files.
410     This is usually due to bugs in `make'.  You should either ignore
411     this problem, or use GNU Make.
412
413     *Warning: there is a bug in `alloca' in the Sun library.  To avoid
414     this bug, be sure to install the executables of GNU CC that were
415     compiled by GNU CC.  (That is, the executables from stage 2 or 3,
416     not stage 1.)  They use `alloca' as a built-in function and never
417     the one in the library.*
418
419     (It is usually better to install GNU CC executables from stage 2
420     or 3, since they usually run faster than the ones compiled with
421     some other compiler.)
422
423 16. If you're going to use C++, it's likely that you need to also
424     install the libg++ distribution.  It should be available from the
425     same place where you got the GNU C distribution.  Just as GNU C
426     does not distribute a C runtime library, it also does not include
427     a C++ run-time library.  All I/O functionality, special class
428     libraries, etc., are available in the libg++ distribution.
429
430Configurations Supported by GNU CC
431==================================
432
433   Here are the possible CPU types:
434
435     1750a, a29k, alpha, arm, cN, clipper, dsp16xx, elxsi, h8300,
436     hppa1.0, hppa1.1, i370, i386, i486, i586, i860, i960, m68000, m68k,
437     m88k, mips, mipsel, mips64, mips64el, ns32k, powerpc, powerpcle,
438     pyramid, romp, rs6000, sh, sparc, sparclite, sparc64, vax, we32k.
439
440   Here are the recognized company names.  As you can see, customary
441abbreviations are used rather than the longer official names.
442
443     acorn, alliant, altos, apollo, att, bull, cbm, convergent, convex,
444     crds, dec, dg, dolphin, elxsi, encore, harris, hitachi, hp, ibm,
445     intergraph, isi, mips, motorola, ncr, next, ns, omron, plexus,
446     sequent, sgi, sony, sun, tti, unicom, wrs.
447
448   The company name is meaningful only to disambiguate when the rest of
449the information supplied is insufficient.  You can omit it, writing
450just `CPU-SYSTEM', if it is not needed.  For example, `vax-ultrix4.2'
451is equivalent to `vax-dec-ultrix4.2'.
452
453   Here is a list of system types:
454
455     386bsd, aix, acis, amigados, aos, aout, bosx, bsd, clix, coff,
456     ctix, cxux, dgux, dynix, ebmon, ecoff, elf, esix, freebsd, hms,
457     genix, gnu, gnu/linux, hiux, hpux, iris, irix, isc, luna, lynxos,
458     mach, minix, msdos, mvs, netbsd, newsos, nindy, ns, osf, osfrose,
459     ptx, riscix, riscos, rtu, sco, sim, solaris, sunos, sym, sysv,
460     udi, ultrix, unicos, uniplus, unos, vms, vsta, vxworks, winnt,
461     xenix.
462
463You can omit the system type; then `configure' guesses the operating
464system from the CPU and company.
465
466   You can add a version number to the system type; this may or may not
467make a difference.  For example, you can write `bsd4.3' or `bsd4.4' to
468distinguish versions of BSD.  In practice, the version number is most
469needed for `sysv3' and `sysv4', which are often treated differently.
470
471   If you specify an impossible combination such as `i860-dg-vms', then
472you may get an error message from `configure', or it may ignore part of
473the information and do the best it can with the rest.  `configure'
474always prints the canonical name for the alternative that it used.  GNU
475CC does not support all possible alternatives.
476
477   Often a particular model of machine has a name.  Many machine names
478are recognized as aliases for CPU/company combinations.  Thus, the
479machine name `sun3', mentioned above, is an alias for `m68k-sun'.
480Sometimes we accept a company name as a machine name, when the name is
481popularly used for a particular machine.  Here is a table of the known
482machine names:
483
484     3300, 3b1, 3bN, 7300, altos3068, altos, apollo68, att-7300,
485     balance, convex-cN, crds, decstation-3100, decstation, delta,
486     encore, fx2800, gmicro, hp7NN, hp8NN, hp9k2NN, hp9k3NN, hp9k7NN,
487     hp9k8NN, iris4d, iris, isi68, m3230, magnum, merlin, miniframe,
488     mmax, news-3600, news800, news, next, pbd, pc532, pmax, powerpc,
489     powerpcle, ps2, risc-news, rtpc, sun2, sun386i, sun386, sun3,
490     sun4, symmetry, tower-32, tower.
491
492Remember that a machine name specifies both the cpu type and the company
493name.  If you want to install your own homemade configuration files,
494you can use `local' as the company name to access them.  If you use
495configuration `CPU-local', the configuration name without the cpu prefix
496is used to form the configuration file names.
497
498   Thus, if you specify `m68k-local', configuration uses files
499`m68k.md', `local.h', `m68k.c', `xm-local.h', `t-local', and `x-local',
500all in the directory `config/m68k'.
501
502   Here is a list of configurations that have special treatment or
503special things you must know:
504
505`1750a-*-*'
506     MIL-STD-1750A processors.
507
508     Starting with GCC 2.6.1, the MIL-STD-1750A cross configuration no
509     longer supports the Tektronix Assembler, but instead produces
510     output for `as1750', an assembler/linker available under the GNU
511     Public License for the 1750A. Contact *kellogg@space.otn.dasa.de*
512     for more details on obtaining `as1750'.  A similarly licensed
513     simulator for the 1750A is available from same address.
514
515     You should ignore a fatal error during the building of libgcc
516     (libgcc is not yet implemented for the 1750A.)
517
518     The `as1750' assembler requires the file `ms1750.inc', which is
519     found in the directory `config/1750a'.
520
521     GNU CC produced the same sections as the Fairchild F9450 C
522     Compiler, namely:
523
524    `Normal'
525          The program code section.
526
527    `Static'
528          The read/write (RAM) data section.
529
530    `Konst'
531          The read-only (ROM) constants section.
532
533    `Init'
534          Initialization section (code to copy KREL to SREL).
535
536     The smallest addressable unit is 16 bits (BITS_PER_UNIT is 16).
537     This means that type `char' is represented with a 16-bit word per
538     character.  The 1750A's "Load/Store Upper/Lower Byte" instructions
539     are not used by GNU CC.
540
541`alpha-*-osf1'
542     Systems using processors that implement the DEC Alpha architecture
543     and are running the DEC Unix (OSF/1) operating system, for example
544     the DEC Alpha AXP systems.  (VMS on the Alpha is not currently
545     supported by GNU CC.)
546
547     GNU CC writes a `.verstamp' directive to the assembler output file
548     unless it is built as a cross-compiler.  It gets the version to
549     use from the system header file `/usr/include/stamp.h'.  If you
550     install a new version of DEC Unix, you should rebuild GCC to pick
551     up the new version stamp.
552
553     Note that since the Alpha is a 64-bit architecture,
554     cross-compilers from 32-bit machines will not generate code as
555     efficient as that generated when the compiler is running on a
556     64-bit machine because many optimizations that depend on being
557     able to represent a word on the target in an integral value on the
558     host cannot be performed.  Building cross-compilers on the Alpha
559     for 32-bit machines has only been tested in a few cases and may
560     not work properly.
561
562     `make compare' may fail on old versions of DEC Unix unless you add
563     `-save-temps' to `CFLAGS'.  On these systems, the name of the
564     assembler input file is stored in the object file, and that makes
565     comparison fail if it differs between the `stage1' and `stage2'
566     compilations.  The option `-save-temps' forces a fixed name to be
567     used for the assembler input file, instead of a randomly chosen
568     name in `/tmp'.  Do not add `-save-temps' unless the comparisons
569     fail without that option.  If you add `-save-temps', you will have
570     to manually delete the `.i' and `.s' files after each series of
571     compilations.
572
573     GNU CC now supports both the native (ECOFF) debugging format used
574     by DBX and GDB and an encapsulated STABS format for use only with
575     GDB.  See the discussion of the `--with-stabs' option of
576     `configure' above for more information on these formats and how to
577     select them.
578
579     There is a bug in DEC's assembler that produces incorrect line
580     numbers for ECOFF format when the `.align' directive is used.  To
581     work around this problem, GNU CC will not emit such alignment
582     directives while writing ECOFF format debugging information even
583     if optimization is being performed.  Unfortunately, this has the
584     very undesirable side-effect that code addresses when `-O' is
585     specified are different depending on whether or not `-g' is also
586     specified.
587
588     To avoid this behavior, specify `-gstabs+' and use GDB instead of
589     DBX.  DEC is now aware of this problem with the assembler and
590     hopes to provide a fix shortly.
591
592`arm'
593     Advanced RISC Machines ARM-family processors.  These are often
594     used in embedded applications.  There are no standard Unix
595     configurations.  This configuration corresponds to the basic
596     instruction sequences and will produce a.out format object modules.
597
598     You may need to make a variant of the file `arm.h' for your
599     particular configuration.
600
601`arm-*-riscix'
602     The ARM2 or ARM3 processor running RISC iX, Acorn's port of BSD
603     Unix.  If you are running a version of RISC iX prior to 1.2 then
604     you must specify the version number during configuration.  Note
605     that the assembler shipped with RISC iX does not support stabs
606     debugging information; a new version of the assembler, with stabs
607     support included, is now available from Acorn.
608
609`a29k'
610     AMD Am29k-family processors.  These are normally used in embedded
611     applications.  There are no standard Unix configurations.  This
612     configuration corresponds to AMD's standard calling sequence and
613     binary interface and is compatible with other 29k tools.
614
615     You may need to make a variant of the file `a29k.h' for your
616     particular configuration.
617
618`a29k-*-bsd'
619     AMD Am29050 used in a system running a variant of BSD Unix.
620
621`decstation-*'
622     DECstations can support three different personalities: Ultrix, DEC
623     OSF/1, and OSF/rose.  To configure GCC for these platforms use the
624     following configurations:
625
626    `decstation-ultrix'
627          Ultrix configuration.
628
629    `decstation-osf1'
630          Dec's version of OSF/1.
631
632    `decstation-osfrose'
633          Open Software Foundation reference port of OSF/1 which uses
634          the OSF/rose object file format instead of ECOFF.  Normally,
635          you would not select this configuration.
636
637     The MIPS C compiler needs to be told to increase its table size
638     for switch statements with the `-Wf,-XNg1500' option in order to
639     compile `cp/parse.c'.  If you use the `-O2' optimization option,
640     you also need to use `-Olimit 3000'.  Both of these options are
641     automatically generated in the `Makefile' that the shell script
642     `configure' builds.  If you override the `CC' make variable and
643     use the MIPS compilers, you may need to add `-Wf,-XNg1500 -Olimit
644     3000'.
645
646`elxsi-elxsi-bsd'
647     The Elxsi's C compiler has known limitations that prevent it from
648     compiling GNU C.  Please contact `mrs@cygnus.com' for more details.
649
650`dsp16xx'
651     A port to the AT&T DSP1610 family of processors.
652
653`h8300-*-*'
654     The calling convention and structure layout has changed in release
655     2.6.  All code must be recompiled.  The calling convention now
656     passes the first three arguments in function calls in registers.
657     Structures are no longer a multiple of 2 bytes.
658
659`hppa*-*-*'
660     There are several variants of the HP-PA processor which run a
661     variety of operating systems.  GNU CC must be configured to use
662     the correct processor type and operating system, or GNU CC will
663     not function correctly.  The easiest way to handle this problem is
664     to *not* specify a target when configuring GNU CC, the `configure'
665     script will try to automatically determine the right processor
666     type and operating system.
667
668     `-g' does not work on HP-UX, since that system uses a peculiar
669     debugging format which GNU CC does not know about.  However, `-g'
670     will work if you also use GAS and GDB in conjunction with GCC.  We
671     highly recommend using GAS for all HP-PA configurations.
672
673     You should be using GAS-2.6 (or later) along with GDB-4.16 (or
674     later).  These can be retrieved from all the traditional GNU ftp
675     archive sites.
676
677     GAS will need to be installed into a directory before `/bin',
678     `/usr/bin', and `/usr/ccs/bin' in your search path.  You should
679     install GAS before you build GNU CC.
680
681     To enable debugging, you must configure GNU CC with the
682     `--with-gnu-as' option before building.
683
684`i370-*-*'
685     This port is very preliminary and has many known bugs.  We hope to
686     have a higher-quality port for this machine soon.
687
688`i386-*-linuxoldld'
689     Use this configuration to generate a.out binaries on Linux-based
690     GNU systems, if you do not have gas/binutils version 2.5.2 or later
691     installed.  This is an obsolete configuration.
692
693`i386-*-linuxaout'
694     Use this configuration to generate a.out binaries on Linux-based
695     GNU systems.  This configuration is being superseded.  You must use
696     gas/binutils version 2.5.2 or later.
697
698`i386-*-linux'
699     Use this configuration to generate ELF binaries on Linux-based GNU
700     systems.  You must use gas/binutils version 2.5.2 or later.
701
702`i386-*-sco'
703     Compilation with RCC is recommended.  Also, it may be a good idea
704     to link with GNU malloc instead of the malloc that comes with the
705     system.
706
707`i386-*-sco3.2v4'
708     Use this configuration for SCO release 3.2 version 4.
709
710`i386-*-isc'
711     It may be a good idea to link with GNU malloc instead of the
712     malloc that comes with the system.
713
714     In ISC version 4.1, `sed' core dumps when building `deduced.h'.
715     Use the version of `sed' from version 4.0.
716
717`i386-*-esix'
718     It may be good idea to link with GNU malloc instead of the malloc
719     that comes with the system.
720
721`i386-ibm-aix'
722     You need to use GAS version 2.1 or later, and and LD from GNU
723     binutils version 2.2 or later.
724
725`i386-sequent-bsd'
726     Go to the Berkeley universe before compiling.  In addition, you
727     probably need to create a file named `string.h' containing just
728     one line: `#include <strings.h>'.
729
730`i386-sequent-ptx1*'
731     Sequent DYNIX/ptx 1.x.
732
733`i386-sequent-ptx2*'
734     Sequent DYNIX/ptx 2.x.
735
736`i386-sun-sunos4'
737     You may find that you need another version of GNU CC to begin
738     bootstrapping with, since the current version when built with the
739     system's own compiler seems to get an infinite loop compiling part
740     of `libgcc2.c'.  GNU CC version 2 compiled with GNU CC (any
741     version) seems not to have this problem.
742
743     See *Note Sun Install::, for information on installing GNU CC on
744     Sun systems.
745
746`i[345]86-*-winnt3.5'
747     This version requires a GAS that has not let been released.  Until
748     it is, you can get a prebuilt binary version via anonymous ftp from
749     `cs.washington.edu:pub/gnat' or `cs.nyu.edu:pub/gnat'. You must
750     also use the Microsoft header files from the Windows NT 3.5 SDK.
751     Find these on the CDROM in the `/mstools/h' directory dated
752     9/4/94.  You must use a fixed version of Microsoft linker made
753     especially for NT 3.5, which is also is available on the NT 3.5
754     SDK CDROM.  If you do not have this linker, can you also use the
755     linker from Visual C/C++ 1.0 or 2.0.
756
757     Installing GNU CC for NT builds a wrapper linker, called `ld.exe',
758     which mimics the behaviour of Unix `ld' in the specification of
759     libraries (`-L' and `-l').  `ld.exe' looks for both Unix and
760     Microsoft named libraries.  For example, if you specify `-lfoo',
761     `ld.exe' will look first for `libfoo.a' and then for `foo.lib'.
762
763     You may install GNU CC for Windows NT in one of two ways,
764     depending on whether or not you have a Unix-like shell and various
765     Unix-like utilities.
766
767       1. If you do not have a Unix-like shell and few Unix-like
768          utilities, you will use a DOS style batch script called
769          `configure.bat'.  Invoke it as `configure winnt' from an
770          MSDOS console window or from the program manager dialog box.
771          `configure.bat' assumes you have already installed and have
772          in your path a Unix-like `sed' program which is used to
773          create a working `Makefile' from `Makefile.in'.
774
775          `Makefile' uses the Microsoft Nmake program maintenance
776          utility and the Visual C/C++ V8.00 compiler to build GNU CC.
777          You need only have the utilities `sed' and `touch' to use
778          this installation method, which only automatically builds the
779          compiler itself.  You must then examine what `fixinc.winnt'
780          does, edit the header files by hand and build `libgcc.a'
781          manually.
782
783       2. The second type of installation assumes you are running a
784          Unix-like shell, have a complete suite of Unix-like utilities
785          in your path, and have a previous version of GNU CC already
786          installed, either through building it via the above
787          installation method or acquiring a pre-built binary.  In this
788          case, use the `configure' script in the normal fashion.
789
790`i860-intel-osf1'
791     This is the Paragon.  If you have version 1.0 of the operating
792     system, you need to take special steps to build GNU CC due to
793     peculiarities of the system.  Newer system versions have no
794     problem.  See the section `Installation Problems' in the GNU CC
795     Manual.
796
797`*-lynx-lynxos'
798     LynxOS 2.2 and earlier comes with GNU CC 1.x already installed as
799     `/bin/gcc'.  You should compile with this instead of `/bin/cc'.
800     You can tell GNU CC to use the GNU assembler and linker, by
801     specifying `--with-gnu-as --with-gnu-ld' when configuring.  These
802     will produce COFF format object files and executables;  otherwise
803     GNU CC will use the installed tools, which produce a.out format
804     executables.
805
806`m68000-hp-bsd'
807     HP 9000 series 200 running BSD.  Note that the C compiler that
808     comes with this system cannot compile GNU CC; contact
809     `law@cs.utah.edu' to get binaries of GNU CC for bootstrapping.
810
811`m68k-altos'
812     Altos 3068.  You must use the GNU assembler, linker and debugger.
813     Also, you must fix a kernel bug.  Details in the file
814     `README.ALTOS'.
815
816`m68k-att-sysv'
817     AT&T 3b1, a.k.a. 7300 PC.  Special procedures are needed to
818     compile GNU CC with this machine's standard C compiler, due to
819     bugs in that compiler.  You can bootstrap it more easily with
820     previous versions of GNU CC if you have them.
821
822     Installing GNU CC on the 3b1 is difficult if you do not already
823     have GNU CC running, due to bugs in the installed C compiler.
824     However, the following procedure might work.  We are unable to
825     test it.
826
827       1. Comment out the `#include "config.h"' line on line 37 of
828          `cccp.c' and do `make cpp'.  This makes a preliminary version
829          of GNU cpp.
830
831       2. Save the old `/lib/cpp' and copy the preliminary GNU cpp to
832          that file name.
833
834       3. Undo your change in `cccp.c', or reinstall the original
835          version, and do `make cpp' again.
836
837       4. Copy this final version of GNU cpp into `/lib/cpp'.
838
839       5. Replace every occurrence of `obstack_free' in the file
840          `tree.c' with `_obstack_free'.
841
842       6. Run `make' to get the first-stage GNU CC.
843
844       7. Reinstall the original version of `/lib/cpp'.
845
846       8. Now you can compile GNU CC with itself and install it in the
847          normal fashion.
848
849`m68k-bull-sysv'
850     Bull DPX/2 series 200 and 300 with BOS-2.00.45 up to BOS-2.01. GNU
851     CC works either with native assembler or GNU assembler. You can use
852     GNU assembler with native coff generation by providing
853     `--with-gnu-as' to the configure script or use GNU assembler with
854     dbx-in-coff encapsulation by providing `--with-gnu-as --stabs'.
855     For any problem with native assembler or for availability of the
856     DPX/2 port of GAS, contact `F.Pierresteguy@frcl.bull.fr'.
857
858`m68k-crds-unox'
859     Use `configure unos' for building on Unos.
860
861     The Unos assembler is named `casm' instead of `as'.  For some
862     strange reason linking `/bin/as' to `/bin/casm' changes the
863     behavior, and does not work.  So, when installing GNU CC, you
864     should install the following script as `as' in the subdirectory
865     where the passes of GCC are installed:
866
867          #!/bin/sh
868          casm $*
869
870     The default Unos library is named `libunos.a' instead of `libc.a'.
871     To allow GNU CC to function, either change all references to
872     `-lc' in `gcc.c' to `-lunos' or link `/lib/libc.a' to
873     `/lib/libunos.a'.
874
875     When compiling GNU CC with the standard compiler, to overcome bugs
876     in the support of `alloca', do not use `-O' when making stage 2.
877     Then use the stage 2 compiler with `-O' to make the stage 3
878     compiler.  This compiler will have the same characteristics as the
879     usual stage 2 compiler on other systems.  Use it to make a stage 4
880     compiler and compare that with stage 3 to verify proper
881     compilation.
882
883     (Perhaps simply defining `ALLOCA' in `x-crds' as described in the
884     comments there will make the above paragraph superfluous.  Please
885     inform us of whether this works.)
886
887     Unos uses memory segmentation instead of demand paging, so you
888     will need a lot of memory.  5 Mb is barely enough if no other
889     tasks are running.  If linking `cc1' fails, try putting the object
890     files into a library and linking from that library.
891
892`m68k-hp-hpux'
893     HP 9000 series 300 or 400 running HP-UX.  HP-UX version 8.0 has a
894     bug in the assembler that prevents compilation of GNU CC.  To fix
895     it, get patch PHCO_4484 from HP.
896
897     In addition, if you wish to use gas `--with-gnu-as' you must use
898     gas version 2.1 or later, and you must use the GNU linker version
899     2.1 or later.  Earlier versions of gas relied upon a program which
900     converted the gas output into the native HP/UX format, but that
901     program has not been kept up to date.  gdb does not understand
902     that native HP/UX format, so you must use gas if you wish to use
903     gdb.
904
905`m68k-sun'
906     Sun 3.  We do not provide a configuration file to use the Sun FPA
907     by default, because programs that establish signal handlers for
908     floating point traps inherently cannot work with the FPA.
909
910     See *Note Sun Install::, for information on installing GNU CC on
911     Sun systems.
912
913`m88k-*-svr3'
914     Motorola m88k running the AT&T/Unisoft/Motorola V.3 reference port.
915     These systems tend to use the Green Hills C, revision 1.8.5, as the
916     standard C compiler.  There are apparently bugs in this compiler
917     that result in object files differences between stage 2 and stage
918     3.  If this happens, make the stage 4 compiler and compare it to
919     the stage 3 compiler.  If the stage 3 and stage 4 object files are
920     identical, this suggests you encountered a problem with the
921     standard C compiler; the stage 3 and 4 compilers may be usable.
922
923     It is best, however, to use an older version of GNU CC for
924     bootstrapping if you have one.
925
926`m88k-*-dgux'
927     Motorola m88k running DG/UX.  To build 88open BCS native or cross
928     compilers on DG/UX, specify the configuration name as
929     `m88k-*-dguxbcs' and build in the 88open BCS software development
930     environment.  To build ELF native or cross compilers on DG/UX,
931     specify `m88k-*-dgux' and build in the DG/UX ELF development
932     environment.  You set the software development environment by
933     issuing `sde-target' command and specifying either `m88kbcs' or
934     `m88kdguxelf' as the operand.
935
936     If you do not specify a configuration name, `configure' guesses the
937     configuration based on the current software development
938     environment.
939
940`m88k-tektronix-sysv3'
941     Tektronix XD88 running UTekV 3.2e.  Do not turn on optimization
942     while building stage1 if you bootstrap with the buggy Green Hills
943     compiler.  Also, The bundled LAI System V NFS is buggy so if you
944     build in an NFS mounted directory, start from a fresh reboot, or
945     avoid NFS all together.  Otherwise you may have trouble getting
946     clean comparisons between stages.
947
948`mips-mips-bsd'
949     MIPS machines running the MIPS operating system in BSD mode.  It's
950     possible that some old versions of the system lack the functions
951     `memcpy', `memcmp', and `memset'.  If your system lacks these, you
952     must remove or undo the definition of `TARGET_MEM_FUNCTIONS' in
953     `mips-bsd.h'.
954
955     The MIPS C compiler needs to be told to increase its table size
956     for switch statements with the `-Wf,-XNg1500' option in order to
957     compile `cp/parse.c'.  If you use the `-O2' optimization option,
958     you also need to use `-Olimit 3000'.  Both of these options are
959     automatically generated in the `Makefile' that the shell script
960     `configure' builds.  If you override the `CC' make variable and
961     use the MIPS compilers, you may need to add `-Wf,-XNg1500 -Olimit
962     3000'.
963
964`mips-mips-riscos*'
965     The MIPS C compiler needs to be told to increase its table size
966     for switch statements with the `-Wf,-XNg1500' option in order to
967     compile `cp/parse.c'.  If you use the `-O2' optimization option,
968     you also need to use `-Olimit 3000'.  Both of these options are
969     automatically generated in the `Makefile' that the shell script
970     `configure' builds.  If you override the `CC' make variable and
971     use the MIPS compilers, you may need to add `-Wf,-XNg1500 -Olimit
972     3000'.
973
974     MIPS computers running RISC-OS can support four different
975     personalities: default, BSD 4.3, System V.3, and System V.4 (older
976     versions of RISC-OS don't support V.4).  To configure GCC for
977     these platforms use the following configurations:
978
979    `mips-mips-riscos`rev''
980          Default configuration for RISC-OS, revision `rev'.
981
982    `mips-mips-riscos`rev'bsd'
983          BSD 4.3 configuration for RISC-OS, revision `rev'.
984
985    `mips-mips-riscos`rev'sysv4'
986          System V.4 configuration for RISC-OS, revision `rev'.
987
988    `mips-mips-riscos`rev'sysv'
989          System V.3 configuration for RISC-OS, revision `rev'.
990
991     The revision `rev' mentioned above is the revision of RISC-OS to
992     use.  You must reconfigure GCC when going from a RISC-OS revision
993     4 to RISC-OS revision 5.  This has the effect of avoiding a linker
994     bug.
995
996`mips-sgi-*'
997     In order to compile GCC on an SGI running IRIX 4, the "c.hdr.lib"
998     option must be installed from the CD-ROM supplied from Silicon
999     Graphics.  This is found on the 2nd CD in release 4.0.1.
1000
1001     In order to compile GCC on an SGI running IRIX 5, the
1002     "compiler_dev.hdr" subsystem must be installed from the IDO CD-ROM
1003     supplied by Silicon Graphics.
1004
1005     `make compare' may fail on version 5 of IRIX unless you add
1006     `-save-temps' to `CFLAGS'.  On these systems, the name of the
1007     assembler input file is stored in the object file, and that makes
1008     comparison fail if it differs between the `stage1' and `stage2'
1009     compilations.  The option `-save-temps' forces a fixed name to be
1010     used for the assembler input file, instead of a randomly chosen
1011     name in `/tmp'.  Do not add `-save-temps' unless the comparisons
1012     fail without that option.  If you do you `-save-temps', you will
1013     have to manually delete the `.i' and `.s' files after each series
1014     of compilations.
1015
1016     The MIPS C compiler needs to be told to increase its table size
1017     for switch statements with the `-Wf,-XNg1500' option in order to
1018     compile `cp/parse.c'.  If you use the `-O2' optimization option,
1019     you also need to use `-Olimit 3000'.  Both of these options are
1020     automatically generated in the `Makefile' that the shell script
1021     `configure' builds.  If you override the `CC' make variable and
1022     use the MIPS compilers, you may need to add `-Wf,-XNg1500 -Olimit
1023     3000'.
1024
1025     On Irix version 4.0.5F, and perhaps on some other versions as well,
1026     there is an assembler bug that reorders instructions incorrectly.
1027     To work around it, specify the target configuration
1028     `mips-sgi-irix4loser'.  This configuration inhibits assembler
1029     optimization.
1030
1031     In a compiler configured with target `mips-sgi-irix4', you can turn
1032     off assembler optimization by using the `-noasmopt' option.  This
1033     compiler option passes the option `-O0' to the assembler, to
1034     inhibit reordering.
1035
1036     The `-noasmopt' option can be useful for testing whether a problem
1037     is due to erroneous assembler reordering.  Even if a problem does
1038     not go away with `-noasmopt', it may still be due to assembler
1039     reordering--perhaps GNU CC itself was miscompiled as a result.
1040
1041     To enable debugging under Irix 5, you must use GNU as 2.5 or later,
1042     and use the `--with-gnu-as' configure option when configuring gcc.
1043     GNU as is distributed as part of the binutils package.
1044
1045`mips-sony-sysv'
1046     Sony MIPS NEWS.  This works in NEWSOS 5.0.1, but not in 5.0.2
1047     (which uses ELF instead of COFF).  Support for 5.0.2 will probably
1048     be provided soon by volunteers.  In particular, the linker does
1049     not like the code generated by GCC when shared libraries are
1050     linked in.
1051
1052`ns32k-encore'
1053     Encore ns32000 system.  Encore systems are supported only under
1054     BSD.
1055
1056`ns32k-*-genix'
1057     National Semiconductor ns32000 system.  Genix has bugs in `alloca'
1058     and `malloc'; you must get the compiled versions of these from GNU
1059     Emacs.
1060
1061`ns32k-sequent'
1062     Go to the Berkeley universe before compiling.  In addition, you
1063     probably need to create a file named `string.h' containing just
1064     one line: `#include <strings.h>'.
1065
1066`ns32k-utek'
1067     UTEK ns32000 system ("merlin").  The C compiler that comes with
1068     this system cannot compile GNU CC; contact `tektronix!reed!mason'
1069     to get binaries of GNU CC for bootstrapping.
1070
1071`romp-*-aos'
1072`romp-*-mach'
1073     The only operating systems supported for the IBM RT PC are AOS and
1074     MACH.  GNU CC does not support AIX running on the RT.  We
1075     recommend you compile GNU CC with an earlier version of itself; if
1076     you compile GNU CC with `hc', the Metaware compiler, it will work,
1077     but you will get mismatches between the stage 2 and stage 3
1078     compilers in various files.  These errors are minor differences in
1079     some floating-point constants and can be safely ignored; the stage
1080     3 compiler is correct.
1081
1082`rs6000-*-aix'
1083`powerpc-*-aix'
1084     Various early versions of each release of the IBM XLC compiler
1085     will not bootstrap GNU CC.  Symptoms include differences between
1086     the stage2 and stage3 object files, and errors when compiling
1087     `libgcc.a' or `enquire'.  Known problematic releases include:
1088     xlc-1.2.1.8, xlc-1.3.0.0 (distributed with AIX 3.2.5), and
1089     xlc-1.3.0.19.  Both xlc-1.2.1.28 and xlc-1.3.0.24 (PTF 432238) are
1090     known to produce working versions of GNU CC, but most other recent
1091     releases correctly bootstrap GNU CC.  Also, releases of AIX prior
1092     to AIX 3.2.4 include a version of the IBM assembler which does not
1093     accept debugging directives: assembler updates are available as
1094     PTFs.  Also, if you are using AIX 3.2.5 or greater and the GNU
1095     assembler, you must have a version modified after October 16th,
1096     1995 in order for the GNU C compiler to build.  See the file
1097     `README.RS6000' for more details on of these problems.
1098
1099     GNU CC does not yet support the 64-bit PowerPC instructions.
1100
1101     Objective C does not work on this architecture because it makes
1102     assumptions that are incompatible with the calling conventions.
1103
1104     AIX on the RS/6000 provides support (NLS) for environments outside
1105     of the United States.  Compilers and assemblers use NLS to support
1106     locale-specific representations of various objects including
1107     floating-point numbers ("." vs "," for separating decimal
1108     fractions).  There have been problems reported where the library
1109     linked with GNU CC does not produce the same floating-point
1110     formats that the assembler accepts.  If you have this problem, set
1111     the LANG environment variable to "C" or "En_US".
1112
1113     Due to changes in the way that GNU CC invokes the binder (linker)
1114     for AIX 4.1, you may now receive warnings of duplicate symbols
1115     from the link step that were not reported before.  The assembly
1116     files generated by GNU CC for AIX have always included multiple
1117     symbol definitions for certain global variable and function
1118     declarations in the original program.  The warnings should not
1119     prevent the linker from producing a correct library or runnable
1120     executable.
1121
1122`powerpc-*-elf'
1123`powerpc-*-sysv4'
1124     PowerPC system in big endian mode, running System V.4.
1125
1126     This configuration is currently under development.
1127
1128`powerpc-*-eabiaix'
1129     Embedded PowerPC system in big endian mode with -mcall-aix
1130     selected as the default.  This system is currently under
1131     development.
1132
1133`powerpc-*-eabisim'
1134     Embedded PowerPC system in big endian mode for use in running
1135     under the PSIM simulator.  This system is currently under
1136     development.
1137
1138`powerpc-*-eabi'
1139     Embedded PowerPC system in big endian mode.
1140
1141     This configuration is currently under development.
1142
1143`powerpcle-*-elf'
1144`powerpcle-*-sysv4'
1145     PowerPC system in little endian mode, running System V.4.
1146
1147     This configuration is currently under development.
1148
1149`powerpcle-*-sysv4'
1150     Embedded PowerPC system in little endian mode.
1151
1152     This system is currently under development.
1153
1154`powerpcle-*-eabisim'
1155     Embedded PowerPC system in little endian mode for use in running
1156     under the PSIM simulator.
1157
1158     This system is currently under development.
1159
1160`powerpcle-*-eabi'
1161     Embedded PowerPC system in little endian mode.
1162
1163     This configuration is currently under development.
1164
1165`vax-dec-ultrix'
1166     Don't try compiling with Vax C (`vcc').  It produces incorrect code
1167     in some cases (for example, when `alloca' is used).
1168
1169     Meanwhile, compiling `cp/parse.c' with pcc does not work because of
1170     an internal table size limitation in that compiler.  To avoid this
1171     problem, compile just the GNU C compiler first, and use it to
1172     recompile building all the languages that you want to run.
1173
1174`sparc-sun-*'
1175     See *Note Sun Install::, for information on installing GNU CC on
1176     Sun systems.
1177
1178`vax-dec-vms'
1179     See *Note VMS Install::, for details on how to install GNU CC on
1180     VMS.
1181
1182`we32k-*-*'
1183     These computers are also known as the 3b2, 3b5, 3b20 and other
1184     similar names.  (However, the 3b1 is actually a 68000; see *Note
1185     Configurations::.)
1186
1187     Don't use `-g' when compiling with the system's compiler.  The
1188     system's linker seems to be unable to handle such a large program
1189     with debugging information.
1190
1191     The system's compiler runs out of capacity when compiling `stmt.c'
1192     in GNU CC.  You can work around this by building `cpp' in GNU CC
1193     first, then use that instead of the system's preprocessor with the
1194     system's C compiler to compile `stmt.c'.  Here is how:
1195
1196          mv /lib/cpp /lib/cpp.att
1197          cp cpp /lib/cpp.gnu
1198          echo '/lib/cpp.gnu -traditional ${1+"$@"}' > /lib/cpp
1199          chmod +x /lib/cpp
1200
1201     The system's compiler produces bad code for some of the GNU CC
1202     optimization files.  So you must build the stage 2 compiler without
1203     optimization.  Then build a stage 3 compiler with optimization.
1204     That executable should work.  Here are the necessary commands:
1205
1206          make LANGUAGES=c CC=stage1/xgcc CFLAGS="-Bstage1/ -g"
1207          make stage2
1208          make CC=stage2/xgcc CFLAGS="-Bstage2/ -g -O"
1209
1210     You may need to raise the ULIMIT setting to build a C++ compiler,
1211     as the file `cc1plus' is larger than one megabyte.
1212
1213Compilation in a Separate Directory
1214===================================
1215
1216   If you wish to build the object files and executables in a directory
1217other than the one containing the source files, here is what you must
1218do differently:
1219
1220  1. Make sure you have a version of Make that supports the `VPATH'
1221     feature.  (GNU Make supports it, as do Make versions on most BSD
1222     systems.)
1223
1224  2. If you have ever run `configure' in the source directory, you must
1225     undo the configuration.  Do this by running:
1226
1227          make distclean
1228
1229  3. Go to the directory in which you want to build the compiler before
1230     running `configure':
1231
1232          mkdir gcc-sun3
1233          cd gcc-sun3
1234
1235     On systems that do not support symbolic links, this directory must
1236     be on the same file system as the source code directory.
1237
1238  4. Specify where to find `configure' when you run it:
1239
1240          ../gcc/configure ...
1241
1242     This also tells `configure' where to find the compiler sources;
1243     `configure' takes the directory from the file name that was used to
1244     invoke it.  But if you want to be sure, you can specify the source
1245     directory with the `--srcdir' option, like this:
1246
1247          ../gcc/configure --srcdir=../gcc OTHER OPTIONS
1248
1249     The directory you specify with `--srcdir' need not be the same as
1250     the one that `configure' is found in.
1251
1252   Now, you can run `make' in that directory.  You need not repeat the
1253configuration steps shown above, when ordinary source files change.  You
1254must, however, run `configure' again when the configuration files
1255change, if your system does not support symbolic links.
1256
1257Building and Installing a Cross-Compiler
1258========================================
1259
1260   GNU CC can function as a cross-compiler for many machines, but not
1261all.
1262
1263   * Cross-compilers for the Mips as target using the Mips assembler
1264     currently do not work, because the auxiliary programs
1265     `mips-tdump.c' and `mips-tfile.c' can't be compiled on anything
1266     but a Mips.  It does work to cross compile for a Mips if you use
1267     the GNU assembler and linker.
1268
1269   * Cross-compilers between machines with different floating point
1270     formats have not all been made to work.  GNU CC now has a floating
1271     point emulator with which these can work, but each target machine
1272     description needs to be updated to take advantage of it.
1273
1274   * Cross-compilation between machines of different word sizes is
1275     somewhat problematic and sometimes does not work.
1276
1277   Since GNU CC generates assembler code, you probably need a
1278cross-assembler that GNU CC can run, in order to produce object files.
1279If you want to link on other than the target machine, you need a
1280cross-linker as well.  You also need header files and libraries suitable
1281for the target machine that you can install on the host machine.
1282
1283Steps of Cross-Compilation
1284--------------------------
1285
1286   To compile and run a program using a cross-compiler involves several
1287steps:
1288
1289   * Run the cross-compiler on the host machine to produce assembler
1290     files for the target machine.  This requires header files for the
1291     target machine.
1292
1293   * Assemble the files produced by the cross-compiler.  You can do this
1294     either with an assembler on the target machine, or with a
1295     cross-assembler on the host machine.
1296
1297   * Link those files to make an executable.  You can do this either
1298     with a linker on the target machine, or with a cross-linker on the
1299     host machine.  Whichever machine you use, you need libraries and
1300     certain startup files (typically `crt....o') for the target
1301     machine.
1302
1303   It is most convenient to do all of these steps on the same host
1304machine, since then you can do it all with a single invocation of GNU
1305CC.  This requires a suitable cross-assembler and cross-linker.  For
1306some targets, the GNU assembler and linker are available.
1307
1308Configuring a Cross-Compiler
1309----------------------------
1310
1311   To build GNU CC as a cross-compiler, you start out by running
1312`configure'.  Use the `--target=TARGET' to specify the target type.  If
1313`configure' was unable to correctly identify the system you are running
1314on, also specify the `--build=BUILD' option.  For example, here is how
1315to configure for a cross-compiler that produces code for an HP 68030
1316system running BSD on a system that `configure' can correctly identify:
1317
1318     ./configure --target=m68k-hp-bsd4.3
1319
1320Tools and Libraries for a Cross-Compiler
1321----------------------------------------
1322
1323   If you have a cross-assembler and cross-linker available, you should
1324install them now.  Put them in the directory `/usr/local/TARGET/bin'.
1325Here is a table of the tools you should put in this directory:
1326
1327`as'
1328     This should be the cross-assembler.
1329
1330`ld'
1331     This should be the cross-linker.
1332
1333`ar'
1334     This should be the cross-archiver: a program which can manipulate
1335     archive files (linker libraries) in the target machine's format.
1336
1337`ranlib'
1338     This should be a program to construct a symbol table in an archive
1339     file.
1340
1341   The installation of GNU CC will find these programs in that
1342directory, and copy or link them to the proper place to for the
1343cross-compiler to find them when run later.
1344
1345   The easiest way to provide these files is to build the Binutils
1346package and GAS.  Configure them with the same `--host' and `--target'
1347options that you use for configuring GNU CC, then build and install
1348them.  They install their executables automatically into the proper
1349directory.  Alas, they do not support all the targets that GNU CC
1350supports.
1351
1352   If you want to install libraries to use with the cross-compiler,
1353such as a standard C library, put them in the directory
1354`/usr/local/TARGET/lib'; installation of GNU CC copies all all the
1355files in that subdirectory into the proper place for GNU CC to find
1356them and link with them.  Here's an example of copying some libraries
1357from a target machine:
1358
1359     ftp TARGET-MACHINE
1360     lcd /usr/local/TARGET/lib
1361     cd /lib
1362     get libc.a
1363     cd /usr/lib
1364     get libg.a
1365     get libm.a
1366     quit
1367
1368The precise set of libraries you'll need, and their locations on the
1369target machine, vary depending on its operating system.
1370
1371   Many targets require "start files" such as `crt0.o' and `crtn.o'
1372which are linked into each executable; these too should be placed in
1373`/usr/local/TARGET/lib'.  There may be several alternatives for
1374`crt0.o', for use with profiling or other compilation options.  Check
1375your target's definition of `STARTFILE_SPEC' to find out what start
1376files it uses.  Here's an example of copying these files from a target
1377machine:
1378
1379     ftp TARGET-MACHINE
1380     lcd /usr/local/TARGET/lib
1381     prompt
1382     cd /lib
1383     mget *crt*.o
1384     cd /usr/lib
1385     mget *crt*.o
1386     quit
1387
1388`libgcc.a' and Cross-Compilers
1389------------------------------
1390
1391   Code compiled by GNU CC uses certain runtime support functions
1392implicitly.  Some of these functions can be compiled successfully with
1393GNU CC itself, but a few cannot be.  These problem functions are in the
1394source file `libgcc1.c'; the library made from them is called
1395`libgcc1.a'.
1396
1397   When you build a native compiler, these functions are compiled with
1398some other compiler-the one that you use for bootstrapping GNU CC.
1399Presumably it knows how to open code these operations, or else knows how
1400to call the run-time emulation facilities that the machine comes with.
1401But this approach doesn't work for building a cross-compiler.  The
1402compiler that you use for building knows about the host system, not the
1403target system.
1404
1405   So, when you build a cross-compiler you have to supply a suitable
1406library `libgcc1.a' that does the job it is expected to do.
1407
1408   To compile `libgcc1.c' with the cross-compiler itself does not work.
1409The functions in this file are supposed to implement arithmetic
1410operations that GNU CC does not know how to open code for your target
1411machine.  If these functions are compiled with GNU CC itself, they will
1412compile into infinite recursion.
1413
1414   On any given target, most of these functions are not needed.  If GNU
1415CC can open code an arithmetic operation, it will not call these
1416functions to perform the operation.  It is possible that on your target
1417machine, none of these functions is needed.  If so, you can supply an
1418empty library as `libgcc1.a'.
1419
1420   Many targets need library support only for multiplication and
1421division.  If you are linking with a library that contains functions for
1422multiplication and division, you can tell GNU CC to call them directly
1423by defining the macros `MULSI3_LIBCALL', and the like.  These macros
1424need to be defined in the target description macro file.  For some
1425targets, they are defined already.  This may be sufficient to avoid the
1426need for libgcc1.a; if so, you can supply an empty library.
1427
1428   Some targets do not have floating point instructions; they need other
1429functions in `libgcc1.a', which do floating arithmetic.  Recent
1430versions of GNU CC have a file which emulates floating point.  With a
1431certain amount of work, you should be able to construct a floating
1432point emulator that can be used as `libgcc1.a'.  Perhaps future
1433versions will contain code to do this automatically and conveniently.
1434That depends on whether someone wants to implement it.
1435
1436   Some embedded targets come with all the necessary `libgcc1.a'
1437routines written in C or assembler.  These targets build `libgcc1.a'
1438automatically and you do not need to do anything special for them.
1439Other embedded targets do not need any `libgcc1.a' routines since all
1440the necessary operations are supported by the hardware.
1441
1442   If your target system has another C compiler, you can configure GNU
1443CC as a native compiler on that machine, build just `libgcc1.a' with
1444`make libgcc1.a' on that machine, and use the resulting file with the
1445cross-compiler.  To do this, execute the following on the target
1446machine:
1447
1448     cd TARGET-BUILD-DIR
1449     ./configure --host=sparc --target=sun3
1450     make libgcc1.a
1451
1452And then this on the host machine:
1453
1454     ftp TARGET-MACHINE
1455     binary
1456     cd TARGET-BUILD-DIR
1457     get libgcc1.a
1458     quit
1459
1460   Another way to provide the functions you need in `libgcc1.a' is to
1461define the appropriate `perform_...' macros for those functions.  If
1462these definitions do not use the C arithmetic operators that they are
1463meant to implement, you should be able to compile them with the
1464cross-compiler you are building.  (If these definitions already exist
1465for your target file, then you are all set.)
1466
1467   To build `libgcc1.a' using the perform macros, use
1468`LIBGCC1=libgcc1.a OLDCC=./xgcc' when building the compiler.
1469Otherwise, you should place your replacement library under the name
1470`libgcc1.a' in the directory in which you will build the
1471cross-compiler, before you run `make'.
1472
1473Cross-Compilers and Header Files
1474--------------------------------
1475
1476   If you are cross-compiling a standalone program or a program for an
1477embedded system, then you may not need any header files except the few
1478that are part of GNU CC (and those of your program).  However, if you
1479intend to link your program with a standard C library such as `libc.a',
1480then you probably need to compile with the header files that go with
1481the library you use.
1482
1483   The GNU C compiler does not come with these files, because (1) they
1484are system-specific, and (2) they belong in a C library, not in a
1485compiler.
1486
1487   If the GNU C library supports your target machine, then you can get
1488the header files from there (assuming you actually use the GNU library
1489when you link your program).
1490
1491   If your target machine comes with a C compiler, it probably comes
1492with suitable header files also.  If you make these files accessible
1493from the host machine, the cross-compiler can use them also.
1494
1495   Otherwise, you're on your own in finding header files to use when
1496cross-compiling.
1497
1498   When you have found suitable header files, put them in
1499`/usr/local/TARGET/include', before building the cross compiler.  Then
1500installation will run fixincludes properly and install the corrected
1501versions of the header files where the compiler will use them.
1502
1503   Provide the header files before you build the cross-compiler, because
1504the build stage actually runs the cross-compiler to produce parts of
1505`libgcc.a'.  (These are the parts that *can* be compiled with GNU CC.)
1506Some of them need suitable header files.
1507
1508   Here's an example showing how to copy the header files from a target
1509machine.  On the target machine, do this:
1510
1511     (cd /usr/include; tar cf - .) > tarfile
1512
1513   Then, on the host machine, do this:
1514
1515     ftp TARGET-MACHINE
1516     lcd /usr/local/TARGET/include
1517     get tarfile
1518     quit
1519     tar xf tarfile
1520
1521Actually Building the Cross-Compiler
1522------------------------------------
1523
1524   Now you can proceed just as for compiling a single-machine compiler
1525through the step of building stage 1.  If you have not provided some
1526sort of `libgcc1.a', then compilation will give up at the point where
1527it needs that file, printing a suitable error message.  If you do
1528provide `libgcc1.a', then building the compiler will automatically
1529compile and link a test program called `libgcc1-test'; if you get
1530errors in the linking, it means that not all of the necessary routines
1531in `libgcc1.a' are available.
1532
1533   You must provide the header file `float.h'.  One way to do this is
1534to compile `enquire' and run it on your target machine.  The job of
1535`enquire' is to run on the target machine and figure out by experiment
1536the nature of its floating point representation.  `enquire' records its
1537findings in the header file `float.h'.  If you can't produce this file
1538by running `enquire' on the target machine, then you will need to come
1539up with a suitable `float.h' in some other way (or else, avoid using it
1540in your programs).
1541
1542   Do not try to build stage 2 for a cross-compiler.  It doesn't work to
1543rebuild GNU CC as a cross-compiler using the cross-compiler, because
1544that would produce a program that runs on the target machine, not on the
1545host.  For example, if you compile a 386-to-68030 cross-compiler with
1546itself, the result will not be right either for the 386 (because it was
1547compiled into 68030 code) or for the 68030 (because it was configured
1548for a 386 as the host).  If you want to compile GNU CC into 68030 code,
1549whether you compile it on a 68030 or with a cross-compiler on a 386, you
1550must specify a 68030 as the host when you configure it.
1551
1552   To install the cross-compiler, use `make install', as usual.
1553
1554Installing GNU CC on the Sun
1555============================
1556
1557   On Solaris (version 2.1), do not use the linker or other tools in
1558`/usr/ucb' to build GNU CC.  Use `/usr/ccs/bin'.
1559
1560   Make sure the environment variable `FLOAT_OPTION' is not set when
1561you compile `libgcc.a'.  If this option were set to `f68881' when
1562`libgcc.a' is compiled, the resulting code would demand to be linked
1563with a special startup file and would not link properly without special
1564pains.
1565
1566   There is a bug in `alloca' in certain versions of the Sun library.
1567To avoid this bug, install the binaries of GNU CC that were compiled by
1568GNU CC.  They use `alloca' as a built-in function and never the one in
1569the library.
1570
1571   Some versions of the Sun compiler crash when compiling GNU CC.  The
1572problem is a segmentation fault in cpp.  This problem seems to be due to
1573the bulk of data in the environment variables.  You may be able to avoid
1574it by using the following command to compile GNU CC with Sun CC:
1575
1576     make CC="TERMCAP=x OBJS=x LIBFUNCS=x STAGESTUFF=x cc"
1577
1578Installing GNU CC on VMS
1579========================
1580
1581   The VMS version of GNU CC is distributed in a backup saveset
1582containing both source code and precompiled binaries.
1583
1584   To install the `gcc' command so you can use the compiler easily, in
1585the same manner as you use the VMS C compiler, you must install the VMS
1586CLD file for GNU CC as follows:
1587
1588  1. Define the VMS logical names `GNU_CC' and `GNU_CC_INCLUDE' to
1589     point to the directories where the GNU CC executables
1590     (`gcc-cpp.exe', `gcc-cc1.exe', etc.) and the C include files are
1591     kept respectively.  This should be done with the commands:
1592
1593          $ assign /system /translation=concealed -
1594            disk:[gcc.] gnu_cc
1595          $ assign /system /translation=concealed -
1596            disk:[gcc.include.] gnu_cc_include
1597
1598     with the appropriate disk and directory names.  These commands can
1599     be placed in your system startup file so they will be executed
1600     whenever the machine is rebooted.  You may, if you choose, do this
1601     via the `GCC_INSTALL.COM' script in the `[GCC]' directory.
1602
1603  2. Install the `GCC' command with the command line:
1604
1605          $ set command /table=sys$common:[syslib]dcltables -
1606            /output=sys$common:[syslib]dcltables gnu_cc:[000000]gcc
1607          $ install replace sys$common:[syslib]dcltables
1608
1609  3. To install the help file, do the following:
1610
1611          $ library/help sys$library:helplib.hlb gcc.hlp
1612
1613     Now you can invoke the compiler with a command like `gcc /verbose
1614     file.c', which is equivalent to the command `gcc -v -c file.c' in
1615     Unix.
1616
1617   If you wish to use GNU C++ you must first install GNU CC, and then
1618perform the following steps:
1619
1620  1. Define the VMS logical name `GNU_GXX_INCLUDE' to point to the
1621     directory where the preprocessor will search for the C++ header
1622     files.  This can be done with the command:
1623
1624          $ assign /system /translation=concealed -
1625            disk:[gcc.gxx_include.] gnu_gxx_include
1626
1627     with the appropriate disk and directory name.  If you are going to
1628     be using libg++, this is where the libg++ install procedure will
1629     install the libg++ header files.
1630
1631  2. Obtain the file `gcc-cc1plus.exe', and place this in the same
1632     directory that `gcc-cc1.exe' is kept.
1633
1634     The GNU C++ compiler can be invoked with a command like `gcc /plus
1635     /verbose file.cc', which is equivalent to the command `g++ -v -c
1636     file.cc' in Unix.
1637
1638   We try to put corresponding binaries and sources on the VMS
1639distribution tape.  But sometimes the binaries will be from an older
1640version than the sources, because we don't always have time to update
1641them.  (Use the `/version' option to determine the version number of
1642the binaries and compare it with the source file `version.c' to tell
1643whether this is so.)  In this case, you should use the binaries you get
1644to recompile the sources.  If you must recompile, here is how:
1645
1646  1. Execute the command procedure `vmsconfig.com' to set up the files
1647     `tm.h', `config.h', `aux-output.c', and `md.', and to create files
1648     `tconfig.h' and `hconfig.h'.  This procedure also creates several
1649     linker option files used by `make-cc1.com' and a data file used by
1650     `make-l2.com'.
1651
1652          $ @vmsconfig.com
1653
1654  2. Setup the logical names and command tables as defined above.  In
1655     addition, define the VMS logical name `GNU_BISON' to point at the
1656     to the directories where the Bison executable is kept.  This
1657     should be done with the command:
1658
1659          $ assign /system /translation=concealed -
1660            disk:[bison.] gnu_bison
1661
1662     You may, if you choose, use the `INSTALL_BISON.COM' script in the
1663     `[BISON]' directory.
1664
1665  3. Install the `BISON' command with the command line:
1666
1667          $ set command /table=sys$common:[syslib]dcltables -
1668            /output=sys$common:[syslib]dcltables -
1669            gnu_bison:[000000]bison
1670          $ install replace sys$common:[syslib]dcltables
1671
1672  4. Type `@make-gcc' to recompile everything (alternatively, submit
1673     the file `make-gcc.com' to a batch queue).  If you wish to build
1674     the GNU C++ compiler as well as the GNU CC compiler, you must
1675     first edit `make-gcc.com' and follow the instructions that appear
1676     in the comments.
1677
1678  5. In order to use GCC, you need a library of functions which GCC
1679     compiled code will call to perform certain tasks, and these
1680     functions are defined in the file `libgcc2.c'.  To compile this
1681     you should use the command procedure `make-l2.com', which will
1682     generate the library `libgcc2.olb'.  `libgcc2.olb' should be built
1683     using the compiler built from the same distribution that
1684     `libgcc2.c' came from, and `make-gcc.com' will automatically do
1685     all of this for you.
1686
1687     To install the library, use the following commands:
1688
1689          $ library gnu_cc:[000000]gcclib/delete=(new,eprintf)
1690          $ library gnu_cc:[000000]gcclib/delete=L_*
1691          $ library libgcc2/extract=*/output=libgcc2.obj
1692          $ library gnu_cc:[000000]gcclib libgcc2.obj
1693
1694     The first command simply removes old modules that will be replaced
1695     with modules from `libgcc2' under different module names.  The
1696     modules `new' and `eprintf' may not actually be present in your
1697     `gcclib.olb'--if the VMS librarian complains about those modules
1698     not being present, simply ignore the message and continue on with
1699     the next command.  The second command removes the modules that
1700     came from the previous version of the library `libgcc2.c'.
1701
1702     Whenever you update the compiler on your system, you should also
1703     update the library with the above procedure.
1704
1705  6. You may wish to build GCC in such a way that no files are written
1706     to the directory where the source files reside.  An example would
1707     be the when the source files are on a read-only disk.  In these
1708     cases, execute the following DCL commands (substituting your
1709     actual path names):
1710
1711          $ assign dua0:[gcc.build_dir.]/translation=concealed, -
1712                   dua1:[gcc.source_dir.]/translation=concealed  gcc_build
1713          $ set default gcc_build:[000000]
1714
1715     where the directory `dua1:[gcc.source_dir]' contains the source
1716     code, and the directory `dua0:[gcc.build_dir]' is meant to contain
1717     all of the generated object files and executables.  Once you have
1718     done this, you can proceed building GCC as described above.  (Keep
1719     in mind that `gcc_build' is a rooted logical name, and thus the
1720     device names in each element of the search list must be an actual
1721     physical device name rather than another rooted logical name).
1722
1723  7. *If you are building GNU CC with a previous version of GNU CC, you
1724     also should check to see that you have the newest version of the
1725     assembler*.  In particular, GNU CC version 2 treats global constant
1726     variables slightly differently from GNU CC version 1, and GAS
1727     version 1.38.1 does not have the patches required to work with GCC
1728     version 2.  If you use GAS 1.38.1, then `extern const' variables
1729     will not have the read-only bit set, and the linker will generate
1730     warning messages about mismatched psect attributes for these
1731     variables.  These warning messages are merely a nuisance, and can
1732     safely be ignored.
1733
1734     If you are compiling with a version of GNU CC older than 1.33,
1735     specify `/DEFINE=("inline=")' as an option in all the
1736     compilations.  This requires editing all the `gcc' commands in
1737     `make-cc1.com'.  (The older versions had problems supporting
1738     `inline'.)  Once you have a working 1.33 or newer GNU CC, you can
1739     change this file back.
1740
1741  8. If you want to build GNU CC with the VAX C compiler, you will need
1742     to make minor changes in `make-cccp.com' and `make-cc1.com' to
1743     choose alternate definitions of `CC', `CFLAGS', and `LIBS'.  See
1744     comments in those files.  However, you must also have a working
1745     version of the GNU assembler (GNU as, aka GAS) as it is used as
1746     the back-end for GNU CC to produce binary object modules and is
1747     not included in the GNU CC sources.  GAS is also needed to compile
1748     `libgcc2' in order to build `gcclib' (see above); `make-l2.com'
1749     expects to be able to find it operational in
1750     `gnu_cc:[000000]gnu-as.exe'.
1751
1752     To use GNU CC on VMS, you need the VMS driver programs `gcc.exe',
1753     `gcc.com', and `gcc.cld'.  They are distributed with the VMS
1754     binaries (`gcc-vms') rather than the GNU CC sources.  GAS is also
1755     included in `gcc-vms', as is Bison.
1756
1757     Once you have successfully built GNU CC with VAX C, you should use
1758     the resulting compiler to rebuild itself.  Before doing this, be
1759     sure to restore the `CC', `CFLAGS', and `LIBS' definitions in
1760     `make-cccp.com' and `make-cc1.com'.  The second generation
1761     compiler will be able to take advantage of many optimizations that
1762     must be suppressed when building with other compilers.
1763
1764   Under previous versions of GNU CC, the generated code would
1765occasionally give strange results when linked with the sharable
1766`VAXCRTL' library.  Now this should work.
1767
1768   Even with this version, however, GNU CC itself should not be linked
1769with the sharable `VAXCRTL'.  The version of `qsort' in `VAXCRTL' has a
1770bug (known to be present in VMS versions V4.6 through V5.5) which
1771causes the compiler to fail.
1772
1773   The executables are generated by `make-cc1.com' and `make-cccp.com'
1774use the object library version of `VAXCRTL' in order to make use of the
1775`qsort' routine in `gcclib.olb'.  If you wish to link the compiler
1776executables with the shareable image version of `VAXCRTL', you should
1777edit the file `tm.h' (created by `vmsconfig.com') to define the macro
1778`QSORT_WORKAROUND'.
1779
1780   `QSORT_WORKAROUND' is always defined when GNU CC is compiled with
1781VAX C, to avoid a problem in case `gcclib.olb' is not yet available.
1782
1783`collect2'
1784==========
1785
1786   Many target systems do not have support in the assembler and linker
1787for "constructors"--initialization functions to be called before the
1788official "start" of `main'.  On such systems, GNU CC uses a utility
1789called `collect2' to arrange to call these functions at start time.
1790
1791   The program `collect2' works by linking the program once and looking
1792through the linker output file for symbols with particular names
1793indicating they are constructor functions.  If it finds any, it creates
1794a new temporary `.c' file containing a table of them, compiles it, and
1795links the program a second time including that file.
1796
1797   The actual calls to the constructors are carried out by a subroutine
1798called `__main', which is called (automatically) at the beginning of
1799the body of `main' (provided `main' was compiled with GNU CC).  Calling
1800`__main' is necessary, even when compiling C code, to allow linking C
1801and C++ object code together.  (If you use `-nostdlib', you get an
1802unresolved reference to `__main', since it's defined in the standard
1803GCC library.  Include `-lgcc' at the end of your compiler command line
1804to resolve this reference.)
1805
1806   The program `collect2' is installed as `ld' in the directory where
1807the passes of the compiler are installed.  When `collect2' needs to
1808find the *real* `ld', it tries the following file names:
1809
1810   * `real-ld' in the directories listed in the compiler's search
1811     directories.
1812
1813   * `real-ld' in the directories listed in the environment variable
1814     `PATH'.
1815
1816   * The file specified in the `REAL_LD_FILE_NAME' configuration macro,
1817     if specified.
1818
1819   * `ld' in the compiler's search directories, except that `collect2'
1820     will not execute itself recursively.
1821
1822   * `ld' in `PATH'.
1823
1824   "The compiler's search directories" means all the directories where
1825`gcc' searches for passes of the compiler.  This includes directories
1826that you specify with `-B'.
1827
1828   Cross-compilers search a little differently:
1829
1830   * `real-ld' in the compiler's search directories.
1831
1832   * `TARGET-real-ld' in `PATH'.
1833
1834   * The file specified in the `REAL_LD_FILE_NAME' configuration macro,
1835     if specified.
1836
1837   * `ld' in the compiler's search directories.
1838
1839   * `TARGET-ld' in `PATH'.
1840
1841   `collect2' explicitly avoids running `ld' using the file name under
1842which `collect2' itself was invoked.  In fact, it remembers up a list
1843of such names--in case one copy of `collect2' finds another copy (or
1844version) of `collect2' installed as `ld' in a second place in the
1845search path.
1846
1847   `collect2' searches for the utilities `nm' and `strip' using the
1848same algorithm as above for `ld'.
1849
1850Standard Header File Directories
1851================================
1852
1853   `GCC_INCLUDE_DIR' means the same thing for native and cross.  It is
1854where GNU CC stores its private include files, and also where GNU CC
1855stores the fixed include files.  A cross compiled GNU CC runs
1856`fixincludes' on the header files in `$(tooldir)/include'.  (If the
1857cross compilation header files need to be fixed, they must be installed
1858before GNU CC is built.  If the cross compilation header files are
1859already suitable for ANSI C and GNU CC, nothing special need be done).
1860
1861   `GPLUS_INCLUDE_DIR' means the same thing for native and cross.  It
1862is where `g++' looks first for header files.  `libg++' installs only
1863target independent header files in that directory.
1864
1865   `LOCAL_INCLUDE_DIR' is used only for a native compiler.  It is
1866normally `/usr/local/include'.  GNU CC searches this directory so that
1867users can install header files in `/usr/local/include'.
1868
1869   `CROSS_INCLUDE_DIR' is used only for a cross compiler.  GNU CC
1870doesn't install anything there.
1871
1872   `TOOL_INCLUDE_DIR' is used for both native and cross compilers.  It
1873is the place for other packages to install header files that GNU CC will
1874use.  For a cross-compiler, this is the equivalent of `/usr/include'.
1875When you build a cross-compiler, `fixincludes' processes any header
1876files in this directory.
1877
Note: See TracBrowser for help on using the repository browser.