Daily bump.
[official-gcc.git] / gcc / INSTALL
bloba7c63d57de89b8ad523189001d5b3ffbb9c6aecb
1 This is Info file INSTALL, produced by Makeinfo version 1.68 from the
2 input file install1.texi.
4    This file documents the installation of the GNU compiler.  Copyright
5 (C) 1988, 1989, 1992, 1994, 1995 Free Software Foundation, Inc.  You
6 may copy, distribute, and modify it freely as long as you preserve this
7 copyright notice and permission notice.
9 \x1f
10 File: INSTALL,  Node: Installation,  Up: (dir)
12 Installing GNU CC
13 *****************
15    Note most of this information is out of date and superceded by the
16 EGCS install procedures.  It is provided for historical reference only.
18 * Menu:
20 * Configurations::    Configurations Supported by GNU CC.
21 * Other Dir::     Compiling in a separate directory (not where the source is).
22 * Cross-Compiler::   Building and installing a cross-compiler.
23 * Sun Install::   See below for installation on the Sun.
24 * VMS Install::   See below for installation on VMS.
25 * Collect2::      How `collect2' works; how it finds `ld'.
26 * Header Dirs::   Understanding the standard header file directories.
28    Here is the procedure for installing GNU CC on a Unix system.  See
29 *Note VMS Install::, for VMS systems.  In this section we assume you
30 compile in the same directory that contains the source files; see *Note
31 Other Dir::, to find out how to compile in a separate directory on Unix
32 systems.
34    You cannot install GNU C by itself on MSDOS; it will not compile
35 under any MSDOS compiler except itself.  You need to get the complete
36 compilation package DJGPP, which includes binaries as well as sources,
37 and includes all the necessary compilation tools and libraries.
39   1. If you have built GNU CC previously in the same directory for a
40      different target machine, do `make distclean' to delete all files
41      that might be invalid.  One of the files this deletes is
42      `Makefile'; if `make distclean' complains that `Makefile' does not
43      exist, it probably means that the directory is already suitably
44      clean.
46   2. On a System V release 4 system, make sure `/usr/bin' precedes
47      `/usr/ucb' in `PATH'.  The `cc' command in `/usr/ucb' uses
48      libraries which have bugs.
50   3. Specify the host, build and target machine configurations.  You do
51      this by running the file `configure'.
53      The "build" machine is the system which you are using, the "host"
54      machine is the system where you want to run the resulting compiler
55      (normally the build machine), and the "target" machine is the
56      system for which you want the compiler to generate code.
58      If you are building a compiler to produce code for the machine it
59      runs on (a native compiler), you normally do not need to specify
60      any operands to `configure'; it will try to guess the type of
61      machine you are on and use that as the build, host and target
62      machines.  So you don't need to specify a configuration when
63      building a native compiler unless `configure' cannot figure out
64      what your configuration is or guesses wrong.
66      In those cases, specify the build machine's "configuration name"
67      with the `--host' option; the host and target will default to be
68      the same as the host machine.  (If you are building a
69      cross-compiler, see *Note Cross-Compiler::.)
71      Here is an example:
73           ./configure --host=sparc-sun-sunos4.1
75      A configuration name may be canonical or it may be more or less
76      abbreviated.
78      A canonical configuration name has three parts, separated by
79      dashes.  It looks like this: `CPU-COMPANY-SYSTEM'.  (The three
80      parts may themselves contain dashes; `configure' can figure out
81      which dashes serve which purpose.)  For example,
82      `m68k-sun-sunos4.1' specifies a Sun 3.
84      You can also replace parts of the configuration by nicknames or
85      aliases.  For example, `sun3' stands for `m68k-sun', so
86      `sun3-sunos4.1' is another way to specify a Sun 3.  You can also
87      use simply `sun3-sunos', since the version of SunOS is assumed by
88      default to be version 4.
90      You can specify a version number after any of the system types,
91      and some of the CPU types.  In most cases, the version is
92      irrelevant, and will be ignored.  So you might as well specify the
93      version if you know it.
95      See *Note Configurations::, for a list of supported configuration
96      names and notes on many of the configurations.  You should check
97      the notes in that section before proceeding any further with the
98      installation of GNU CC.
100      There are four additional options you can specify independently to
101      describe variant hardware and software configurations.  These are
102      `--with-gnu-as', `--with-gnu-ld', `--with-stabs' and `--nfp'.
104     `--with-gnu-as'
105           If you will use GNU CC with the GNU assembler (GAS), you
106           should declare this by using the `--with-gnu-as' option when
107           you run `configure'.
109           Using this option does not install GAS.  It only modifies the
110           output of GNU CC to work with GAS.  Building and installing
111           GAS is up to you.
113           Conversely, if you *do not* wish to use GAS and do not specify
114           `--with-gnu-as' when building GNU CC, it is up to you to make
115           sure that GAS is not installed.  GNU CC searches for a
116           program named `as' in various directories; if the program it
117           finds is GAS, then it runs GAS.  If you are not sure where
118           GNU CC finds the assembler it is using, try specifying `-v'
119           when you run it.
121           The systems where it makes a difference whether you use GAS
122           are
123           `hppa1.0-ANY-ANY', `hppa1.1-ANY-ANY', `i386-ANY-sysv',
124           `i386-ANY-isc',
125           `i860-ANY-bsd', `m68k-bull-sysv',
126           `m68k-hp-hpux', `m68k-sony-bsd',
127           `m68k-altos-sysv', `m68000-hp-hpux',
128           `m68000-att-sysv', `ANY-lynx-lynxos', and `mips-ANY').  On
129           any other system, `--with-gnu-as' has no effect.
131           On the systems listed above (except for the HP-PA, for ISC on
132           the 386, and for `mips-sgi-irix5.*'), if you use GAS, you
133           should also use the GNU linker (and specify `--with-gnu-ld').
135     `--with-gnu-ld'
136           Specify the option `--with-gnu-ld' if you plan to use the GNU
137           linker with GNU CC.
139           This option does not cause the GNU linker to be installed; it
140           just modifies the behavior of GNU CC to work with the GNU
141           linker.
143     `--with-stabs'
144           On MIPS based systems and on Alphas, you must specify whether
145           you want GNU CC to create the normal ECOFF debugging format,
146           or to use BSD-style stabs passed through the ECOFF symbol
147           table.  The normal ECOFF debug format cannot fully handle
148           languages other than C.  BSD stabs format can handle other
149           languages, but it only works with the GNU debugger GDB.
151           Normally, GNU CC uses the ECOFF debugging format by default;
152           if you prefer BSD stabs, specify `--with-stabs' when you
153           configure GNU CC.
155           No matter which default you choose when you configure GNU CC,
156           the user can use the `-gcoff' and `-gstabs+' options to
157           specify explicitly the debug format for a particular
158           compilation.
160           `--with-stabs' is meaningful on the ISC system on the 386,
161           also, if `--with-gas' is used.  It selects use of stabs
162           debugging information embedded in COFF output.  This kind of
163           debugging information supports C++ well; ordinary COFF
164           debugging information does not.
166           `--with-stabs' is also meaningful on 386 systems running
167           SVR4.  It selects use of stabs debugging information embedded
168           in ELF output.  The C++ compiler currently (2.6.0) does not
169           support the DWARF debugging information normally used on 386
170           SVR4 platforms; stabs provide a workable alternative.  This
171           requires gas and gdb, as the normal SVR4 tools can not
172           generate or interpret stabs.
174     `--nfp'
175           On certain systems, you must specify whether the machine has
176           a floating point unit.  These systems include
177           `m68k-sun-sunosN' and `m68k-isi-bsd'.  On any other system,
178           `--nfp' currently has no effect, though perhaps there are
179           other systems where it could usefully make a difference.
181     `--enable-haifa'
182     `--disable-haifa'
183           Use `--enable-haifa' to enable use of an experimental
184           instruction scheduler (from IBM Haifa).  This may or may not
185           produce better code.  Some targets on which it is known to be
186           a win enable it by default; use `--disable-haifa' to disable
187           it in these cases.  `configure' will print out whether the
188           Haifa scheduler is enabled when it is run.
190     `--enable-threads=TYPE'
191           Certain systems, notably Linux-based GNU systems, can't be
192           relied on to supply a threads facility for the Objective C
193           runtime and so will default to single-threaded runtime.  They
194           may, however, have a library threads implementation
195           available, in which case threads can be enabled with this
196           option by supplying a suitable TYPE, probably `posix'.  The
197           possibilities for TYPE are `single', `posix', `win32',
198           `solaris', `irix' and `mach'.
200     `--enable-checking'
201           When you specify this option, the compiler is built to
202           perform checking of tree node types when referencing fields
203           of that node.  This does not change the generated code, but
204           adds error checking within the compiler.  This will slow down
205           the compiler and may only work properly if you are building
206           the compiler with GNU C.
208      The `configure' script searches subdirectories of the source
209      directory for other compilers that are to be integrated into GNU
210      CC.  The GNU compiler for C++, called G++ is in a subdirectory
211      named `cp'.  `configure' inserts rules into `Makefile' to build
212      all of those compilers.
214      Here we spell out what files will be set up by `configure'.
215      Normally you need not be concerned with these files.
217         * A file named `config.h' is created that contains a `#include'
218           of the top-level config file for the machine you will run the
219           compiler on (*note The Configuration File:
220           (gcc.info)Config.).  This file is responsible for defining
221           information about the host machine.  It includes `tm.h'.
223           The top-level config file is located in the subdirectory
224           `config'.  Its name is always `xm-SOMETHING.h'; usually
225           `xm-MACHINE.h', but there are some exceptions.
227           If your system does not support symbolic links, you might
228           want to set up `config.h' to contain a `#include' command
229           which refers to the appropriate file.
231         * A file named `tconfig.h' is created which includes the
232           top-level config file for your target machine.  This is used
233           for compiling certain programs to run on that machine.
235         * A file named `tm.h' is created which includes the
236           machine-description macro file for your target machine.  It
237           should be in the subdirectory `config' and its name is often
238           `MACHINE.h'.
240         * The command file `configure' also constructs the file
241           `Makefile' by adding some text to the template file
242           `Makefile.in'.  The additional text comes from files in the
243           `config' directory, named `t-TARGET' and `x-HOST'.  If these
244           files do not exist, it means nothing needs to be added for a
245           given target or host.
247   4. The standard directory for installing GNU CC is `/usr/local/lib'.
248      If you want to install its files somewhere else, specify
249      `--prefix=DIR' when you run `configure'.  Here DIR is a directory
250      name to use instead of `/usr/local' for all purposes with one
251      exception: the directory `/usr/local/include' is searched for
252      header files no matter where you install the compiler.  To override
253      this name, use the `--with-local-prefix' option below.  The
254      directory you specify need not exist, but its parent directory
255      must exist.
257   5. Specify `--with-local-prefix=DIR' if you want the compiler to
258      search directory `DIR/include' for locally installed header files
259      *instead* of `/usr/local/include'.
261      You should specify `--with-local-prefix' *only* if your site has a
262      different convention (not `/usr/local') for where to put
263      site-specific files.
265      The default value for `--with-local-prefix' is `/usr/local'
266      regardless of the value of `--prefix'.  Specifying `--prefix' has
267      no effect on which directory GNU CC searches for local header
268      files.  This may seem counterintuitive, but actually it is logical.
270      The purpose of `--prefix' is to specify where to *install GNU CC*.
271      The local header files in `/usr/local/include'--if you put any in
272      that directory--are not part of GNU CC.  They are part of other
273      programs--perhaps many others.  (GNU CC installs its own header
274      files in another directory which is based on the `--prefix' value.)
276      *Do not* specify `/usr' as the `--with-local-prefix'!  The
277      directory you use for `--with-local-prefix' *must not* contain any
278      of the system's standard header files.  If it did contain them,
279      certain programs would be miscompiled (including GNU Emacs, on
280      certain targets), because this would override and nullify the
281      header file corrections made by the `fixincludes' script.
283      Indications are that people who use this option use it based on
284      mistaken ideas of what it is for.  People use it as if it specified
285      where to install part of GNU CC.  Perhaps they make this assumption
286      because installing GNU CC creates the directory.
288   6. Make sure the Bison parser generator is installed.  (This is
289      unnecessary if the Bison output files `c-parse.c' and `cexp.c' are
290      more recent than `c-parse.y' and `cexp.y' and you do not plan to
291      change the `.y' files.)
293      Bison versions older than Sept 8, 1988 will produce incorrect
294      output for `c-parse.c'.
296   7. If you have chosen a configuration for GNU CC which requires other
297      GNU tools (such as GAS or the GNU linker) instead of the standard
298      system tools, install the required tools in the build directory
299      under the names `as', `ld' or whatever is appropriate.  This will
300      enable the compiler to find the proper tools for compilation of
301      the program `enquire'.
303      Alternatively, you can do subsequent compilation using a value of
304      the `PATH' environment variable such that the necessary GNU tools
305      come before the standard system tools.
307   8. Build the compiler.  Just type `make LANGUAGES=c' in the compiler
308      directory.
310      `LANGUAGES=c' specifies that only the C compiler should be
311      compiled.  The makefile normally builds compilers for all the
312      supported languages; currently, C, C++ and Objective C.  However,
313      C is the only language that is sure to work when you build with
314      other non-GNU C compilers.  In addition, building anything but C
315      at this stage is a waste of time.
317      In general, you can specify the languages to build by typing the
318      argument `LANGUAGES="LIST"', where LIST is one or more words from
319      the list `c', `c++', and `objective-c'.  If you have any
320      additional GNU compilers as subdirectories of the GNU CC source
321      directory, you may also specify their names in this list.
323      Ignore any warnings you may see about "statement not reached" in
324      `insn-emit.c'; they are normal.  Also, warnings about "unknown
325      escape sequence" are normal in `genopinit.c' and perhaps some
326      other files.  Likewise, you should ignore warnings about "constant
327      is so large that it is unsigned" in `insn-emit.c' and
328      `insn-recog.c', a warning about a comparison always being zero in
329      `enquire.o', and warnings about shift counts exceeding type widths
330      in `cexp.y'.  Any other compilation errors may represent bugs in
331      the port to your machine or operating system, and should be
332      investigated and reported.
334      Some commercial compilers fail to compile GNU CC because they have
335      bugs or limitations.  For example, the Microsoft compiler is said
336      to run out of macro space.  Some Ultrix compilers run out of
337      expression space; then you need to break up the statement where
338      the problem happens.
340   9. If you are building a cross-compiler, stop here.  *Note
341      Cross-Compiler::.
343  10. Move the first-stage object files and executables into a
344      subdirectory with this command:
346           make stage1
348      The files are moved into a subdirectory named `stage1'.  Once
349      installation is complete, you may wish to delete these files with
350      `rm -r stage1'.
352  11. If you have chosen a configuration for GNU CC which requires other
353      GNU tools (such as GAS or the GNU linker) instead of the standard
354      system tools, install the required tools in the `stage1'
355      subdirectory under the names `as', `ld' or whatever is
356      appropriate.  This will enable the stage 1 compiler to find the
357      proper tools in the following stage.
359      Alternatively, you can do subsequent compilation using a value of
360      the `PATH' environment variable such that the necessary GNU tools
361      come before the standard system tools.
363  12. Recompile the compiler with itself, with this command:
365           make CC="stage1/xgcc -Bstage1/" CFLAGS="-g -O2"
367      This is called making the stage 2 compiler.
369      The command shown above builds compilers for all the supported
370      languages.  If you don't want them all, you can specify the
371      languages to build by typing the argument `LANGUAGES="LIST"'.  LIST
372      should contain one or more words from the list `c', `c++',
373      `objective-c', and `proto'.  Separate the words with spaces.
374      `proto' stands for the programs `protoize' and `unprotoize'; they
375      are not a separate language, but you use `LANGUAGES' to enable or
376      disable their installation.
378      If you are going to build the stage 3 compiler, then you might
379      want to build only the C language in stage 2.
381      Once you have built the stage 2 compiler, if you are short of disk
382      space, you can delete the subdirectory `stage1'.
384      On a 68000 or 68020 system lacking floating point hardware, unless
385      you have selected a `tm.h' file that expects by default that there
386      is no such hardware, do this instead:
388           make CC="stage1/xgcc -Bstage1/" CFLAGS="-g -O2 -msoft-float"
390  13. If you wish to test the compiler by compiling it with itself one
391      more time, install any other necessary GNU tools (such as GAS or
392      the GNU linker) in the `stage2' subdirectory as you did in the
393      `stage1' subdirectory, then do this:
395           make stage2
396           make CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O2"
398      This is called making the stage 3 compiler.  Aside from the `-B'
399      option, the compiler options should be the same as when you made
400      the stage 2 compiler.  But the `LANGUAGES' option need not be the
401      same.  The command shown above builds compilers for all the
402      supported languages; if you don't want them all, you can specify
403      the languages to build by typing the argument `LANGUAGES="LIST"',
404      as described above.
406      If you do not have to install any additional GNU tools, you may
407      use the command
409           make bootstrap LANGUAGES=LANGUAGE-LIST BOOT_CFLAGS=OPTION-LIST
411      instead of making `stage1', `stage2', and performing the two
412      compiler builds.
414  14. Then compare the latest object files with the stage 2 object
415      files--they ought to be identical, aside from time stamps (if any).
417      On some systems, meaningful comparison of object files is
418      impossible; they always appear "different."  This is currently
419      true on Solaris and some systems that use ELF object file format.
420      On some versions of Irix on SGI machines and DEC Unix (OSF/1) on
421      Alpha systems, you will not be able to compare the files without
422      specifying `-save-temps'; see the description of individual
423      systems above to see if you get comparison failures.  You may have
424      similar problems on other systems.
426      Use this command to compare the files:
428           make compare
430      This will mention any object files that differ between stage 2 and
431      stage 3.  Any difference, no matter how innocuous, indicates that
432      the stage 2 compiler has compiled GNU CC incorrectly, and is
433      therefore a potentially serious bug which you should investigate
434      and report.
436      If your system does not put time stamps in the object files, then
437      this is a faster way to compare them (using the Bourne shell):
439           for file in *.o; do
440           cmp $file stage2/$file
441           done
443      If you have built the compiler with the `-mno-mips-tfile' option on
444      MIPS machines, you will not be able to compare the files.
446  15. Install the compiler driver, the compiler's passes and run-time
447      support with `make install'.  Use the same value for `CC',
448      `CFLAGS' and `LANGUAGES' that you used when compiling the files
449      that are being installed.  One reason this is necessary is that
450      some versions of Make have bugs and recompile files gratuitously
451      when you do this step.  If you use the same variable values, those
452      files will be recompiled properly.
454      For example, if you have built the stage 2 compiler, you can use
455      the following command:
457           make install CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O" LANGUAGES="LIST"
459      This copies the files `cc1', `cpp' and `libgcc.a' to files `cc1',
460      `cpp' and `libgcc.a' in the directory
461      `/usr/local/lib/gcc-lib/TARGET/VERSION', which is where the
462      compiler driver program looks for them.  Here TARGET is the
463      canonicalized form of target machine type specified when you ran
464      `configure', and VERSION is the version number of GNU CC.  This
465      naming scheme permits various versions and/or cross-compilers to
466      coexist.  It also copies the executables for compilers for other
467      languages (e.g., `cc1plus' for C++) to the same directory.
469      This also copies the driver program `xgcc' into
470      `/usr/local/bin/gcc', so that it appears in typical execution
471      search paths.  It also copies `gcc.1' into `/usr/local/man/man1'
472      and info pages into `/usr/local/info'.
474      On some systems, this command causes recompilation of some files.
475      This is usually due to bugs in `make'.  You should either ignore
476      this problem, or use GNU Make.
478      *Warning: there is a bug in `alloca' in the Sun library.  To avoid
479      this bug, be sure to install the executables of GNU CC that were
480      compiled by GNU CC.  (That is, the executables from stage 2 or 3,
481      not stage 1.)  They use `alloca' as a built-in function and never
482      the one in the library.*
484      (It is usually better to install GNU CC executables from stage 2
485      or 3, since they usually run faster than the ones compiled with
486      some other compiler.)
488  16. If you're going to use C++, it's likely that you need to also
489      install a C++ runtime library.  Just as GNU C does not distribute
490      a C runtime library, it also does not include a C++ runtime
491      library.  All I/O functionality, special class libraries, etc., are
492      provided by the C++ runtime library.
494      The standard C++ runtime library for GNU CC is called `libstdc++'.
495      An obsolescent library `libg++' may also be available, but it's
496      necessary only for older software that hasn't been converted yet;
497      if you don't know whether you need `libg++' then you probably don't
498      need it.
500      Here's one way to build and install `libstdc++' for GNU CC:
502         * Build and install GNU CC, so that invoking `gcc' obtains the
503           GNU CC that was just built.
505         * Obtain a copy of a compatible `libstdc++' distribution.  For
506           example, the `libstdc++-2.8.0.tar.gz' distribution should be
507           compatible with GCC 2.8.0.  GCC distributors normally
508           distribute `libstdc++' as well.
510         * Set the `CXX' environment variable to `gcc' while running the
511           `libstdc++' distribution's `configure' command.  Use the same
512           `configure' options that you used when you invoked GCC's
513           `configure' command.
515         * Invoke `make' to build the C++ runtime.
517         * Invoke `make install' to install the C++ runtime.
519      To summarize, after building and installing GNU CC, invoke the
520      following shell commands in the topmost directory of the C++
521      library distribution.  For CONFIGURE-OPTIONS, use the same options
522      that you used to configure GNU CC.
524           $ CXX=gcc ./configure CONFIGURE-OPTIONS
525           $ make
526           $ make install
528  17. GNU CC includes a runtime library for Objective-C because it is an
529      integral part of the language.  You can find the files associated
530      with the library in the subdirectory `objc'.  The GNU Objective-C
531      Runtime Library requires header files for the target's C library in
532      order to be compiled,and also requires the header files for the
533      target's thread library if you want thread support.  *Note
534      Cross-Compilers and Header Files: Cross Headers, for discussion
535      about header files issues for cross-compilation.
537      When you run `configure', it picks the appropriate Objective-C
538      thread implementation file for the target platform.  In some
539      situations, you may wish to choose a different back-end as some
540      platforms support multiple thread implementations or you may wish
541      to disable thread support completely.  You do this by specifying a
542      value for the OBJC_THREAD_FILE makefile variable on the command
543      line when you run make, for example:
545           make CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O2" OBJC_THREAD_FILE=thr-single
547      Below is a list of the currently available back-ends.
549         * thr-single Disable thread support, should work for all
550           platforms.
552         * thr-decosf1 DEC OSF/1 thread support.
554         * thr-irix SGI IRIX thread support.
556         * thr-mach Generic MACH thread support, known to work on
557           NEXTSTEP.
559         * thr-os2 IBM OS/2 thread support.
561         * thr-posix Generix POSIX thread support.
563         * thr-pthreads PCThreads on Linux-based GNU systems.
565         * thr-solaris SUN Solaris thread support.
567         * thr-win32 Microsoft Win32 API thread support.
569 \x1f
570 File: INSTALL,  Node: Configurations,  Next: Other Dir,  Up: Installation
572 Configurations Supported by GNU CC
573 ==================================
575    Here are the possible CPU types:
577      1750a, a29k, alpha, arm, cN, clipper, dsp16xx, elxsi, h8300,
578      hppa1.0, hppa1.1, i370, i386, i486, i586, i860, i960, m32r,
579      m68000, m68k, m88k, mips, mipsel, mips64, mips64el, ns32k,
580      powerpc, powerpcle, pyramid, romp, rs6000, sh, sparc, sparclite,
581      sparc64, vax, we32k.
583    Here are the recognized company names.  As you can see, customary
584 abbreviations are used rather than the longer official names.
586      acorn, alliant, altos, apollo, apple, att, bull, cbm, convergent,
587      convex, crds, dec, dg, dolphin, elxsi, encore, harris, hitachi,
588      hp, ibm, intergraph, isi, mips, motorola, ncr, next, ns, omron,
589      plexus, sequent, sgi, sony, sun, tti, unicom, wrs.
591    The company name is meaningful only to disambiguate when the rest of
592 the information supplied is insufficient.  You can omit it, writing
593 just `CPU-SYSTEM', if it is not needed.  For example, `vax-ultrix4.2'
594 is equivalent to `vax-dec-ultrix4.2'.
596    Here is a list of system types:
598      386bsd, aix, acis, amigaos, aos, aout, aux, bosx, bsd, clix, coff,
599      ctix, cxux, dgux, dynix, ebmon, ecoff, elf, esix, freebsd, hms,
600      genix, gnu, linux-gnu, hiux, hpux, iris, irix, isc, luna, lynxos,
601      mach, minix, msdos, mvs, netbsd, newsos, nindy, ns, osf, osfrose,
602      ptx, riscix, riscos, rtu, sco, sim, solaris, sunos, sym, sysv,
603      udi, ultrix, unicos, uniplus, unos, vms, vsta, vxworks, winnt,
604      xenix.
606 You can omit the system type; then `configure' guesses the operating
607 system from the CPU and company.
609    You can add a version number to the system type; this may or may not
610 make a difference.  For example, you can write `bsd4.3' or `bsd4.4' to
611 distinguish versions of BSD.  In practice, the version number is most
612 needed for `sysv3' and `sysv4', which are often treated differently.
614    If you specify an impossible combination such as `i860-dg-vms', then
615 you may get an error message from `configure', or it may ignore part of
616 the information and do the best it can with the rest.  `configure'
617 always prints the canonical name for the alternative that it used.  GNU
618 CC does not support all possible alternatives.
620    Often a particular model of machine has a name.  Many machine names
621 are recognized as aliases for CPU/company combinations.  Thus, the
622 machine name `sun3', mentioned above, is an alias for `m68k-sun'.
623 Sometimes we accept a company name as a machine name, when the name is
624 popularly used for a particular machine.  Here is a table of the known
625 machine names:
627      3300, 3b1, 3bN, 7300, altos3068, altos, apollo68, att-7300,
628      balance, convex-cN, crds, decstation-3100, decstation, delta,
629      encore, fx2800, gmicro, hp7NN, hp8NN, hp9k2NN, hp9k3NN, hp9k7NN,
630      hp9k8NN, iris4d, iris, isi68, m3230, magnum, merlin, miniframe,
631      mmax, news-3600, news800, news, next, pbd, pc532, pmax, powerpc,
632      powerpcle, ps2, risc-news, rtpc, sun2, sun386i, sun386, sun3,
633      sun4, symmetry, tower-32, tower.
635 Remember that a machine name specifies both the cpu type and the company
636 name.  If you want to install your own homemade configuration files,
637 you can use `local' as the company name to access them.  If you use
638 configuration `CPU-local', the configuration name without the cpu prefix
639 is used to form the configuration file names.
641    Thus, if you specify `m68k-local', configuration uses files
642 `m68k.md', `local.h', `m68k.c', `xm-local.h', `t-local', and `x-local',
643 all in the directory `config/m68k'.
645    Here is a list of configurations that have special treatment or
646 special things you must know:
648 `1750a-*-*'
649      MIL-STD-1750A processors.
651      The MIL-STD-1750A cross configuration produces output for
652      `as1750', an assembler/linker available under the GNU Public
653      License for the 1750A. `as1750' can be obtained at
654      *ftp://ftp.fta-berlin.de/pub/crossgcc/1750gals/*.  A similarly
655      licensed simulator for the 1750A is available from same address.
657      You should ignore a fatal error during the building of libgcc
658      (libgcc is not yet implemented for the 1750A.)
660      The `as1750' assembler requires the file `ms1750.inc', which is
661      found in the directory `config/1750a'.
663      GNU CC produced the same sections as the Fairchild F9450 C
664      Compiler, namely:
666     `Normal'
667           The program code section.
669     `Static'
670           The read/write (RAM) data section.
672     `Konst'
673           The read-only (ROM) constants section.
675     `Init'
676           Initialization section (code to copy KREL to SREL).
678      The smallest addressable unit is 16 bits (BITS_PER_UNIT is 16).
679      This means that type `char' is represented with a 16-bit word per
680      character.  The 1750A's "Load/Store Upper/Lower Byte" instructions
681      are not used by GNU CC.
683 `alpha-*-osf1'
684      Systems using processors that implement the DEC Alpha architecture
685      and are running the DEC Unix (OSF/1) operating system, for example
686      the DEC Alpha AXP systems.CC.)
688      GNU CC writes a `.verstamp' directive to the assembler output file
689      unless it is built as a cross-compiler.  It gets the version to
690      use from the system header file `/usr/include/stamp.h'.  If you
691      install a new version of DEC Unix, you should rebuild GCC to pick
692      up the new version stamp.
694      Note that since the Alpha is a 64-bit architecture,
695      cross-compilers from 32-bit machines will not generate code as
696      efficient as that generated when the compiler is running on a
697      64-bit machine because many optimizations that depend on being
698      able to represent a word on the target in an integral value on the
699      host cannot be performed.  Building cross-compilers on the Alpha
700      for 32-bit machines has only been tested in a few cases and may
701      not work properly.
703      `make compare' may fail on old versions of DEC Unix unless you add
704      `-save-temps' to `CFLAGS'.  On these systems, the name of the
705      assembler input file is stored in the object file, and that makes
706      comparison fail if it differs between the `stage1' and `stage2'
707      compilations.  The option `-save-temps' forces a fixed name to be
708      used for the assembler input file, instead of a randomly chosen
709      name in `/tmp'.  Do not add `-save-temps' unless the comparisons
710      fail without that option.  If you add `-save-temps', you will have
711      to manually delete the `.i' and `.s' files after each series of
712      compilations.
714      GNU CC now supports both the native (ECOFF) debugging format used
715      by DBX and GDB and an encapsulated STABS format for use only with
716      GDB.  See the discussion of the `--with-stabs' option of
717      `configure' above for more information on these formats and how to
718      select them.
720      There is a bug in DEC's assembler that produces incorrect line
721      numbers for ECOFF format when the `.align' directive is used.  To
722      work around this problem, GNU CC will not emit such alignment
723      directives while writing ECOFF format debugging information even
724      if optimization is being performed.  Unfortunately, this has the
725      very undesirable side-effect that code addresses when `-O' is
726      specified are different depending on whether or not `-g' is also
727      specified.
729      To avoid this behavior, specify `-gstabs+' and use GDB instead of
730      DBX.  DEC is now aware of this problem with the assembler and
731      hopes to provide a fix shortly.
733 `arc-*-elf'
734      Argonaut ARC processor.  This configuration is intended for
735      embedded systems.
737 `arm-*-aout'
738      Advanced RISC Machines ARM-family processors.  These are often
739      used in embedded applications.  There are no standard Unix
740      configurations.  This configuration corresponds to the basic
741      instruction sequences and will produce `a.out' format object
742      modules.
744      You may need to make a variant of the file `arm.h' for your
745      particular configuration.
747 `arm-*-linuxaout'
748      Any of the ARM family processors running the Linux-based GNU
749      system with the `a.out' binary format (ELF is not yet supported).
750      You must use version 2.8.1.0.7 or later of the GNU/Linux binutils,
751      which you can download from `sunsite.unc.edu:/pub/Linux/GCC' and
752      other mirror sites for Linux-based GNU systems.
754 `arm-*-riscix'
755      The ARM2 or ARM3 processor running RISC iX, Acorn's port of BSD
756      Unix.  If you are running a version of RISC iX prior to 1.2 then
757      you must specify the version number during configuration.  Note
758      that the assembler shipped with RISC iX does not support stabs
759      debugging information; a new version of the assembler, with stabs
760      support included, is now available from Acorn and via ftp
761      `ftp.acorn.com:/pub/riscix/as+xterm.tar.Z'.  To enable stabs
762      debugging, pass `--with-gnu-as' to configure.
764      You will need to install GNU `sed' before you can run configure.
766 `a29k'
767      AMD Am29k-family processors.  These are normally used in embedded
768      applications.  There are no standard Unix configurations.  This
769      configuration corresponds to AMD's standard calling sequence and
770      binary interface and is compatible with other 29k tools.
772      You may need to make a variant of the file `a29k.h' for your
773      particular configuration.
775 `a29k-*-bsd'
776      AMD Am29050 used in a system running a variant of BSD Unix.
778 `decstation-*'
779      MIPS-based DECstations can support three different personalities:
780      Ultrix, DEC OSF/1, and OSF/rose.  (Alpha-based DECstation products
781      have a configuration name beginning with `alpha-dec'.)  To
782      configure GCC for these platforms use the following configurations:
784     `decstation-ultrix'
785           Ultrix configuration.
787     `decstation-osf1'
788           Dec's version of OSF/1.
790     `decstation-osfrose'
791           Open Software Foundation reference port of OSF/1 which uses
792           the OSF/rose object file format instead of ECOFF.  Normally,
793           you would not select this configuration.
795      The MIPS C compiler needs to be told to increase its table size
796      for switch statements with the `-Wf,-XNg1500' option in order to
797      compile `cp/parse.c'.  If you use the `-O2' optimization option,
798      you also need to use `-Olimit 3000'.  Both of these options are
799      automatically generated in the `Makefile' that the shell script
800      `configure' builds.  If you override the `CC' make variable and
801      use the MIPS compilers, you may need to add `-Wf,-XNg1500 -Olimit
802      3000'.
804 `elxsi-elxsi-bsd'
805      The Elxsi's C compiler has known limitations that prevent it from
806      compiling GNU C.  Please contact `mrs@cygnus.com' for more details.
808 `dsp16xx'
809      A port to the AT&T DSP1610 family of processors.
811 `h8300-*-*'
812      Hitachi H8/300 series of processors.
814      The calling convention and structure layout has changed in release
815      2.6.  All code must be recompiled.  The calling convention now
816      passes the first three arguments in function calls in registers.
817      Structures are no longer a multiple of 2 bytes.
819 `hppa*-*-*'
820      There are several variants of the HP-PA processor which run a
821      variety of operating systems.  GNU CC must be configured to use
822      the correct processor type and operating system, or GNU CC will
823      not function correctly.  The easiest way to handle this problem is
824      to *not* specify a target when configuring GNU CC, the `configure'
825      script will try to automatically determine the right processor
826      type and operating system.
828      `-g' does not work on HP-UX, since that system uses a peculiar
829      debugging format which GNU CC does not know about.  However, `-g'
830      will work if you also use GAS and GDB in conjunction with GCC.  We
831      highly recommend using GAS for all HP-PA configurations.
833      You should be using GAS-2.6 (or later) along with GDB-4.16 (or
834      later).  These can be retrieved from all the traditional GNU ftp
835      archive sites.
837      On some versions of HP-UX, you will need to install GNU `sed'.
839      You will need to be install GAS into a directory before `/bin',
840      `/usr/bin', and `/usr/ccs/bin' in your search path.  You should
841      install GAS before you build GNU CC.
843      To enable debugging, you must configure GNU CC with the
844      `--with-gnu-as' option before building.
846 `i370-*-*'
847      This port is very preliminary and has many known bugs.  We hope to
848      have a higher-quality port for this machine soon.
850 `i386-*-linux-gnuoldld'
851      Use this configuration to generate `a.out' binaries on Linux-based
852      GNU systems if you do not have gas/binutils version 2.5.2 or later
853      installed. This is an obsolete configuration.
855 `i386-*-linux-gnuaout'
856      Use this configuration to generate `a.out' binaries on Linux-based
857      GNU systems. This configuration is being superseded. You must use
858      gas/binutils version 2.5.2 or later.
860 `i386-*-linux-gnu'
861      Use this configuration to generate ELF binaries on Linux-based GNU
862      systems.  You must use gas/binutils version 2.5.2 or later.
864 `i386-*-sco'
865      Compilation with RCC is recommended.  Also, it may be a good idea
866      to link with GNU malloc instead of the malloc that comes with the
867      system.
869 `i386-*-sco3.2v4'
870      Use this configuration for SCO release 3.2 version 4.
872 `i386-*-sco3.2v5*'
873      Use this for the SCO OpenServer Release family including 5.0.0,
874      5.0.2, 5.0.4, 5.0.5, Internet FastStart 1.0, and Internet
875      FastStart 1.1.
877      GNU CC can generate COFF binaries if you specify `-mcoff' or ELF
878      binaries, the default.    A full `make bootstrap' is recommended
879      so that an ELF compiler that builds ELF is generated.
881      You must have TLS597 from `ftp://ftp.sco.com/TLS' installed for ELF
882      C++ binaries to work correctly on releases before 5.0.4.
884      The native SCO assembler that is provided with the OS at no charge
885      is normally required.  If, however, you must be able to use the GNU
886      assembler (perhaps you have complex asms) you must configure this
887      package `--with-gnu-as'.  To do this, install (cp or symlink)
888      gcc/as to your copy of the GNU assembler.  You must use a recent
889      version of GNU binutils; version 2.9.1 seems to work well.  If you
890      select this option, you will be unable to build COFF images.
891      Trying to do so will result in non-obvious failures.  In general,
892      the "-with-gnu-as" option isn't as well tested as the native
893      assembler.
895      *NOTE:* If you are building C++, you must follow the instructions
896      about invoking `make bootstrap' because the native OpenServer
897      compiler may build a `cc1plus' that will not correctly parse many
898      valid C++ programs.  You must do a `make bootstrap' if you are
899      building with the native compiler.
901 `i386-*-isc'
902      It may be a good idea to link with GNU malloc instead of the
903      malloc that comes with the system.
905      In ISC version 4.1, `sed' core dumps when building `deduced.h'.
906      Use the version of `sed' from version 4.0.
908 `i386-*-esix'
909      It may be good idea to link with GNU malloc instead of the malloc
910      that comes with the system.
912 `i386-ibm-aix'
913      You need to use GAS version 2.1 or later, and LD from GNU binutils
914      version 2.2 or later.
916 `i386-sequent-bsd'
917      Go to the Berkeley universe before compiling.
919 `i386-sequent-ptx1*'
920 `i386-sequent-ptx2*'
921      You must install GNU `sed' before running `configure'.
923 `i386-sun-sunos4'
924      You may find that you need another version of GNU CC to begin
925      bootstrapping with, since the current version when built with the
926      system's own compiler seems to get an infinite loop compiling part
927      of `libgcc2.c'.  GNU CC version 2 compiled with GNU CC (any
928      version) seems not to have this problem.
930      See *Note Sun Install::, for information on installing GNU CC on
931      Sun systems.
933 `i[345]86-*-winnt3.5'
934      This version requires a GAS that has not yet been released.  Until
935      it is, you can get a prebuilt binary version via anonymous ftp from
936      `cs.washington.edu:pub/gnat' or `cs.nyu.edu:pub/gnat'. You must
937      also use the Microsoft header files from the Windows NT 3.5 SDK.
938      Find these on the CDROM in the `/mstools/h' directory dated
939      9/4/94.  You must use a fixed version of Microsoft linker made
940      especially for NT 3.5, which is also is available on the NT 3.5
941      SDK CDROM.  If you do not have this linker, can you also use the
942      linker from Visual C/C++ 1.0 or 2.0.
944      Installing GNU CC for NT builds a wrapper linker, called `ld.exe',
945      which mimics the behaviour of Unix `ld' in the specification of
946      libraries (`-L' and `-l').  `ld.exe' looks for both Unix and
947      Microsoft named libraries.  For example, if you specify `-lfoo',
948      `ld.exe' will look first for `libfoo.a' and then for `foo.lib'.
950      You may install GNU CC for Windows NT in one of two ways,
951      depending on whether or not you have a Unix-like shell and various
952      Unix-like utilities.
954        1. If you do not have a Unix-like shell and few Unix-like
955           utilities, you will use a DOS style batch script called
956           `configure.bat'.  Invoke it as `configure winnt' from an
957           MSDOS console window or from the program manager dialog box.
958           `configure.bat' assumes you have already installed and have
959           in your path a Unix-like `sed' program which is used to
960           create a working `Makefile' from `Makefile.in'.
962           `Makefile' uses the Microsoft Nmake program maintenance
963           utility and the Visual C/C++ V8.00 compiler to build GNU CC.
964           You need only have the utilities `sed' and `touch' to use
965           this installation method, which only automatically builds the
966           compiler itself.  You must then examine what `fixinc.winnt'
967           does, edit the header files by hand and build `libgcc.a'
968           manually.
970        2. The second type of installation assumes you are running a
971           Unix-like shell, have a complete suite of Unix-like utilities
972           in your path, and have a previous version of GNU CC already
973           installed, either through building it via the above
974           installation method or acquiring a pre-built binary.  In this
975           case, use the `configure' script in the normal fashion.
977 `i860-intel-osf1'
978      This is the Paragon.  If you have version 1.0 of the operating
979      system, you need to take special steps to build GNU CC due to
980      peculiarities of the system.  Newer system versions have no
981      problem.  See the section `Installation Problems' in the GNU CC
982      Manual.
984 `*-lynx-lynxos'
985      LynxOS 2.2 and earlier comes with GNU CC 1.x already installed as
986      `/bin/gcc'.  You should compile with this instead of `/bin/cc'.
987      You can tell GNU CC to use the GNU assembler and linker, by
988      specifying `--with-gnu-as --with-gnu-ld' when configuring.  These
989      will produce COFF format object files and executables;  otherwise
990      GNU CC will use the installed tools, which produce `a.out' format
991      executables.
993 `m32r-*-elf'
994      Mitsubishi M32R processor.  This configuration is intended for
995      embedded systems.
997 `m68000-hp-bsd'
998      HP 9000 series 200 running BSD.  Note that the C compiler that
999      comes with this system cannot compile GNU CC; contact
1000      `law@cygnus.com' to get binaries of GNU CC for bootstrapping.
1002 `m68k-altos'
1003      Altos 3068.  You must use the GNU assembler, linker and debugger.
1004      Also, you must fix a kernel bug.  Details in the file
1005      `README.ALTOS'.
1007 `m68k-apple-aux'
1008      Apple Macintosh running A/UX.  You may configure GCC  to use
1009      either the system assembler and linker or the GNU assembler and
1010      linker.  You should use the GNU configuration if you can,
1011      especially if you also want to use GNU C++.  You enabled that
1012      configuration with + the `--with-gnu-as' and `--with-gnu-ld'
1013      options to `configure'.
1015      Note the C compiler that comes with this system cannot compile GNU
1016      CC.  You can find binaries of GNU CC for bootstrapping on
1017      `jagubox.gsfc.nasa.gov'.  You will also a patched version of
1018      `/bin/ld' there that raises some of the arbitrary limits found in
1019      the original.
1021 `m68k-att-sysv'
1022      AT&T 3b1, a.k.a. 7300 PC.  Special procedures are needed to
1023      compile GNU CC with this machine's standard C compiler, due to
1024      bugs in that compiler.  You can bootstrap it more easily with
1025      previous versions of GNU CC if you have them.
1027      Installing GNU CC on the 3b1 is difficult if you do not already
1028      have GNU CC running, due to bugs in the installed C compiler.
1029      However, the following procedure might work.  We are unable to
1030      test it.
1032        1. Comment out the `#include "config.h"' line near the start of
1033           `cccp.c' and do `make cpp'.  This makes a preliminary version
1034           of GNU cpp.
1036        2. Save the old `/lib/cpp' and copy the preliminary GNU cpp to
1037           that file name.
1039        3. Undo your change in `cccp.c', or reinstall the original
1040           version, and do `make cpp' again.
1042        4. Copy this final version of GNU cpp into `/lib/cpp'.
1044        5. Replace every occurrence of `obstack_free' in the file
1045           `tree.c' with `_obstack_free'.
1047        6. Run `make' to get the first-stage GNU CC.
1049        7. Reinstall the original version of `/lib/cpp'.
1051        8. Now you can compile GNU CC with itself and install it in the
1052           normal fashion.
1054 `m68k-bull-sysv'
1055      Bull DPX/2 series 200 and 300 with BOS-2.00.45 up to BOS-2.01. GNU
1056      CC works either with native assembler or GNU assembler. You can use
1057      GNU assembler with native coff generation by providing
1058      `--with-gnu-as' to the configure script or use GNU assembler with
1059      dbx-in-coff encapsulation by providing `--with-gnu-as --stabs'.
1060      For any problem with native assembler or for availability of the
1061      DPX/2 port of GAS, contact `F.Pierresteguy@frcl.bull.fr'.
1063 `m68k-crds-unox'
1064      Use `configure unos' for building on Unos.
1066      The Unos assembler is named `casm' instead of `as'.  For some
1067      strange reason linking `/bin/as' to `/bin/casm' changes the
1068      behavior, and does not work.  So, when installing GNU CC, you
1069      should install the following script as `as' in the subdirectory
1070      where the passes of GCC are installed:
1072           #!/bin/sh
1073           casm $*
1075      The default Unos library is named `libunos.a' instead of `libc.a'.
1076      To allow GNU CC to function, either change all references to
1077      `-lc' in `gcc.c' to `-lunos' or link `/lib/libc.a' to
1078      `/lib/libunos.a'.
1080      When compiling GNU CC with the standard compiler, to overcome bugs
1081      in the support of `alloca', do not use `-O' when making stage 2.
1082      Then use the stage 2 compiler with `-O' to make the stage 3
1083      compiler.  This compiler will have the same characteristics as the
1084      usual stage 2 compiler on other systems.  Use it to make a stage 4
1085      compiler and compare that with stage 3 to verify proper
1086      compilation.
1088      (Perhaps simply defining `ALLOCA' in `x-crds' as described in the
1089      comments there will make the above paragraph superfluous.  Please
1090      inform us of whether this works.)
1092      Unos uses memory segmentation instead of demand paging, so you
1093      will need a lot of memory.  5 Mb is barely enough if no other
1094      tasks are running.  If linking `cc1' fails, try putting the object
1095      files into a library and linking from that library.
1097 `m68k-hp-hpux'
1098      HP 9000 series 300 or 400 running HP-UX.  HP-UX version 8.0 has a
1099      bug in the assembler that prevents compilation of GNU CC.  To fix
1100      it, get patch PHCO_4484 from HP.
1102      In addition, if you wish to use gas `--with-gnu-as' you must use
1103      gas version 2.1 or later, and you must use the GNU linker version
1104      2.1 or later.  Earlier versions of gas relied upon a program which
1105      converted the gas output into the native HP-UX format, but that
1106      program has not been kept up to date.  gdb does not understand
1107      that native HP-UX format, so you must use gas if you wish to use
1108      gdb.
1110 `m68k-sun'
1111      Sun 3.  We do not provide a configuration file to use the Sun FPA
1112      by default, because programs that establish signal handlers for
1113      floating point traps inherently cannot work with the FPA.
1115      See *Note Sun Install::, for information on installing GNU CC on
1116      Sun systems.
1118 `m88k-*-svr3'
1119      Motorola m88k running the AT&T/Unisoft/Motorola V.3 reference port.
1120      These systems tend to use the Green Hills C, revision 1.8.5, as the
1121      standard C compiler.  There are apparently bugs in this compiler
1122      that result in object files differences between stage 2 and stage
1123      3.  If this happens, make the stage 4 compiler and compare it to
1124      the stage 3 compiler.  If the stage 3 and stage 4 object files are
1125      identical, this suggests you encountered a problem with the
1126      standard C compiler; the stage 3 and 4 compilers may be usable.
1128      It is best, however, to use an older version of GNU CC for
1129      bootstrapping if you have one.
1131 `m88k-*-dgux'
1132      Motorola m88k running DG/UX.  To build 88open BCS native or cross
1133      compilers on DG/UX, specify the configuration name as
1134      `m88k-*-dguxbcs' and build in the 88open BCS software development
1135      environment.  To build ELF native or cross compilers on DG/UX,
1136      specify `m88k-*-dgux' and build in the DG/UX ELF development
1137      environment.  You set the software development environment by
1138      issuing `sde-target' command and specifying either `m88kbcs' or
1139      `m88kdguxelf' as the operand.
1141      If you do not specify a configuration name, `configure' guesses the
1142      configuration based on the current software development
1143      environment.
1145 `m88k-tektronix-sysv3'
1146      Tektronix XD88 running UTekV 3.2e.  Do not turn on optimization
1147      while building stage1 if you bootstrap with the buggy Green Hills
1148      compiler.  Also, The bundled LAI System V NFS is buggy so if you
1149      build in an NFS mounted directory, start from a fresh reboot, or
1150      avoid NFS all together.  Otherwise you may have trouble getting
1151      clean comparisons between stages.
1153 `mips-mips-bsd'
1154      MIPS machines running the MIPS operating system in BSD mode.  It's
1155      possible that some old versions of the system lack the functions
1156      `memcpy', `memcmp', and `memset'.  If your system lacks these, you
1157      must remove or undo the definition of `TARGET_MEM_FUNCTIONS' in
1158      `mips-bsd.h'.
1160      The MIPS C compiler needs to be told to increase its table size
1161      for switch statements with the `-Wf,-XNg1500' option in order to
1162      compile `cp/parse.c'.  If you use the `-O2' optimization option,
1163      you also need to use `-Olimit 3000'.  Both of these options are
1164      automatically generated in the `Makefile' that the shell script
1165      `configure' builds.  If you override the `CC' make variable and
1166      use the MIPS compilers, you may need to add `-Wf,-XNg1500 -Olimit
1167      3000'.
1169 `mips-mips-riscos*'
1170      The MIPS C compiler needs to be told to increase its table size
1171      for switch statements with the `-Wf,-XNg1500' option in order to
1172      compile `cp/parse.c'.  If you use the `-O2' optimization option,
1173      you also need to use `-Olimit 3000'.  Both of these options are
1174      automatically generated in the `Makefile' that the shell script
1175      `configure' builds.  If you override the `CC' make variable and
1176      use the MIPS compilers, you may need to add `-Wf,-XNg1500 -Olimit
1177      3000'.
1179      MIPS computers running RISC-OS can support four different
1180      personalities: default, BSD 4.3, System V.3, and System V.4 (older
1181      versions of RISC-OS don't support V.4).  To configure GCC for
1182      these platforms use the following configurations:
1184     `mips-mips-riscos`rev''
1185           Default configuration for RISC-OS, revision `rev'.
1187     `mips-mips-riscos`rev'bsd'
1188           BSD 4.3 configuration for RISC-OS, revision `rev'.
1190     `mips-mips-riscos`rev'sysv4'
1191           System V.4 configuration for RISC-OS, revision `rev'.
1193     `mips-mips-riscos`rev'sysv'
1194           System V.3 configuration for RISC-OS, revision `rev'.
1196      The revision `rev' mentioned above is the revision of RISC-OS to
1197      use.  You must reconfigure GCC when going from a RISC-OS revision
1198      4 to RISC-OS revision 5.  This has the effect of avoiding a linker
1199      bug.
1201 `mips-sgi-*'
1202      In order to compile GCC on an SGI running IRIX 4, the "c.hdr.lib"
1203      option must be installed from the CD-ROM supplied from Silicon
1204      Graphics.  This is found on the 2nd CD in release 4.0.1.
1206      In order to compile GCC on an SGI running IRIX 5, the
1207      "compiler_dev.hdr" subsystem must be installed from the IDO CD-ROM
1208      supplied by Silicon Graphics.
1210      `make compare' may fail on version 5 of IRIX unless you add
1211      `-save-temps' to `CFLAGS'.  On these systems, the name of the
1212      assembler input file is stored in the object file, and that makes
1213      comparison fail if it differs between the `stage1' and `stage2'
1214      compilations.  The option `-save-temps' forces a fixed name to be
1215      used for the assembler input file, instead of a randomly chosen
1216      name in `/tmp'.  Do not add `-save-temps' unless the comparisons
1217      fail without that option.  If you do you `-save-temps', you will
1218      have to manually delete the `.i' and `.s' files after each series
1219      of compilations.
1221      The MIPS C compiler needs to be told to increase its table size
1222      for switch statements with the `-Wf,-XNg1500' option in order to
1223      compile `cp/parse.c'.  If you use the `-O2' optimization option,
1224      you also need to use `-Olimit 3000'.  Both of these options are
1225      automatically generated in the `Makefile' that the shell script
1226      `configure' builds.  If you override the `CC' make variable and
1227      use the MIPS compilers, you may need to add `-Wf,-XNg1500 -Olimit
1228      3000'.
1230      On Irix version 4.0.5F, and perhaps on some other versions as well,
1231      there is an assembler bug that reorders instructions incorrectly.
1232      To work around it, specify the target configuration
1233      `mips-sgi-irix4loser'.  This configuration inhibits assembler
1234      optimization.
1236      In a compiler configured with target `mips-sgi-irix4', you can turn
1237      off assembler optimization by using the `-noasmopt' option.  This
1238      compiler option passes the option `-O0' to the assembler, to
1239      inhibit reordering.
1241      The `-noasmopt' option can be useful for testing whether a problem
1242      is due to erroneous assembler reordering.  Even if a problem does
1243      not go away with `-noasmopt', it may still be due to assembler
1244      reordering--perhaps GNU CC itself was miscompiled as a result.
1246      To enable debugging under Irix 5, you must use GNU as 2.5 or later,
1247      and use the `--with-gnu-as' configure option when configuring gcc.
1248      GNU as is distributed as part of the binutils package.
1250 `mips-sony-sysv'
1251      Sony MIPS NEWS.  This works in NEWSOS 5.0.1, but not in 5.0.2
1252      (which uses ELF instead of COFF).  Support for 5.0.2 will probably
1253      be provided soon by volunteers.  In particular, the linker does
1254      not like the code generated by GCC when shared libraries are
1255      linked in.
1257 `ns32k-encore'
1258      Encore ns32000 system.  Encore systems are supported only under
1259      BSD.
1261 `ns32k-*-genix'
1262      National Semiconductor ns32000 system.  Genix has bugs in `alloca'
1263      and `malloc'; you must get the compiled versions of these from GNU
1264      Emacs.
1266 `ns32k-sequent'
1267      Go to the Berkeley universe before compiling.
1269 `ns32k-utek'
1270      UTEK ns32000 system ("merlin").  The C compiler that comes with
1271      this system cannot compile GNU CC; contact `tektronix!reed!mason'
1272      to get binaries of GNU CC for bootstrapping.
1274 `romp-*-aos'
1275 `romp-*-mach'
1276      The only operating systems supported for the IBM RT PC are AOS and
1277      MACH.  GNU CC does not support AIX running on the RT.  We
1278      recommend you compile GNU CC with an earlier version of itself; if
1279      you compile GNU CC with `hc', the Metaware compiler, it will work,
1280      but you will get mismatches between the stage 2 and stage 3
1281      compilers in various files.  These errors are minor differences in
1282      some floating-point constants and can be safely ignored; the stage
1283      3 compiler is correct.
1285 `rs6000-*-aix'
1286 `powerpc-*-aix'
1287      Various early versions of each release of the IBM XLC compiler
1288      will not bootstrap GNU CC.  Symptoms include differences between
1289      the stage2 and stage3 object files, and errors when compiling
1290      `libgcc.a' or `enquire'.  Known problematic releases include:
1291      xlc-1.2.1.8, xlc-1.3.0.0 (distributed with AIX 3.2.5), and
1292      xlc-1.3.0.19.  Both xlc-1.2.1.28 and xlc-1.3.0.24 (PTF 432238) are
1293      known to produce working versions of GNU CC, but most other recent
1294      releases correctly bootstrap GNU CC.
1296      Release 4.3.0 of AIX and ones prior to AIX 3.2.4 include a version
1297      of the IBM assembler which does not accept debugging directives:
1298      assembler updates are available as PTFs.  Also, if you are using
1299      AIX 3.2.5 or greater and the GNU assembler, you must have a
1300      version modified after October 16th, 1995 in order for the GNU C
1301      compiler to build.  See the file `README.RS6000' for more details
1302      on any of these problems.
1304      GNU CC does not yet support the 64-bit PowerPC instructions.
1306      Objective C does not work on this architecture because it makes
1307      assumptions that are incompatible with the calling conventions.
1309      AIX on the RS/6000 provides support (NLS) for environments outside
1310      of the United States.  Compilers and assemblers use NLS to support
1311      locale-specific representations of various objects including
1312      floating-point numbers ("." vs "," for separating decimal
1313      fractions).  There have been problems reported where the library
1314      linked with GNU CC does not produce the same floating-point
1315      formats that the assembler accepts.  If you have this problem, set
1316      the LANG environment variable to "C" or "En_US".
1318      Due to changes in the way that GNU CC invokes the binder (linker)
1319      for AIX 4.1, you may now receive warnings of duplicate symbols
1320      from the link step that were not reported before.  The assembly
1321      files generated by GNU CC for AIX have always included multiple
1322      symbol definitions for certain global variable and function
1323      declarations in the original program.  The warnings should not
1324      prevent the linker from producing a correct library or runnable
1325      executable.
1327      By default, AIX 4.1 produces code that can be used on either Power
1328      or PowerPC processors.
1330      You can specify a default version for the `-mcpu='CPU_TYPE switch
1331      by using the configure option `--with-cpu-'CPU_TYPE.
1333 `powerpc-*-elf'
1334 `powerpc-*-sysv4'
1335      PowerPC system in big endian mode, running System V.4.
1337      You can specify a default version for the `-mcpu='CPU_TYPE switch
1338      by using the configure option `--with-cpu-'CPU_TYPE.
1340 `powerpc-*-linux-gnu'
1341      PowerPC system in big endian mode, running the Linux-based GNU
1342      system.
1344      You can specify a default version for the `-mcpu='CPU_TYPE switch
1345      by using the configure option `--with-cpu-'CPU_TYPE.
1347 `powerpc-*-eabiaix'
1348      Embedded PowerPC system in big endian mode with -mcall-aix
1349      selected as the default.
1351      You can specify a default version for the `-mcpu='CPU_TYPE switch
1352      by using the configure option `--with-cpu-'CPU_TYPE.
1354 `powerpc-*-eabisim'
1355      Embedded PowerPC system in big endian mode for use in running
1356      under the PSIM simulator.
1358      You can specify a default version for the `-mcpu='CPU_TYPE switch
1359      by using the configure option `--with-cpu-'CPU_TYPE.
1361 `powerpc-*-eabi'
1362      Embedded PowerPC system in big endian mode.
1364      You can specify a default version for the `-mcpu='CPU_TYPE switch
1365      by using the configure option `--with-cpu-'CPU_TYPE.
1367 `powerpcle-*-elf'
1368 `powerpcle-*-sysv4'
1369      PowerPC system in little endian mode, running System V.4.
1371      You can specify a default version for the `-mcpu='CPU_TYPE switch
1372      by using the configure option `--with-cpu-'CPU_TYPE.
1374 `powerpcle-*-solaris2*'
1375      PowerPC system in little endian mode, running Solaris 2.5.1 or
1376      higher.
1378      You can specify a default version for the `-mcpu='CPU_TYPE switch
1379      by using the configure option `--with-cpu-'CPU_TYPE.  Beta
1380      versions of the Sun 4.0 compiler do not seem to be able to build
1381      GNU CC correctly.  There are also problems with the host assembler
1382      and linker that are fixed by using the GNU versions of these tools.
1384 `powerpcle-*-eabisim'
1385      Embedded PowerPC system in little endian mode for use in running
1386      under the PSIM simulator.
1388 `powerpcle-*-eabi'
1389      Embedded PowerPC system in little endian mode.
1391      You can specify a default version for the `-mcpu='CPU_TYPE switch
1392      by using the configure option `--with-cpu-'CPU_TYPE.
1394 `powerpcle-*-winnt'
1395 `powerpcle-*-pe'
1396      PowerPC system in little endian mode running Windows NT.
1398      You can specify a default version for the `-mcpu='CPU_TYPE switch
1399      by using the configure option `--with-cpu-'CPU_TYPE.
1401 `vax-dec-ultrix'
1402      Don't try compiling with Vax C (`vcc').  It produces incorrect code
1403      in some cases (for example, when `alloca' is used).
1405      Meanwhile, compiling `cp/parse.c' with pcc does not work because of
1406      an internal table size limitation in that compiler.  To avoid this
1407      problem, compile just the GNU C compiler first, and use it to
1408      recompile building all the languages that you want to run.
1410 `sparc-sun-*'
1411      See *Note Sun Install::, for information on installing GNU CC on
1412      Sun systems.
1414 `vax-dec-vms'
1415      See *Note VMS Install::, for details on how to install GNU CC on
1416      VMS.
1418 `we32k-*-*'
1419      These computers are also known as the 3b2, 3b5, 3b20 and other
1420      similar names.  (However, the 3b1 is actually a 68000; see *Note
1421      Configurations::.)
1423      Don't use `-g' when compiling with the system's compiler.  The
1424      system's linker seems to be unable to handle such a large program
1425      with debugging information.
1427      The system's compiler runs out of capacity when compiling `stmt.c'
1428      in GNU CC.  You can work around this by building `cpp' in GNU CC
1429      first, then use that instead of the system's preprocessor with the
1430      system's C compiler to compile `stmt.c'.  Here is how:
1432           mv /lib/cpp /lib/cpp.att
1433           cp cpp /lib/cpp.gnu
1434           echo '/lib/cpp.gnu -traditional ${1+"$@"}' > /lib/cpp
1435           chmod +x /lib/cpp
1437      The system's compiler produces bad code for some of the GNU CC
1438      optimization files.  So you must build the stage 2 compiler without
1439      optimization.  Then build a stage 3 compiler with optimization.
1440      That executable should work.  Here are the necessary commands:
1442           make LANGUAGES=c CC=stage1/xgcc CFLAGS="-Bstage1/ -g"
1443           make stage2
1444           make CC=stage2/xgcc CFLAGS="-Bstage2/ -g -O"
1446      You may need to raise the ULIMIT setting to build a C++ compiler,
1447      as the file `cc1plus' is larger than one megabyte.
1449 \x1f
1450 File: INSTALL,  Node: Other Dir,  Next: Cross-Compiler,  Prev: Configurations,  Up: Installation
1452 Compilation in a Separate Directory
1453 ===================================
1455    If you wish to build the object files and executables in a directory
1456 other than the one containing the source files, here is what you must
1457 do differently:
1459   1. Make sure you have a version of Make that supports the `VPATH'
1460      feature.  (GNU Make supports it, as do Make versions on most BSD
1461      systems.)
1463   2. If you have ever run `configure' in the source directory, you must
1464      undo the configuration.  Do this by running:
1466           make distclean
1468   3. Go to the directory in which you want to build the compiler before
1469      running `configure':
1471           mkdir gcc-sun3
1472           cd gcc-sun3
1474      On systems that do not support symbolic links, this directory must
1475      be on the same file system as the source code directory.
1477   4. Specify where to find `configure' when you run it:
1479           ../gcc/configure ...
1481      This also tells `configure' where to find the compiler sources;
1482      `configure' takes the directory from the file name that was used to
1483      invoke it.  But if you want to be sure, you can specify the source
1484      directory with the `--srcdir' option, like this:
1486           ../gcc/configure --srcdir=../gcc OTHER OPTIONS
1488      The directory you specify with `--srcdir' need not be the same as
1489      the one that `configure' is found in.
1491    Now, you can run `make' in that directory.  You need not repeat the
1492 configuration steps shown above, when ordinary source files change.  You
1493 must, however, run `configure' again when the configuration files
1494 change, if your system does not support symbolic links.
1496 \x1f
1497 File: INSTALL,  Node: Cross-Compiler,  Next: Sun Install,  Prev: Other Dir,  Up: Installation
1499 Building and Installing a Cross-Compiler
1500 ========================================
1502    GNU CC can function as a cross-compiler for many machines, but not
1503 all.
1505    * Cross-compilers for the Mips as target using the Mips assembler
1506      currently do not work, because the auxiliary programs
1507      `mips-tdump.c' and `mips-tfile.c' can't be compiled on anything
1508      but a Mips.  It does work to cross compile for a Mips if you use
1509      the GNU assembler and linker.
1511    * Cross-compilers between machines with different floating point
1512      formats have not all been made to work.  GNU CC now has a floating
1513      point emulator with which these can work, but each target machine
1514      description needs to be updated to take advantage of it.
1516    * Cross-compilation between machines of different word sizes is
1517      somewhat problematic and sometimes does not work.
1519    Since GNU CC generates assembler code, you probably need a
1520 cross-assembler that GNU CC can run, in order to produce object files.
1521 If you want to link on other than the target machine, you need a
1522 cross-linker as well.  You also need header files and libraries suitable
1523 for the target machine that you can install on the host machine.
1525 * Menu:
1527 * Steps of Cross::      Using a cross-compiler involves several steps
1528                           that may be carried out on different machines.
1529 * Configure Cross::     Configuring a cross-compiler.
1530 * Tools and Libraries:: Where to put the linker and assembler, and the C library.
1531 * Cross Headers::       Finding and installing header files
1532                           for a cross-compiler.
1533 * Cross Runtime::       Supplying arithmetic runtime routines (`libgcc1.a').
1534 * Build Cross::         Actually compiling the cross-compiler.
1536 \x1f
1537 File: INSTALL,  Node: Steps of Cross,  Next: Configure Cross,  Up: Cross-Compiler
1539 Steps of Cross-Compilation
1540 --------------------------
1542    To compile and run a program using a cross-compiler involves several
1543 steps:
1545    * Run the cross-compiler on the host machine to produce assembler
1546      files for the target machine.  This requires header files for the
1547      target machine.
1549    * Assemble the files produced by the cross-compiler.  You can do this
1550      either with an assembler on the target machine, or with a
1551      cross-assembler on the host machine.
1553    * Link those files to make an executable.  You can do this either
1554      with a linker on the target machine, or with a cross-linker on the
1555      host machine.  Whichever machine you use, you need libraries and
1556      certain startup files (typically `crt....o') for the target
1557      machine.
1559    It is most convenient to do all of these steps on the same host
1560 machine, since then you can do it all with a single invocation of GNU
1561 CC.  This requires a suitable cross-assembler and cross-linker.  For
1562 some targets, the GNU assembler and linker are available.
1564 \x1f
1565 File: INSTALL,  Node: Configure Cross,  Next: Tools and Libraries,  Prev: Steps of Cross,  Up: Cross-Compiler
1567 Configuring a Cross-Compiler
1568 ----------------------------
1570    To build GNU CC as a cross-compiler, you start out by running
1571 `configure'.  Use the `--target=TARGET' to specify the target type.  If
1572 `configure' was unable to correctly identify the system you are running
1573 on, also specify the `--build=BUILD' option.  For example, here is how
1574 to configure for a cross-compiler that produces code for an HP 68030
1575 system running BSD on a system that `configure' can correctly identify:
1577      ./configure --target=m68k-hp-bsd4.3
1579 \x1f
1580 File: INSTALL,  Node: Tools and Libraries,  Next: Cross Headers,  Prev: Configure Cross,  Up: Cross-Compiler
1582 Tools and Libraries for a Cross-Compiler
1583 ----------------------------------------
1585    If you have a cross-assembler and cross-linker available, you should
1586 install them now.  Put them in the directory `/usr/local/TARGET/bin'.
1587 Here is a table of the tools you should put in this directory:
1589 `as'
1590      This should be the cross-assembler.
1592 `ld'
1593      This should be the cross-linker.
1595 `ar'
1596      This should be the cross-archiver: a program which can manipulate
1597      archive files (linker libraries) in the target machine's format.
1599 `ranlib'
1600      This should be a program to construct a symbol table in an archive
1601      file.
1603    The installation of GNU CC will find these programs in that
1604 directory, and copy or link them to the proper place to for the
1605 cross-compiler to find them when run later.
1607    The easiest way to provide these files is to build the Binutils
1608 package and GAS.  Configure them with the same `--host' and `--target'
1609 options that you use for configuring GNU CC, then build and install
1610 them.  They install their executables automatically into the proper
1611 directory.  Alas, they do not support all the targets that GNU CC
1612 supports.
1614    If you want to install libraries to use with the cross-compiler,
1615 such as a standard C library, put them in the directory
1616 `/usr/local/TARGET/lib'; installation of GNU CC copies all the files in
1617 that subdirectory into the proper place for GNU CC to find them and
1618 link with them.  Here's an example of copying some libraries from a
1619 target machine:
1621      ftp TARGET-MACHINE
1622      lcd /usr/local/TARGET/lib
1623      cd /lib
1624      get libc.a
1625      cd /usr/lib
1626      get libg.a
1627      get libm.a
1628      quit
1630 The precise set of libraries you'll need, and their locations on the
1631 target machine, vary depending on its operating system.
1633    Many targets require "start files" such as `crt0.o' and `crtn.o'
1634 which are linked into each executable; these too should be placed in
1635 `/usr/local/TARGET/lib'.  There may be several alternatives for
1636 `crt0.o', for use with profiling or other compilation options.  Check
1637 your target's definition of `STARTFILE_SPEC' to find out what start
1638 files it uses.  Here's an example of copying these files from a target
1639 machine:
1641      ftp TARGET-MACHINE
1642      lcd /usr/local/TARGET/lib
1643      prompt
1644      cd /lib
1645      mget *crt*.o
1646      cd /usr/lib
1647      mget *crt*.o
1648      quit
1650 \x1f
1651 File: INSTALL,  Node: Cross Runtime,  Next: Build Cross,  Prev: Cross Headers,  Up: Cross-Compiler
1653 `libgcc.a' and Cross-Compilers
1654 ------------------------------
1656    Code compiled by GNU CC uses certain runtime support functions
1657 implicitly.  Some of these functions can be compiled successfully with
1658 GNU CC itself, but a few cannot be.  These problem functions are in the
1659 source file `libgcc1.c'; the library made from them is called
1660 `libgcc1.a'.
1662    When you build a native compiler, these functions are compiled with
1663 some other compiler-the one that you use for bootstrapping GNU CC.
1664 Presumably it knows how to open code these operations, or else knows how
1665 to call the run-time emulation facilities that the machine comes with.
1666 But this approach doesn't work for building a cross-compiler.  The
1667 compiler that you use for building knows about the host system, not the
1668 target system.
1670    So, when you build a cross-compiler you have to supply a suitable
1671 library `libgcc1.a' that does the job it is expected to do.
1673    To compile `libgcc1.c' with the cross-compiler itself does not work.
1674 The functions in this file are supposed to implement arithmetic
1675 operations that GNU CC does not know how to open code for your target
1676 machine.  If these functions are compiled with GNU CC itself, they will
1677 compile into infinite recursion.
1679    On any given target, most of these functions are not needed.  If GNU
1680 CC can open code an arithmetic operation, it will not call these
1681 functions to perform the operation.  It is possible that on your target
1682 machine, none of these functions is needed.  If so, you can supply an
1683 empty library as `libgcc1.a'.
1685    Many targets need library support only for multiplication and
1686 division.  If you are linking with a library that contains functions for
1687 multiplication and division, you can tell GNU CC to call them directly
1688 by defining the macros `MULSI3_LIBCALL', and the like.  These macros
1689 need to be defined in the target description macro file.  For some
1690 targets, they are defined already.  This may be sufficient to avoid the
1691 need for libgcc1.a; if so, you can supply an empty library.
1693    Some targets do not have floating point instructions; they need other
1694 functions in `libgcc1.a', which do floating arithmetic.  Recent
1695 versions of GNU CC have a file which emulates floating point.  With a
1696 certain amount of work, you should be able to construct a floating
1697 point emulator that can be used as `libgcc1.a'.  Perhaps future
1698 versions will contain code to do this automatically and conveniently.
1699 That depends on whether someone wants to implement it.
1701    Some embedded targets come with all the necessary `libgcc1.a'
1702 routines written in C or assembler.  These targets build `libgcc1.a'
1703 automatically and you do not need to do anything special for them.
1704 Other embedded targets do not need any `libgcc1.a' routines since all
1705 the necessary operations are supported by the hardware.
1707    If your target system has another C compiler, you can configure GNU
1708 CC as a native compiler on that machine, build just `libgcc1.a' with
1709 `make libgcc1.a' on that machine, and use the resulting file with the
1710 cross-compiler.  To do this, execute the following on the target
1711 machine:
1713      cd TARGET-BUILD-DIR
1714      ./configure --host=sparc --target=sun3
1715      make libgcc1.a
1717 And then this on the host machine:
1719      ftp TARGET-MACHINE
1720      binary
1721      cd TARGET-BUILD-DIR
1722      get libgcc1.a
1723      quit
1725    Another way to provide the functions you need in `libgcc1.a' is to
1726 define the appropriate `perform_...' macros for those functions.  If
1727 these definitions do not use the C arithmetic operators that they are
1728 meant to implement, you should be able to compile them with the
1729 cross-compiler you are building.  (If these definitions already exist
1730 for your target file, then you are all set.)
1732    To build `libgcc1.a' using the perform macros, use
1733 `LIBGCC1=libgcc1.a OLDCC=./xgcc' when building the compiler.
1734 Otherwise, you should place your replacement library under the name
1735 `libgcc1.a' in the directory in which you will build the
1736 cross-compiler, before you run `make'.
1738 \x1f
1739 File: INSTALL,  Node: Cross Headers,  Next: Cross Runtime,  Prev: Tools and Libraries,  Up: Cross-Compiler
1741 Cross-Compilers and Header Files
1742 --------------------------------
1744    If you are cross-compiling a standalone program or a program for an
1745 embedded system, then you may not need any header files except the few
1746 that are part of GNU CC (and those of your program).  However, if you
1747 intend to link your program with a standard C library such as `libc.a',
1748 then you probably need to compile with the header files that go with
1749 the library you use.
1751    The GNU C compiler does not come with these files, because (1) they
1752 are system-specific, and (2) they belong in a C library, not in a
1753 compiler.
1755    If the GNU C library supports your target machine, then you can get
1756 the header files from there (assuming you actually use the GNU library
1757 when you link your program).
1759    If your target machine comes with a C compiler, it probably comes
1760 with suitable header files also.  If you make these files accessible
1761 from the host machine, the cross-compiler can use them also.
1763    Otherwise, you're on your own in finding header files to use when
1764 cross-compiling.
1766    When you have found suitable header files, put them in the directory
1767 `/usr/local/TARGET/include', before building the cross compiler.  Then
1768 installation will run fixincludes properly and install the corrected
1769 versions of the header files where the compiler will use them.
1771    Provide the header files before you build the cross-compiler, because
1772 the build stage actually runs the cross-compiler to produce parts of
1773 `libgcc.a'.  (These are the parts that *can* be compiled with GNU CC.)
1774 Some of them need suitable header files.
1776    Here's an example showing how to copy the header files from a target
1777 machine.  On the target machine, do this:
1779      (cd /usr/include; tar cf - .) > tarfile
1781    Then, on the host machine, do this:
1783      ftp TARGET-MACHINE
1784      lcd /usr/local/TARGET/include
1785      get tarfile
1786      quit
1787      tar xf tarfile
1789 \x1f
1790 File: INSTALL,  Node: Build Cross,  Prev: Cross Runtime,  Up: Cross-Compiler
1792 Actually Building the Cross-Compiler
1793 ------------------------------------
1795    Now you can proceed just as for compiling a single-machine compiler
1796 through the step of building stage 1.  If you have not provided some
1797 sort of `libgcc1.a', then compilation will give up at the point where
1798 it needs that file, printing a suitable error message.  If you do
1799 provide `libgcc1.a', then building the compiler will automatically
1800 compile and link a test program called `libgcc1-test'; if you get
1801 errors in the linking, it means that not all of the necessary routines
1802 in `libgcc1.a' are available.
1804    You must provide the header file `float.h'.  One way to do this is
1805 to compile `enquire' and run it on your target machine.  The job of
1806 `enquire' is to run on the target machine and figure out by experiment
1807 the nature of its floating point representation.  `enquire' records its
1808 findings in the header file `float.h'.  If you can't produce this file
1809 by running `enquire' on the target machine, then you will need to come
1810 up with a suitable `float.h' in some other way (or else, avoid using it
1811 in your programs).
1813    Do not try to build stage 2 for a cross-compiler.  It doesn't work to
1814 rebuild GNU CC as a cross-compiler using the cross-compiler, because
1815 that would produce a program that runs on the target machine, not on the
1816 host.  For example, if you compile a 386-to-68030 cross-compiler with
1817 itself, the result will not be right either for the 386 (because it was
1818 compiled into 68030 code) or for the 68030 (because it was configured
1819 for a 386 as the host).  If you want to compile GNU CC into 68030 code,
1820 whether you compile it on a 68030 or with a cross-compiler on a 386, you
1821 must specify a 68030 as the host when you configure it.
1823    To install the cross-compiler, use `make install', as usual.
1825 \x1f
1826 File: INSTALL,  Node: Sun Install,  Next: VMS Install,  Prev: Cross-Compiler,  Up: Installation
1828 Installing GNU CC on the Sun
1829 ============================
1831    On Solaris, do not use the linker or other tools in `/usr/ucb' to
1832 build GNU CC.  Use `/usr/ccs/bin'.
1834    If the assembler reports `Error: misaligned data' when bootstrapping,
1835 you are probably using an obsolete version of the GNU assembler.
1836 Upgrade to the latest version of GNU `binutils', or use the Solaris
1837 assembler.
1839    Make sure the environment variable `FLOAT_OPTION' is not set when
1840 you compile `libgcc.a'.  If this option were set to `f68881' when
1841 `libgcc.a' is compiled, the resulting code would demand to be linked
1842 with a special startup file and would not link properly without special
1843 pains.
1845    There is a bug in `alloca' in certain versions of the Sun library.
1846 To avoid this bug, install the binaries of GNU CC that were compiled by
1847 GNU CC.  They use `alloca' as a built-in function and never the one in
1848 the library.
1850    Some versions of the Sun compiler crash when compiling GNU CC.  The
1851 problem is a segmentation fault in cpp.  This problem seems to be due to
1852 the bulk of data in the environment variables.  You may be able to avoid
1853 it by using the following command to compile GNU CC with Sun CC:
1855      make CC="TERMCAP=x OBJS=x LIBFUNCS=x STAGESTUFF=x cc"
1857    SunOS 4.1.3 and 4.1.3_U1 have bugs that can cause intermittent core
1858 dumps when compiling GNU CC.  A common symptom is an internal compiler
1859 error which does not recur if you run it again.  To fix the problem,
1860 install Sun recommended patch 100726 (for SunOS 4.1.3) or 101508 (for
1861 SunOS 4.1.3_U1), or upgrade to a later SunOS release.
1863 \x1f
1864 File: INSTALL,  Node: VMS Install,  Next: Collect2,  Prev: Sun Install,  Up: Installation
1866 Installing GNU CC on VMS
1867 ========================
1869    The VMS version of GNU CC is distributed in a backup saveset
1870 containing both source code and precompiled binaries.
1872    To install the `gcc' command so you can use the compiler easily, in
1873 the same manner as you use the VMS C compiler, you must install the VMS
1874 CLD file for GNU CC as follows:
1876   1. Define the VMS logical names `GNU_CC' and `GNU_CC_INCLUDE' to
1877      point to the directories where the GNU CC executables
1878      (`gcc-cpp.exe', `gcc-cc1.exe', etc.) and the C include files are
1879      kept respectively.  This should be done with the commands:
1881           $ assign /system /translation=concealed -
1882             disk:[gcc.] gnu_cc
1883           $ assign /system /translation=concealed -
1884             disk:[gcc.include.] gnu_cc_include
1886      with the appropriate disk and directory names.  These commands can
1887      be placed in your system startup file so they will be executed
1888      whenever the machine is rebooted.  You may, if you choose, do this
1889      via the `GCC_INSTALL.COM' script in the `[GCC]' directory.
1891   2. Install the `GCC' command with the command line:
1893           $ set command /table=sys$common:[syslib]dcltables -
1894             /output=sys$common:[syslib]dcltables gnu_cc:[000000]gcc
1895           $ install replace sys$common:[syslib]dcltables
1897   3. To install the help file, do the following:
1899           $ library/help sys$library:helplib.hlb gcc.hlp
1901      Now you can invoke the compiler with a command like `gcc /verbose
1902      file.c', which is equivalent to the command `gcc -v -c file.c' in
1903      Unix.
1905    If you wish to use GNU C++ you must first install GNU CC, and then
1906 perform the following steps:
1908   1. Define the VMS logical name `GNU_GXX_INCLUDE' to point to the
1909      directory where the preprocessor will search for the C++ header
1910      files.  This can be done with the command:
1912           $ assign /system /translation=concealed -
1913             disk:[gcc.gxx_include.] gnu_gxx_include
1915      with the appropriate disk and directory name.  If you are going to
1916      be using a C++ runtime library, this is where its install
1917      procedure will install its header files.
1919   2. Obtain the file `gcc-cc1plus.exe', and place this in the same
1920      directory that `gcc-cc1.exe' is kept.
1922      The GNU C++ compiler can be invoked with a command like `gcc /plus
1923      /verbose file.cc', which is equivalent to the command `g++ -v -c
1924      file.cc' in Unix.
1926    We try to put corresponding binaries and sources on the VMS
1927 distribution tape.  But sometimes the binaries will be from an older
1928 version than the sources, because we don't always have time to update
1929 them.  (Use the `/version' option to determine the version number of
1930 the binaries and compare it with the source file `version.c' to tell
1931 whether this is so.)  In this case, you should use the binaries you get
1932 to recompile the sources.  If you must recompile, here is how:
1934   1. Execute the command procedure `vmsconfig.com' to set up the files
1935      `tm.h', `config.h', `aux-output.c', and `md.', and to create files
1936      `tconfig.h' and `hconfig.h'.  This procedure also creates several
1937      linker option files used by `make-cc1.com' and a data file used by
1938      `make-l2.com'.
1940           $ @vmsconfig.com
1942   2. Setup the logical names and command tables as defined above.  In
1943      addition, define the VMS logical name `GNU_BISON' to point at the
1944      to the directories where the Bison executable is kept.  This
1945      should be done with the command:
1947           $ assign /system /translation=concealed -
1948             disk:[bison.] gnu_bison
1950      You may, if you choose, use the `INSTALL_BISON.COM' script in the
1951      `[BISON]' directory.
1953   3. Install the `BISON' command with the command line:
1955           $ set command /table=sys$common:[syslib]dcltables -
1956             /output=sys$common:[syslib]dcltables -
1957             gnu_bison:[000000]bison
1958           $ install replace sys$common:[syslib]dcltables
1960   4. Type `@make-gcc' to recompile everything (alternatively, submit
1961      the file `make-gcc.com' to a batch queue).  If you wish to build
1962      the GNU C++ compiler as well as the GNU CC compiler, you must
1963      first edit `make-gcc.com' and follow the instructions that appear
1964      in the comments.
1966   5. In order to use GCC, you need a library of functions which GCC
1967      compiled code will call to perform certain tasks, and these
1968      functions are defined in the file `libgcc2.c'.  To compile this
1969      you should use the command procedure `make-l2.com', which will
1970      generate the library `libgcc2.olb'.  `libgcc2.olb' should be built
1971      using the compiler built from the same distribution that
1972      `libgcc2.c' came from, and `make-gcc.com' will automatically do
1973      all of this for you.
1975      To install the library, use the following commands:
1977           $ library gnu_cc:[000000]gcclib/delete=(new,eprintf)
1978           $ library gnu_cc:[000000]gcclib/delete=L_*
1979           $ library libgcc2/extract=*/output=libgcc2.obj
1980           $ library gnu_cc:[000000]gcclib libgcc2.obj
1982      The first command simply removes old modules that will be replaced
1983      with modules from `libgcc2' under different module names.  The
1984      modules `new' and `eprintf' may not actually be present in your
1985      `gcclib.olb'--if the VMS librarian complains about those modules
1986      not being present, simply ignore the message and continue on with
1987      the next command.  The second command removes the modules that
1988      came from the previous version of the library `libgcc2.c'.
1990      Whenever you update the compiler on your system, you should also
1991      update the library with the above procedure.
1993   6. You may wish to build GCC in such a way that no files are written
1994      to the directory where the source files reside.  An example would
1995      be the when the source files are on a read-only disk.  In these
1996      cases, execute the following DCL commands (substituting your
1997      actual path names):
1999           $ assign dua0:[gcc.build_dir.]/translation=concealed, -
2000                    dua1:[gcc.source_dir.]/translation=concealed  gcc_build
2001           $ set default gcc_build:[000000]
2003      where the directory `dua1:[gcc.source_dir]' contains the source
2004      code, and the directory `dua0:[gcc.build_dir]' is meant to contain
2005      all of the generated object files and executables.  Once you have
2006      done this, you can proceed building GCC as described above.  (Keep
2007      in mind that `gcc_build' is a rooted logical name, and thus the
2008      device names in each element of the search list must be an actual
2009      physical device name rather than another rooted logical name).
2011   7. *If you are building GNU CC with a previous version of GNU CC, you
2012      also should check to see that you have the newest version of the
2013      assembler*.  In particular, GNU CC version 2 treats global constant
2014      variables slightly differently from GNU CC version 1, and GAS
2015      version 1.38.1 does not have the patches required to work with GCC
2016      version 2.  If you use GAS 1.38.1, then `extern const' variables
2017      will not have the read-only bit set, and the linker will generate
2018      warning messages about mismatched psect attributes for these
2019      variables.  These warning messages are merely a nuisance, and can
2020      safely be ignored.
2022      If you are compiling with a version of GNU CC older than 1.33,
2023      specify `/DEFINE=("inline=")' as an option in all the
2024      compilations.  This requires editing all the `gcc' commands in
2025      `make-cc1.com'.  (The older versions had problems supporting
2026      `inline'.)  Once you have a working 1.33 or newer GNU CC, you can
2027      change this file back.
2029   8. If you want to build GNU CC with the VAX C compiler, you will need
2030      to make minor changes in `make-cccp.com' and `make-cc1.com' to
2031      choose alternate definitions of `CC', `CFLAGS', and `LIBS'.  See
2032      comments in those files.  However, you must also have a working
2033      version of the GNU assembler (GNU as, aka GAS) as it is used as
2034      the back-end for GNU CC to produce binary object modules and is
2035      not included in the GNU CC sources.  GAS is also needed to compile
2036      `libgcc2' in order to build `gcclib' (see above); `make-l2.com'
2037      expects to be able to find it operational in
2038      `gnu_cc:[000000]gnu-as.exe'.
2040      To use GNU CC on VMS, you need the VMS driver programs `gcc.exe',
2041      `gcc.com', and `gcc.cld'.  They are distributed with the VMS
2042      binaries (`gcc-vms') rather than the GNU CC sources.  GAS is also
2043      included in `gcc-vms', as is Bison.
2045      Once you have successfully built GNU CC with VAX C, you should use
2046      the resulting compiler to rebuild itself.  Before doing this, be
2047      sure to restore the `CC', `CFLAGS', and `LIBS' definitions in
2048      `make-cccp.com' and `make-cc1.com'.  The second generation
2049      compiler will be able to take advantage of many optimizations that
2050      must be suppressed when building with other compilers.
2052    Under previous versions of GNU CC, the generated code would
2053 occasionally give strange results when linked with the sharable
2054 `VAXCRTL' library.  Now this should work.
2056    Even with this version, however, GNU CC itself should not be linked
2057 with the sharable `VAXCRTL'.  The version of `qsort' in `VAXCRTL' has a
2058 bug (known to be present in VMS versions V4.6 through V5.5) which
2059 causes the compiler to fail.
2061    The executables are generated by `make-cc1.com' and `make-cccp.com'
2062 use the object library version of `VAXCRTL' in order to make use of the
2063 `qsort' routine in `gcclib.olb'.  If you wish to link the compiler
2064 executables with the shareable image version of `VAXCRTL', you should
2065 edit the file `tm.h' (created by `vmsconfig.com') to define the macro
2066 `QSORT_WORKAROUND'.
2068    `QSORT_WORKAROUND' is always defined when GNU CC is compiled with
2069 VAX C, to avoid a problem in case `gcclib.olb' is not yet available.
2071 \x1f
2072 File: INSTALL,  Node: Collect2,  Next: Header Dirs,  Prev: VMS Install,  Up: Installation
2074 `collect2'
2075 ==========
2077    GNU CC uses a utility called `collect2' on nearly all systems to
2078 arrange to call various initialization functions at start time.
2080    The program `collect2' works by linking the program once and looking
2081 through the linker output file for symbols with particular names
2082 indicating they are constructor functions.  If it finds any, it creates
2083 a new temporary `.c' file containing a table of them, compiles it, and
2084 links the program a second time including that file.
2086    The actual calls to the constructors are carried out by a subroutine
2087 called `__main', which is called (automatically) at the beginning of
2088 the body of `main' (provided `main' was compiled with GNU CC).  Calling
2089 `__main' is necessary, even when compiling C code, to allow linking C
2090 and C++ object code together.  (If you use `-nostdlib', you get an
2091 unresolved reference to `__main', since it's defined in the standard
2092 GCC library.  Include `-lgcc' at the end of your compiler command line
2093 to resolve this reference.)
2095    The program `collect2' is installed as `ld' in the directory where
2096 the passes of the compiler are installed.  When `collect2' needs to
2097 find the *real* `ld', it tries the following file names:
2099    * `real-ld' in the directories listed in the compiler's search
2100      directories.
2102    * `real-ld' in the directories listed in the environment variable
2103      `PATH'.
2105    * The file specified in the `REAL_LD_FILE_NAME' configuration macro,
2106      if specified.
2108    * `ld' in the compiler's search directories, except that `collect2'
2109      will not execute itself recursively.
2111    * `ld' in `PATH'.
2113    "The compiler's search directories" means all the directories where
2114 `gcc' searches for passes of the compiler.  This includes directories
2115 that you specify with `-B'.
2117    Cross-compilers search a little differently:
2119    * `real-ld' in the compiler's search directories.
2121    * `TARGET-real-ld' in `PATH'.
2123    * The file specified in the `REAL_LD_FILE_NAME' configuration macro,
2124      if specified.
2126    * `ld' in the compiler's search directories.
2128    * `TARGET-ld' in `PATH'.
2130    `collect2' explicitly avoids running `ld' using the file name under
2131 which `collect2' itself was invoked.  In fact, it remembers up a list
2132 of such names--in case one copy of `collect2' finds another copy (or
2133 version) of `collect2' installed as `ld' in a second place in the
2134 search path.
2136    `collect2' searches for the utilities `nm' and `strip' using the
2137 same algorithm as above for `ld'.
2139 \x1f
2140 File: INSTALL,  Node: Header Dirs,  Prev: Collect2,  Up: Installation
2142 Standard Header File Directories
2143 ================================
2145    `GCC_INCLUDE_DIR' means the same thing for native and cross.  It is
2146 where GNU CC stores its private include files, and also where GNU CC
2147 stores the fixed include files.  A cross compiled GNU CC runs
2148 `fixincludes' on the header files in `$(tooldir)/include'.  (If the
2149 cross compilation header files need to be fixed, they must be installed
2150 before GNU CC is built.  If the cross compilation header files are
2151 already suitable for ANSI C and GNU CC, nothing special need be done).
2153    `GPLUS_INCLUDE_DIR' means the same thing for native and cross.  It
2154 is where `g++' looks first for header files.  The C++ library installs
2155 only target independent header files in that directory.
2157    `LOCAL_INCLUDE_DIR' is used only for a native compiler.  It is
2158 normally `/usr/local/include'.  GNU CC searches this directory so that
2159 users can install header files in `/usr/local/include'.
2161    `CROSS_INCLUDE_DIR' is used only for a cross compiler.  GNU CC
2162 doesn't install anything there.
2164    `TOOL_INCLUDE_DIR' is used for both native and cross compilers.  It
2165 is the place for other packages to install header files that GNU CC will
2166 use.  For a cross-compiler, this is the equivalent of `/usr/include'.
2167 When you build a cross-compiler, `fixincludes' processes any header
2168 files in this directory.
2171 \x1f
2172 Tag Table:
2173 Node: Installation\x7f351
2174 Node: Configurations\x7f26618
2175 Node: Other Dir\x7f65739
2176 Node: Cross-Compiler\x7f67454
2177 Node: Steps of Cross\x7f69284
2178 Node: Configure Cross\x7f70401
2179 Node: Tools and Libraries\x7f71037
2180 Node: Cross Runtime\x7f73475
2181 Node: Cross Headers\x7f77555
2182 Node: Build Cross\x7f79553
2183 Node: Sun Install\x7f81428
2184 Node: VMS Install\x7f83099
2185 Node: Collect2\x7f93028
2186 Node: Header Dirs\x7f95592
2187 \x1f
2188 End Tag Table