-
Notifications
You must be signed in to change notification settings - Fork 4
/
INSTALL
2072 lines (1631 loc) · 90.8 KB
/
INSTALL
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
This file documents the installation of the GNU compiler. Copyright
(C) 1988, 1989, 1992, 1994, 1995 Free Software Foundation, Inc. You
may copy, distribute, and modify it freely as long as you preserve this
copyright notice and permission notice.
Installing GNU CC
*****************
Here is the procedure for installing GNU CC on a Unix system. See
*Note VMS Install::, for VMS systems. In this section we assume you
compile in the same directory that contains the source files; see *Note
Other Dir::, to find out how to compile in a separate directory on Unix
systems.
You cannot install GNU C by itself on MSDOS; it will not compile
under any MSDOS compiler except itself. You need to get the complete
compilation package DJGPP, which includes binaries as well as sources,
and includes all the necessary compilation tools and libraries.
1. If you have built GNU CC previously in the same directory for a
different target machine, do `make distclean' to delete all files
that might be invalid. One of the files this deletes is
`Makefile'; if `make distclean' complains that `Makefile' does not
exist, it probably means that the directory is already suitably
clean.
2. On a System V release 4 system, make sure `/usr/bin' precedes
`/usr/ucb' in `PATH'. The `cc' command in `/usr/ucb' uses
libraries which have bugs.
3. Specify the host, build and target machine configurations. You do
this by running the file `configure'.
The "build" machine is the system which you are using, the "host"
machine is the system where you want to run the resulting compiler
(normally the build machine), and the "target" machine is the
system for which you want the compiler to generate code.
If you are building a compiler to produce code for the machine it
runs on (a native compiler), you normally do not need to specify
any operands to `configure'; it will try to guess the type of
machine you are on and use that as the build, host and target
machines. So you don't need to specify a configuration when
building a native compiler unless `configure' cannot figure out
what your configuration is or guesses wrong.
In those cases, specify the build machine's "configuration name"
with the `--host' option; the host and target will default to be
the same as the host machine. (If you are building a
cross-compiler, see *Note Cross-Compiler::.)
Here is an example:
./configure --build=sparc-sun-sunos4.1
A configuration name may be canonical or it may be more or less
abbreviated.
A canonical configuration name has three parts, separated by
dashes. It looks like this: `CPU-COMPANY-SYSTEM'. (The three
parts may themselves contain dashes; `configure' can figure out
which dashes serve which purpose.) For example,
`m68k-sun-sunos4.1' specifies a Sun 3.
You can also replace parts of the configuration by nicknames or
aliases. For example, `sun3' stands for `m68k-sun', so
`sun3-sunos4.1' is another way to specify a Sun 3. You can also
use simply `sun3-sunos', since the version of SunOS is assumed by
default to be version 4.
You can specify a version number after any of the system types,
and some of the CPU types. In most cases, the version is
irrelevant, and will be ignored. So you might as well specify the
version if you know it.
See *Note Configurations::, for a list of supported configuration
names and notes on many of the configurations. You should check
the notes in that section before proceeding any further with the
installation of GNU CC.
There are four additional options you can specify independently to
describe variant hardware and software configurations. These are
`--with-gnu-as', `--with-gnu-ld', `--with-stabs' and `--nfp'.
`--with-gnu-as'
If you will use GNU CC with the GNU assembler (GAS), you
should declare this by using the `--with-gnu-as' option when
you run `configure'.
Using this option does not install GAS. It only modifies the
output of GNU CC to work with GAS. Building and installing
GAS is up to you.
Conversely, if you *do not* wish to use GAS and do not specify
`--with-gnu-as' when building GNU CC, it is up to you to make
sure that GAS is not installed. GNU CC searches for a
program named `as' in various directories; if the program it
finds is GAS, then it runs GAS. If you are not sure where
GNU CC finds the assembler it is using, try specifying `-v'
when you run it.
The systems where it makes a difference whether you use GAS
are
`hppa1.0-ANY-ANY', `hppa1.1-ANY-ANY', `i386-ANY-sysv',
`i386-ANY-isc',
`i860-ANY-bsd', `m68k-bull-sysv',
`m68k-hp-hpux', `m68k-sony-bsd',
`m68k-altos-sysv', `m68000-hp-hpux',
`m68000-att-sysv', `ANY-lynx-lynxos', and `mips-ANY'). On
any other system, `--with-gnu-as' has no effect.
On the systems listed above (except for the HP-PA, for ISC on
the 386, and for `mips-sgi-irix5.*'), if you use GAS, you
should also use the GNU linker (and specify `--with-gnu-ld').
`--with-gnu-ld'
Specify the option `--with-gnu-ld' if you plan to use the GNU
linker with GNU CC.
This option does not cause the GNU linker to be installed; it
just modifies the behavior of GNU CC to work with the GNU
linker. Specifically, it inhibits the installation of
`collect2', a program which otherwise serves as a front-end
for the system's linker on most configurations.
`--with-stabs'
On MIPS based systems and on Alphas, you must specify whether
you want GNU CC to create the normal ECOFF debugging format,
or to use BSD-style stabs passed through the ECOFF symbol
table. The normal ECOFF debug format cannot fully handle
languages other than C. BSD stabs format can handle other
languages, but it only works with the GNU debugger GDB.
Normally, GNU CC uses the ECOFF debugging format by default;
if you prefer BSD stabs, specify `--with-stabs' when you
configure GNU CC.
No matter which default you choose when you configure GNU CC,
the user can use the `-gcoff' and `-gstabs+' options to
specify explicitly the debug format for a particular
compilation.
`--with-stabs' is meaningful on the ISC system on the 386,
also, if `--with-gas' is used. It selects use of stabs
debugging information embedded in COFF output. This kind of
debugging information supports C++ well; ordinary COFF
debugging information does not.
`--with-stabs' is also meaningful on 386 systems running
SVR4. It selects use of stabs debugging information embedded
in ELF output. The C++ compiler currently (2.6.0) does not
support the DWARF debugging information normally used on 386
SVR4 platforms; stabs provide a workable alternative. This
requires gas and gdb, as the normal SVR4 tools can not
generate or interpret stabs.
`--nfp'
On certain systems, you must specify whether the machine has
a floating point unit. These systems include
`m68k-sun-sunosN' and `m68k-isi-bsd'. On any other system,
`--nfp' currently has no effect, though perhaps there are
other systems where it could usefully make a difference.
`--enable-threads=TYPE'
Certain systems, notably Linux-based GNU systems, can't be
relied on to supply a threads facility for the Objective C
runtime and so will default to single-threaded runtime. They
may, however, have a library threads implementation
available, in which case threads can be enabled with this
option by supplying a suitable TYPE, probably `posix'. The
possibilities for TYPE are `single', `posix', `win32',
`solaris', `irix' and `mach'.
The `configure' script searches subdirectories of the source
directory for other compilers that are to be integrated into GNU
CC. The GNU compiler for C++, called G++ is in a subdirectory
named `cp'. `configure' inserts rules into `Makefile' to build
all of those compilers.
Here we spell out what files will be set up by `configure'.
Normally you need not be concerned with these files.
* A file named `config.h' is created that contains a `#include'
of the top-level config file for the machine you will run the
compiler on (*note The Configuration File:
(gcc.info)Config.). This file is responsible for defining
information about the host machine. It includes `tm.h'.
The top-level config file is located in the subdirectory
`config'. Its name is always `xm-SOMETHING.h'; usually
`xm-MACHINE.h', but there are some exceptions.
If your system does not support symbolic links, you might
want to set up `config.h' to contain a `#include' command
which refers to the appropriate file.
* A file named `tconfig.h' is created which includes the
top-level config file for your target machine. This is used
for compiling certain programs to run on that machine.
* A file named `tm.h' is created which includes the
machine-description macro file for your target machine. It
should be in the subdirectory `config' and its name is often
`MACHINE.h'.
* The command file `configure' also constructs the file
`Makefile' by adding some text to the template file
`Makefile.in'. The additional text comes from files in the
`config' directory, named `t-TARGET' and `x-HOST'. If these
files do not exist, it means nothing needs to be added for a
given target or host.
4. The standard directory for installing GNU CC is `/usr/local/lib'.
If you want to install its files somewhere else, specify
`--prefix=DIR' when you run `configure'. Here DIR is a directory
name to use instead of `/usr/local' for all purposes with one
exception: the directory `/usr/local/include' is searched for
header files no matter where you install the compiler. To override
this name, use the `--local-prefix' option below.
5. Specify `--local-prefix=DIR' if you want the compiler to search
directory `DIR/include' for locally installed header files
*instead* of `/usr/local/include'.
You should specify `--local-prefix' *only* if your site has a
different convention (not `/usr/local') for where to put
site-specific files.
The default value for `--local-prefix' is `/usr/local' regardless
of the value of `--prefix'. Specifying `--prefix' has no effect
on which directory GNU CC searches for local header files. This
may seem counterintuitive, but actually it is logical.
The purpose of `--prefix' is to specify where to *install GNU CC*.
The local header files in `/usr/local/include'--if you put any in
that directory--are not part of GNU CC. They are part of other
programs--perhaps many others. (GNU CC installs its own header
files in another directory which is based on the `--prefix' value.)
*Do not* specify `/usr' as the `--local-prefix'! The directory
you use for `--local-prefix' *must not* contain any of the
system's standard header files. If it did contain them, certain
programs would be miscompiled (including GNU Emacs, on certain
targets), because this would override and nullify the header file
corrections made by the `fixincludes' script.
Indications are that people who use this option use it based on
mistaken ideas of what it is for. People use it as if it specified
where to install part of GNU CC. Perhaps they make this assumption
because installing GNU CC creates the directory.
6. Make sure the Bison parser generator is installed. (This is
unnecessary if the Bison output files `c-parse.c' and `cexp.c' are
more recent than `c-parse.y' and `cexp.y' and you do not plan to
change the `.y' files.)
Bison versions older than Sept 8, 1988 will produce incorrect
output for `c-parse.c'.
7. If you have chosen a configuration for GNU CC which requires other
GNU tools (such as GAS or the GNU linker) instead of the standard
system tools, install the required tools in the build directory
under the names `as', `ld' or whatever is appropriate. This will
enable the compiler to find the proper tools for compilation of
the program `enquire'.
Alternatively, you can do subsequent compilation using a value of
the `PATH' environment variable such that the necessary GNU tools
come before the standard system tools.
8. Build the compiler. Just type `make LANGUAGES=c' in the compiler
directory.
`LANGUAGES=c' specifies that only the C compiler should be
compiled. The makefile normally builds compilers for all the
supported languages; currently, C, C++ and Objective C. However,
C is the only language that is sure to work when you build with
other non-GNU C compilers. In addition, building anything but C
at this stage is a waste of time.
In general, you can specify the languages to build by typing the
argument `LANGUAGES="LIST"', where LIST is one or more words from
the list `c', `c++', and `objective-c'. If you have any
additional GNU compilers as subdirectories of the GNU CC source
directory, you may also specify their names in this list.
Ignore any warnings you may see about "statement not reached" in
`insn-emit.c'; they are normal. Also, warnings about "unknown
escape sequence" are normal in `genopinit.c' and perhaps some
other files. Likewise, you should ignore warnings about "constant
is so large that it is unsigned" in `insn-emit.c' and
`insn-recog.c' and a warning about a comparison always being zero
in `enquire.o'. Any other compilation errors may represent bugs in
the port to your machine or operating system, and should be
investigated and reported.
Some commercial compilers fail to compile GNU CC because they have
bugs or limitations. For example, the Microsoft compiler is said
to run out of macro space. Some Ultrix compilers run out of
expression space; then you need to break up the statement where
the problem happens.
9. If you are building a cross-compiler, stop here. *Note
Cross-Compiler::.
10. Move the first-stage object files and executables into a
subdirectory with this command:
make stage1
The files are moved into a subdirectory named `stage1'. Once
installation is complete, you may wish to delete these files with
`rm -r stage1'.
11. If you have chosen a configuration for GNU CC which requires other
GNU tools (such as GAS or the GNU linker) instead of the standard
system tools, install the required tools in the `stage1'
subdirectory under the names `as', `ld' or whatever is
appropriate. This will enable the stage 1 compiler to find the
proper tools in the following stage.
Alternatively, you can do subsequent compilation using a value of
the `PATH' environment variable such that the necessary GNU tools
come before the standard system tools.
12. Recompile the compiler with itself, with this command:
make CC="stage1/xgcc -Bstage1/" CFLAGS="-g -O2"
This is called making the stage 2 compiler.
The command shown above builds compilers for all the supported
languages. If you don't want them all, you can specify the
languages to build by typing the argument `LANGUAGES="LIST"'. LIST
should contain one or more words from the list `c', `c++',
`objective-c', and `proto'. Separate the words with spaces.
`proto' stands for the programs `protoize' and `unprotoize'; they
are not a separate language, but you use `LANGUAGES' to enable or
disable their installation.
If you are going to build the stage 3 compiler, then you might
want to build only the C language in stage 2.
Once you have built the stage 2 compiler, if you are short of disk
space, you can delete the subdirectory `stage1'.
On a 68000 or 68020 system lacking floating point hardware, unless
you have selected a `tm.h' file that expects by default that there
is no such hardware, do this instead:
make CC="stage1/xgcc -Bstage1/" CFLAGS="-g -O2 -msoft-float"
13. If you wish to test the compiler by compiling it with itself one
more time, install any other necessary GNU tools (such as GAS or
the GNU linker) in the `stage2' subdirectory as you did in the
`stage1' subdirectory, then do this:
make stage2
make CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O2"
This is called making the stage 3 compiler. Aside from the `-B'
option, the compiler options should be the same as when you made
the stage 2 compiler. But the `LANGUAGES' option need not be the
same. The command shown above builds compilers for all the
supported languages; if you don't want them all, you can specify
the languages to build by typing the argument `LANGUAGES="LIST"',
as described above.
If you do not have to install any additional GNU tools, you may
use the command
make bootstrap LANGUAGES=LANGUAGE-LIST BOOT_CFLAGS=OPTION-LIST
instead of making `stage1', `stage2', and performing the two
compiler builds.
14. Then compare the latest object files with the stage 2 object
files--they ought to be identical, aside from time stamps (if any).
On some systems, meaningful comparison of object files is
impossible; they always appear "different." This is currently
true on Solaris and some systems that use ELF object file format.
On some versions of Irix on SGI machines and DEC Unix (OSF/1) on
Alpha systems, you will not be able to compare the files without
specifying `-save-temps'; see the description of individual
systems above to see if you get comparison failures. You may have
similar problems on other systems.
Use this command to compare the files:
make compare
This will mention any object files that differ between stage 2 and
stage 3. Any difference, no matter how innocuous, indicates that
the stage 2 compiler has compiled GNU CC incorrectly, and is
therefore a potentially serious bug which you should investigate
and report.
If your system does not put time stamps in the object files, then
this is a faster way to compare them (using the Bourne shell):
for file in *.o; do
cmp $file stage2/$file
done
If you have built the compiler with the `-mno-mips-tfile' option on
MIPS machines, you will not be able to compare the files.
15. Install the compiler driver, the compiler's passes and run-time
support with `make install'. Use the same value for `CC',
`CFLAGS' and `LANGUAGES' that you used when compiling the files
that are being installed. One reason this is necessary is that
some versions of Make have bugs and recompile files gratuitously
when you do this step. If you use the same variable values, those
files will be recompiled properly.
For example, if you have built the stage 2 compiler, you can use
the following command:
make install CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O" LANGUAGES="LIST"
This copies the files `cc1', `cpp' and `libgcc.a' to files `cc1',
`cpp' and `libgcc.a' in the directory
`/usr/local/lib/gcc-lib/TARGET/VERSION', which is where the
compiler driver program looks for them. Here TARGET is the
canonicalized form of target machine type specified when you ran
`configure', and VERSION is the version number of GNU CC. This
naming scheme permits various versions and/or cross-compilers to
coexist. It also copies the executables for compilers for other
languages (e.g., `cc1plus' for C++) to the same directory.
This also copies the driver program `xgcc' into
`/usr/local/bin/gcc', so that it appears in typical execution
search paths. It also copies `gcc.1' into `/usr/local/man/man1'
and info pages into `/usr/local/info'.
On some systems, this command causes recompilation of some files.
This is usually due to bugs in `make'. You should either ignore
this problem, or use GNU Make.
*Warning: there is a bug in `alloca' in the Sun library. To avoid
this bug, be sure to install the executables of GNU CC that were
compiled by GNU CC. (That is, the executables from stage 2 or 3,
not stage 1.) They use `alloca' as a built-in function and never
the one in the library.*
(It is usually better to install GNU CC executables from stage 2
or 3, since they usually run faster than the ones compiled with
some other compiler.)
16. If you're going to use C++, it's likely that you need to also
install a C++ runtime library. Just as GNU C does not distribute
a C runtime library, it also does not include a C++ runtime
library. All I/O functionality, special class libraries, etc., are
provided by the C++ runtime library.
The standard C++ runtime library for GNU CC is called `libstdc++'.
An obsolescent library `libg++' may also be available, but it's
necessary only for older software that hasn't been converted yet;
if you don't know whether you need `libg++' then you probably don't
need it.
Here's one way to build and install `libstdc++' for GNU CC:
* Build and install GNU CC, so that invoking `gcc' obtains the
GNU CC that was just built.
* Obtain a copy of a compatible `libstdc++' distribution. For
example, the `libstdc++-2.8.0.tar.gz' distribution should be
compatible with GCC 2.8.0. GCC distributors normally
distribute `libstdc++' as well.
* Set the `CXX' environment variable to `gcc' while running the
`libstdc++' distribution's `configure' command. Use the same
`configure' options that you used when you invoked GCC's
`configure' command.
* Invoke `make' to build the C++ runtime.
* Invoke `make install' to install the C++ runtime.
To summarize, after building and installing GNU CC, invoke the
following shell commands in the topmost directory of the C++
library distribution. For CONFIGURE-OPTIONS, use the same options
that you used to configure GNU CC.
$ CXX=gcc ./configure CONFIGURE-OPTIONS
$ make
$ make install
17. GNU CC includes a runtime library for Objective-C because it is an
integral part of the language. You can find the files associated
with the library in the subdirectory `objc'. The GNU Objective-C
Runtime Library requires header files for the target's C library in
order to be compiled,and also requires the header files for the
target's thread library if you want thread support. *Note
Cross-Compilers and Header Files: Cross Headers, for discussion
about header files issues for cross-compilation.
When you run `configure', it picks the appropriate Objective-C
thread implementation file for the target platform. In some
situations, you may wish to choose a different back-end as some
platforms support multiple thread implementations or you may wish
to disable thread support completely. You do this by specifying a
value for the OBJC_THREAD_FILE makefile variable on the command
line when you run make, for example:
make CC="stage2/xgcc -Bstage2/" CFLAGS="-g -O2" OBJC_THREAD_FILE=thr-single
Below is a list of the currently available back-ends.
* thr-single Disable thread support, should work for all
platforms.
* thr-decosf1 DEC OSF/1 thread support.
* thr-irix SGI IRIX thread support.
* thr-mach Generic MACH thread support, known to work on
NEXTSTEP.
* thr-os2 IBM OS/2 thread support.
* thr-posix Generix POSIX thread support.
* thr-pthreads PCThreads on Linux-based GNU systems.
* thr-solaris SUN Solaris thread support.
* thr-win32 Microsoft Win32 API thread support.
Configurations Supported by GNU CC
==================================
Here are the possible CPU types:
1750a, a29k, alpha, arm, cN, clipper, dsp16xx, elxsi, h8300,
hppa1.0, hppa1.1, i370, i386, i486, i586, i860, i960, m32r,
m68000, m68k, m88k, mips, mipsel, mips64, mips64el, ns32k,
powerpc, powerpcle, pyramid, romp, rs6000, sh, sparc, sparclite,
sparc64, vax, we32k.
Here are the recognized company names. As you can see, customary
abbreviations are used rather than the longer official names.
acorn, alliant, altos, apollo, apple, att, bull, cbm, convergent,
convex, crds, dec, dg, dolphin, elxsi, encore, harris, hitachi,
hp, ibm, intergraph, isi, mips, motorola, ncr, next, ns, omron,
plexus, sequent, sgi, sony, sun, tti, unicom, wrs.
The company name is meaningful only to disambiguate when the rest of
the information supplied is insufficient. You can omit it, writing
just `CPU-SYSTEM', if it is not needed. For example, `vax-ultrix4.2'
is equivalent to `vax-dec-ultrix4.2'.
Here is a list of system types:
386bsd, aix, acis, amigaos, aos, aout, aux, bosx, bsd, clix, coff,
ctix, cxux, dgux, dynix, ebmon, ecoff, elf, esix, freebsd, hms,
genix, gnu, linux-gnu, hiux, hpux, iris, irix, isc, luna, lynxos,
mach, minix, msdos, mvs, netbsd, newsos, nindy, ns, osf, osfrose,
ptx, riscix, riscos, rtu, sco, sim, solaris, sunos, sym, sysv,
udi, ultrix, unicos, uniplus, unos, vms, vsta, vxworks, winnt,
xenix.
You can omit the system type; then `configure' guesses the operating
system from the CPU and company.
You can add a version number to the system type; this may or may not
make a difference. For example, you can write `bsd4.3' or `bsd4.4' to
distinguish versions of BSD. In practice, the version number is most
needed for `sysv3' and `sysv4', which are often treated differently.
If you specify an impossible combination such as `i860-dg-vms', then
you may get an error message from `configure', or it may ignore part of
the information and do the best it can with the rest. `configure'
always prints the canonical name for the alternative that it used. GNU
CC does not support all possible alternatives.
Often a particular model of machine has a name. Many machine names
are recognized as aliases for CPU/company combinations. Thus, the
machine name `sun3', mentioned above, is an alias for `m68k-sun'.
Sometimes we accept a company name as a machine name, when the name is
popularly used for a particular machine. Here is a table of the known
machine names:
3300, 3b1, 3bN, 7300, altos3068, altos, apollo68, att-7300,
balance, convex-cN, crds, decstation-3100, decstation, delta,
encore, fx2800, gmicro, hp7NN, hp8NN, hp9k2NN, hp9k3NN, hp9k7NN,
hp9k8NN, iris4d, iris, isi68, m3230, magnum, merlin, miniframe,
mmax, news-3600, news800, news, next, pbd, pc532, pmax, powerpc,
powerpcle, ps2, risc-news, rtpc, sun2, sun386i, sun386, sun3,
sun4, symmetry, tower-32, tower.
Remember that a machine name specifies both the cpu type and the company
name. If you want to install your own homemade configuration files,
you can use `local' as the company name to access them. If you use
configuration `CPU-local', the configuration name without the cpu prefix
is used to form the configuration file names.
Thus, if you specify `m68k-local', configuration uses files
`m68k.md', `local.h', `m68k.c', `xm-local.h', `t-local', and `x-local',
all in the directory `config/m68k'.
Here is a list of configurations that have special treatment or
special things you must know:
`1750a-*-*'
MIL-STD-1750A processors.
The MIL-STD-1750A cross configuration produces output for
`as1750', an assembler/linker available under the GNU Public
License for the 1750A. `as1750' can be obtained at
*ftp://ftp.fta-berlin.de/pub/crossgcc/1750gals/*. A similarly
licensed simulator for the 1750A is available from same address.
You should ignore a fatal error during the building of libgcc
(libgcc is not yet implemented for the 1750A.)
The `as1750' assembler requires the file `ms1750.inc', which is
found in the directory `config/1750a'.
GNU CC produced the same sections as the Fairchild F9450 C
Compiler, namely:
`Normal'
The program code section.
`Static'
The read/write (RAM) data section.
`Konst'
The read-only (ROM) constants section.
`Init'
Initialization section (code to copy KREL to SREL).
The smallest addressable unit is 16 bits (BITS_PER_UNIT is 16).
This means that type `char' is represented with a 16-bit word per
character. The 1750A's "Load/Store Upper/Lower Byte" instructions
are not used by GNU CC.
`alpha-*-osf1'
Systems using processors that implement the DEC Alpha architecture
and are running the DEC Unix (OSF/1) operating system, for example
the DEC Alpha AXP systems.CC.)
GNU CC writes a `.verstamp' directive to the assembler output file
unless it is built as a cross-compiler. It gets the version to
use from the system header file `/usr/include/stamp.h'. If you
install a new version of DEC Unix, you should rebuild GCC to pick
up the new version stamp.
Note that since the Alpha is a 64-bit architecture,
cross-compilers from 32-bit machines will not generate code as
efficient as that generated when the compiler is running on a
64-bit machine because many optimizations that depend on being
able to represent a word on the target in an integral value on the
host cannot be performed. Building cross-compilers on the Alpha
for 32-bit machines has only been tested in a few cases and may
not work properly.
`make compare' may fail on old versions of DEC Unix unless you add
`-save-temps' to `CFLAGS'. On these systems, the name of the
assembler input file is stored in the object file, and that makes
comparison fail if it differs between the `stage1' and `stage2'
compilations. The option `-save-temps' forces a fixed name to be
used for the assembler input file, instead of a randomly chosen
name in `/tmp'. Do not add `-save-temps' unless the comparisons
fail without that option. If you add `-save-temps', you will have
to manually delete the `.i' and `.s' files after each series of
compilations.
GNU CC now supports both the native (ECOFF) debugging format used
by DBX and GDB and an encapsulated STABS format for use only with
GDB. See the discussion of the `--with-stabs' option of
`configure' above for more information on these formats and how to
select them.
There is a bug in DEC's assembler that produces incorrect line
numbers for ECOFF format when the `.align' directive is used. To
work around this problem, GNU CC will not emit such alignment
directives while writing ECOFF format debugging information even
if optimization is being performed. Unfortunately, this has the
very undesirable side-effect that code addresses when `-O' is
specified are different depending on whether or not `-g' is also
specified.
To avoid this behavior, specify `-gstabs+' and use GDB instead of
DBX. DEC is now aware of this problem with the assembler and
hopes to provide a fix shortly.
`arc-*-elf'
Argonaut ARC processor. This configuration is intended for
embedded systems.
`arm-*-aout'
Advanced RISC Machines ARM-family processors. These are often
used in embedded applications. There are no standard Unix
configurations. This configuration corresponds to the basic
instruction sequences and will produce `a.out' format object
modules.
You may need to make a variant of the file `arm.h' for your
particular configuration.
`arm-*-linuxaout'
Any of the ARM family processors running the Linux-based GNU
system with the `a.out' binary format (ELF is not yet supported).
You must use version 2.8.1.0.7 or later of the GNU/Linux binutils,
which you can download from `sunsite.unc.edu:/pub/Linux/GCC' and
other mirror sites for Linux-based GNU systems.
`arm-*-riscix'
The ARM2 or ARM3 processor running RISC iX, Acorn's port of BSD
Unix. If you are running a version of RISC iX prior to 1.2 then
you must specify the version number during configuration. Note
that the assembler shipped with RISC iX does not support stabs
debugging information; a new version of the assembler, with stabs
support included, is now available from Acorn and via ftp
`ftp.acorn.com:/pub/riscix/as+xterm.tar.Z'. To enable stabs
debugging, pass `--with-gnu-as' to configure.
You will need to install GNU `sed' before you can run configure.
`a29k'
AMD Am29k-family processors. These are normally used in embedded
applications. There are no standard Unix configurations. This
configuration corresponds to AMD's standard calling sequence and
binary interface and is compatible with other 29k tools.
You may need to make a variant of the file `a29k.h' for your
particular configuration.
`a29k-*-bsd'
AMD Am29050 used in a system running a variant of BSD Unix.
`decstation-*'
MIPS-based DECstations can support three different personalities:
Ultrix, DEC OSF/1, and OSF/rose. (Alpha-based DECstation products
have a configuration name beginning with `alpha-dec'.) To
configure GCC for these platforms use the following configurations:
`decstation-ultrix'
Ultrix configuration.
`decstation-osf1'
Dec's version of OSF/1.
`decstation-osfrose'
Open Software Foundation reference port of OSF/1 which uses
the OSF/rose object file format instead of ECOFF. Normally,
you would not select this configuration.
The MIPS C compiler needs to be told to increase its table size
for switch statements with the `-Wf,-XNg1500' option in order to
compile `cp/parse.c'. If you use the `-O2' optimization option,
you also need to use `-Olimit 3000'. Both of these options are
automatically generated in the `Makefile' that the shell script
`configure' builds. If you override the `CC' make variable and
use the MIPS compilers, you may need to add `-Wf,-XNg1500 -Olimit
3000'.
`elxsi-elxsi-bsd'
The Elxsi's C compiler has known limitations that prevent it from
compiling GNU C. Please contact `mrs@cygnus.com' for more details.
`dsp16xx'
A port to the AT&T DSP1610 family of processors.
`h8300-*-*'
Hitachi H8/300 series of processors.
The calling convention and structure layout has changed in release
2.6. All code must be recompiled. The calling convention now
passes the first three arguments in function calls in registers.
Structures are no longer a multiple of 2 bytes.
`hppa*-*-*'
There are several variants of the HP-PA processor which run a
variety of operating systems. GNU CC must be configured to use
the correct processor type and operating system, or GNU CC will
not function correctly. The easiest way to handle this problem is
to *not* specify a target when configuring GNU CC, the `configure'
script will try to automatically determine the right processor
type and operating system.
`-g' does not work on HP-UX, since that system uses a peculiar
debugging format which GNU CC does not know about. However, `-g'
will work if you also use GAS and GDB in conjunction with GCC. We
highly recommend using GAS for all HP-PA configurations.
You should be using GAS-2.6 (or later) along with GDB-4.16 (or
later). These can be retrieved from all the traditional GNU ftp
archive sites.
GAS will need to be installed into a directory before `/bin',
`/usr/bin', and `/usr/ccs/bin' in your search path. You should
install GAS before you build GNU CC.
To enable debugging, you must configure GNU CC with the
`--with-gnu-as' option before building.
`i370-*-*'
This port is very preliminary and has many known bugs. We hope to
have a higher-quality port for this machine soon.
`i386-*-linux-gnuoldld'
Use this configuration to generate `a.out' binaries on Linux-based
GNU systems if you do not have gas/binutils version 2.5.2 or later
installed. This is an obsolete configuration.
`i386-*-linux-gnuaout'
Use this configuration to generate `a.out' binaries on Linux-based
GNU systems. This configuration is being superseded. You must use
gas/binutils version 2.5.2 or later.
`i386-*-linux-gnu'
Use this configuration to generate ELF binaries on Linux-based GNU
systems. You must use gas/binutils version 2.5.2 or later.
`i386-*-sco'
Compilation with RCC is recommended. Also, it may be a good idea
to link with GNU malloc instead of the malloc that comes with the
system.
`i386-*-sco3.2v4'
Use this configuration for SCO release 3.2 version 4.
`i386-*-sco3.2v5*'
Use this for the SCO OpenServer Release family including 5.0.0,
5.0.2, 5.0.4, Internet FastStart 1.0, and Internet FastStart 1.1.
GNU CC can generate either ELF or COFF binaries. ELF is the
default. To get COFF output, you must specify `-mcoff' on the
command line.
For 5.0.0 and 5.0.2, you must install TLS597 from ftp.sco.com/TLS.
5.0.4 and later do not require this patch.
*NOTE:* You must follow the instructions about invoking `make
bootstrap' because the native OpenServer compiler builds a
`cc1plus' that will not correctly parse many valid C++ programs.
You must do a `make bootstrap' if you are building with the native
compiler.
`i386-*-isc'
It may be a good idea to link with GNU malloc instead of the
malloc that comes with the system.
In ISC version 4.1, `sed' core dumps when building `deduced.h'.
Use the version of `sed' from version 4.0.
`i386-*-esix'
It may be good idea to link with GNU malloc instead of the malloc
that comes with the system.
`i386-ibm-aix'
You need to use GAS version 2.1 or later, and LD from GNU binutils
version 2.2 or later.
`i386-sequent-bsd'
Go to the Berkeley universe before compiling.
`i386-sequent-ptx1*'
Sequent DYNIX/ptx 1.x.
`i386-sequent-ptx2*'
Sequent DYNIX/ptx 2.x.
`i386-sun-sunos4'
You may find that you need another version of GNU CC to begin
bootstrapping with, since the current version when built with the
system's own compiler seems to get an infinite loop compiling part
of `libgcc2.c'. GNU CC version 2 compiled with GNU CC (any
version) seems not to have this problem.
See *Note Sun Install::, for information on installing GNU CC on
Sun systems.
`i[345]86-*-winnt3.5'
This version requires a GAS that has not yet been released. Until
it is, you can get a prebuilt binary version via anonymous ftp from
`cs.washington.edu:pub/gnat' or `cs.nyu.edu:pub/gnat'. You must
also use the Microsoft header files from the Windows NT 3.5 SDK.
Find these on the CDROM in the `/mstools/h' directory dated
9/4/94. You must use a fixed version of Microsoft linker made
especially for NT 3.5, which is also is available on the NT 3.5
SDK CDROM. If you do not have this linker, can you also use the
linker from Visual C/C++ 1.0 or 2.0.
Installing GNU CC for NT builds a wrapper linker, called `ld.exe',
which mimics the behaviour of Unix `ld' in the specification of
libraries (`-L' and `-l'). `ld.exe' looks for both Unix and
Microsoft named libraries. For example, if you specify `-lfoo',
`ld.exe' will look first for `libfoo.a' and then for `foo.lib'.
You may install GNU CC for Windows NT in one of two ways,
depending on whether or not you have a Unix-like shell and various
Unix-like utilities.
1. If you do not have a Unix-like shell and few Unix-like
utilities, you will use a DOS style batch script called
`configure.bat'. Invoke it as `configure winnt' from an
MSDOS console window or from the program manager dialog box.
`configure.bat' assumes you have already installed and have
in your path a Unix-like `sed' program which is used to
create a working `Makefile' from `Makefile.in'.
`Makefile' uses the Microsoft Nmake program maintenance
utility and the Visual C/C++ V8.00 compiler to build GNU CC.
You need only have the utilities `sed' and `touch' to use
this installation method, which only automatically builds the
compiler itself. You must then examine what `fixinc.winnt'
does, edit the header files by hand and build `libgcc.a'
manually.
2. The second type of installation assumes you are running a
Unix-like shell, have a complete suite of Unix-like utilities
in your path, and have a previous version of GNU CC already
installed, either through building it via the above
installation method or acquiring a pre-built binary. In this
case, use the `configure' script in the normal fashion.
`i860-intel-osf1'
This is the Paragon. If you have version 1.0 of the operating
system, you need to take special steps to build GNU CC due to
peculiarities of the system. Newer system versions have no
problem. See the section `Installation Problems' in the GNU CC
Manual.
`*-lynx-lynxos'
LynxOS 2.2 and earlier comes with GNU CC 1.x already installed as
`/bin/gcc'. You should compile with this instead of `/bin/cc'.
You can tell GNU CC to use the GNU assembler and linker, by
specifying `--with-gnu-as --with-gnu-ld' when configuring. These
will produce COFF format object files and executables; otherwise
GNU CC will use the installed tools, which produce `a.out' format
executables.
`m32r-*-elf'
Mitsubishi M32R processor. This configuration is intended for
embedded systems.
`m68000-hp-bsd'
HP 9000 series 200 running BSD. Note that the C compiler that
comes with this system cannot compile GNU CC; contact
`law@cygnus.com' to get binaries of GNU CC for bootstrapping.
`m68k-altos'
Altos 3068. You must use the GNU assembler, linker and debugger.
Also, you must fix a kernel bug. Details in the file
`README.ALTOS'.
`m68k-apple-aux'
Apple Macintosh running A/UX. You may configure GCC to use
either the system assembler and linker or the GNU assembler and
linker. You should use the GNU configuration if you can,
especially if you also want to use GNU C++. You enabled that
configuration with + the `--with-gnu-as' and `--with-gnu-ld'
options to `configure'.
Note the C compiler that comes with this system cannot compile GNU
CC. You can fine binaries of GNU CC for bootstrapping on
`jagubox.gsfc.nasa.gov'. You will also a patched version of
`/bin/ld' there that raises some of the arbitrary limits found in
the original.
`m68k-att-sysv'
AT&T 3b1, a.k.a. 7300 PC. Special procedures are needed to
compile GNU CC with this machine's standard C compiler, due to
bugs in that compiler. You can bootstrap it more easily with
previous versions of GNU CC if you have them.
Installing GNU CC on the 3b1 is difficult if you do not already
have GNU CC running, due to bugs in the installed C compiler.
However, the following procedure might work. We are unable to
test it.
1. Comment out the `#include "config.h"' line near the start of
`cccp.c' and do `make cpp'. This makes a preliminary version
of GNU cpp.
2. Save the old `/lib/cpp' and copy the preliminary GNU cpp to
that file name.
3. Undo your change in `cccp.c', or reinstall the original
version, and do `make cpp' again.
4. Copy this final version of GNU cpp into `/lib/cpp'.
5. Replace every occurrence of `obstack_free' in the file
`tree.c' with `_obstack_free'.
6. Run `make' to get the first-stage GNU CC.
7. Reinstall the original version of `/lib/cpp'.
8. Now you can compile GNU CC with itself and install it in the
normal fashion.