Compiler description

C requirement

Instead of producing assembly code, Bigloo produces C code. This C code is ISO-C compliant [IsoC]. So, it is necessary to have an ISO-C compiler. The current version has been developed with gcc [Stallman95].

JVM requirement

In order to compile the Bigloo JVM back-end, you have to be provided with a JDK 1.2 or more recent (available at http://www.javasoft.com). The JVM must support for -noverify option because, by default, Bigloo produces JVM code that is not conform to the rules enforced by the Java byte code verifiers.

Linking

It is easier to use Bigloo for linking object files which have been compiled by Bigloo. An easy way to perform this operation is, after having compiled all the files using the -c option, to invoke Bigloo with the name of the compiled files.

When Bigloo is only given object file name as argument, it searches in the current directory and the directory named in the *load-path* list the Scheme source file in order to perform a correct link. Scheme source files are supposed to be ended by the suffix .scm. Additional suffixes can be added using the -suffix option. Hence, if source files are named foo1.sc and foo2.sc, a link command line could look like:

bigloo -suffix sc foo1.o foo2.o -o foo

Note: In order to understand how the Bigloo linkers operates and which libraries it uses, it might be useful to use the -v2 option which unveil all the details of the compilation and the link.

The compiler environment and options

There are four ways to change the behaviour of Bigloo. Flags on the command line, the option module clause runtime-command file and environment variables Modules. When the compiler is invoked, it first gets the environment variables, then it scans the runtime-command file and, at end, it parses the command line. If the same option is set many times, Bigloo uses the last one.

Efficiency

In order to get maximum speed, compile with the -Obench option. This will enable all compiler optimization options and disable dynamic type checks. To improve arithmetic performance see next section.

Genericity of arithmetic procedures

By default, arithmetic procedures are generic. This means that it is allowed to use them with flonum and fixnum. This feature, of course, implies performances penalty. To improve performance, you may use specialized procedures (such as +fx, =fx, ... or +fl, =fl, ...) but, it is possible to suppress the genericity and to make all generic arithmetic procedures (= for example) fixnum ones. For this you must use the compiler option -farithmetic, or add the following module clause

(option
(set! *genericity* #f))

in your module declaration.

Safety

It is possible to generate safe or unsafe code. The safety's scope is type, arity, version and range. Let's see an example:

(define (foo f v indice)
   (car (f (vector-ref v indice))))

In safe mode, the result of the compilation will be:

(define (foo f v indice)
  (let ((pair 
        (if (and (procedure? f)
              ;; type check
              (= (procedure-arity f) 1))
              ;; arity check
           (if (vector? v)
              ;; type check
              (if (and (integer? k)
                    ;; type check
                    (>= k 0)
                    ;; range check
                    (< k (vector-length v)))
                    ;; range check
                (f (vector-ref v indice))
                (error ...))
              (error ...))
           (error ...))))
    (if (pair? pair)
       ;; type check
       (car pair)
       (error ...))))

It is possible to remove some or all safe checks. For example, here is the result of the compilation where safe check on types have been removed:

(define (foo f v indice)
  (let ((pair (if (= (procedure-arity f) 1)
             ;; arity check
             (if (and (>= k 0)
                   ;; range check
                   (< k (vector-length v)))
                   ;; range check
                (f (vector-ref v indice))
                (error ...))
             (error ...))))
     (car pair)))

The runtime-command file

Each Bigloo's user can use a special configuration file. This file must be named ``.bigloorc'' or ``~/.bigloorc''. Bigloo tries to load one of these in this order. This file is a Scheme file. Bigloo exports variables which allow the user to change the behavior of the compiler. All these variables can be checked using the -help2 option.

The Bigloo's runtime command file is read before the arguments are parsed.

The Bigloo command line

If no input file is specified, Bigloo enters its interpreter. Here is the exhaustive list of Bigloo options and configuration variables:

usage: bigloo [options] [name.suf]

Misc: - Read source code on current input channel -help,--help This help message -help2 The exhaustive help message -help-manual The help message formatted for the manual -o FILE Name the output FILE --to-stdout Write C code on current output channel -c Suppress linking and produce a .o file -y Generate a shared library -suffix SUFFIX Recognize suffix as Scheme source -afile FILE Name of the access file -access MODULE FILE Set access between module and file -jfile FILE Name of the Jvm package file -jadd MODULE QTYPE Set JVM qualifed type name for module -main FUN Set the main function -with MODULE Import addition module -multiple-inclusion Enables multiple inclusions of the Bigloo includes -library LIBRARY Compile/link with additional Bigloo library -srfi SRFI Declares srfi support -dload-sym Emit a Bigloo dynamic loading entry point -dload-init-sym NAME Emit a Bigloo dynamic loading entry point, named NAME -dload-init-gc For GC initialization for dynamic code -heapsize SIZE Set the initial heap size value (in megabyte)

Configuration and path: -version The current release -revision The current release (short format) -query Dump the current configuration -q Do not load any rc file -eval STRING Evaluate STRING before compiling -load FILE Load FILE before compiling -I DIR Add DIR to the load path -lib-dir DIR Set lib-path to DIR -L NAME Set additional library path -lib-version VERSION Set the Bigloo library version -libgc-version VERSION Set the Bigloo GC library version -libgc GC Use the given GC library

Back-end: -native Compile module to native object file (via C) -jvm Compile module to JVM .class files -saw Cut the AST in the saw-mill -no-saw Disable saw back-ends -i Interprete module

Dialect: -snow Compiles a snow source code -scmpkg,-spi Compiles a ScmPkg source code -nil Evaluate '() as #f in `if' expression -call/cc Enable call/cc function -hygien Obsolete (R5rs macros are always supported) -fidentifier-syntax SYNTAX Identifiers syntax "r5rs" (default) or "bigloo" -fno-reflection Deprecated +fno-reflection Deprecated -fclass-nil Deprecated -fno-class-nil Deprecated -farithmetic Suppress genericity of arithmetic operators -farithmetic-overflow Suppress arithmetic overflow checks -fno-arithmetic-overflow Enable arithmetic overflow checks -fno-arithmetic-overflow Enable arithmetic overflow checks -farithmetic-new-overflow Enable the new overflow arithmetic checks -fno-arithmetic-new-overflow Disable the new overflow arithmetic checks -fcase-sensitive Case sensitive reader (default) -fcase-insensitive Case insensitive reader (downcase symbols) -fallow-type-redefinition allow type redifinition

Optimization: -Obench Benchmarking mode -O[0..6] Optimization modes -ftagged-fxop Enable tagged fix-ops optimization -fno-tagged-fxop Disable tagged fix-ops optimization -ffloop Enable flonum specialization -fno-flop Disable flonum specialization -fcfa Enable CFA -fno-cfa Disable CFA -fcfa-arithmetic Enable arithmetic spec. (see -farithmetic-overflow) -fno-cfa-arithmetic Disable arithmetic spec. -fcfa-arithmetic-fixnum Enable fixnum arithmetic spec. -fno-cfa-arithmetic-fixnum Disable fixnum arithmetic spec. -fcfa-arithmetic-flonum Enable flonum arithmetic spec. (enabled from -O2) -fno-cfa-arithmetic-flonum Disable flonum arithmetic spec. -fcfa-tracking Enable CFA tracking (enabled from -O2) -fno-cfa-tracking Disable CFA tracking -fcfa-pair Enable CFA pairs approximations -fno-cfa-pair Disable CFA pairs approximations -fcfa-unbox-closure-args Enable CFA unboxed closure args (enabled from -O2) -fno-cfa-unbox-closure-args Disable CFA unboxed closure args -fno-cfa-local-function Disable CFA local function tracking -funroll-loop Enable loop unrolling (enabled from -O3) -fno-unroll-loop Disable loop unrolling -fno-loop-inlining Disable loop inlining -floop-inlining Enable loop inlining (default) -fno-inlining Disable inline optimization -fno-user-inlining Disable user inline optimization -fisa Inline isa? type predicate -fno-isa Inline isa? type predicate -fbeta-reduce Enable simple beta reduction (enabled from -O2) -fno-beta-reduce Disable simple beta reduction -fdataflow Enable dataflow optimizations (enabled from -O) -fno-dataflow Disable dataflow optimizations -fdataflow-for-errors Enable dataflow optimizations for improviing type error messages -fno-dataflow-for-errors Disable dataflow optimizations for improviing type error messages -fdataflow-types Enable type dataflow optimizations (enabled from -O2) -fno-dataflow-types Disable type dataflow optimizations -finitflow Enable init flow -fno-initflow Disable init flow -fsync-failsafe Enable failsafe synchronize optimization -fno-sync-failsafe Disable failsafe synchronize optimization -fO-macro Enable Optimization macro (default) -fno-O-macro Disable Optimization macro -ftailc Enable tail-call optimization -fno-tailc Disable tail-call optimization -fglobal-tailc Enable global tail-call optimization -fno-global-tailc Disable global tail-call optimization -freturn Enable set-exit replacement with return -fno-return Disable set-exit replacement -freturn-goto Enable local set-exit replacement with return -fno-return-goto Disable local set-exit replacement -fstackable Enable stackable optimization -fno-stackable Disable stackable optimization -funcell Enable cell removal -fno-uncell Disable cell removal -flocal-exit Inline with-handler and bind-exit -fno-local-exit Compile with-handler and bind-exit in separate functions -fsaw-realloc Enable saw register re-allocation -fsaw-regalloc Enable saw register allocation -fno-saw-regalloc Disable saw register allocation -fsaw-bbv Enable saw basic-blocks versionning -fno-saw-bbv Disable saw basic-blocks versionning -fsaw-bbv-fun NAME Apply bbv on this very function -fsaw-regalloc-msize SIZE Set the register allocation body size limit -fsaw-regalloc-fun NAME Allocate registers on this very function -fno-saw-regalloc-fun NAME Don't allocate registers on this very function -fsaw-regalloc-onexpr Allocate registers on expressions -fno-saw-regalloc-onexpr Don't allocate registers on expressions -fsaw-spill Enable saw spill optimization

Safety: -unsafe[atrsvleh] Don't check [type/arity/range/struct/version/library/eval/heap] -safe[atrsvle] Enforce check [type/arity/range/struct/version/library/eval]

Debug: -glines Emit # line directives -gbdb-no-line Don't emit # line directives -gbdb[23] Compile with bdb debug informations -gself Enables self compiler debug options -gmodule Debug module initialization -gerror-localization Localize error calls in the source code -gno-error-localization Don't localize error calls in the source code -gjvm Annote JVM classes for debug -gtrace[12all] Instrument for stack tracing -g[234] Produce Bigloo debug informations -cg Compile C files with debug option -export-all Eval export-all all routines -export-exports Eval export-exports all routines -export-mutable Enables Eval redefinition of all "::obj" routines

Profiling: -p[2g] Compile for cpu profiling -pmem[level] Compile for memory profiling -psync Profile synchronize expr (see $exitd-mutex-profile)

Verbosity: -s Be silent and inhibit all warning messages -v[234] Be verbose -hello Say hello -no-hello Dont' say hello even in verbose mode -w Inhibit all warning messages -wslots Inhibit overriden slots warning messages -Wvariables Enable overriden variable warning messages -Wtypes Enable type check warning messages -Wslot Enable default slot value warning messages -Wno-slot Disable default slot value warning messages -Wall Warn about all possible type errors -Werror=type Treat type warnings as error

Compilation modes: <-/+>rm Don't or force removing .c or .il files -extend NAME Extend the compiler -extend-module EXP Extend the module syntax -fsharing Attempt to share constant data -fno-sharing Do not attempt to share constant data -fmco Produce an .mco file -fmco-include-path DIR Add dir to mco C include path

Native specific options: -cc COMPILER Specify the C compiler -stdc Generate strict ISO C code -copt STRING Invoke cc with STRING -cheader STRING C header -cfoot STRING C foot -rpath PATH Add C runtime-path (rpath) -ldopt STRING Invoke ld with STRING -ldpostopt STRING Invoke ld with STRING (end of arguments) --force-cc-o Force the C compiler to use -o instead of mv -ld-relative Link using -l notation for libraries (default) -ld-absolute Link using absolute path names for libraries -static-bigloo Link with the static bigloo library -static-all-bigloo Link with static version of all bigloo libraries -ld-libs1 Add once user libraries when linking -ld-libs2 Add twice user libraries when linking (default) -lLIBRARY Link with host library -auto-link-main Enable main generation when needed for linking -no-auto-link-main Disable main generation --force-gc-roots Register global variables as GC roots

Jvm specific options: -jvm-shell SHELL Shell for JVM scripts ("sh", "msdos") -jvm-purify Produce byte code verifier compliant JVM code (default) -no-jvm-purify Don't care about JVM code verifier -jvm-mainclass CLASS JVM main class -jvm-classpath PATH JVM application classpath -jvm-bigloo-classpath P JVM Bigloo rts classpath -jvm-path-separator SEP Set the JVM classpath separator -jvm-directory NAME Directory where to store class files. -jvm-catch-errors Catch internal JVM errors -no-jvm-catch-errors Don't catch internal JVM errors -jvm-jarpath NAME Set the JVM classpath for the produced jar file -jvm-cinit-module Enable JVM class constructors to initiliaze bigloo modules -no-jvm-cinit-module Disable JVM class constructors to initiliaze bigloo modules -jvm-char-info Generate char info for the debugger (in addition to line info) -no-jvm-char-info Do not generate char info for the debugger -fjvm-inlining Enable JVM back-end inlining -fjvm-constr-inlining Enable JVM back-end inlining for constructors -fno-jvm-inlining Disable JVM back-end inlining -fno-jvm-constr-inlining Disable JVM back-end inlining for constructors -fjvm-peephole Enable JVM back-end peephole -fno-jvm-peephole Disable JVM back-end peephole -fjvm-branch Enable JVM back-end branch -fno-jvm-branch Disable JVM back-end branch -fjvm-fasteq EQ? no longer works on integers (use =FX) -fno-jvm-fasteq Disable JVM back-end fasteq transformation -jvm-env VAR Make the shell variable visible to GETENV -jvm-jar Enable JVM jar files generation -no-jvm-jar Disable JVM jar files generation (default) -jvm-java FILE Use FILE as JVM -jvm-opt STRING JVM invocation option

Traces: -t[1|2|3|4] Generate a trace file (*) +tPASS Force pass to be traced -shape[mktTalunx] Some debugging tools (private)

Compilation stages: -mco Stop after .mco production -syntax Stop after the syntax stage (see -hygiene) -expand Stop after the preprocessing stage -expand-module Produce the expanded module clause -ast Stop after the ast construction stage -syntax-check Stop after checking syntax -bdb-spread-obj Stop after the bdb obj spread stage -trace Stop after the trace pass -callcc Stop after the callcc pass -bivalue Stop after the bivaluation stage -inline Stop after the inlining stage -inline+ Stop after the 2nd inlining stage -beta Stop after the constant beta reduction stage -fail Stop after the failure replacement stage -abound Stop after the array bound checking stage -initflow Stop after the type initflow stage -narrow Stop after the scope narrowing stage -tlift Stop after the type lifting stage -reduce0 Stop after the early reduction stage -dataflow Stop after the type dataflow stage -dataflow+ Stop after the second type dataflow stage -dataflow++ Stop after the third type dataflow stage -fuse Stop after the fuse stage -user Stop after the user pass -fxop Stop after the fx-ops optimization -flop Stop after the flonum specialization optimization -coerce Stop after the type coercing stage -effect Stop after the effect stage -effect+ Stop after the 2nd effect stage -reduce Stop after the reduction opt. stage -reduce+ Stop after the 2nd reduction opt. stage -reduce- Stop after the very first reduction stage -assert Stop after the assertions stage -cfa Stop after the cfa stage -stackable Stop after the stackable stage -closure Stop after the globalization stage -recovery Stop after the type recovery stage -bdb Stop after the Bdb code production -cnst Stop after the constant allocation -integrate Stop after the integration stage -tailc Stop after the tailc stage -return Stop after the return stage -uncell Stop after the cell removal stage -isa Stop after the isa stage -init Stop after the initialization construction stage -classgen Produce an include file for class accessors -egen Produce an include file for effects (requires -saw) -hgen Produce a C header file with class definitions -cgen Do not C compile and produce a .c file -indent Produce an indented .c file -jvmas Produce a JVM .jas file

Constant initialization: -init-[lib|read|intern] Constants initialization mode -init-object-[legacy|staged] Object system initialization

Bootstrap and setup: -mklib Compile a library module -mkaddlib Compile an additional library module -mkheap Build an heap file -mkaddheap Build an additional heap file -mkdistrib Compile a main file for a distribution --license Display the Bigloo license and exit -LICENSE Add the license to the generated C files -heap NAME Specify an heap file (or #f to not load heap) -heap-library LIB The library the heap belongs to -dump-heap NAME Dump the content of a heap -addheap NAME Specify an additional heap file -fread-internal Read source from binary interned file -fread-internal-src Read source only from binary interned file -fread-internal-src-file-name NAME Set fake source file name -fread-plain Read source from plain text file -target LANG DON'T USE, (see -native, -jvm) -- end bigloo arg parsing

Shell Variables: - TMPDIR temporary directory (default "/tmp") - BIGLOOLIB libraries' directory - BIGLOOHEAP the initial heap size in megabytes (4 MB by default) - BIGLOOMAXHEAP the maxium heap size in megabytes (unlimited by default) - BIGLOOSTACKDEPTH the error stack depth printing - BIGLOOLIVEPROCESS the maximum number of Bigloo live processes - BIGLOOTRACE list of active traces - BIGLOOGCTHREADS Max GC threads number

Runtime Command file: - ~/.bigloorc

------------ * : only available in developing mode . : option enabled from -O3 mode

Bigloo Control Variables: All the Bigloo control variables can be changed from the interpreter, by the means of the `-eval' option, or using the module clause `option'. For instance the option "-eval '(set! *strip* #t)'" will set the variable `*strip*' to the value `#t'. These variables are:

- *access-file-default* : The default access file name default: ".afile" - *access-files* : The access file names default: () - *additional-bigloo-libraries* : The user extra Bigloo libraries default: () - *additional-bigloo-zips* : The user extra Bigloo Zip files default: () - *additional-heap-name* : A name of an additional heap file name to be build default: #f - *additional-heap-names* : A list of Bigloo additional heap file name default: () - *additional-include-foreign* : The additional C included files default: () - *allow-type-redefinition* : If true, allow type redefinitions default: #f - *ast-case-sensitive* : Case sensitivity default: #t - *auto-link-main* : Enable automatically a main generation when linking default: #t - *auto-mode* : auto-mode (extend mode) list default: (("ml" . "caml") ("mli" . "caml") ("oon" . "meroon") ("snow" . "snow") ("spi" . "pkgcomp")) - *bdb-debug* : Bdb debugging mode default: 0 - *bigloo-abort?* : Do we have the bigloo-abort function in executables? default: #f - *bigloo-lib* : The Bigloo library default: bigloo - *bigloo-libraries-c-setup* : A list of C functions to be called when starting the application default: () - *bigloo-licensing?* : Add the Bigloo license ? default: #f - *bigloo-name* : The Bigloo name default: "Bigloo (4.5b)" - *bigloo-specific-version* : The Bigloo specific version default: "" - *bigloo-tmp* : The tmp directory name default: "/tmp" - *bigloo-user-lib* : The user extra C libraries default: ("-ldl" "-lresolv" "-lunistring" "-lpcre2-8" "-lgmp" "-lm" "-lc") - *bigloo-version* : The Bigloo major release number default: "4.5b" - *bmem-profiling* : Instrument code for bmem profiling default: #f - *c-debug* : C debugging mode? default: #f - *c-debug-lines-info* : Emit # line directives default: #f - *c-debug-option* : cc debugging option default: "-g" - *c-files* : The C source files default: () - *c-object-file-extension* : The C object file extension default: "o" - *c-split-string* : C split long strings default: #f - *c-suffix* : C legal suffixes default: ("c") - *c-tail-call* : C tail call? default: #unspecified - *c-user-foot* : C foot default: () - *c-user-header* : C header default: () - *call/cc?* : Shall we enable call/cc? default: #f - *cc* : The C compiler default: "gcc" - *cc-move* : Use mv instead of -o when C compiling default: #t - *cc-o-option* : The C compiler -o option default: "-o " - *cc-options* : cc options default: ("") - *cc-style* : The C compiler style default: "gcc" - *cflags* : The C compiler option default: " -Wpointer-arith -Wswitch -Wtrigraphs -Wno-alloca-larger-than -DBGL_BOOTCONFIG -Wno-unused-value -Wno-parentheses-equality -Wno-parentheses -Wno-invalid-source-encoding -Wno-return-type -Wno-trigraphs" - *cflags-optim* : The C compiler optimization option default: "-O3" - *cflags-prof* : The C compiler profiling option default: "-pg -fno-inline -Wpointer-arith -Wswitch -Wtrigraphs -Wno-alloca-larger-than -DBGL_BOOTCONFIG -Wno-unused-value -Wno-parentheses-equality -Wno-parentheses -Wno-invalid-source-encoding -Wno-return-type -Wno-trigraphs" - *cflags-rpath* : The C compiler rpath option default: ("/home/serrano/prgm/project/bigloo/4.5b/lib/bigloo/4.5b") - *compiler-debug* : Debugging level default: 0 - *compiler-debug-trace* : Debugging trace level default: 0 - *compiler-sharing-debug?* : Compiler self sharing debug default: #f - *compiler-stack-debug?* : Compiler self stack trace debug default: #f - *compiler-type-debug?* : Compiler self type debug default: #f - *csharp-suffix* : C# legal suffixes default: ("cs") - *debug-module* : Module initilazation debugging default: 0 - *default-lib-dir* : Depreacted, don't use default: "/home/serrano/prgm/project/bigloo/4.5b/lib/bigloo/4.5b" - *dest* : The target name default: #f - *dlopen-init* : Emit a standard Bigloo dynamic loading init entry point default: #f - *dlopen-init-gc* : Emit a standard GC init call when initialization the module default: #f - *double-ld-libs?* : Do we include the additional user libraries twice? default: #t - *error-localization* : Localize error calls in the source code default: #f - *eval-options* : A user variable to store dynamic command line options default: () - *extend-entry* : Extend entry default: #f - *garbage-collector* : The garbage collector default: boehm - *gc-custom?* : Are we using a custom GC library? default: #t - *gc-force-register-roots?* : Force GC roots registration for global variables (for experts only) default: #t - *gc-lib* : The Gc library default: bigloogc - *global-tail-call?* : Do we apply the self-global-tail-call stage? default: #f - *heap-base-name* : The Bigloo heap base name default: "bigloo" - *heap-dump-names* : The name of the heap to be dumped default: () - *heap-jvm-name* : The Bigloo heap file name for the JVM backend default: "bigloo.jheap" - *heap-library* : The library the heap belongs to default: bigloo - *heap-name* : The Bigloo heap file name default: "bigloo.heap" - *hello* : Say hello (when verbose) default: #f - *include-foreign* : The C included files default: ("bigloo.h") - *include-multiple* : Enable/disable multiple inclusion of same file default: #f - *indent* : The name of the C beautifier default: "indent -npro -bap -bad -nbc -bl -ncdb -nce -nfc1 -ip0 -nlp -npcs -nsc -nsob -cli0.5 -di0 -l80 -d1 -c0 -ts2 -st" - *init-mode* : Module initialization mode default: read - *inlining-kfactor* : Inlining growth factor default: #<procedure:55e9437fa0e0.1> - *inlining-reduce-kfactor* : Inlinine growth factor reductor default: #<procedure:55e9437fa020.1> - *inlining?* : Inlining optimization default: #t - *interpreter* : Shall we interprete the source file? default: #f - *jvm-bigloo-classpath* : JVM Bigloo classpath default: #f - *jvm-catch* : Catch internal errors default: #t - *jvm-cinit-module* : Enable JVM class constructors to initiliaze bigloo modules default: #f - *jvm-classpath* : JVM classpath default: "." - *jvm-debug* : JVM debugging mode? default: #f - *jvm-directory* : JVM object directory default: #f - *jvm-env* : List of environment variables to be available in the compiled code default: () - *jvm-foreign-class-id* : The identifier of the Jlib foreign class default: foreign - *jvm-foreign-class-name* : The name of the Jlib foreign class default: "bigloo.foreign" - *jvm-jar?* : Enable/disable a JAR file production for the JVM back-end default: #f - *jvm-jarpath* : JVM jarpath default: #f - *jvm-java* : JVM to be used to run Java programs default: "java" - *jvm-mainclass* : JVM main class default: #f - *jvm-options* : JVM options default: "" - *jvm-path-separator* : JVM classpath default: #f - *jvm-shell* : Shell to be used when producing JVM run scripts default: "sh" - *ld-debug-option* : The C linker debugging option default: "-g " - *ld-library-dir* : Depreacted, don't use default: "/home/serrano/prgm/project/bigloo/4.5b/lib/bigloo/4.5b" - *ld-o-option* : The C linker -o option default: "-o " - *ld-optim-flags* : The C linker optimization flags default: "" - *ld-options* : ld options default: "-L/home/serrano/prgm/project/bigloo/4.5b/libbacktrace/home/serrano/prgm/project/bigloo/4.5b/lib/bigloo/4.5b " - *ld-post-options* : ld post options default: ("") - *ld-relative* : Relative or absolute path names for libraries default: #t - *ld-style* : ld style default: "gcc" - *lib-dir* : The lib dir path default: ("." "/home/serrano/prgm/project/bigloo/4.5b/lib/bigloo/4.5b") - *lib-mode* : Lib-mode compilation? default: #f - *lib-src-dir* : The lib dir path default: "runtime" - *load-path* : The load path default: ("." "/home/serrano/prgm/project/bigloo/4.5b/lib/bigloo/4.5b") - *local-exit?* : If false, set-ex-it nodes force the creation of a globalized function default: #f - *max-c-foreign-arity* : Max C function arity default: 16 - *max-c-token-length* : Max C token length default: 1024 - *mco-include-path* : Module checksum C include path default: (".") - *mco-suffix* : Module checksum object legal suffixes default: ("mco") - *module-checksum-object?* : Produce a module checksum object (.mco) default: #f - *multi-threaded-gc?* : Are we using a multi-threaded GC? default: #f - *o-files* : The additional obect files default: () - *obj-suffix* : Object legal suffixes default: ("o" "a" "so") - *object-init-mode* : Object initialization mode default: stagged - *optim* : Optimization level default: 0 - *optim-O-macro?* : Enable optimization by macro-expansion default: #f - *optim-atom-inlining?* : Skip atom in inlining parameter counting default: #t - *optim-cfa-apply-tracking?* : Track values across apply default: #f - *optim-cfa-fixnum-arithmetic?* : Enable refined fixnum arithmetic specialization default: #f - *optim-cfa-flonum-arithmetic?* : Enable refined flonum arithmetic specialization default: #f - *optim-cfa-force-loose-local-function?* : Force loosing local function approximations (for debugging) default: #f - *optim-cfa-free-var-tracking?* : Enable closure free-variables specialization default: #f - *optim-cfa-pair-quote-max-length* : Maximum length for pair literal tracking default: 4 - *optim-cfa-pair?* : Track values across pairs default: #f - *optim-cfa-unbox-closure-args* : Unbox closure arguments default: #f - *optim-cfa?* : Enable CFA default: #t - *optim-dataflow-for-errors?* : Enable simple dataflow optimization for eliminating bad error messages default: #t - *optim-dataflow-types?* : Enable dataflow optimization for types default: #f - *optim-dataflow?* : Enable simple dataflow optimization default: #f - *optim-initflow?* : Enable initflow optimization for global variables default: #f - *optim-integrate?* : Enable function integration (closure analysis) default: #t - *optim-isa?* : Enable isa type tests optimization (inlining) default: #f - *optim-jvm* : Enable optimization by inlining jvm code default: 0 - *optim-jvm-branch* : Enable JVM branch tensioning default: 0 - *optim-jvm-constructor-inlining* : Enable JVM inlining for constructors default: 0 - *optim-jvm-fasteq* : EQ? no longer works on integers (use =FX instead) default: #f - *optim-jvm-inlining* : Enable JVM inlining default: 0 - *optim-jvm-peephole* : Enable JVM peephole optimization default: 0 - *optim-loop-inlining?* : Loop inlining optimization default: #t - *optim-reduce-beta?* : Enable simple beta reduction default: #f - *optim-return-goto?* : Optimize set-exit by enabling local return default: #f - *optim-return?* : Optimize set-exit used as return default: #f - *optim-specialize-flonum?* : Optimize specialize flonum operations default: #f - *optim-stackable?* : Optimize stackable allocation default: #f - *optim-symbol-case* : Optimize case forms descrimining on symbols only default: #f - *optim-sync-failsafe?* : Enable failsafe synchronize optimization default: #f - *optim-tagged-fxop?* : Optimize tagged fixnum operations default: #f - *optim-uncell?* : Remove useless cells default: #f - *optim-unroll-loop?* : Loop unrolling optimization default: #unspecified - *pass* : Stop after the pass default: ld - *pre-processor* : An optional function that pre-processes the source file default: #<procedure:55e9437f89c0.1> - *prof-table-name* : Bprof translation table file name default: "bmon.out" - *profile-library* : Use the profiled library version default: #f - *profile-mode* : Bigloo profile mode default: 0 - *purify* : Produce byte code verifier compliant JVM code default: #t - *qualified-type-file* : The qualifed-type association file name default: #f - *qualified-type-file-default* : The qualifed-type association file name default: ".jfile" - *reader* : The way the reader reads input file ('plain or 'intern) default: plain - *rm-tmp-files* : Shall the .c and .il produced files be removed? default: #t - *saw* : Do we go to the saw-mill? default: #f - *saw-bbv-functions* : Optional white list of bbv functions default: () - *saw-bbv?* : Enable/disable saw basic-blocks versionning default: #f - *saw-no-register-allocation-functions* : The list of functions disabling register allocation default: () - *saw-register-allocation-functions* : The list of functions allowing register allocation default: () - *saw-register-allocation-max-size* : Max function size for optimizing the register allocation default: 4000 - *saw-register-allocation-onexpression?* : Enable/disable saw register allocation on expression default: #f - *saw-register-allocation?* : Enable/disable saw register allocation default: #f - *saw-register-reallocation?* : Enable/disable saw register re-allocation default: #f - *saw-spill* : Enable saw spill optimization default: #f - *shared-cnst?* : Shared constant compilation? default: #t - *shell* : The shell to exec C compilations default: "/bin/sh" - *src-files* : The sources files default: () - *src-suffix* : Scheme legal suffixes default: ("scm" "bgl") - *startup-file* : A startup file for the interpreter default: #f - *static-all-bigloo?* : Do we use the static version of all Bigloo libraries? default: #f - *static-bigloo?* : Do we use the static Bigloo library default: #f - *stdc* : Shall we produce ISO C? default: #f - *strip* : Shall we strip the executable? default: #t - *sync-profiling* : Instrument code for synchronize profiling default: #f - *target-language* : The target language (either c, c-saw, jvm, or .net) default: native - *trace-level* : Trace level default: 0 - *trace-name* : Trace file name default: "trace" - *trace-write-length* : Trace dumping max level default: 80 - *unsafe-arity* : Runtime type arity safety default: #f - *unsafe-eval* : Disable type checking for eval functions default: #f - *unsafe-heap* : Disable heap version checking default: #f - *unsafe-library* : Use the unsafe library version default: #f - *unsafe-range* : Runtime range safety default: #f - *unsafe-struct* : Runtime struct range safety default: #f - *unsafe-type* : Runtime type safety default: #f - *unsafe-version* : Module version safety default: #f - *user-heap-size* : Heap size (in MegaByte) or #f for default value default: 0 - *user-inlining?* : User inlining optimization default: #t - *user-pass* : The user specific compilation pass default: #unspecified - *verbose* : The verbosity level default: 0 - *warning-default-slot-value* : Set to #t to warn about non-inlinable default slot values default: #f - *warning-overriden-slots* : Set to #t to warn about virtual slot overriding default: #t - *warning-overriden-variables* : Set to #t to warn about variable overriding default: #f - *warning-type-error* : Set to #t to treat type warnigns as error default: #f - *warning-types* : Set to #t to warn about type checks default: #f - *with-files* : The additional modules default: ()

Bigloo / Compiler description