gcj(1)

NAME

gcj - Ahead-of-time compiler for the Java language

SYNOPSIS

gcj [-Idir...] [-d dir...]
    [--CLASSPATH=path] [--classpath=path]
    [-foption...] [--encoding=name]
    [--main=classname] [-Dname[=value]...]
    [-C] [--resource resource-name] [-d directory]
    [-Wwarn...]
    sourcefile...

DESCRIPTION

As gcj is just another front end to gcc, it supports many of the same options as gcc. This manual only documents
the options specific to gcj.

OPTIONS

Input and output files

A gcj command is like a gcc command, in that it consists of a number of options and file names. The following
kinds of input file names are supported:

file.java: Java source files.
file.class: Java bytecode files.
file.zip
file.jar: An archive containing one or more ".class" files, all
of which are compiled. The archive may be compressed.
@file: A file containing a whitespace-separated list of input
file names. (Currently, these must all be ".java"
source files, but that may change.) Each named file
is compiled, just as if it had been on the command
line.
library.a
library.so
-llibname: Libraries to use when linking. See the gcc manual.
You can specify more than one input file on the gcj com mand line, in which case they will all be compiled. If
you specify a "-o FILENAME" option, all the input files
will be compiled together, producing a single output file,
named FILENAME. This is allowed even when using "-S" or "-c", but not when using "-C" or "--resource". (This is
an extension beyond the what plain gcc allows.) (If more than one input file is specified, all must currently be
".java" files, though we hope to fix this.)
Input Options
gcj has options to control where it looks to find files it needs. For instance, gcj might need to load a class that is referenced by the file it has been asked to compile.
Like other compilers for the Java language, gcj has a notion of a class path. There are several options and environment variables which can be used to manipulate the
class path. When gcj looks for a given class, it searches the class path looking for matching .class or .java file. gcj comes with a built-in class path which points at the installed libgcj.jar, a file which contains all the stan dard classes.
In the below, a directory or path component can refer
either to an actual directory on the filesystem, or to a
.zip or .jar file, which gcj will search as if it is a directory.
-Idir: All directories specified by "-I" are kept in order
and prepended to the class path constructed from all
the other options. Unless compatibility with tools
like "javac" is imported, we recommend always using
"-I" instead of the other options for manipulating the
class path.
--classpath=path: This sets the class path to path, a colon-separated
list of paths (on Windows-based systems, a semicolonseparate list of paths). This does not override the
builtin (``boot'') search path.
--CLASSPATH=path: Deprecated synonym for "--classpath".
--bootclasspath=path: Where to find the standard builtin classes, such as
"java.lang.String".
--extdirs=path: For each directory in the path, place the contents of
that directory at the end of the class path.
CLASSPATH: This is an environment variable which holds a list of
paths.
The final class path is constructed like so:
� First come all directories specified via "-I".
� If --classpath is specified, its value is appended.: Otherwise, if the "CLASSPATH" environment variable is
specified, then its value is appended. Otherwise, the
current directory (""."") is appended.
� If "--bootclasspath" was specified, append its value.: Otherwise, append the built-in system directory,
libgcj.jar.
� Finaly, if "--extdirs" was specified, append the con: tents of the specified directories at the end of the
class path. Otherwise, append the contents of the
built-in extdirs at "$(prefix)/share/java/ext".
The classfile built by gcj for the class
"java.lang.Object" (and placed in "libgcj.jar") contains a
special zero length attribute "gnu.gcj.gcj-compiled". The
compiler looks for this attribute when loading
"java.lang.Object" and will report an error if it isn't
found, unless it compiles to bytecode (the option
"-fforce-classes-archive-check" can be used to override
this behavior in this particular case.)
-fforce-classes-archive-check: This forces the compiler to always check for the spe
cial zero length attribute "gnu.gcj.gcj-compiled" in
"java.lang.Object" and issue an error if it isn't
found.
Encodings
The Java programming language uses Unicode throughout. In
an effort to integrate well with other locales, gcj allows .java files to be written using almost any encoding. gcj knows how to convert these encodings into its internal
encoding at compile time.
You can use the "--encoding=NAME" option to specify an
encoding (of a particular character set) to use for source
files. If this is not specified, the default encoding
comes from your current locale. If your host system has
insufficient locale support, then gcj assumes the default encoding to be the UTF-8 encoding of Unicode.
To implement "--encoding", gcj simply uses the host plat form's "iconv" conversion routine. This means that in
practice gcj is limited by the capabilities of the host platform.
The names allowed for the argument "--encoding" vary from
platform to platform (since they are not standardized any
where). However, gcj implements the encoding named UTF-8 internally, so if you choose to use this for your source
files you can be assured that it will work on every host.
Warnings
gcj implements several warnings. As with other generic gcc warnings, if an option of the form "-Wfoo" enables a warning, then "-Wno-foo" will disable it. Here we've cho
sen to document the form of the warning which will have an
effect -- the default being the opposite of what is
listed.
-Wredundant-modifiers: With this flag, gcj will warn about redundant modi fiers. For instance, it will warn if an interface
method is declared "public".
-Wextraneous-semicolon: This causes gcj to warn about empty statements. Empty statements have been deprecated.
-Wno-out-of-date: This option will cause gcj not to warn when a source file is newer than its matching class file. By
default gcj will warn about this.
-Wunused: This is the same as gcc's "-Wunused".
-Wall: This is the same as "-Wredundant-modifiers -Wextrane
ous-semicolon -Wunused".
Code Generation
In addition to the many gcc options controlling code gen eration, gcj has several options specific to itself.
--main=CLASSNAME: This option is used when linking to specify the name
of the class whose "main" method should be invoked
when the resulting executable is run. [1]
-Dname[=value]: This option can only be used with "--main". It
defines a system property named name with value value. If value is not specified then it defaults to the
empty string. These system properties are initialized
at the program's startup and can be retrieved at run
time using the "java.lang.System.getProperty" method.
-C This option is used to tell gcj to generate bytecode: (.class files) rather than object code.
--resource resource-name: This option is used to tell gcj to compile the con tents of a given file to object code so it may be
accessed at runtime with the core protocol handler as
core:/resource-name. Note that resource-name is the name of the resource as found at runtime; for
instance, it could be used in a call to "ResourceBun
dle.getBundle". The actual file name to be compiled
this way must be specified separately.
-d directory: When used with "-C", this causes all generated .class
files to be put in the appropriate subdirectory of
directory. By default they will be put in subdirecto ries of the current working directory.
-fno-bounds-check: By default, gcj generates code which checks the bounds of all array indexing operations. With this option,
these checks are omitted, which can improve perfor
mance for code that uses arrays extensively. Note
that this can result in unpredictable behavior if the
code in question actually does violate array bounds
constraints. It is safe to use this option if you are
sure that your code will never throw an "ArrayIndex
OutOfBoundsException".
-fno-store-check: Don't generate array store checks. When storing
objects into arrays, a runtime check is normally gen
erated in order to ensure that the object is assign
ment compatible with the component type of the array
(which may not be known at compile-time). With this
option, these checks are omitted. This can improve
performance for code which stores objects into arrays
frequently. It is safe to use this option if you are
sure your code will never throw an "ArrayStoreExcep
tion".
-fjni: With gcj there are two options for writing native methods: CNI and JNI. By default gcj assumes you are using CNI. If you are compiling a class with native
methods, and these methods are implemented using JNI,
then you must use "-fjni". This option causes gcj to generate stubs which will invoke the underlying JNI
methods.
-fno-optimize-static-class-initialization: When the optimization level is greather or equal to
"-O2", gcj will try to optimize the way calls into the runtime are made to initialize static classes upon
their first use (this optimization isn't carried out
if "-C" was specified.) When compiling to native code,
"-fno-optimize-static-class-initialization" will turn
this optimization off, regardless of the optimization
level in use.
Configure-time Options
Some gcj code generations options affect the resulting ABI, and so can only be meaningfully given when "libgcj",
the runtime package, is configured. "libgcj" puts the
appropriate options from this group into a spec file which is read by gcj. These options are listed here for com pleteness; if you are using "libgcj" then you won't want
to touch these options.
-fuse-boehm-gc: This enables the use of the Boehm GC bitmap marking
code. In particular this causes gcj to put an object marking descriptor into each vtable.
-fhash-synchronization: By default, synchronization data (the data used for
"synchronize", "wait", and "notify") is pointed to by
a word in each object. With this option gcj assumes that this information is stored in a hash table and
not in the object itself.
-fuse-divide-subroutine: On some systems, a library routine is called to per
form integer division. This is required to get excep
tion handling correct when dividing by zero.
-fcheck-references: On some systems it's necessary to insert inline checks
whenever accessing an object via a reference. On
other systems you won't need this because null pointer
accesses are caught automatically by the processor.

FOOTNOTES

1. The linker by default looks for a global function: named "main". Since Java does not have global func
tions, and a collection of Java classes may have more
than one class with a "main" method, you need to let
the linker know which of those "main" methods it
should invoke when starting the application.

COPYRIGHT

Permission is granted to copy, distribute and/or modify
this document under the terms of the GNU Free Documenta
tion License, Version 1.1 or any later version published
by the Free Software Foundation; with the Invariant
Sections being ``GNU General Public License'', the FrontCover texts being (a) (see below), and with the Back-Cover
Texts being (b) (see below). A copy of the license is
included in the man page gfdl(7).

docs.sk

comprehensive documentation repository

See also