The VMS version of GNU CC is distributed in a backup saveset containing both source code and precompiled binaries.
To install the `gcc' 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:
$ assign /system /translation=concealed - disk:[gcc.] gnu_cc $ assign /system /translation=concealed - disk:[gcc.include.] gnu_cc_includewith 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 `GCC_INSTALL.COM' script in the `[GCC]' directory.
$ set command /table=sys$common:[syslib]dcltables - /output=sys$common:[syslib]dcltables gnu_cc:[000000]gcc $ install replace sys$common:[syslib]dcltables
$ library/help sys$library:helplib.hlb gcc.hlpNow you can invoke the compiler with a command like `gcc /verbose file.c', which is equivalent to the command `gcc -v -c file.c' in Unix.
If you wish to use GNU C++ you must first install GNU CC, and then perform the following steps:
$ assign /system /translation=concealed - disk:[gcc.gxx_include.] gnu_gxx_includewith the appropriate disk and directory name. If you are going to be using libg++, this is where the libg++ install procedure will install the libg++ header files.
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 `/version' option to determine the version number of the binaries and compare it with the source file `version.c' 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:
$ @vmsconfig.com
$ assign /system /translation=concealed - disk:[bison.] gnu_bisonYou may, if you choose, use the `INSTALL_BISON.COM' script in the `[BISON]' directory.
$ set command /table=sys$common:[syslib]dcltables - /output=sys$common:[syslib]dcltables - gnu_bison:[000000]bison $ install replace sys$common:[syslib]dcltables
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 `libgcc2.c'. To compile this you should use the command procedure
`make-l2.com', which will generate the library `libgcc2.olb'.
`libgcc2.olb' should be built using the compiler built from
the same distribution that `libgcc2.c' came from, and
`make-gcc.com' will automatically do all of this for you.
To install the library, use the following commands:
$ 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.objThe first command simply removes old modules that will be replaced with modules from `libgcc2' under different module names. The modules
new
and eprintf
may not actually be present in your
`gcclib.olb'---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 `libgcc2.c'.
Whenever you update the compiler on your system, you should also update the
library with the above procedure.
gcc
in such a way that no files are
written to the directory where the source files reside. An example would be
when the source files are on a read-only disk. In these cases, execute the
following DCL commands (substituting your actual path names):
$ assign dua0:[gcc.build_dir.]/translation=concealed, - dua1:[gcc.source_dir.]/translation=concealed gcc_build $ set default gcc_build:[000000]where the directory `dua1:[gcc.source_dir]' contains the source code, and the directory `dua0:[gcc.build_dir]' 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 `gcc_build' 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).
gcc
version 2. If you use GAS 1.38.1, then extern const
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.
If you are compiling with a version of GNU CC older than 1.33, specify
`/DEFINE=("inline=")' as an option in all the compilations. This
requires editing all the gcc
commands in `make-cc1.com'.
(The older versions had problems supporting inline
.) Once you
have a working 1.33 or newer GNU CC, you can change this file back.
CC
, CFLAGS
, and
LIBS
. 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 `libgcc2' in order to build `gcclib' (see above);
`make-l2.com' expects to be able to find it operational in
`gnu_cc:[000000]gnu-as.exe'.
To use GNU CC on VMS, you need the VMS driver programs
`gcc.exe', `gcc.com', and `gcc.cld'. They are
distributed with the VMS binaries (`gcc-vms') rather than the
GNU CC sources. GAS is also included in `gcc-vms', as is Bison.
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 CC
, CFLAGS
, and LIBS
definitions in
`make-cccp.com' and `make-cc1.com'. The second generation
compiler will be able to take advantage of many optimizations that must
be suppressed when building with other compilers.
Under previous versions of GNU CC, the generated code would occasionally give strange results when linked with the sharable `VAXCRTL' library. Now this should work.
Even with this version, however, GNU CC itself should not be linked with
the sharable `VAXCRTL'. The version of qsort
in
`VAXCRTL' has a bug (known to be present in VMS versions V4.6
through V5.5) which causes the compiler to fail.
The executables are generated by `make-cc1.com' and
`make-cccp.com'. Use the object library version of `VAXCRTL' in
order to make use of the qsort
routine in `gcclib.olb'. If
you wish to link the compiler executables with the shareable image
version of `VAXCRTL', you should edit the file `tm.h' (created
by `vmsconfig.com') to define the macro QSORT_WORKAROUND
.
QSORT_WORKAROUND
is always defined when GNU CC is compiled with
VAX C, to avoid a problem in case `gcclib.olb' is not yet
available.