`--log`
: Generate various log files.
- Currently unused.
+
+ The tool will generate some files in the logging directory (see `--log-dir`).
+ These files are intended to the advanced user and the developers of the tools.
`--log-dir`
: Directory where to generate log files.
- Currently unused.
+
+ By default the directory is called `logs` in the working directory.
`-h`, `-?`, `--help`
: Do not compile dead methods (semi-global).
Need `--rta`.
+## LINK-BOOST OPTIMIZATIONS
+
+In `--separate` and in `--erasure` modes, some optimization can be gained by hijacking the linker process.
+
+Warning: these optimisations are not portable since they use extra features of the GNU linker `ld`.
+However, there is very few reasons to not use them if GNU `ld` is available.
+
+`--link-boost`
+: Enable all link-boost optimizations.
+
+`--colors-are-symbols`
+: Store colors as symbols instead of static data.
+
+ By default, the various identifiers used to implement OO-mechanisms are stored as genuine constant static variables.
+
+ This option uses linker symbols to encode these identifiers.
+ This makes the compiled program faster since less indirections are required to get the values.
+ It also produces executables that are a little bit smaller since static memory does not have to store the colors.
+
+`--substitute-monomorph`
+: Replace monomorphic trampolines with direct call.
+
+ Late-binding is implemented with *trampolines*, that are small functions that just select and jump the to right implementations.
+ If, at link-time, is it known that the target will always by the same implementation then all calls to the trampoline are replaced by
+ direct calls to this single implementation.
+
+ Note that using trampolines as indirection slows down the executable.
+ However, it is expected that the gain of monomorphic direct-calls overcompensates the additional indirections in polymorphic trampoline-calls.
+
+ Note: automatically enable option `--trampoline-call`.
## DANGEROUS OPTIMIZATIONS
`--no-shortcut-equal`
: Always call == in a polymorphic way.
+`--no-tag-primitive`
+: Use only boxes for primitive types.
+
+The separate compiler uses tagged values to encode common primitive types like Int, Bool and Char.
+This option disables tags and forces such primitive values to be boxed.
+The drawback is that each boxing costs a memory allocation thus increases the amount of work for the garbage collector.
+
+However, in some cases, it is possible that this option improves performance since the absence of tags simplify the implementation
+of OO mechanisms like method calls or equality tests.
+
`--no-inline-intern`
: Do not inline call to intern methods.
`--no-gcc-directive`
: Disable advanced gcc directives for optimization.
+`--trampoline-call`
+: Use an indirection when calling.
+
+ Just add the trampolines of `--substitute-monomorph` without doing any aditionnal optimizations.
## INTERNAL OPTIONS
`--no-main`
: Do not generate main entry point.
-`--stacktrace`
-: Control the generation of stack traces.
+`--no-stacktrace`
+: The compiled program will not display stack traces on runtime errors.
+
+ Because stack traces rely on libunwind, this option might be useful in order to generate more portable binaries
+ since libunwind might be non available on the runtime system (or available with an ABI incompatible version).
+
+ The generated C is API-portable and can be reused, distributed and compiled on any supported system.
+ If the option `--no-stacktrace` is not used but the development files of the library `libunwind` are not available, then a warning will be displayed
+ and stack trace will be disabled.
+
+ Note that the `--no-stacktrace` option (or this absence) can be toggled manually in the generated Makefile (search `NO_STACKTRACE` in the Makefile).
+ Moreover, the environment variable `NIT_NO_STACK` (see bellow) can also be used at runtime to disable stack traces.
`--max-c-lines`
: Maximum number of lines in generated C files. Use 0 for unlimited.
`--stub-man`
: Generate a stub manpage in pandoc markdown format.
+`--keep-going`
+: Continue after errors, whatever the consequences.
+
+The tool does not stop after some errors but continue until it produces incorrect result, crashes, erases the hard drive, or just continue forever in an infinite loop.
+This option is used to test the robustness of the tools by allowing phases to progress on incorrect data.
# ENVIRONMENT VARIABLES
* large: disable the GC and just allocate a large memory area to use for all instantiation.
* help: show the list of available options.
+`NIT_NO_STACK`
+: Runtime control of stack traces.
+
+ By default, stack traces are printed when a runtime errors occurs during the execution of a compiled program.
+ When setting this environment variable to a non empty value, such stack traces are disabled.
+
+ The environment variable is used when programs are executed, not when they are compiled.
+ Thus, you do not need to recompile programs in order to disable generated stack traces.
+
+ Note that stack traces require that, during the compilation, development files of the library `libunwind` are available.
+ If they are not available, then programs are compiled without any stack trace support.
+
+ To completely disable stack traces, see the option `--no-stacktrace`.
+
# SEE ALSO
The Nit language documentation and the source code of its tools and libraries may be downloaded from <http://nitlanguage.org>
nitlanguage / nit.git / blobdiff