Copyright © tutorialspoint.com
|file.java||Java source files.|
|file.class||Java bytecode files.|
|file.jar||An archive containing one or more .class files, all of which are compiled. The archive may be compressed. Files in an archive which dont end with .class are treated as resource files; they are compiled into the resulting object file as core: URLs.|
|@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.|
|-llibname||Libraries to use when linking. See the gcc manual.|
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 important, 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 semicolon-separate 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.|
|o||First come all directories specified via -I.|
|o||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.|
|o||If --bootclasspath was specified, append its value. Otherwise, append the built-in system directory, libgcj.jar.|
|o||Finally, if --extdirs was specified, append the contents 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.|
|-fforce-classes-archive-check||This forces the compiler to always check for the special zero length attribute gnu.gcj.gcj-compiled in java.lang.Object and issue an error if it isnt found.|
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 platforms 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 anywhere). 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.
|-Wredundant-modifiers||With this flag, gcj will warn about redundant modifiers. 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.|
|-Wno-deprecated||Warn if a deprecated class, method, or field is referred to.|
|-Wunused||This is the same as gccs -Wunused.|
|-Wall||This is the same as -Wredundant-modifiers -Wextraneous-semicolon -Wunused.|
|o||Specify the class containing the desired main method when you link the application, using the --main flag, described below.|
|o||Link the Java package(s) into a shared library (dll) rather than an executable. Then invoke the application using the gij program, making sure that gij can find the libraries it needs.|
|o||Link the Java packages(s) with the flag -lgij, which links in the main routine from the gij command. This allows you to select the class whose main method you want to run when you run the application. You can also use other gij flags, such as -D flags to set properties. Using the -lgij library (rather than the gij program of the previous mechanism) has some advantages: it is compatible with static linking, and does not require configuring or installing libraries.|
|--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.|
|-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 programs startup and can be retrieved at runtime using the java.lang.System.getProperty method.|
Create an application whose command-line processing is that
of the gij command.
This option is an alternative to using --main; you cannot use both.
This option causes linking to be done against a static version of the
libgcj runtime library. This option is only available if
corresponding linker support exists.
Caution: Static linking of libgcj may cause essential parts of libgcj to be omitted. Some parts of libgcj use reflection to load classes at runtime. Since the linker does not see these references at link time, it can omit the referred to classes. The result is usually (but not always) a ClassNotFoundException being thrown at runtime. Caution must be used when using this option. For more details see: <http://gcc.gnu.org/wiki/Statically%20linking%20libgcj>
|-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 contents 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 ResourceBundle.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 subdirectories 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 performance 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 ArrayIndexOutOfBoundsException.|
|-fno-store-check||Dont generate array store checks. When storing objects into arrays, a runtime check is normally generated in order to ensure that the object is assignment 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 ArrayStoreException.|
|-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-assert||Dont recognize the assert keyword. This is for compatibility with older versions of the language specification.|
|-fno-optimize-static-class-initialization||When the optimization level is greater 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 isnt 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.|
Dont include code for checking assertions in the compiled code.
If =class-or-package is missing disables assertion code
generation for all classes, unless overridden by a more
specific --enable-assertions flag.
If class-or-package is a class name, only disables generating
assertion checks within the named class or its inner classes.
If class-or-package is a package name, disables generating
assertion checks within the named package or a subpackage.
By default, assertions are enabled when generating class files or when not optimizing, and disabled when generating optimized binaries.
|--enable-assertions[=class-or-package]||Generates code to check assertions. The option is perhaps misnamed, as you still need to turn on assertion checking at run-time, and we dont support any easy way to do that. So this flag isnt very useful yet, except to partially override --disable-assertions.|
gcj has a special binary compatibility ABI, which is enabled
by the -findirect-dispatch option. In this mode, the code
generated by gcj honors the binary compatibility guarantees
in the Java Language Specification, and the resulting object files do
not need to be directly linked against their dependencies. Instead,
all dependencies are looked up at runtime. This allows free mixing of
interpreted and compiled code.
Note that, at present, -findirect-dispatch can only be used when compiling .class files. It will not work when compiling from source. CNI also does not yet work with the binary compatibility ABI. These restrictions will be lifted in some future release.
However, if you compile CNI code with the standard ABI, you can call it from code built with the binary compatibility ABI.
|-fbootstrap-classes||This option can be use to tell libgcj that the compiled classes should be loaded by the bootstrap loader, not the system class loader. By default, if you compile a class and link it into an executable, it will be treated as if it was loaded using the system class loader. This is convenient, as it means that things like Class.forName() will search CLASSPATH to find the desired class.|
This option causes the code generated by gcj to contain a
reduced amount of the class meta-data used to support runtime
reflection. The cost of this savings is the loss of
the ability to use certain reflection capabilities of the standard
Java runtime environment. When set all meta-data except for that
which is needed to obtain correct runtime semantics is eliminated.
For code that does not use reflection (i.e. the methods in the java.lang.reflect package), -freduced-reflection will result in proper operation with a savings in executable code size.
JNI (-fjni) and the binary compatibility ABI (-findirect-dispatch) do not work properly without full reflection meta-data. Because of this, it is an error to use these options with -freduced-reflection.
Caution: If there is no reflection meta-data, code that uses a SecurityManager may not work properly. Also calling Class.forName() may fail if the calling method has no reflection meta-data.
|-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 perform integer division. This is required to get exception handling correct when dividing by zero.|
|-fcheck-references||On some systems its necessary to insert inline checks whenever accessing an object via a reference. On other systems you wont need this because null pointer accesses are caught automatically by the processor.|
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with the Invariant Sections being GNU General Public License, the Front-Cover 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).
(a) The FSFs Front-Cover Text is:
A GNU Manual
(b) The FSFs Back-Cover Text is:
You have freedom to copy and modify this GNU Manual, like GNU
software. Copies published by the Free Software Foundation raise
funds for GNU development.
Copyright © tutorialspoint.com