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