1 This file documents the installation of the GNU compiler. Copyright
2 (C) 1988, 1989, 1992, 1994, 1995 Free Software Foundation, Inc. You
3 may copy, distribute, and modify it freely as long as you preserve this
4 copyright notice and permission notice.
9 Here is the procedure for installing GNU CC on a Unix system. See
10 *Note VMS Install::, for VMS systems. In this section we assume you
11 compile in the same directory that contains the source files; see *Note
12 Other Dir::, to find out how to compile in a separate directory on Unix
15 You cannot install GNU C by itself on MSDOS; it will not compile
16 under any MSDOS compiler except itself. You need to get the complete
17 compilation package DJGPP, which includes binaries as well as sources,
18 and includes all the necessary compilation tools and libraries.
20 1. If you have built GNU CC previously in the same directory for a
21 different target machine, do `make distclean' to delete all files
22 that might be invalid. One of the files this deletes is
23 `Makefile'; if `make distclean' complains that `Makefile' does not
24 exist, it probably means that the directory is already suitably
27 2. On a System V release 4 system, make sure `/usr/bin' precedes
28 `/usr/ucb' in `PATH'. The `cc' command in `/usr/ucb' uses
29 libraries which have bugs.
31 3. Specify the host, build and target machine configurations. You do
32 this by running the file `configure'.
34 The "build" machine is the system which you are using, the "host"
35 machine is the system where you want to run the resulting compiler
36 (normally the build machine), and the "target" machine is the
37 system for which you want the compiler to generate code.
39 If you are building a compiler to produce code for the machine it
40 runs on (a native compiler), you normally do not need to specify
41 any operands to `configure'; it will try to guess the type of
42 machine you are on and use that as the build, host and target
43 machines. So you don't need to specify a configuration when
44 building a native compiler unless `configure' cannot figure out
45 what your configuration is or guesses wrong.
47 In those cases, specify the build machine's "configuration name"
48 with the `--host' option; the host and target will default to be
49 the same as the host machine. (If you are building a
50 cross-compiler, see *Note Cross-Compiler::.)
54 ./configure --build=sparc-sun-sunos4.1
56 A configuration name may be canonical or it may be more or less
59 A canonical configuration name has three parts, separated by
60 dashes. It looks like this: `CPU-COMPANY-SYSTEM'. (The three
61 parts may themselves contain dashes; `configure' can figure out
62 which dashes serve which purpose.) For example,
63 `m68k-sun-sunos4.1' specifies a Sun 3.
65 You can also replace parts of the configuration by nicknames or
66 aliases. For example, `sun3' stands for `m68k-sun', so
67 `sun3-sunos4.1' is another way to specify a Sun 3. You can also
68 use simply `sun3-sunos', since the version of SunOS is assumed by
69 default to be version 4.
71 You can specify a version number after any of the system types,
72 and some of the CPU types. In most cases, the version is
73 irrelevant, and will be ignored. So you might as well specify the
74 version if you know it.
76 See *Note Configurations::, for a list of supported configuration
77 names and notes on many of the configurations. You should check
78 the notes in that section before proceeding any further with the
79 installation of GNU CC.
81 There are four additional options you can specify independently to
82 describe variant hardware and software configurations. These are
83 `--with-gnu-as', `--with-gnu-ld', `--with-stabs' and `--nfp'.
86 If you will use GNU CC with the GNU assembler (GAS), you
87 should declare this by using the `--with-gnu-as' option when
90 Using this option does not install GAS. It only modifies the
91 output of GNU CC to work with GAS. Building and installing
94 Conversely, if you *do not* wish to use GAS and do not specify
95 `--with-gnu-as' when building GNU CC, it is up to you to make
96 sure that GAS is not installed. GNU CC searches for a
97 program named `as' in various directories; if the program it
98 finds is GAS, then it runs GAS. If you are not sure where
99 GNU CC finds the assembler it is using, try specifying `-v'
102 The systems where it makes a difference whether you use GAS
104 `hppa1.0-ANY-ANY', `hppa1.1-ANY-ANY', `i386-ANY-sysv',
106 `i860-ANY-bsd', `m68k-bull-sysv',
107 `m68k-hp-hpux', `m68k-sony-bsd',
108 `m68k-altos-sysv', `m68000-hp-hpux',
109 `m68000-att-sysv', `ANY-lynx-lynxos', and `mips-ANY'). On
110 any other system, `--with-gnu-as' has no effect.
112 On the systems listed above (except for the HP-PA, for ISC on
113 the 386, and for `mips-sgi-irix5.*'), if you use GAS, you
114 should also use the GNU linker (and specify `--with-gnu-ld').
117 Specify the option `--with-gnu-ld' if you plan to use the GNU
120 This option does not cause the GNU linker to be installed; it
121 just modifies the behavior of GNU CC to work with the GNU
122 linker. Specifically, it inhibits the installation of
123 `collect2', a program which otherwise serves as a front-end
124 for the system's linker on most configurations.
127 On MIPS based systems and on Alphas, you must specify whether
128 you want GNU CC to create the normal ECOFF debugging format,
129 or to use BSD-style stabs passed through the ECOFF symbol
130 table. The normal ECOFF debug format cannot fully handle
131 languages other than C. BSD stabs format can handle other
132 languages, but it only works with the GNU debugger GDB.
134 Normally, GNU CC uses the ECOFF debugging format by default;
135 if you prefer BSD stabs, specify `--with-stabs' when you
138 No matter which default you choose when you configure GNU CC,
139 the user can use the `-gcoff' and `-gstabs+' options to
140 specify explicitly the debug format for a particular
143 `--with-stabs' is meaningful on the ISC system on the 386,
144 also, if `--with-gas' is used. It selects use of stabs
145 debugging information embedded in COFF output. This kind of
146 debugging information supports C++ well; ordinary COFF
147 debugging information does not.
149 `--with-stabs' is also meaningful on 386 systems running
150 SVR4. It selects use of stabs debugging information embedded
151 in ELF output. The C++ compiler currently (2.6.0) does not
152 support the DWARF debugging information normally used on 386
153 SVR4 platforms; stabs provide a workable alternative. This
154 requires gas and gdb, as the normal SVR4 tools can not
155 generate or interpret stabs.
158 On certain systems, you must specify whether the machine has
159 a floating point unit. These systems include
160 `m68k-sun-sunosN' and `m68k-isi-bsd'. On any other system,
161 `--nfp' currently has no effect, though perhaps there are
162 other systems where it could usefully make a difference.
164 `--enable-threads=TYPE'
165 Certain systems, notably Linux-based GNU systems, can't be
166 relied on to supply a threads facility for the Objective C
167 runtime and so will default to single-threaded runtime. They
168 may, however, have a library threads implementation
169 available, in which case threads can be enabled with this
170 option by supplying a suitable TYPE, probably `posix'. The
171 possibilities for TYPE are `single', `posix', `win32',
172 `solaris', `irix' and `mach'.
174 The `configure' script searches subdirectories of the source
175 directory for other compilers that are to be integrated into GNU
176 CC. The GNU compiler for C++, called G++ is in a subdirectory
177 named `cp'. `configure' inserts rules into `Makefile' to build
178 all of those compilers.
180 Here we spell out what files will be set up by `configure'.
181 Normally you need not be concerned with these files.
183 * A file named `config.h' is created that contains a `#include'
184 of the top-level config file for the machine you will run the
185 compiler on (*note The Configuration File:
186 (gcc.info)Config.). This file is responsible for defining
187 information about the host machine. It includes `tm.h'.
189 The top-level config file is located in the subdirectory
190 `config'. Its name is always `xm-SOMETHING.h'; usually
191 `xm-MACHINE.h', but there are some exceptions.
193 If your system does not support symbolic links, you might
194 want to set up `config.h' to contain a `#include' command
195 which refers to the appropriate file.
197 * A file named `tconfig.h' is created which includes the
198 top-level config file for your target machine. This is used
199 for compiling certain programs to run on that machine.
201 * A file named `tm.h' is created which includes the
202 machine-description macro file for your target machine. It
203 should be in the subdirectory `config' and its name is often
206 * The command file `configure' also constructs the file
207 `Makefile' by adding some text to the template file
208 `Makefile.in'. The additional text comes from files in the
209 `config' directory, named `t-TARGET' and `x-HOST'. If these
210 files do not exist, it means nothing needs to be added for a
211 given target or host.
213 4. The standard directory for installing GNU CC is `/usr/local/lib'.
214 If you want to install its files somewhere else, specify
215 `--prefix=DIR' when you run `configure'. Here DIR is a directory
216 name to use instead of `/usr/local' for all purposes with one
217 exception: the directory `/usr/local/include' is searched for
218 header files no matter where you install the compiler. To override
219 this name, use the `--local-prefix' option below.
221 5. Specify `--local-prefix=DIR' if you want the compiler to search
222 directory `DIR/include' for locally installed header files
223 *instead* of `/usr/local/include'.
225 You should specify `--local-prefix' *only* if your site has a
226 different convention (not `/usr/local') for where to put
229 The default value for `--local-prefix' is `/usr/local' regardless
230 of the value of `--prefix'. Specifying `--prefix' has no effect
231 on which directory GNU CC searches for local header files. This
232 may seem counterintuitive, but actually it is logical.
234 The purpose of `--prefix' is to specify where to *install GNU CC*.
235 The local header files in `/usr/local/include'--if you put any in
236 that directory--are not part of GNU CC. They are part of other
237 programs--perhaps many others. (GNU CC installs its own header
238 files in another directory which is based on the `--prefix' value.)
240 *Do not* specify `/usr' as the `--local-prefix'! The directory
241 you use for `--local-prefix' *must not* contain any of the
242 system's standard header files. If it did contain them, certain
243 programs would be miscompiled (including GNU Emacs, on certain
244 targets), because this would override and nullify the header file
245 corrections made by the `fixincludes' script.
247 Indications are that people who use this option use it based on
248 mistaken ideas of what it is for. People use it as if it specified
249 where to install part of GNU CC. Perhaps they make this assumption
250 because installing GNU CC creates the directory.
252 6. Make sure the Bison parser generator is installed. (This is
253 unnecessary if the Bison output files `c-parse.c' and `cexp.c' are
254 more recent than `c-parse.y' and `cexp.y' and you do not plan to
255 change the `.y' files.)
257 Bison versions older than Sept 8, 1988 will produce incorrect
258 output for `c-parse.c'.
260 7. If you have chosen a configuration for GNU CC which requires other
261 GNU tools (such as GAS or the GNU linker) instead of the standard
262 system tools, install the required tools in the build directory
263 under the names `as', `ld' or whatever is appropriate. This will
264 enable the compiler to find the proper tools for compilation of
265 the program `enquire'.
267 Alternatively, you can do subsequent compilation using a value of
268 the `PATH' environment variable such that the necessary GNU tools
269 come before the standard system tools.
271 8. Build the compiler. Just type `make LANGUAGES=c' in the compiler
274 `LANGUAGES=c' specifies that only the C compiler should be
275 compiled. The makefile normally builds compilers for all the
276 supported languages; currently, C, C++ and Objective C. However,
277 C is the only language that is sure to work when you build with
278 other non-GNU C compilers. In addition, building anything but C
279 at this stage is a waste of time.
281 In general, you can specify the languages to build by typing the
282 argument `LANGUAGES="LIST"', where LIST is one or more words from
283 the list `c', `c++', and `objective-c'. If you have any
284 additional GNU compilers as subdirectories of the GNU CC source
285 directory, you may also specify their names in this list.
287 Ignore any warnings you may see about "statement not reached" in
288 `insn-emit.c'; they are normal. Also, warnings about "unknown
289 escape sequence" are normal in `genopinit.c' and perhaps some
290 other files. Likewise, you should ignore warnings about "constant
291 is so large that it is unsigned" in `insn-emit.c' and
292 `insn-recog.c' and a warning about a comparison always being zero
293 in `enquire.o'. Any other compilation errors may represent bugs in
294 the port to your machine or operating system, and should be
295 investigated and reported.
297 Some commercial compilers fail to compile GNU CC because they have
298 bugs or limitations. For example, the Microsoft compiler is said
299 to run out of macro space. Some Ultrix compilers run out of
300 expression space; then you need to break up the statement where
303 9. If you are building a cross-compiler, stop here. *Note
306 10. Move the first-stage object files and executables into a
307 subdirectory with this command:
311 The files are moved into a subdirectory named `stage1'. Once
312 installation is complete, you may wish to delete these files with
315 11. If you have chosen a configuration for GNU CC which requires other
316 GNU tools (such as GAS or the GNU linker) instead of the standard
317 system tools, install the required tools in the `stage1'
318 subdirectory under the names `as', `ld' or whatever is
319 appropriate. This will enable the stage 1 compiler to find the
320 proper tools in the following stage.
322 Alternatively, you can do subsequent compilation using a value of
323 the `PATH' environment variable such that the necessary GNU tools
324 come before the standard system tools.
326 12. Recompile the compiler with itself, with this command:
328 make CC="stage1/xgcc -Bstage1/" CFLAGS="-g -O2"
330 This is called making the stage 2 compiler.
332 The command shown above builds compilers for all the supported
333 languages. If you don't want them all, you can specify the
334 languages to build by typing the argument `LANGUAGES="LIST"'. LIST
335 should contain one or more words from the list `c', `c++',
336 `objective-c', and `proto'. Separate the words with spaces.
337 `proto' stands for the programs `protoize' and `unprotoize'; they
338 are not a separate language, but you use `LANGUAGES' to enable or
339 disable their installation.
341 If you are going to build the stage 3 compiler, then you might
342 want to build only the C language in stage 2.
344 Once you have built the stage 2 compiler, if you are short of disk
345 space, you can delete the subdirectory `stage1'.
347 On a 68000 or 68020 system lacking floating point hardware, unless
348 you have selected a `tm.h' file that expects by default that there
349 is no such hardware, do this instead:
351 make CC="stage1/xgcc -Bstage1/" CFLAGS="-g -O2 -msoft-float"
353 13. If you wish to test the compiler by compiling it with itself one
354 more time, install any other necessary GNU tools (such as GAS or
355 the GNU linker) in the `stage2' subdirectory as you did in the
356 `stage1' subdirectory, then do this:
359 make CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O2"
361 This is called making the stage 3 compiler. Aside from the `-B'
362 option, the compiler options should be the same as when you made
363 the stage 2 compiler. But the `LANGUAGES' option need not be the
364 same. The command shown above builds compilers for all the
365 supported languages; if you don't want them all, you can specify
366 the languages to build by typing the argument `LANGUAGES="LIST"',
369 If you do not have to install any additional GNU tools, you may
372 make bootstrap LANGUAGES=LANGUAGE-LIST BOOT_CFLAGS=OPTION-LIST
374 instead of making `stage1', `stage2', and performing the two
377 14. Then compare the latest object files with the stage 2 object
378 files--they ought to be identical, aside from time stamps (if any).
380 On some systems, meaningful comparison of object files is
381 impossible; they always appear "different." This is currently
382 true on Solaris and some systems that use ELF object file format.
383 On some versions of Irix on SGI machines and DEC Unix (OSF/1) on
384 Alpha systems, you will not be able to compare the files without
385 specifying `-save-temps'; see the description of individual
386 systems above to see if you get comparison failures. You may have
387 similar problems on other systems.
389 Use this command to compare the files:
393 This will mention any object files that differ between stage 2 and
394 stage 3. Any difference, no matter how innocuous, indicates that
395 the stage 2 compiler has compiled GNU CC incorrectly, and is
396 therefore a potentially serious bug which you should investigate
399 If your system does not put time stamps in the object files, then
400 this is a faster way to compare them (using the Bourne shell):
403 cmp $file stage2/$file
406 If you have built the compiler with the `-mno-mips-tfile' option on
407 MIPS machines, you will not be able to compare the files.
409 15. Install the compiler driver, the compiler's passes and run-time
410 support with `make install'. Use the same value for `CC',
411 `CFLAGS' and `LANGUAGES' that you used when compiling the files
412 that are being installed. One reason this is necessary is that
413 some versions of Make have bugs and recompile files gratuitously
414 when you do this step. If you use the same variable values, those
415 files will be recompiled properly.
417 For example, if you have built the stage 2 compiler, you can use
418 the following command:
420 make install CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O" LANGUAGES="LIST"
422 This copies the files `cc1', `cpp' and `libgcc.a' to files `cc1',
423 `cpp' and `libgcc.a' in the directory
424 `/usr/local/lib/gcc-lib/TARGET/VERSION', which is where the
425 compiler driver program looks for them. Here TARGET is the
426 canonicalized form of target machine type specified when you ran
427 `configure', and VERSION is the version number of GNU CC. This
428 naming scheme permits various versions and/or cross-compilers to
429 coexist. It also copies the executables for compilers for other
430 languages (e.g., `cc1plus' for C++) to the same directory.
432 This also copies the driver program `xgcc' into
433 `/usr/local/bin/gcc', so that it appears in typical execution
434 search paths. It also copies `gcc.1' into `/usr/local/man/man1'
435 and info pages into `/usr/local/info'.
437 On some systems, this command causes recompilation of some files.
438 This is usually due to bugs in `make'. You should either ignore
439 this problem, or use GNU Make.
441 *Warning: there is a bug in `alloca' in the Sun library. To avoid
442 this bug, be sure to install the executables of GNU CC that were
443 compiled by GNU CC. (That is, the executables from stage 2 or 3,
444 not stage 1.) They use `alloca' as a built-in function and never
445 the one in the library.*
447 (It is usually better to install GNU CC executables from stage 2
448 or 3, since they usually run faster than the ones compiled with
449 some other compiler.)
451 16. If you're going to use C++, it's likely that you need to also
452 install a C++ runtime library. Just as GNU C does not distribute
453 a C runtime library, it also does not include a C++ runtime
454 library. All I/O functionality, special class libraries, etc., are
455 provided by the C++ runtime library.
457 The standard C++ runtime library for GNU CC is called `libstdc++'.
458 An obsolescent library `libg++' may also be available, but it's
459 necessary only for older software that hasn't been converted yet;
460 if you don't know whether you need `libg++' then you probably don't
463 Here's one way to build and install `libstdc++' for GNU CC:
465 * Build and install GNU CC, so that invoking `gcc' obtains the
466 GNU CC that was just built.
468 * Obtain a copy of a compatible `libstdc++' distribution. For
469 example, the `libstdc++-2.8.0.tar.gz' distribution should be
470 compatible with GCC 2.8.0. GCC distributors normally
471 distribute `libstdc++' as well.
473 * Set the `CXX' environment variable to `gcc' while running the
474 `libstdc++' distribution's `configure' command. Use the same
475 `configure' options that you used when you invoked GCC's
478 * Invoke `make' to build the C++ runtime.
480 * Invoke `make install' to install the C++ runtime.
482 To summarize, after building and installing GNU CC, invoke the
483 following shell commands in the topmost directory of the C++
484 library distribution. For CONFIGURE-OPTIONS, use the same options
485 that you used to configure GNU CC.
487 $ CXX=gcc ./configure CONFIGURE-OPTIONS
491 17. GNU CC includes a runtime library for Objective-C because it is an
492 integral part of the language. You can find the files associated
493 with the library in the subdirectory `objc'. The GNU Objective-C
494 Runtime Library requires header files for the target's C library in
495 order to be compiled,and also requires the header files for the
496 target's thread library if you want thread support. *Note
497 Cross-Compilers and Header Files: Cross Headers, for discussion
498 about header files issues for cross-compilation.
500 When you run `configure', it picks the appropriate Objective-C
501 thread implementation file for the target platform. In some
502 situations, you may wish to choose a different back-end as some
503 platforms support multiple thread implementations or you may wish
504 to disable thread support completely. You do this by specifying a
505 value for the OBJC_THREAD_FILE makefile variable on the command
506 line when you run make, for example:
508 make CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O2" OBJC_THREAD_FILE=thr-single
510 Below is a list of the currently available back-ends.
512 * thr-single Disable thread support, should work for all
515 * thr-decosf1 DEC OSF/1 thread support.
517 * thr-irix SGI IRIX thread support.
519 * thr-mach Generic MACH thread support, known to work on
522 * thr-os2 IBM OS/2 thread support.
524 * thr-posix Generix POSIX thread support.
526 * thr-pthreads PCThreads on Linux-based GNU systems.
528 * thr-solaris SUN Solaris thread support.
530 * thr-win32 Microsoft Win32 API thread support.
532 Configurations Supported by GNU CC
533 ==================================
535 Here are the possible CPU types:
537 1750a, a29k, alpha, arm, cN, clipper, dsp16xx, elxsi, h8300,
538 hppa1.0, hppa1.1, i370, i386, i486, i586, i860, i960, m32r,
539 m68000, m68k, m88k, mips, mipsel, mips64, mips64el, ns32k,
540 powerpc, powerpcle, pyramid, romp, rs6000, sh, sparc, sparclite,
543 Here are the recognized company names. As you can see, customary
544 abbreviations are used rather than the longer official names.
546 acorn, alliant, altos, apollo, apple, att, bull, cbm, convergent,
547 convex, crds, dec, dg, dolphin, elxsi, encore, harris, hitachi,
548 hp, ibm, intergraph, isi, mips, motorola, ncr, next, ns, omron,
549 plexus, sequent, sgi, sony, sun, tti, unicom, wrs.
551 The company name is meaningful only to disambiguate when the rest of
552 the information supplied is insufficient. You can omit it, writing
553 just `CPU-SYSTEM', if it is not needed. For example, `vax-ultrix4.2'
554 is equivalent to `vax-dec-ultrix4.2'.
556 Here is a list of system types:
558 386bsd, aix, acis, amigaos, aos, aout, aux, bosx, bsd, clix, coff,
559 ctix, cxux, dgux, dynix, ebmon, ecoff, elf, esix, freebsd, hms,
560 genix, gnu, linux-gnu, hiux, hpux, iris, irix, isc, luna, lynxos,
561 mach, minix, msdos, mvs, netbsd, newsos, nindy, ns, osf, osfrose,
562 ptx, riscix, riscos, rtu, sco, sim, solaris, sunos, sym, sysv,
563 udi, ultrix, unicos, uniplus, unos, vms, vsta, vxworks, winnt,
566 You can omit the system type; then `configure' guesses the operating
567 system from the CPU and company.
569 You can add a version number to the system type; this may or may not
570 make a difference. For example, you can write `bsd4.3' or `bsd4.4' to
571 distinguish versions of BSD. In practice, the version number is most
572 needed for `sysv3' and `sysv4', which are often treated differently.
574 If you specify an impossible combination such as `i860-dg-vms', then
575 you may get an error message from `configure', or it may ignore part of
576 the information and do the best it can with the rest. `configure'
577 always prints the canonical name for the alternative that it used. GNU
578 CC does not support all possible alternatives.
580 Often a particular model of machine has a name. Many machine names
581 are recognized as aliases for CPU/company combinations. Thus, the
582 machine name `sun3', mentioned above, is an alias for `m68k-sun'.
583 Sometimes we accept a company name as a machine name, when the name is
584 popularly used for a particular machine. Here is a table of the known
587 3300, 3b1, 3bN, 7300, altos3068, altos, apollo68, att-7300,
588 balance, convex-cN, crds, decstation-3100, decstation, delta,
589 encore, fx2800, gmicro, hp7NN, hp8NN, hp9k2NN, hp9k3NN, hp9k7NN,
590 hp9k8NN, iris4d, iris, isi68, m3230, magnum, merlin, miniframe,
591 mmax, news-3600, news800, news, next, pbd, pc532, pmax, powerpc,
592 powerpcle, ps2, risc-news, rtpc, sun2, sun386i, sun386, sun3,
593 sun4, symmetry, tower-32, tower.
595 Remember that a machine name specifies both the cpu type and the company
596 name. If you want to install your own homemade configuration files,
597 you can use `local' as the company name to access them. If you use
598 configuration `CPU-local', the configuration name without the cpu prefix
599 is used to form the configuration file names.
601 Thus, if you specify `m68k-local', configuration uses files
602 `m68k.md', `local.h', `m68k.c', `xm-local.h', `t-local', and `x-local',
603 all in the directory `config/m68k'.
605 Here is a list of configurations that have special treatment or
606 special things you must know:
609 MIL-STD-1750A processors.
611 The MIL-STD-1750A cross configuration produces output for
612 `as1750', an assembler/linker available under the GNU Public
613 License for the 1750A. `as1750' can be obtained at
614 *ftp://ftp.fta-berlin.de/pub/crossgcc/1750gals/*. A similarly
615 licensed simulator for the 1750A is available from same address.
617 You should ignore a fatal error during the building of libgcc
618 (libgcc is not yet implemented for the 1750A.)
620 The `as1750' assembler requires the file `ms1750.inc', which is
621 found in the directory `config/1750a'.
623 GNU CC produced the same sections as the Fairchild F9450 C
627 The program code section.
630 The read/write (RAM) data section.
633 The read-only (ROM) constants section.
636 Initialization section (code to copy KREL to SREL).
638 The smallest addressable unit is 16 bits (BITS_PER_UNIT is 16).
639 This means that type `char' is represented with a 16-bit word per
640 character. The 1750A's "Load/Store Upper/Lower Byte" instructions
641 are not used by GNU CC.
644 Systems using processors that implement the DEC Alpha architecture
645 and are running the DEC Unix (OSF/1) operating system, for example
646 the DEC Alpha AXP systems.CC.)
648 GNU CC writes a `.verstamp' directive to the assembler output file
649 unless it is built as a cross-compiler. It gets the version to
650 use from the system header file `/usr/include/stamp.h'. If you
651 install a new version of DEC Unix, you should rebuild GCC to pick
652 up the new version stamp.
654 Note that since the Alpha is a 64-bit architecture,
655 cross-compilers from 32-bit machines will not generate code as
656 efficient as that generated when the compiler is running on a
657 64-bit machine because many optimizations that depend on being
658 able to represent a word on the target in an integral value on the
659 host cannot be performed. Building cross-compilers on the Alpha
660 for 32-bit machines has only been tested in a few cases and may
663 `make compare' may fail on old versions of DEC Unix unless you add
664 `-save-temps' to `CFLAGS'. On these systems, the name of the
665 assembler input file is stored in the object file, and that makes
666 comparison fail if it differs between the `stage1' and `stage2'
667 compilations. The option `-save-temps' forces a fixed name to be
668 used for the assembler input file, instead of a randomly chosen
669 name in `/tmp'. Do not add `-save-temps' unless the comparisons
670 fail without that option. If you add `-save-temps', you will have
671 to manually delete the `.i' and `.s' files after each series of
674 GNU CC now supports both the native (ECOFF) debugging format used
675 by DBX and GDB and an encapsulated STABS format for use only with
676 GDB. See the discussion of the `--with-stabs' option of
677 `configure' above for more information on these formats and how to
680 There is a bug in DEC's assembler that produces incorrect line
681 numbers for ECOFF format when the `.align' directive is used. To
682 work around this problem, GNU CC will not emit such alignment
683 directives while writing ECOFF format debugging information even
684 if optimization is being performed. Unfortunately, this has the
685 very undesirable side-effect that code addresses when `-O' is
686 specified are different depending on whether or not `-g' is also
689 To avoid this behavior, specify `-gstabs+' and use GDB instead of
690 DBX. DEC is now aware of this problem with the assembler and
691 hopes to provide a fix shortly.
694 Argonaut ARC processor. This configuration is intended for
698 Advanced RISC Machines ARM-family processors. These are often
699 used in embedded applications. There are no standard Unix
700 configurations. This configuration corresponds to the basic
701 instruction sequences and will produce `a.out' format object
704 You may need to make a variant of the file `arm.h' for your
705 particular configuration.
708 Any of the ARM family processors running the Linux-based GNU
709 system with the `a.out' binary format (ELF is not yet supported).
710 You must use version 2.8.1.0.7 or later of the GNU/Linux binutils,
711 which you can download from `sunsite.unc.edu:/pub/Linux/GCC' and
712 other mirror sites for Linux-based GNU systems.
715 The ARM2 or ARM3 processor running RISC iX, Acorn's port of BSD
716 Unix. If you are running a version of RISC iX prior to 1.2 then
717 you must specify the version number during configuration. Note
718 that the assembler shipped with RISC iX does not support stabs
719 debugging information; a new version of the assembler, with stabs
720 support included, is now available from Acorn and via ftp
721 `ftp.acorn.com:/pub/riscix/as+xterm.tar.Z'. To enable stabs
722 debugging, pass `--with-gnu-as' to configure.
724 You will need to install GNU `sed' before you can run configure.
727 AMD Am29k-family processors. These are normally used in embedded
728 applications. There are no standard Unix configurations. This
729 configuration corresponds to AMD's standard calling sequence and
730 binary interface and is compatible with other 29k tools.
732 You may need to make a variant of the file `a29k.h' for your
733 particular configuration.
736 AMD Am29050 used in a system running a variant of BSD Unix.
739 MIPS-based DECstations can support three different personalities:
740 Ultrix, DEC OSF/1, and OSF/rose. (Alpha-based DECstation products
741 have a configuration name beginning with `alpha-dec'.) To
742 configure GCC for these platforms use the following configurations:
745 Ultrix configuration.
748 Dec's version of OSF/1.
751 Open Software Foundation reference port of OSF/1 which uses
752 the OSF/rose object file format instead of ECOFF. Normally,
753 you would not select this configuration.
755 The MIPS C compiler needs to be told to increase its table size
756 for switch statements with the `-Wf,-XNg1500' option in order to
757 compile `cp/parse.c'. If you use the `-O2' optimization option,
758 you also need to use `-Olimit 3000'. Both of these options are
759 automatically generated in the `Makefile' that the shell script
760 `configure' builds. If you override the `CC' make variable and
761 use the MIPS compilers, you may need to add `-Wf,-XNg1500 -Olimit
765 The Elxsi's C compiler has known limitations that prevent it from
766 compiling GNU C. Please contact `mrs@cygnus.com' for more details.
769 A port to the AT&T DSP1610 family of processors.
772 Hitachi H8/300 series of processors.
774 The calling convention and structure layout has changed in release
775 2.6. All code must be recompiled. The calling convention now
776 passes the first three arguments in function calls in registers.
777 Structures are no longer a multiple of 2 bytes.
780 There are several variants of the HP-PA processor which run a
781 variety of operating systems. GNU CC must be configured to use
782 the correct processor type and operating system, or GNU CC will
783 not function correctly. The easiest way to handle this problem is
784 to *not* specify a target when configuring GNU CC, the `configure'
785 script will try to automatically determine the right processor
786 type and operating system.
788 `-g' does not work on HP-UX, since that system uses a peculiar
789 debugging format which GNU CC does not know about. However, `-g'
790 will work if you also use GAS and GDB in conjunction with GCC. We
791 highly recommend using GAS for all HP-PA configurations.
793 You should be using GAS-2.6 (or later) along with GDB-4.16 (or
794 later). These can be retrieved from all the traditional GNU ftp
797 GAS will need to be installed into a directory before `/bin',
798 `/usr/bin', and `/usr/ccs/bin' in your search path. You should
799 install GAS before you build GNU CC.
801 To enable debugging, you must configure GNU CC with the
802 `--with-gnu-as' option before building.
805 This port is very preliminary and has many known bugs. We hope to
806 have a higher-quality port for this machine soon.
808 `i386-*-linux-gnuoldld'
809 Use this configuration to generate `a.out' binaries on Linux-based
810 GNU systems if you do not have gas/binutils version 2.5.2 or later
811 installed. This is an obsolete configuration.
813 `i386-*-linux-gnuaout'
814 Use this configuration to generate `a.out' binaries on Linux-based
815 GNU systems. This configuration is being superseded. You must use
816 gas/binutils version 2.5.2 or later.
819 Use this configuration to generate ELF binaries on Linux-based GNU
820 systems. You must use gas/binutils version 2.5.2 or later.
823 Compilation with RCC is recommended. Also, it may be a good idea
824 to link with GNU malloc instead of the malloc that comes with the
828 Use this configuration for SCO release 3.2 version 4.
831 Use this for the SCO OpenServer Release family including 5.0.0,
832 5.0.2, 5.0.4, Internet FastStart 1.0, and Internet FastStart 1.1.
834 GNU CC can generate either ELF or COFF binaries. ELF is the
835 default. To get COFF output, you must specify `-mcoff' on the
838 For 5.0.0 and 5.0.2, you must install TLS597 from ftp.sco.com/TLS.
839 5.0.4 and later do not require this patch.
841 *NOTE:* You must follow the instructions about invoking `make
842 bootstrap' because the native OpenServer compiler builds a
843 `cc1plus' that will not correctly parse many valid C++ programs.
844 You must do a `make bootstrap' if you are building with the native
848 It may be a good idea to link with GNU malloc instead of the
849 malloc that comes with the system.
851 In ISC version 4.1, `sed' core dumps when building `deduced.h'.
852 Use the version of `sed' from version 4.0.
855 It may be good idea to link with GNU malloc instead of the malloc
856 that comes with the system.
859 You need to use GAS version 2.1 or later, and LD from GNU binutils
860 version 2.2 or later.
863 Go to the Berkeley universe before compiling.
866 Sequent DYNIX/ptx 1.x.
869 Sequent DYNIX/ptx 2.x.
872 You may find that you need another version of GNU CC to begin
873 bootstrapping with, since the current version when built with the
874 system's own compiler seems to get an infinite loop compiling part
875 of `libgcc2.c'. GNU CC version 2 compiled with GNU CC (any
876 version) seems not to have this problem.
878 See *Note Sun Install::, for information on installing GNU CC on
881 `i[345]86-*-winnt3.5'
882 This version requires a GAS that has not yet been released. Until
883 it is, you can get a prebuilt binary version via anonymous ftp from
884 `cs.washington.edu:pub/gnat' or `cs.nyu.edu:pub/gnat'. You must
885 also use the Microsoft header files from the Windows NT 3.5 SDK.
886 Find these on the CDROM in the `/mstools/h' directory dated
887 9/4/94. You must use a fixed version of Microsoft linker made
888 especially for NT 3.5, which is also is available on the NT 3.5
889 SDK CDROM. If you do not have this linker, can you also use the
890 linker from Visual C/C++ 1.0 or 2.0.
892 Installing GNU CC for NT builds a wrapper linker, called `ld.exe',
893 which mimics the behaviour of Unix `ld' in the specification of
894 libraries (`-L' and `-l'). `ld.exe' looks for both Unix and
895 Microsoft named libraries. For example, if you specify `-lfoo',
896 `ld.exe' will look first for `libfoo.a' and then for `foo.lib'.
898 You may install GNU CC for Windows NT in one of two ways,
899 depending on whether or not you have a Unix-like shell and various
902 1. If you do not have a Unix-like shell and few Unix-like
903 utilities, you will use a DOS style batch script called
904 `configure.bat'. Invoke it as `configure winnt' from an
905 MSDOS console window or from the program manager dialog box.
906 `configure.bat' assumes you have already installed and have
907 in your path a Unix-like `sed' program which is used to
908 create a working `Makefile' from `Makefile.in'.
910 `Makefile' uses the Microsoft Nmake program maintenance
911 utility and the Visual C/C++ V8.00 compiler to build GNU CC.
912 You need only have the utilities `sed' and `touch' to use
913 this installation method, which only automatically builds the
914 compiler itself. You must then examine what `fixinc.winnt'
915 does, edit the header files by hand and build `libgcc.a'
918 2. The second type of installation assumes you are running a
919 Unix-like shell, have a complete suite of Unix-like utilities
920 in your path, and have a previous version of GNU CC already
921 installed, either through building it via the above
922 installation method or acquiring a pre-built binary. In this
923 case, use the `configure' script in the normal fashion.
926 This is the Paragon. If you have version 1.0 of the operating
927 system, you need to take special steps to build GNU CC due to
928 peculiarities of the system. Newer system versions have no
929 problem. See the section `Installation Problems' in the GNU CC
933 LynxOS 2.2 and earlier comes with GNU CC 1.x already installed as
934 `/bin/gcc'. You should compile with this instead of `/bin/cc'.
935 You can tell GNU CC to use the GNU assembler and linker, by
936 specifying `--with-gnu-as --with-gnu-ld' when configuring. These
937 will produce COFF format object files and executables; otherwise
938 GNU CC will use the installed tools, which produce `a.out' format
942 Mitsubishi M32R processor. This configuration is intended for
946 HP 9000 series 200 running BSD. Note that the C compiler that
947 comes with this system cannot compile GNU CC; contact
948 `law@cygnus.com' to get binaries of GNU CC for bootstrapping.
951 Altos 3068. You must use the GNU assembler, linker and debugger.
952 Also, you must fix a kernel bug. Details in the file
956 Apple Macintosh running A/UX. You may configure GCC to use
957 either the system assembler and linker or the GNU assembler and
958 linker. You should use the GNU configuration if you can,
959 especially if you also want to use GNU C++. You enabled that
960 configuration with + the `--with-gnu-as' and `--with-gnu-ld'
961 options to `configure'.
963 Note the C compiler that comes with this system cannot compile GNU
964 CC. You can fine binaries of GNU CC for bootstrapping on
965 `jagubox.gsfc.nasa.gov'. You will also a patched version of
966 `/bin/ld' there that raises some of the arbitrary limits found in
970 AT&T 3b1, a.k.a. 7300 PC. Special procedures are needed to
971 compile GNU CC with this machine's standard C compiler, due to
972 bugs in that compiler. You can bootstrap it more easily with
973 previous versions of GNU CC if you have them.
975 Installing GNU CC on the 3b1 is difficult if you do not already
976 have GNU CC running, due to bugs in the installed C compiler.
977 However, the following procedure might work. We are unable to
980 1. Comment out the `#include "config.h"' line near the start of
981 `cccp.c' and do `make cpp'. This makes a preliminary version
984 2. Save the old `/lib/cpp' and copy the preliminary GNU cpp to
987 3. Undo your change in `cccp.c', or reinstall the original
988 version, and do `make cpp' again.
990 4. Copy this final version of GNU cpp into `/lib/cpp'.
992 5. Replace every occurrence of `obstack_free' in the file
993 `tree.c' with `_obstack_free'.
995 6. Run `make' to get the first-stage GNU CC.
997 7. Reinstall the original version of `/lib/cpp'.
999 8. Now you can compile GNU CC with itself and install it in the
1003 Bull DPX/2 series 200 and 300 with BOS-2.00.45 up to BOS-2.01. GNU
1004 CC works either with native assembler or GNU assembler. You can use
1005 GNU assembler with native coff generation by providing
1006 `--with-gnu-as' to the configure script or use GNU assembler with
1007 dbx-in-coff encapsulation by providing `--with-gnu-as --stabs'.
1008 For any problem with native assembler or for availability of the
1009 DPX/2 port of GAS, contact `F.Pierresteguy@frcl.bull.fr'.
1012 Use `configure unos' for building on Unos.
1014 The Unos assembler is named `casm' instead of `as'. For some
1015 strange reason linking `/bin/as' to `/bin/casm' changes the
1016 behavior, and does not work. So, when installing GNU CC, you
1017 should install the following script as `as' in the subdirectory
1018 where the passes of GCC are installed:
1023 The default Unos library is named `libunos.a' instead of `libc.a'.
1024 To allow GNU CC to function, either change all references to
1025 `-lc' in `gcc.c' to `-lunos' or link `/lib/libc.a' to
1028 When compiling GNU CC with the standard compiler, to overcome bugs
1029 in the support of `alloca', do not use `-O' when making stage 2.
1030 Then use the stage 2 compiler with `-O' to make the stage 3
1031 compiler. This compiler will have the same characteristics as the
1032 usual stage 2 compiler on other systems. Use it to make a stage 4
1033 compiler and compare that with stage 3 to verify proper
1036 (Perhaps simply defining `ALLOCA' in `x-crds' as described in the
1037 comments there will make the above paragraph superfluous. Please
1038 inform us of whether this works.)
1040 Unos uses memory segmentation instead of demand paging, so you
1041 will need a lot of memory. 5 Mb is barely enough if no other
1042 tasks are running. If linking `cc1' fails, try putting the object
1043 files into a library and linking from that library.
1046 HP 9000 series 300 or 400 running HP-UX. HP-UX version 8.0 has a
1047 bug in the assembler that prevents compilation of GNU CC. To fix
1048 it, get patch PHCO_4484 from HP.
1050 In addition, if you wish to use gas `--with-gnu-as' you must use
1051 gas version 2.1 or later, and you must use the GNU linker version
1052 2.1 or later. Earlier versions of gas relied upon a program which
1053 converted the gas output into the native HP/UX format, but that
1054 program has not been kept up to date. gdb does not understand
1055 that native HP/UX format, so you must use gas if you wish to use
1059 Sun 3. We do not provide a configuration file to use the Sun FPA
1060 by default, because programs that establish signal handlers for
1061 floating point traps inherently cannot work with the FPA.
1063 See *Note Sun Install::, for information on installing GNU CC on
1067 Motorola m88k running the AT&T/Unisoft/Motorola V.3 reference port.
1068 These systems tend to use the Green Hills C, revision 1.8.5, as the
1069 standard C compiler. There are apparently bugs in this compiler
1070 that result in object files differences between stage 2 and stage
1071 3. If this happens, make the stage 4 compiler and compare it to
1072 the stage 3 compiler. If the stage 3 and stage 4 object files are
1073 identical, this suggests you encountered a problem with the
1074 standard C compiler; the stage 3 and 4 compilers may be usable.
1076 It is best, however, to use an older version of GNU CC for
1077 bootstrapping if you have one.
1080 Motorola m88k running DG/UX. To build 88open BCS native or cross
1081 compilers on DG/UX, specify the configuration name as
1082 `m88k-*-dguxbcs' and build in the 88open BCS software development
1083 environment. To build ELF native or cross compilers on DG/UX,
1084 specify `m88k-*-dgux' and build in the DG/UX ELF development
1085 environment. You set the software development environment by
1086 issuing `sde-target' command and specifying either `m88kbcs' or
1087 `m88kdguxelf' as the operand.
1089 If you do not specify a configuration name, `configure' guesses the
1090 configuration based on the current software development
1093 `m88k-tektronix-sysv3'
1094 Tektronix XD88 running UTekV 3.2e. Do not turn on optimization
1095 while building stage1 if you bootstrap with the buggy Green Hills
1096 compiler. Also, The bundled LAI System V NFS is buggy so if you
1097 build in an NFS mounted directory, start from a fresh reboot, or
1098 avoid NFS all together. Otherwise you may have trouble getting
1099 clean comparisons between stages.
1102 MIPS machines running the MIPS operating system in BSD mode. It's
1103 possible that some old versions of the system lack the functions
1104 `memcpy', `memcmp', and `memset'. If your system lacks these, you
1105 must remove or undo the definition of `TARGET_MEM_FUNCTIONS' in
1108 The MIPS C compiler needs to be told to increase its table size
1109 for switch statements with the `-Wf,-XNg1500' option in order to
1110 compile `cp/parse.c'. If you use the `-O2' optimization option,
1111 you also need to use `-Olimit 3000'. Both of these options are
1112 automatically generated in the `Makefile' that the shell script
1113 `configure' builds. If you override the `CC' make variable and
1114 use the MIPS compilers, you may need to add `-Wf,-XNg1500 -Olimit
1118 The MIPS C compiler needs to be told to increase its table size
1119 for switch statements with the `-Wf,-XNg1500' option in order to
1120 compile `cp/parse.c'. If you use the `-O2' optimization option,
1121 you also need to use `-Olimit 3000'. Both of these options are
1122 automatically generated in the `Makefile' that the shell script
1123 `configure' builds. If you override the `CC' make variable and
1124 use the MIPS compilers, you may need to add `-Wf,-XNg1500 -Olimit
1127 MIPS computers running RISC-OS can support four different
1128 personalities: default, BSD 4.3, System V.3, and System V.4 (older
1129 versions of RISC-OS don't support V.4). To configure GCC for
1130 these platforms use the following configurations:
1132 `mips-mips-riscos`rev''
1133 Default configuration for RISC-OS, revision `rev'.
1135 `mips-mips-riscos`rev'bsd'
1136 BSD 4.3 configuration for RISC-OS, revision `rev'.
1138 `mips-mips-riscos`rev'sysv4'
1139 System V.4 configuration for RISC-OS, revision `rev'.
1141 `mips-mips-riscos`rev'sysv'
1142 System V.3 configuration for RISC-OS, revision `rev'.
1144 The revision `rev' mentioned above is the revision of RISC-OS to
1145 use. You must reconfigure GCC when going from a RISC-OS revision
1146 4 to RISC-OS revision 5. This has the effect of avoiding a linker
1150 In order to compile GCC on an SGI running IRIX 4, the "c.hdr.lib"
1151 option must be installed from the CD-ROM supplied from Silicon
1152 Graphics. This is found on the 2nd CD in release 4.0.1.
1154 In order to compile GCC on an SGI running IRIX 5, the
1155 "compiler_dev.hdr" subsystem must be installed from the IDO CD-ROM
1156 supplied by Silicon Graphics.
1158 `make compare' may fail on version 5 of IRIX unless you add
1159 `-save-temps' to `CFLAGS'. On these systems, the name of the
1160 assembler input file is stored in the object file, and that makes
1161 comparison fail if it differs between the `stage1' and `stage2'
1162 compilations. The option `-save-temps' forces a fixed name to be
1163 used for the assembler input file, instead of a randomly chosen
1164 name in `/tmp'. Do not add `-save-temps' unless the comparisons
1165 fail without that option. If you do you `-save-temps', you will
1166 have to manually delete the `.i' and `.s' files after each series
1169 The MIPS C compiler needs to be told to increase its table size
1170 for switch statements with the `-Wf,-XNg1500' option in order to
1171 compile `cp/parse.c'. If you use the `-O2' optimization option,
1172 you also need to use `-Olimit 3000'. Both of these options are
1173 automatically generated in the `Makefile' that the shell script
1174 `configure' builds. If you override the `CC' make variable and
1175 use the MIPS compilers, you may need to add `-Wf,-XNg1500 -Olimit
1178 On Irix version 4.0.5F, and perhaps on some other versions as well,
1179 there is an assembler bug that reorders instructions incorrectly.
1180 To work around it, specify the target configuration
1181 `mips-sgi-irix4loser'. This configuration inhibits assembler
1184 In a compiler configured with target `mips-sgi-irix4', you can turn
1185 off assembler optimization by using the `-noasmopt' option. This
1186 compiler option passes the option `-O0' to the assembler, to
1189 The `-noasmopt' option can be useful for testing whether a problem
1190 is due to erroneous assembler reordering. Even if a problem does
1191 not go away with `-noasmopt', it may still be due to assembler
1192 reordering--perhaps GNU CC itself was miscompiled as a result.
1194 To enable debugging under Irix 5, you must use GNU as 2.5 or later,
1195 and use the `--with-gnu-as' configure option when configuring gcc.
1196 GNU as is distributed as part of the binutils package.
1199 Sony MIPS NEWS. This works in NEWSOS 5.0.1, but not in 5.0.2
1200 (which uses ELF instead of COFF). Support for 5.0.2 will probably
1201 be provided soon by volunteers. In particular, the linker does
1202 not like the code generated by GCC when shared libraries are
1206 Encore ns32000 system. Encore systems are supported only under
1210 National Semiconductor ns32000 system. Genix has bugs in `alloca'
1211 and `malloc'; you must get the compiled versions of these from GNU
1215 Go to the Berkeley universe before compiling.
1218 UTEK ns32000 system ("merlin"). The C compiler that comes with
1219 this system cannot compile GNU CC; contact `tektronix!reed!mason'
1220 to get binaries of GNU CC for bootstrapping.
1224 The only operating systems supported for the IBM RT PC are AOS and
1225 MACH. GNU CC does not support AIX running on the RT. We
1226 recommend you compile GNU CC with an earlier version of itself; if
1227 you compile GNU CC with `hc', the Metaware compiler, it will work,
1228 but you will get mismatches between the stage 2 and stage 3
1229 compilers in various files. These errors are minor differences in
1230 some floating-point constants and can be safely ignored; the stage
1231 3 compiler is correct.
1235 Various early versions of each release of the IBM XLC compiler
1236 will not bootstrap GNU CC. Symptoms include differences between
1237 the stage2 and stage3 object files, and errors when compiling
1238 `libgcc.a' or `enquire'. Known problematic releases include:
1239 xlc-1.2.1.8, xlc-1.3.0.0 (distributed with AIX 3.2.5), and
1240 xlc-1.3.0.19. Both xlc-1.2.1.28 and xlc-1.3.0.24 (PTF 432238) are
1241 known to produce working versions of GNU CC, but most other recent
1242 releases correctly bootstrap GNU CC.
1244 Release 4.3.0 of AIX and ones prior to AIX 3.2.4 include a version
1245 of the IBM assembler which does not accept debugging directives:
1246 assembler updates are available as PTFs. Also, if you are using
1247 AIX 3.2.5 or greater and the GNU assembler, you must have a
1248 version modified after October 16th, 1995 in order for the GNU C
1249 compiler to build. See the file `README.RS6000' for more details
1250 on any of these problems.
1252 GNU CC does not yet support the 64-bit PowerPC instructions.
1254 Objective C does not work on this architecture because it makes
1255 assumptions that are incompatible with the calling conventions.
1257 AIX on the RS/6000 provides support (NLS) for environments outside
1258 of the United States. Compilers and assemblers use NLS to support
1259 locale-specific representations of various objects including
1260 floating-point numbers ("." vs "," for separating decimal
1261 fractions). There have been problems reported where the library
1262 linked with GNU CC does not produce the same floating-point
1263 formats that the assembler accepts. If you have this problem, set
1264 the LANG environment variable to "C" or "En_US".
1266 Due to changes in the way that GNU CC invokes the binder (linker)
1267 for AIX 4.1, you may now receive warnings of duplicate symbols
1268 from the link step that were not reported before. The assembly
1269 files generated by GNU CC for AIX have always included multiple
1270 symbol definitions for certain global variable and function
1271 declarations in the original program. The warnings should not
1272 prevent the linker from producing a correct library or runnable
1275 By default, AIX 4.1 produces code that can be used on either Power
1276 or PowerPC processors.
1278 You can specify a default version for the `-mcpu='CPU_TYPE switch
1279 by using the configure option `--with-cpu-'CPU_TYPE.
1283 PowerPC system in big endian mode, running System V.4.
1285 You can specify a default version for the `-mcpu='CPU_TYPE switch
1286 by using the configure option `--with-cpu-'CPU_TYPE.
1288 `powerpc-*-linux-gnu'
1289 PowerPC system in big endian mode, running the Linux-based GNU
1292 You can specify a default version for the `-mcpu='CPU_TYPE switch
1293 by using the configure option `--with-cpu-'CPU_TYPE.
1296 Embedded PowerPC system in big endian mode with -mcall-aix
1297 selected as the default.
1299 You can specify a default version for the `-mcpu='CPU_TYPE switch
1300 by using the configure option `--with-cpu-'CPU_TYPE.
1303 Embedded PowerPC system in big endian mode for use in running
1304 under the PSIM simulator.
1306 You can specify a default version for the `-mcpu='CPU_TYPE switch
1307 by using the configure option `--with-cpu-'CPU_TYPE.
1310 Embedded PowerPC system in big endian mode.
1312 You can specify a default version for the `-mcpu='CPU_TYPE switch
1313 by using the configure option `--with-cpu-'CPU_TYPE.
1317 PowerPC system in little endian mode, running System V.4.
1319 You can specify a default version for the `-mcpu='CPU_TYPE switch
1320 by using the configure option `--with-cpu-'CPU_TYPE.
1322 `powerpcle-*-solaris2*'
1323 PowerPC system in little endian mode, running Solaris 2.5.1 or
1326 You can specify a default version for the `-mcpu='CPU_TYPE switch
1327 by using the configure option `--with-cpu-'CPU_TYPE. Beta
1328 versions of the Sun 4.0 compiler do not seem to be able to build
1329 GNU CC correctly. There are also problems with the host assembler
1330 and linker that are fixed by using the GNU versions of these tools.
1332 `powerpcle-*-eabisim'
1333 Embedded PowerPC system in little endian mode for use in running
1334 under the PSIM simulator.
1337 Embedded PowerPC system in little endian mode.
1339 You can specify a default version for the `-mcpu='CPU_TYPE switch
1340 by using the configure option `--with-cpu-'CPU_TYPE.
1344 PowerPC system in little endian mode running Windows NT.
1346 You can specify a default version for the `-mcpu='CPU_TYPE switch
1347 by using the configure option `--with-cpu-'CPU_TYPE.
1350 Don't try compiling with Vax C (`vcc'). It produces incorrect code
1351 in some cases (for example, when `alloca' is used).
1353 Meanwhile, compiling `cp/parse.c' with pcc does not work because of
1354 an internal table size limitation in that compiler. To avoid this
1355 problem, compile just the GNU C compiler first, and use it to
1356 recompile building all the languages that you want to run.
1359 See *Note Sun Install::, for information on installing GNU CC on
1363 See *Note VMS Install::, for details on how to install GNU CC on
1367 These computers are also known as the 3b2, 3b5, 3b20 and other
1368 similar names. (However, the 3b1 is actually a 68000; see *Note
1371 Don't use `-g' when compiling with the system's compiler. The
1372 system's linker seems to be unable to handle such a large program
1373 with debugging information.
1375 The system's compiler runs out of capacity when compiling `stmt.c'
1376 in GNU CC. You can work around this by building `cpp' in GNU CC
1377 first, then use that instead of the system's preprocessor with the
1378 system's C compiler to compile `stmt.c'. Here is how:
1380 mv /lib/cpp /lib/cpp.att
1382 echo '/lib/cpp.gnu -traditional ${1+"$@"}' > /lib/cpp
1385 The system's compiler produces bad code for some of the GNU CC
1386 optimization files. So you must build the stage 2 compiler without
1387 optimization. Then build a stage 3 compiler with optimization.
1388 That executable should work. Here are the necessary commands:
1390 make LANGUAGES=c CC=stage1/xgcc CFLAGS="-Bstage1/ -g"
1392 make CC=stage2/xgcc CFLAGS="-Bstage2/ -g -O"
1394 You may need to raise the ULIMIT setting to build a C++ compiler,
1395 as the file `cc1plus' is larger than one megabyte.
1397 Compilation in a Separate Directory
1398 ===================================
1400 If you wish to build the object files and executables in a directory
1401 other than the one containing the source files, here is what you must
1404 1. Make sure you have a version of Make that supports the `VPATH'
1405 feature. (GNU Make supports it, as do Make versions on most BSD
1408 2. If you have ever run `configure' in the source directory, you must
1409 undo the configuration. Do this by running:
1413 3. Go to the directory in which you want to build the compiler before
1414 running `configure':
1419 On systems that do not support symbolic links, this directory must
1420 be on the same file system as the source code directory.
1422 4. Specify where to find `configure' when you run it:
1424 ../gcc/configure ...
1426 This also tells `configure' where to find the compiler sources;
1427 `configure' takes the directory from the file name that was used to
1428 invoke it. But if you want to be sure, you can specify the source
1429 directory with the `--srcdir' option, like this:
1431 ../gcc/configure --srcdir=../gcc OTHER OPTIONS
1433 The directory you specify with `--srcdir' need not be the same as
1434 the one that `configure' is found in.
1436 Now, you can run `make' in that directory. You need not repeat the
1437 configuration steps shown above, when ordinary source files change. You
1438 must, however, run `configure' again when the configuration files
1439 change, if your system does not support symbolic links.
1441 Building and Installing a Cross-Compiler
1442 ========================================
1444 GNU CC can function as a cross-compiler for many machines, but not
1447 * Cross-compilers for the Mips as target using the Mips assembler
1448 currently do not work, because the auxiliary programs
1449 `mips-tdump.c' and `mips-tfile.c' can't be compiled on anything
1450 but a Mips. It does work to cross compile for a Mips if you use
1451 the GNU assembler and linker.
1453 * Cross-compilers between machines with different floating point
1454 formats have not all been made to work. GNU CC now has a floating
1455 point emulator with which these can work, but each target machine
1456 description needs to be updated to take advantage of it.
1458 * Cross-compilation between machines of different word sizes is
1459 somewhat problematic and sometimes does not work.
1461 Since GNU CC generates assembler code, you probably need a
1462 cross-assembler that GNU CC can run, in order to produce object files.
1463 If you want to link on other than the target machine, you need a
1464 cross-linker as well. You also need header files and libraries suitable
1465 for the target machine that you can install on the host machine.
1467 Steps of Cross-Compilation
1468 --------------------------
1470 To compile and run a program using a cross-compiler involves several
1473 * Run the cross-compiler on the host machine to produce assembler
1474 files for the target machine. This requires header files for the
1477 * Assemble the files produced by the cross-compiler. You can do this
1478 either with an assembler on the target machine, or with a
1479 cross-assembler on the host machine.
1481 * Link those files to make an executable. You can do this either
1482 with a linker on the target machine, or with a cross-linker on the
1483 host machine. Whichever machine you use, you need libraries and
1484 certain startup files (typically `crt....o') for the target
1487 It is most convenient to do all of these steps on the same host
1488 machine, since then you can do it all with a single invocation of GNU
1489 CC. This requires a suitable cross-assembler and cross-linker. For
1490 some targets, the GNU assembler and linker are available.
1492 Configuring a Cross-Compiler
1493 ----------------------------
1495 To build GNU CC as a cross-compiler, you start out by running
1496 `configure'. Use the `--target=TARGET' to specify the target type. If
1497 `configure' was unable to correctly identify the system you are running
1498 on, also specify the `--build=BUILD' option. For example, here is how
1499 to configure for a cross-compiler that produces code for an HP 68030
1500 system running BSD on a system that `configure' can correctly identify:
1502 ./configure --target=m68k-hp-bsd4.3
1504 Tools and Libraries for a Cross-Compiler
1505 ----------------------------------------
1507 If you have a cross-assembler and cross-linker available, you should
1508 install them now. Put them in the directory `/usr/local/TARGET/bin'.
1509 Here is a table of the tools you should put in this directory:
1512 This should be the cross-assembler.
1515 This should be the cross-linker.
1518 This should be the cross-archiver: a program which can manipulate
1519 archive files (linker libraries) in the target machine's format.
1522 This should be a program to construct a symbol table in an archive
1525 The installation of GNU CC will find these programs in that
1526 directory, and copy or link them to the proper place to for the
1527 cross-compiler to find them when run later.
1529 The easiest way to provide these files is to build the Binutils
1530 package and GAS. Configure them with the same `--host' and `--target'
1531 options that you use for configuring GNU CC, then build and install
1532 them. They install their executables automatically into the proper
1533 directory. Alas, they do not support all the targets that GNU CC
1536 If you want to install libraries to use with the cross-compiler,
1537 such as a standard C library, put them in the directory
1538 `/usr/local/TARGET/lib'; installation of GNU CC copies all the files in
1539 that subdirectory into the proper place for GNU CC to find them and
1540 link with them. Here's an example of copying some libraries from a
1544 lcd /usr/local/TARGET/lib
1552 The precise set of libraries you'll need, and their locations on the
1553 target machine, vary depending on its operating system.
1555 Many targets require "start files" such as `crt0.o' and `crtn.o'
1556 which are linked into each executable; these too should be placed in
1557 `/usr/local/TARGET/lib'. There may be several alternatives for
1558 `crt0.o', for use with profiling or other compilation options. Check
1559 your target's definition of `STARTFILE_SPEC' to find out what start
1560 files it uses. Here's an example of copying these files from a target
1564 lcd /usr/local/TARGET/lib
1572 `libgcc.a' and Cross-Compilers
1573 ------------------------------
1575 Code compiled by GNU CC uses certain runtime support functions
1576 implicitly. Some of these functions can be compiled successfully with
1577 GNU CC itself, but a few cannot be. These problem functions are in the
1578 source file `libgcc1.c'; the library made from them is called
1581 When you build a native compiler, these functions are compiled with
1582 some other compiler-the one that you use for bootstrapping GNU CC.
1583 Presumably it knows how to open code these operations, or else knows how
1584 to call the run-time emulation facilities that the machine comes with.
1585 But this approach doesn't work for building a cross-compiler. The
1586 compiler that you use for building knows about the host system, not the
1589 So, when you build a cross-compiler you have to supply a suitable
1590 library `libgcc1.a' that does the job it is expected to do.
1592 To compile `libgcc1.c' with the cross-compiler itself does not work.
1593 The functions in this file are supposed to implement arithmetic
1594 operations that GNU CC does not know how to open code for your target
1595 machine. If these functions are compiled with GNU CC itself, they will
1596 compile into infinite recursion.
1598 On any given target, most of these functions are not needed. If GNU
1599 CC can open code an arithmetic operation, it will not call these
1600 functions to perform the operation. It is possible that on your target
1601 machine, none of these functions is needed. If so, you can supply an
1602 empty library as `libgcc1.a'.
1604 Many targets need library support only for multiplication and
1605 division. If you are linking with a library that contains functions for
1606 multiplication and division, you can tell GNU CC to call them directly
1607 by defining the macros `MULSI3_LIBCALL', and the like. These macros
1608 need to be defined in the target description macro file. For some
1609 targets, they are defined already. This may be sufficient to avoid the
1610 need for libgcc1.a; if so, you can supply an empty library.
1612 Some targets do not have floating point instructions; they need other
1613 functions in `libgcc1.a', which do floating arithmetic. Recent
1614 versions of GNU CC have a file which emulates floating point. With a
1615 certain amount of work, you should be able to construct a floating
1616 point emulator that can be used as `libgcc1.a'. Perhaps future
1617 versions will contain code to do this automatically and conveniently.
1618 That depends on whether someone wants to implement it.
1620 Some embedded targets come with all the necessary `libgcc1.a'
1621 routines written in C or assembler. These targets build `libgcc1.a'
1622 automatically and you do not need to do anything special for them.
1623 Other embedded targets do not need any `libgcc1.a' routines since all
1624 the necessary operations are supported by the hardware.
1626 If your target system has another C compiler, you can configure GNU
1627 CC as a native compiler on that machine, build just `libgcc1.a' with
1628 `make libgcc1.a' on that machine, and use the resulting file with the
1629 cross-compiler. To do this, execute the following on the target
1633 ./configure --host=sparc --target=sun3
1636 And then this on the host machine:
1644 Another way to provide the functions you need in `libgcc1.a' is to
1645 define the appropriate `perform_...' macros for those functions. If
1646 these definitions do not use the C arithmetic operators that they are
1647 meant to implement, you should be able to compile them with the
1648 cross-compiler you are building. (If these definitions already exist
1649 for your target file, then you are all set.)
1651 To build `libgcc1.a' using the perform macros, use
1652 `LIBGCC1=libgcc1.a OLDCC=./xgcc' when building the compiler.
1653 Otherwise, you should place your replacement library under the name
1654 `libgcc1.a' in the directory in which you will build the
1655 cross-compiler, before you run `make'.
1657 Cross-Compilers and Header Files
1658 --------------------------------
1660 If you are cross-compiling a standalone program or a program for an
1661 embedded system, then you may not need any header files except the few
1662 that are part of GNU CC (and those of your program). However, if you
1663 intend to link your program with a standard C library such as `libc.a',
1664 then you probably need to compile with the header files that go with
1665 the library you use.
1667 The GNU C compiler does not come with these files, because (1) they
1668 are system-specific, and (2) they belong in a C library, not in a
1671 If the GNU C library supports your target machine, then you can get
1672 the header files from there (assuming you actually use the GNU library
1673 when you link your program).
1675 If your target machine comes with a C compiler, it probably comes
1676 with suitable header files also. If you make these files accessible
1677 from the host machine, the cross-compiler can use them also.
1679 Otherwise, you're on your own in finding header files to use when
1682 When you have found suitable header files, put them in the directory
1683 `/usr/local/TARGET/include', before building the cross compiler. Then
1684 installation will run fixincludes properly and install the corrected
1685 versions of the header files where the compiler will use them.
1687 Provide the header files before you build the cross-compiler, because
1688 the build stage actually runs the cross-compiler to produce parts of
1689 `libgcc.a'. (These are the parts that *can* be compiled with GNU CC.)
1690 Some of them need suitable header files.
1692 Here's an example showing how to copy the header files from a target
1693 machine. On the target machine, do this:
1695 (cd /usr/include; tar cf - .) > tarfile
1697 Then, on the host machine, do this:
1700 lcd /usr/local/TARGET/include
1705 Actually Building the Cross-Compiler
1706 ------------------------------------
1708 Now you can proceed just as for compiling a single-machine compiler
1709 through the step of building stage 1. If you have not provided some
1710 sort of `libgcc1.a', then compilation will give up at the point where
1711 it needs that file, printing a suitable error message. If you do
1712 provide `libgcc1.a', then building the compiler will automatically
1713 compile and link a test program called `libgcc1-test'; if you get
1714 errors in the linking, it means that not all of the necessary routines
1715 in `libgcc1.a' are available.
1717 You must provide the header file `float.h'. One way to do this is
1718 to compile `enquire' and run it on your target machine. The job of
1719 `enquire' is to run on the target machine and figure out by experiment
1720 the nature of its floating point representation. `enquire' records its
1721 findings in the header file `float.h'. If you can't produce this file
1722 by running `enquire' on the target machine, then you will need to come
1723 up with a suitable `float.h' in some other way (or else, avoid using it
1726 Do not try to build stage 2 for a cross-compiler. It doesn't work to
1727 rebuild GNU CC as a cross-compiler using the cross-compiler, because
1728 that would produce a program that runs on the target machine, not on the
1729 host. For example, if you compile a 386-to-68030 cross-compiler with
1730 itself, the result will not be right either for the 386 (because it was
1731 compiled into 68030 code) or for the 68030 (because it was configured
1732 for a 386 as the host). If you want to compile GNU CC into 68030 code,
1733 whether you compile it on a 68030 or with a cross-compiler on a 386, you
1734 must specify a 68030 as the host when you configure it.
1736 To install the cross-compiler, use `make install', as usual.
1738 Installing GNU CC on the Sun
1739 ============================
1741 On Solaris, do not use the linker or other tools in `/usr/ucb' to
1742 build GNU CC. Use `/usr/ccs/bin'.
1744 If the assembler reports `Error: misaligned data' when bootstrapping,
1745 you are probably using an obsolete version of the GNU assembler.
1746 Upgrade to the latest version of GNU `binutils', or use the Solaris
1749 Make sure the environment variable `FLOAT_OPTION' is not set when
1750 you compile `libgcc.a'. If this option were set to `f68881' when
1751 `libgcc.a' is compiled, the resulting code would demand to be linked
1752 with a special startup file and would not link properly without special
1755 There is a bug in `alloca' in certain versions of the Sun library.
1756 To avoid this bug, install the binaries of GNU CC that were compiled by
1757 GNU CC. They use `alloca' as a built-in function and never the one in
1760 Some versions of the Sun compiler crash when compiling GNU CC. The
1761 problem is a segmentation fault in cpp. This problem seems to be due to
1762 the bulk of data in the environment variables. You may be able to avoid
1763 it by using the following command to compile GNU CC with Sun CC:
1765 make CC="TERMCAP=x OBJS=x LIBFUNCS=x STAGESTUFF=x cc"
1767 SunOS 4.1.3 and 4.1.3_U1 have bugs that can cause intermittent core
1768 dumps when compiling GNU CC. A common symptom is an internal compiler
1769 error which does not recur if you run it again. To fix the problem,
1770 install Sun recommended patch 100726 (for SunOS 4.1.3) or 101508 (for
1771 SunOS 4.1.3_U1), or upgrade to a later SunOS release.
1773 Installing GNU CC on VMS
1774 ========================
1776 The VMS version of GNU CC is distributed in a backup saveset
1777 containing both source code and precompiled binaries.
1779 To install the `gcc' command so you can use the compiler easily, in
1780 the same manner as you use the VMS C compiler, you must install the VMS
1781 CLD file for GNU CC as follows:
1783 1. Define the VMS logical names `GNU_CC' and `GNU_CC_INCLUDE' to
1784 point to the directories where the GNU CC executables
1785 (`gcc-cpp.exe', `gcc-cc1.exe', etc.) and the C include files are
1786 kept respectively. This should be done with the commands:
1788 $ assign /system /translation=concealed -
1790 $ assign /system /translation=concealed -
1791 disk:[gcc.include.] gnu_cc_include
1793 with the appropriate disk and directory names. These commands can
1794 be placed in your system startup file so they will be executed
1795 whenever the machine is rebooted. You may, if you choose, do this
1796 via the `GCC_INSTALL.COM' script in the `[GCC]' directory.
1798 2. Install the `GCC' command with the command line:
1800 $ set command /table=sys$common:[syslib]dcltables -
1801 /output=sys$common:[syslib]dcltables gnu_cc:[000000]gcc
1802 $ install replace sys$common:[syslib]dcltables
1804 3. To install the help file, do the following:
1806 $ library/help sys$library:helplib.hlb gcc.hlp
1808 Now you can invoke the compiler with a command like `gcc /verbose
1809 file.c', which is equivalent to the command `gcc -v -c file.c' in
1812 If you wish to use GNU C++ you must first install GNU CC, and then
1813 perform the following steps:
1815 1. Define the VMS logical name `GNU_GXX_INCLUDE' to point to the
1816 directory where the preprocessor will search for the C++ header
1817 files. This can be done with the command:
1819 $ assign /system /translation=concealed -
1820 disk:[gcc.gxx_include.] gnu_gxx_include
1822 with the appropriate disk and directory name. If you are going to
1823 be using a C++ runtime library, this is where its install
1824 procedure will install its header files.
1826 2. Obtain the file `gcc-cc1plus.exe', and place this in the same
1827 directory that `gcc-cc1.exe' is kept.
1829 The GNU C++ compiler can be invoked with a command like `gcc /plus
1830 /verbose file.cc', which is equivalent to the command `g++ -v -c
1833 We try to put corresponding binaries and sources on the VMS
1834 distribution tape. But sometimes the binaries will be from an older
1835 version than the sources, because we don't always have time to update
1836 them. (Use the `/version' option to determine the version number of
1837 the binaries and compare it with the source file `version.c' to tell
1838 whether this is so.) In this case, you should use the binaries you get
1839 to recompile the sources. If you must recompile, here is how:
1841 1. Execute the command procedure `vmsconfig.com' to set up the files
1842 `tm.h', `config.h', `aux-output.c', and `md.', and to create files
1843 `tconfig.h' and `hconfig.h'. This procedure also creates several
1844 linker option files used by `make-cc1.com' and a data file used by
1849 2. Setup the logical names and command tables as defined above. In
1850 addition, define the VMS logical name `GNU_BISON' to point at the
1851 to the directories where the Bison executable is kept. This
1852 should be done with the command:
1854 $ assign /system /translation=concealed -
1855 disk:[bison.] gnu_bison
1857 You may, if you choose, use the `INSTALL_BISON.COM' script in the
1858 `[BISON]' directory.
1860 3. Install the `BISON' command with the command line:
1862 $ set command /table=sys$common:[syslib]dcltables -
1863 /output=sys$common:[syslib]dcltables -
1864 gnu_bison:[000000]bison
1865 $ install replace sys$common:[syslib]dcltables
1867 4. Type `@make-gcc' to recompile everything (alternatively, submit
1868 the file `make-gcc.com' to a batch queue). If you wish to build
1869 the GNU C++ compiler as well as the GNU CC compiler, you must
1870 first edit `make-gcc.com' and follow the instructions that appear
1873 5. In order to use GCC, you need a library of functions which GCC
1874 compiled code will call to perform certain tasks, and these
1875 functions are defined in the file `libgcc2.c'. To compile this
1876 you should use the command procedure `make-l2.com', which will
1877 generate the library `libgcc2.olb'. `libgcc2.olb' should be built
1878 using the compiler built from the same distribution that
1879 `libgcc2.c' came from, and `make-gcc.com' will automatically do
1880 all of this for you.
1882 To install the library, use the following commands:
1884 $ library gnu_cc:[000000]gcclib/delete=(new,eprintf)
1885 $ library gnu_cc:[000000]gcclib/delete=L_*
1886 $ library libgcc2/extract=*/output=libgcc2.obj
1887 $ library gnu_cc:[000000]gcclib libgcc2.obj
1889 The first command simply removes old modules that will be replaced
1890 with modules from `libgcc2' under different module names. The
1891 modules `new' and `eprintf' may not actually be present in your
1892 `gcclib.olb'--if the VMS librarian complains about those modules
1893 not being present, simply ignore the message and continue on with
1894 the next command. The second command removes the modules that
1895 came from the previous version of the library `libgcc2.c'.
1897 Whenever you update the compiler on your system, you should also
1898 update the library with the above procedure.
1900 6. You may wish to build GCC in such a way that no files are written
1901 to the directory where the source files reside. An example would
1902 be the when the source files are on a read-only disk. In these
1903 cases, execute the following DCL commands (substituting your
1906 $ assign dua0:[gcc.build_dir.]/translation=concealed, -
1907 dua1:[gcc.source_dir.]/translation=concealed gcc_build
1908 $ set default gcc_build:[000000]
1910 where the directory `dua1:[gcc.source_dir]' contains the source
1911 code, and the directory `dua0:[gcc.build_dir]' is meant to contain
1912 all of the generated object files and executables. Once you have
1913 done this, you can proceed building GCC as described above. (Keep
1914 in mind that `gcc_build' is a rooted logical name, and thus the
1915 device names in each element of the search list must be an actual
1916 physical device name rather than another rooted logical name).
1918 7. *If you are building GNU CC with a previous version of GNU CC, you
1919 also should check to see that you have the newest version of the
1920 assembler*. In particular, GNU CC version 2 treats global constant
1921 variables slightly differently from GNU CC version 1, and GAS
1922 version 1.38.1 does not have the patches required to work with GCC
1923 version 2. If you use GAS 1.38.1, then `extern const' variables
1924 will not have the read-only bit set, and the linker will generate
1925 warning messages about mismatched psect attributes for these
1926 variables. These warning messages are merely a nuisance, and can
1929 If you are compiling with a version of GNU CC older than 1.33,
1930 specify `/DEFINE=("inline=")' as an option in all the
1931 compilations. This requires editing all the `gcc' commands in
1932 `make-cc1.com'. (The older versions had problems supporting
1933 `inline'.) Once you have a working 1.33 or newer GNU CC, you can
1934 change this file back.
1936 8. If you want to build GNU CC with the VAX C compiler, you will need
1937 to make minor changes in `make-cccp.com' and `make-cc1.com' to
1938 choose alternate definitions of `CC', `CFLAGS', and `LIBS'. See
1939 comments in those files. However, you must also have a working
1940 version of the GNU assembler (GNU as, aka GAS) as it is used as
1941 the back-end for GNU CC to produce binary object modules and is
1942 not included in the GNU CC sources. GAS is also needed to compile
1943 `libgcc2' in order to build `gcclib' (see above); `make-l2.com'
1944 expects to be able to find it operational in
1945 `gnu_cc:[000000]gnu-as.exe'.
1947 To use GNU CC on VMS, you need the VMS driver programs `gcc.exe',
1948 `gcc.com', and `gcc.cld'. They are distributed with the VMS
1949 binaries (`gcc-vms') rather than the GNU CC sources. GAS is also
1950 included in `gcc-vms', as is Bison.
1952 Once you have successfully built GNU CC with VAX C, you should use
1953 the resulting compiler to rebuild itself. Before doing this, be
1954 sure to restore the `CC', `CFLAGS', and `LIBS' definitions in
1955 `make-cccp.com' and `make-cc1.com'. The second generation
1956 compiler will be able to take advantage of many optimizations that
1957 must be suppressed when building with other compilers.
1959 Under previous versions of GNU CC, the generated code would
1960 occasionally give strange results when linked with the sharable
1961 `VAXCRTL' library. Now this should work.
1963 Even with this version, however, GNU CC itself should not be linked
1964 with the sharable `VAXCRTL'. The version of `qsort' in `VAXCRTL' has a
1965 bug (known to be present in VMS versions V4.6 through V5.5) which
1966 causes the compiler to fail.
1968 The executables are generated by `make-cc1.com' and `make-cccp.com'
1969 use the object library version of `VAXCRTL' in order to make use of the
1970 `qsort' routine in `gcclib.olb'. If you wish to link the compiler
1971 executables with the shareable image version of `VAXCRTL', you should
1972 edit the file `tm.h' (created by `vmsconfig.com') to define the macro
1975 `QSORT_WORKAROUND' is always defined when GNU CC is compiled with
1976 VAX C, to avoid a problem in case `gcclib.olb' is not yet available.
1981 Many target systems do not have support in the assembler and linker
1982 for "constructors"--initialization functions to be called before the
1983 official "start" of `main'. On such systems, GNU CC uses a utility
1984 called `collect2' to arrange to call these functions at start time.
1986 The program `collect2' works by linking the program once and looking
1987 through the linker output file for symbols with particular names
1988 indicating they are constructor functions. If it finds any, it creates
1989 a new temporary `.c' file containing a table of them, compiles it, and
1990 links the program a second time including that file.
1992 The actual calls to the constructors are carried out by a subroutine
1993 called `__main', which is called (automatically) at the beginning of
1994 the body of `main' (provided `main' was compiled with GNU CC). Calling
1995 `__main' is necessary, even when compiling C code, to allow linking C
1996 and C++ object code together. (If you use `-nostdlib', you get an
1997 unresolved reference to `__main', since it's defined in the standard
1998 GCC library. Include `-lgcc' at the end of your compiler command line
1999 to resolve this reference.)
2001 The program `collect2' is installed as `ld' in the directory where
2002 the passes of the compiler are installed. When `collect2' needs to
2003 find the *real* `ld', it tries the following file names:
2005 * `real-ld' in the directories listed in the compiler's search
2008 * `real-ld' in the directories listed in the environment variable
2011 * The file specified in the `REAL_LD_FILE_NAME' configuration macro,
2014 * `ld' in the compiler's search directories, except that `collect2'
2015 will not execute itself recursively.
2019 "The compiler's search directories" means all the directories where
2020 `gcc' searches for passes of the compiler. This includes directories
2021 that you specify with `-B'.
2023 Cross-compilers search a little differently:
2025 * `real-ld' in the compiler's search directories.
2027 * `TARGET-real-ld' in `PATH'.
2029 * The file specified in the `REAL_LD_FILE_NAME' configuration macro,
2032 * `ld' in the compiler's search directories.
2034 * `TARGET-ld' in `PATH'.
2036 `collect2' explicitly avoids running `ld' using the file name under
2037 which `collect2' itself was invoked. In fact, it remembers up a list
2038 of such names--in case one copy of `collect2' finds another copy (or
2039 version) of `collect2' installed as `ld' in a second place in the
2042 `collect2' searches for the utilities `nm' and `strip' using the
2043 same algorithm as above for `ld'.
2045 Standard Header File Directories
2046 ================================
2048 `GCC_INCLUDE_DIR' means the same thing for native and cross. It is
2049 where GNU CC stores its private include files, and also where GNU CC
2050 stores the fixed include files. A cross compiled GNU CC runs
2051 `fixincludes' on the header files in `$(tooldir)/include'. (If the
2052 cross compilation header files need to be fixed, they must be installed
2053 before GNU CC is built. If the cross compilation header files are
2054 already suitable for ANSI C and GNU CC, nothing special need be done).
2056 `GPLUS_INCLUDE_DIR' means the same thing for native and cross. It
2057 is where `g++' looks first for header files. The C++ library installs
2058 only target independent header files in that directory.
2060 `LOCAL_INCLUDE_DIR' is used only for a native compiler. It is
2061 normally `/usr/local/include'. GNU CC searches this directory so that
2062 users can install header files in `/usr/local/include'.
2064 `CROSS_INCLUDE_DIR' is used only for a cross compiler. GNU CC
2065 doesn't install anything there.
2067 `TOOL_INCLUDE_DIR' is used for both native and cross compilers. It
2068 is the place for other packages to install header files that GNU CC will
2069 use. For a cross-compiler, this is the equivalent of `/usr/include'.
2070 When you build a cross-compiler, `fixincludes' processes any header
2071 files in this directory.