- <p>Thus, if you specify <code>m68k-local</code>, configuration uses
-files <code>m68k.md</code>, <code>local.h</code>, <code>m68k.c</code>,
-<code>xm-local.h</code>, <code>t-local</code>, and <code>x-local</code>, all in the
-directory <code>config/m68k</code>.
-
- <p>Here is a list of configurations that have special treatment or special
-things you must know:
-
- <dl>
-<dt><code>vax-dec-vms</code>
- <dd>See <a href="#VMS%20Install">VMS Install</a>, for details on how to install GNU CC on VMS.
-</dl>
-
- <h2><a name="Cross-Compiler"></a>Building and Installing a Cross-Compiler</h2>
-
- <p>GNU CC can function as a cross-compiler for many machines, but not all.
-
- <ul>
-<li>Cross-compilers for the Mips as target using the Mips assembler
-currently do not work, because the auxiliary programs
-<code>mips-tdump.c</code> and <code>mips-tfile.c</code> can't be compiled on
-anything but a Mips. It does work to cross compile for a Mips
-if you use the GNU assembler and linker.
-
- <li>Cross-compilers between machines with different floating point formats
-have not all been made to work. GNU CC now has a floating point
-emulator with which these can work, but each target machine description
-needs to be updated to take advantage of it.
-
- <li>Cross-compilation between machines of different word sizes is
-somewhat problematic and sometimes does not work.
-</ul>
-
- <p>Since GNU CC generates assembler code, you probably need a
-cross-assembler that GNU CC can run, in order to produce object files.
-If you want to link on other than the target machine, you need a
-cross-linker as well. You also need header files and libraries suitable
-for the target machine that you can install on the host machine.
-
- <h2>Steps of Cross-Compilation</h2>
-
- <p>To compile and run a program using a cross-compiler involves several
-steps:
-
- <ul>
-<li>Run the cross-compiler on the host machine to produce assembler files
-for the target machine. This requires header files for the target
-machine.
-
- <li>Assemble the files produced by the cross-compiler. You can do this
-either with an assembler on the target machine, or with a
-cross-assembler on the host machine.
-
- <li>Link those files to make an executable. You can do this either with a
-linker on the target machine, or with a cross-linker on the host
-machine. Whichever machine you use, you need libraries and certain
-startup files (typically <code>crt....o</code>) for the target machine.
-</ul>
-
- <p>It is most convenient to do all of these steps on the same host machine,
-since then you can do it all with a single invocation of GNU CC. This
-requires a suitable cross-assembler and cross-linker. For some targets,
-the GNU assembler and linker are available.
-
- <h2>Configuring a Cross-Compiler</h2>
-
- <p>To build GNU CC as a cross-compiler, you start out by running
-<code>configure</code>. Use the <code>--target=</code><var>target</var><code></code> to specify the
-target type. If <code>configure</code> was unable to correctly identify the
-system you are running on, also specify the <code>--build=</code><var>build</var><code></code>
-option. For example, here is how to configure for a cross-compiler that
-produces code for an HP 68030 system running BSD on a system that
-<code>configure</code> can correctly identify:
-
-<pre class="smallexample"> ./configure --target=m68k-hp-bsd4.3
- </pre>
-
- <h2>Tools and Libraries for a Cross-Compiler</h2>
-
- <p>If you have a cross-assembler and cross-linker available, you should
-install them now. Put them in the directory
-<code>/usr/local/</code><var>target</var><code>/bin</code>. Here is a table of the tools
-you should put in this directory:
-
- <dl>
-<dt><code>as</code>
- <dd>This should be the cross-assembler.
-
- <br><dt><code>ld</code>
- <dd>This should be the cross-linker.
-
- <br><dt><code>ar</code>
- <dd>This should be the cross-archiver: a program which can manipulate
-archive files (linker libraries) in the target machine's format.
-
- <br><dt><code>ranlib</code>
- <dd>This should be a program to construct a symbol table in an archive file.
-</dl>
-
- <p>The installation of GNU CC will find these programs in that directory,
-and copy or link them to the proper place to for the cross-compiler to
-find them when run later.
-
- <p>The easiest way to provide these files is to build the Binutils package
-and GAS. Configure them with the same <code>--host</code> and <code>--target</code>
-options that you use for configuring GNU CC, then build and install
-them. They install their executables automatically into the proper
-directory. Alas, they do not support all the targets that GNU CC
-supports.
-
- <p>If you want to install libraries to use with the cross-compiler, such as
-a standard C library, put them in the directory
-<code>/usr/local/</code><var>target</var><code>/lib</code>; installation of GNU CC copies
-all the files in that subdirectory into the proper place for GNU CC to
-find them and link with them. Here's an example of copying some
-libraries from a target machine:
-
-<pre class="example"> ftp <var>target-machine</var>
- lcd /usr/local/<var>target</var>/lib
- cd /lib
- get libc.a
- cd /usr/lib
- get libg.a
- get libm.a
- quit
- </pre>
-
-<p>The precise set of libraries you'll need, and their locations on
-the target machine, vary depending on its operating system.
-
- <p>Many targets require "start files" such as <code>crt0.o</code> and
-<code>crtn.o</code> which are linked into each executable; these too should be
-placed in <code>/usr/local/</code><var>target</var><code>/lib</code>. There may be several
-alternatives for <code>crt0.o</code>, for use with profiling or other
-compilation options. Check your target's definition of
-<code>STARTFILE_SPEC</code> to find out what start files it uses.
-Here's an example of copying these files from a target machine:
-
-<pre class="example"> ftp <var>target-machine</var>
- lcd /usr/local/<var>target</var>/lib
- prompt
- cd /lib
- mget *crt*.o
- cd /usr/lib
- mget *crt*.o
- quit
- </pre>
-
- <h2>Cross-Compilers and Header Files</h2>
-
- <p>If you are cross-compiling a standalone program or a program for an
-embedded system, then you may not need any header files except the few
-that are part of GNU CC (and those of your program). However, if you
-intend to link your program with a standard C library such as
-<code>libc.a</code>, then you probably need to compile with the header files
-that go with the library you use.
-
- <p>The GNU C compiler does not come with these files, because (1) they are
-system-specific, and (2) they belong in a C library, not in a compiler.
-
- <p>If the GNU C library supports your target machine, then you can get the
-header files from there (assuming you actually use the GNU library when
-you link your program).
-
- <p>If your target machine comes with a C compiler, it probably comes with
-suitable header files also. If you make these files accessible from the host
-machine, the cross-compiler can use them also.
-
- <p>Otherwise, you're on your own in finding header files to use when
-cross-compiling.
-
- <p>When you have found suitable header files, you should put them in the
-directory <code>/usr/local/</code><var>target</var><code>/include</code>, before building the
-cross compiler. Then installation will run fixincludes properly and
-install the corrected versions of the header files where the compiler
-will use them.
-
- <p>Provide the header files before you build the cross-compiler, because
-the build stage actually runs the cross-compiler to produce parts of
-<code>libgcc.a</code>. (These are the parts that <em>can</em> be compiled with
-GNU CC.) Some of them need suitable header files.
-
- <p>Here's an example showing how to copy the header files from a target
-machine. On the target machine, do this:
-
-<pre class="example"> (cd /usr/include; tar cf - .) > tarfile
- </pre>
-
- <p>Then, on the host machine, do this:
-
-<pre class="example"> ftp <var>target-machine</var>
- lcd /usr/local/<var>target</var>/include
- get tarfile
- quit
- tar xf tarfile
- </pre>
-
- <h2>Actually Building the Cross-Compiler</h2>
-
- <p>Now you can proceed just as for compiling a single-machine compiler
-through the step of building stage 1.
-
- <p>If your target is exotic, you may need to provide the header file
-<code>float.h</code>.One way to do this is to compile <code>enquire</code> and run
-it on your target machine. The job of <code>enquire</code> is to run on the
-target machine and figure out by experiment the nature of its floating
-point representation. <code>enquire</code> records its findings in the header
-file <code>float.h</code>. If you can't produce this file by running
-<code>enquire</code> on the target machine, then you will need to come up with
-a suitable <code>float.h</code> in some other way (or else, avoid using it in
-your programs).
-
- <p>Do not try to build stage 2 for a cross-compiler. It doesn't work to
-rebuild GNU CC as a cross-compiler using the cross-compiler, because
-that would produce a program that runs on the target machine, not on the
-host. For example, if you compile a 386-to-68030 cross-compiler with
-itself, the result will not be right either for the 386 (because it was
-compiled into 68030 code) or for the 68030 (because it was configured
-for a 386 as the host). If you want to compile GNU CC into 68030 code,
-whether you compile it on a 68030 or with a cross-compiler on a 386, you
-must specify a 68030 as the host when you configure it.
-
- <p>To install the cross-compiler, use <code>make install</code>, as usual.
-
- <h2><a name="VMS%20Install"></a>Installing GNU CC on VMS</h2>
-
- <p>The VMS version of GNU CC is distributed in a backup saveset containing
-both source code and precompiled binaries.
-
- <p>To install the <code>gcc</code> command so you can use the compiler easily, in
-the same manner as you use the VMS C compiler, you must install the VMS CLD
-file for GNU CC as follows:
-
- <ol type=1 start=1>
-<li>Define the VMS logical names <code>GNU_CC</code> and <code>GNU_CC_INCLUDE</code>
-to point to the directories where the GNU CC executables
-(<code>gcc-cpp.exe</code>, <code>gcc-cc1.exe</code>, etc.) and the C include files are
-kept respectively. This should be done with the commands:
-
- <pre class="smallexample"> $ assign /system /translation=concealed -
- disk:[gcc.] gnu_cc
- $ assign /system /translation=concealed -
- disk:[gcc.include.] gnu_cc_include
- </pre>
-
- <p>with the appropriate disk and directory names. These commands can be
-placed in your system startup file so they will be executed whenever
-the machine is rebooted. You may, if you choose, do this via the
-<code>GCC_INSTALL.COM</code> script in the <code>[GCC]</code> directory.
-
- </p><li>Install the <code>GCC</code> command with the command line:
-
- <pre class="smallexample"> $ set command /table=sys$common:[syslib]dcltables -
- /output=sys$common:[syslib]dcltables gnu_cc:[000000]gcc
- $ install replace sys$common:[syslib]dcltables
- </pre>
-
- <li>To install the help file, do the following:
-
- <pre class="smallexample"> $ library/help sys$library:helplib.hlb gcc.hlp
- </pre>
-
- <p>Now you can invoke the compiler with a command like <code>gcc /verbose
-file.c</code>, which is equivalent to the command <code>gcc -v -c file.c</code> in
-Unix.
- </ol>
-
- <p>If you wish to use GNU C++ you must first install GNU CC, and then
-perform the following steps:
-
- <ol type=1 start=1>
-<li>Define the VMS logical name <code>GNU_GXX_INCLUDE</code> to point to the
-directory where the preprocessor will search for the C++ header files.
-This can be done with the command:
-
- <pre class="smallexample"> $ assign /system /translation=concealed -
- disk:[gcc.gxx_include.] gnu_gxx_include
- </pre>
-
- <p>with the appropriate disk and directory name. If you are going to be
-using a C++ runtime library, this is where its install procedure will install
-its header files.
-
- </p><li>Obtain the file <code>gcc-cc1plus.exe</code>, and place this in the same
-directory that <code>gcc-cc1.exe</code> is kept.
-
- <p>The GNU C++ compiler can be invoked with a command like <code>gcc /plus
-/verbose file.cc</code>, which is equivalent to the command <code>g++ -v -c
-file.cc</code> in Unix.
- </ol>
-
- <p>We try to put corresponding binaries and sources on the VMS distribution
-tape. But sometimes the binaries will be from an older version than the
-sources, because we don't always have time to update them. (Use the
-<code>/version</code> option to determine the version number of the binaries and
-compare it with the source file <code>version.c</code> to tell whether this is
-so.) In this case, you should use the binaries you get to recompile the
-sources. If you must recompile, here is how:
-
- <ol type=1 start=1>
-<li>Execute the command procedure <code>vmsconfig.com</code> to set up the files
-<code>tm.h</code>, <code>config.h</code>, <code>aux-output.c</code>, and <code>md.</code>, and
-to create files <code>tconfig.h</code> and <code>hconfig.h</code>. This procedure
-also creates several linker option files used by <code>make-cc1.com</code> and
-a data file used by <code>make-l2.com</code>.
-
- <pre class="smallexample"> $ @vmsconfig.com
- </pre>
-
- <li>Setup the logical names and command tables as defined above. In
-addition, define the VMS logical name <code>GNU_BISON</code> to point at the
-to the directories where the Bison executable is kept. This should be
-done with the command:
-
- <pre class="smallexample"> $ assign /system /translation=concealed -
- disk:[bison.] gnu_bison
- </pre>
-
- <p>You may, if you choose, use the <code>INSTALL_BISON.COM</code> script in the
-<code>[BISON]</code> directory.
-
- </p><li>Install the <code>BISON</code> command with the command line:
-
- <pre class="smallexample"> $ set command /table=sys$common:[syslib]dcltables -
- /output=sys$common:[syslib]dcltables -
- gnu_bison:[000000]bison
- $ install replace sys$common:[syslib]dcltables
- </pre>
-
- <li>Type <code>@make-gcc</code> to recompile everything, or submit the file
-<code>make-gcc.com</code> to a batch queue. If you wish to build the GNU C++
-compiler as well as the GNU CC compiler, you must first edit
-<code>make-gcc.com</code> and follow the instructions that appear in the
-comments.
-
- <li>In order to use GCC, you need a library of functions which GCC compiled code
-will call to perform certain tasks, and these functions are defined in the
-file <code>libgcc2.c</code>. To compile this you should use the command procedure
-<code>make-l2.com</code>, which will generate the library <code>libgcc2.olb</code>.
-<code>libgcc2.olb</code> should be built using the compiler built from
-the same distribution that <code>libgcc2.c</code> came from, and
-<code>make-gcc.com</code> will automatically do all of this for you.
-
- <p>To install the library, use the following commands:
-
- <pre class="smallexample"> $ library gnu_cc:[000000]gcclib/delete=(new,eprintf)
- $ library gnu_cc:[000000]gcclib/delete=L_*
- $ library libgcc2/extract=*/output=libgcc2.obj
- $ library gnu_cc:[000000]gcclib libgcc2.obj
- </pre>
-
- <p>The first command simply removes old modules that will be replaced with
-modules from <code>libgcc2</code> under different module names. The modules
-<code>new</code> and <code>eprintf</code> may not actually be present in your
-<code>gcclib.olb</code>--if the VMS librarian complains about those modules
-not being present, simply ignore the message and continue on with the
-next command. The second command removes the modules that came from the
-previous version of the library <code>libgcc2.c</code>.
-
- <p>Whenever you update the compiler on your system, you should also update the
-library with the above procedure.
-
- </p><li>You may wish to build GCC in such a way that no files are written to the
-directory where the source files reside. An example would be the when
-the source files are on a read-only disk. In these cases, execute the
-following DCL commands (substituting your actual path names):
-
- <pre class="smallexample"> $ assign dua0:[gcc.build_dir.]/translation=concealed, -
- dua1:[gcc.source_dir.]/translation=concealed gcc_build
- $ set default gcc_build:[000000]
- </pre>
-
- <p>where the directory <code>dua1:[gcc.source_dir]</code> contains the source
-code, and the directory <code>dua0:[gcc.build_dir]</code> is meant to contain
-all of the generated object files and executables. Once you have done
-this, you can proceed building GCC as described above. (Keep in mind
-that <code>gcc_build</code> is a rooted logical name, and thus the device
-names in each element of the search list must be an actual physical
-device name rather than another rooted logical name).
-
- </p><li><strong>If you are building GNU CC with a previous version of GNU CC,
-you also should check to see that you have the newest version of the
-assembler</strong>. In particular, GNU CC version 2 treats global constant
-variables slightly differently from GNU CC version 1, and GAS version
-1.38.1 does not have the patches required to work with GCC version 2.
-If you use GAS 1.38.1, then <code>extern const</code> variables will not have
-the read-only bit set, and the linker will generate warning messages
-about mismatched psect attributes for these variables. These warning
-messages are merely a nuisance, and can safely be ignored.
-
- <li>If you want to build GNU CC with the VAX C compiler, you will need to
-make minor changes in <code>make-cccp.com</code> and <code>make-cc1.com</code>
-to choose alternate definitions of <code>CC</code>, <code>CFLAGS</code>, and
-<code>LIBS</code>. See comments in those files. However, you must
-also have a working version of the GNU assembler (GNU as, aka GAS) as
-it is used as the back end for GNU CC to produce binary object modules
-and is not included in the GNU CC sources. GAS is also needed to
-compile <code>libgcc2</code> in order to build <code>gcclib</code> (see above);
-<code>make-l2.com</code> expects to be able to find it operational in
-<code>gnu_cc:[000000]gnu-as.exe</code>.
-
- <p>To use GNU CC on VMS, you need the VMS driver programs
-<code>gcc.exe</code>, <code>gcc.com</code>, and <code>gcc.cld</code>. They are
-distributed with the VMS binaries (<code>gcc-vms</code>) rather than the
-GNU CC sources. GAS is also included in <code>gcc-vms</code>, as is Bison.
-
- <p>Once you have successfully built GNU CC with VAX C, you should use the
-resulting compiler to rebuild itself. Before doing this, be sure to
-restore the <code>CC</code>, <code>CFLAGS</code>, and <code>LIBS</code> definitions in
-<code>make-cccp.com</code> and <code>make-cc1.com</code>. The second generation
-compiler will be able to take advantage of many optimizations that must
-be suppressed when building with other compilers.
- </ol>
-
- <p>Under previous versions of GNU CC, the generated code would occasionally
-give strange results when linked with the sharable <code>VAXCRTL</code> library.
-Now this should work.
-
- <p>Even with this version, however, GNU CC itself should not be linked with
-the sharable <code>VAXCRTL</code>. The version of <code>qsort</code> in
-<code>VAXCRTL</code> has a bug (known to be present in VMS versions V4.6
-through V5.5) which causes the compiler to fail.
-
- <p>The executables are generated by <code>make-cc1.com</code> and
-<code>make-cccp.com</code> use the object library version of <code>VAXCRTL</code> in
-order to make use of the <code>qsort</code> routine in <code>gcclib.olb</code>. If
-you wish to link the compiler executables with the shareable image
-version of <code>VAXCRTL</code>, you should edit the file <code>tm.h</code> (created
-by <code>vmsconfig.com</code>) to define the macro <code>QSORT_WORKAROUND</code>.
-
- <p><code>QSORT_WORKAROUND</code> is always defined when GNU CC is compiled with
-VAX C, to avoid a problem in case <code>gcclib.olb</code> is not yet
-available.