mono

asmonly

Instructs the AOT compiler to output assembly code instead of an object file.

bind-to-runtime-version

If specified, forces the generated AOT files to be bound to the runtime version of the compiling Mono. This will prevent the AOT files from being consumed by a different Mono runtime.

data-outfile=FILE.dll.aotdata

This instructs the AOT code generator to output certain data constructs into a separate file. This can reduce the executable images some five to twenty percent. Developers need to then ship the resulting aotdata as a resource and register a hook to load the data on demand by using the mono_install_load_aot_data_hook method.

direct-icalls

When this option is specified, icalls (internal calls made from the standard library into the mono runtime code) are invoked directly instead of going through the operating system symbol lookup operation. This requires use of the static option.

direct-pinvoke

When this option is specified, P/Invoke methods are invoked directly instead of going through the operating system symbol lookup operation. This requires use of the static option.

dwarfdebug

Instructs the AOT compiler to emit DWARF debugging information. When used together with the nodebug option, only DWARF debugging information is emitted, but not the information that can be used at runtime.

full

This creates binaries which can be used with the --full-aot option.

hybrid

This creates binaries which can be used with the --hybrid-aot option.

llvm

AOT will be performed with the LLVM backend instead of the Mono backend where possible. This will be slower to compile but most likely result in a performance improvement.

llvmonly

AOT will be performed with the LLVM backend exclusively and the Mono backend will not be used. The only output in this mode will be the bitcode file normally specified with the llvm-outfile option. Use of llvmonly automatically enables the full and llvm options. This feature is experimental.

llvmopts=[options]

Use this option to add more flags to the built-in set of flags passed to the LLVM optimizer. When you invoke the mono command with the --aot=llvm it displays the current list of flags that are being passed to the opt command. The list of possible flags that can be passed can be obtained by calling the bundled opt program that comes with Mono, and calling it like this:

	opt --help

    

llvmllc=[options]

Use this option to add more flags to the built-in set of flags passed to the LLVM static compiler (llc). The list of possible flags that can be passed can be obtained by calling the bundled llc program that comes with Mono, and calling it like this:

	llc --help

    

mcpu=[native o generic]

cpu=native allows AOT mode to use all instructions current CPU supports, e.g. AVX2, SSE42, etc. Default value is 'generic'. mattr=[cpu feature] Allows AOT code generator to use specified CPU features where possible including `System.Runtime.Intrinsics.*'. E.g. `mattr=+avx2,mattr=-lzcnt' unlocks sse1-4.2, avx1-2 and disables lzcnt. It's useful for cross-compilation or when it's not possible to use `-mcpu=native' (which enables all cpu feature current cpu has). llvm-outfile=[filename] Gives the path for the temporary LLVM bitcode file created during AOT. dedup Each AOT module will typically contain the code for inflated methods and wrappers that are called by code in that module. In dedup mode, we identify and skip compiling all of those methods. When using this mode with fullaot, dedup-include is required or these methods will remain missing.

dedup-include=[filename]

In dedup-include mode, we are in the pass of compilation where we compile the methods that we had previously skipped. All of them are emitted into the assembly that is passed as this option. We consolidate the many duplicate skipped copies of the same method into one.

info

Print the architecture the AOT in this copy of Mono targets and quit.

interp

Generates all required wrappers, so that it is possible to run --interpreter without any code generation at runtime. This option only makes sense with mscorlib.dll. Embedders can set

depfile=[filename]

Outputs a gcc -M style dependency file.

mono_jit_set_aot_mode (MONO_AOT_MODE_INTERP);
    

ld-flags

Additional flags to pass to the C linker (if the current AOT mode calls for invoking it).

llvm-path=<PREFIX>

Same for the llvm tools 'opt' and 'llc'.

msym-dir=<PATH>

Instructs the AOT compiler to generate offline sequence points .msym files. The generated .msym files will be stored into a subfolder of <PATH> named as the compilation AOTID.

mtriple=<TRIPLE>

Use the GNU style target triple <TRIPLE> to determine some code generation options, i.e. --mtriple=armv7-linux-gnueabi will generate code that targets ARMv7. This is currently only supported by the ARM backend. In LLVM mode, this triple is passed on to the LLVM llc compiler.

nimt-trampolines=[number]

When compiling in full aot mode, the IMT trampolines must be precreated in the AOT image. You can add additional method trampolines with this argument. Defaults to 512.

ngsharedvt-trampolines=[number]

When compiling in full aot mode, the value type generic sharing trampolines must be precreated in the AOT image. You can add additional method trampolines with this argument. Defaults to 512.

nodebug

Instructs the AOT compiler to not output any debugging information.

no-direct-calls

This prevents the AOT compiler from generating a direct calls to a method. The AOT compiler usually generates direct calls for certain methods that do not require going through the PLT (for example, methods that are known to not require a hook like a static constructor) or call into simple internal calls.

nrgctx-trampolines=[number]

When compiling in full aot mode, the generic sharing trampolines must be precreated in the AOT image. You can add additional method trampolines with this argument. Defaults to 4096.

nrgctx-fetch-trampolines=[number]

When compiling in full aot mode, the generic sharing fetch trampolines must be precreated in the AOT image. You can add additional method trampolines with this argument. Defaults to 128.

ntrampolines=[number]

When compiling in full aot mode, the method trampolines must be precreated in the AOT image. You can add additional method trampolines with this argument. Defaults to 4096.

outfile=[filename]

Instructs the AOT compiler to save the output to the specified file.

print-skipped-methods

If the AOT compiler cannot compile a method for any reason, enabling this flag will output the skipped methods to the console.

profile=[file]

Specify a file to use for profile-guided optimization. See the AOT profiler sub-section. To specify multiple files, include the profile option multiple times.

profile-only

AOT *only* the methods described in the files specified with the profile option. See the AOT profiler sub-section.

readonly-value=namespace.typename.fieldname=type/value

Override the value of a static readonly field. Usually, during JIT compilation, the static constructor is ran eagerly, so the value of a static readonly field is known at compilation time and the compiler can do a number of optimizations based on it. During AOT, instead, the static constructor can't be ran, so this option can be used to set the value of such a field and enable the same set of optimizations. Type can be any of i1, i2, i4 for integers of the respective sizes (in bytes). Note that signed/unsigned numbers do not matter here, just the storage size. This option can be specified multiple times and it doesn't prevent the static constructor for the type defining the field to execute with the usual rules at runtime (hence possibly computing a different value for the field).

save-temps,keep-temps

Instructs the AOT compiler to keep temporary files.

soft-debug

This instructs the compiler to generate sequence point checks that allow Mono's soft debugger to debug applications even on systems where it is not possible to set breakpoints or to single step (certain hardware configurations like the cell phones and video gaming consoles).

static

Create an ELF object file (.o) or .s file which can be statically linked into an executable when embedding the mono runtime. When this option is used, the object file needs to be registered with the embedded runtime using the mono_aot_register_module function which takes as its argument the mono_aot_module_<ASSEMBLY NAME>_info global symbol from the object file:

extern void *mono_aot_module_hello_info;

mono_aot_register_module (mono_aot_module_hello_info);
    

stats

Print various stats collected during AOT compilation.

temp-path=[path]

Explicitly specify path to store temporary files created during AOT compilation.

threads=[number]

This is an experimental option for the AOT compiler to use multiple threads when compiling the methods.

tool-prefix=<PREFIX>

Prepends <PREFIX> to the name of tools ran by the AOT compiler, i.e. 'as'/'ld'. For example, --tool=prefix=arm-linux-gnueabi- will make the AOT compiler run

verbose

Prints additional information about type loading failures.

write-symbols,no-write-symbols

Instructs the AOT compiler to emit (or not emit) debug symbol information.

no-opt

Instructs the AOT compiler tot no call opt when compiling with LLVM.

--desktop

Configures the virtual machine to be better suited for desktop applications. Currently this sets the GC system to avoid expanding the heap as much as possible at the expense of slowing down garbage collection a bit.

--full-aot

This flag instructs the Mono runtime to not generate any code at runtime and depend exclusively on the code generated from using mono --aot=full previously. This is useful for platforms that do not permit dynamic code generation, or if you need to run assemblies that have been stripped of IL (for example using mono-cil-strip). Notice that this feature will abort execution at runtime if a codepath in your program, or Mono's class libraries attempts to generate code dynamically. You should test your software upfront and make sure that you do not use any dynamic features.

--full-aot-interp

Same as --full-aot with fallback to the interpreter.

--gc=boehm, --gc=sgen

Selects the Garbage Collector engine for Mono to use, Boehm or SGen. Currently this merely ensures that you are running either the mono or mono-sgen commands. This flag can be set in the MONO_ENV_OPTIONS environment variable to force all of your child processes to use one particular kind of GC with the Mono runtime.

--gc-debug=[options]

Command line equivalent of the MONO_GC_DEBUG environment variable.

--gc-params=[options]

Command line equivalent of the MONO_GC_PARAMS environment variable.

--arch=32, --arch=64

(Mac OS X only): Selects the bitness of the Mono binary used, if available. If the binary used is already for the selected bitness, nothing changes. If not, the execution switches to a binary with the selected bitness suffix installed side by side (for example, '/bin/mono --arch=64' will switch to '/bin/mono64' iff '/bin/mono' is a 32-bit build).

--help, -h

Displays usage instructions.

--interpreter

The Mono runtime will use its interpreter to execute a given assembly. The interpreter is usually slower than the JIT, but it can be useful on platforms where code generation at runtime is not allowed.

--hybrid-aot

This flag allows the Mono runtime to run assemblies that have been stripped of IL, for example using mono-cil-strip. For this to work, the assembly must have been AOT compiled with --aot=hybrid. This flag is similar to --full-aot, but it does not disable the JIT. This means you can use dynamic features such as System.Reflection.Emit.

--llvm

If the Mono runtime has been compiled with LLVM support (not available in all configurations), Mono will use the LLVM optimization and code generation engine to JIT or AOT compile. For more information, consult: http://www.mono-project.com/docs/advanced/mono-llvm/

--ffast-math

This flag allows Mono and LLVM to apply aggressive floating point optimizations. Can break IEEE754 compliance.

--nollvm

When using a Mono that has been compiled with LLVM support, it forces Mono to fallback to its JIT engine and not use the LLVM backend.

--optimize=MODE, -O=MODE

MODE is a comma separated list of optimizations. They also allow optimizations to be turned off by prefixing the optimization name with a minus sign. In general, Mono has been tuned to use the default set of flags, before using these flags for a deployment setting, you might want to actually measure the benefits of using them. The following optimization flags are implemented in the core engine:

             abcrem     Array bound checks removal
             all        Turn on all optimizations
             aot        Usage of Ahead Of Time compiled code
             branch     Branch optimizations
             cfold      Constant folding
             cmov       Conditional moves [arch-dependency]
             deadce     Dead code elimination
             consprop   Constant propagation
             copyprop   Copy propagation
             fcmov      Fast x86 FP compares [arch-dependency]
             float32	Perform 32-bit float arithmetic using 32-bit operations
             gshared    Enable generic code sharing.
             inline     Inline method calls
             intrins    Intrinsic method implementations
             linears    Linear scan global reg allocation
             leaf       Leaf procedures optimizations
             loop       Loop related optimizations
             peephole   Peephole postpass
             precomp    Precompile all methods before executing Main
             sched      Instruction scheduling
             shared     Emit per-domain code
             sse2       SSE2 instructions on x86 [arch-dependency]
             tailc      Tail recursion and tail calls
    

For example, to enable all the optimization but dead code elimination and inlining, you can use:

	-O=all,-deadce,-inline
    

The flags that are flagged with [arch-dependency] indicate that the given option if used in combination with Ahead of Time compilation (--aot flag) would produce pre-compiled code that will depend on the current CPU and might not be safely moved to another computer.

--runtime=VERSION

Mono supports different runtime versions. The version used depends on the program that is being run or on its configuration file (named program.exe.config). This option can be used to override such autodetection, by forcing a different runtime version to be used. Note that this should only be used to select a later compatible runtime version than the one the program was compiled against. A typical usage is for running a 1.1 program on a 2.0 version:

         mono --runtime=v2.0.50727 program.exe
    

--server

Configures the virtual machine to be better suited for server operations (currently, allows a heavier threadpool initialization).

--use-map-jit

Instructs Mono to generate code using MAP_JIT on MacOS. Necessary for bundled applications.

--verify-all

Verifies mscorlib and assemblies in the global assembly cache for valid IL, and all user code for IL verifiability. This is different from --security's verifiable or validil in that these options only check user code and skip mscorlib and assemblies located on the global assembly cache.

-V, --version

Prints JIT version information (system configuration, release number and branch names if available).

--version=number

Print version number only.

The following options are supported:

casts

Produces a detailed error when throwing a InvalidCastException. This option needs to be enabled as this generates more verbose code at execution time.

mdb-optimizations

Disable some JIT optimizations which are usually only disabled when running inside the debugger. This can be helpful if you want to attach to the running process with mdb.

gdb

Generate and register debugging information with gdb. This is only supported on some platforms, and only when using gdb 7.0 or later.

mono --profile=custom program.exe

mono --profile=custom:arg1,arg2=arg3 program.exe

local[:path]

Persists event logs and entries to the local file system. The directory in which to persist the event logs, event sources and entries can be specified as part of the value. If the path is not explicitly set, it defaults to "/var/lib/mono/eventlog" on unix and "%APPDATA%no\ventlog" on Windows.

win32

Uses the native win32 API to write events and registers event logs and event sources in the registry. This is only available on Windows. On Unix, the directory permission for individual event log and event source directories is set to 777 (with +t bit) allowing everyone to read and write event log entries while only allowing entries to be deleted by the user(s) that created them.

null

Silently discards any events.

max-heap-size=size

Sets the maximum size of the heap. The size is specified in bytes and must be a power of two. The suffixes `k', `m' and `g' can be used to specify kilo-, mega- and gigabytes, respectively. The limit is the sum of the nursery, major heap and large object heap. Once the limit is reached the application will receive OutOfMemoryExceptions when trying to allocate. Not the full extent of memory set in max-heap-size could be available to satisfy a single allocation due to internal fragmentation. By default heap limits is disabled and the GC will try to use all available memory.

nursery-size=size

Sets the size of the nursery. The size is specified in bytes and must be a power of two. The suffixes `k', `m' and `g' can be used to specify kilo-, mega- and gigabytes, respectively. The nursery is the first generation (of two). A larger nursery will usually speed up the program but will obviously use more memory. The default nursery size 4 MB.

major=collector

Specifies which major collector to use. Options are `marksweep' for the Mark&Sweep collector, `marksweep-conc' for concurrent Mark&Sweep and `marksweep-conc-par' for parallel and concurrent Mark&Sweep. The concurrent Mark&Sweep collector is the default.

mode=balanced|throughput|pause[:max-pause]

Specifies what should be the garbage collector's target. The `throughput' mode aims to reduce time spent in the garbage collector and improve application speed, the `pause' mode aims to keep pause times to a minimum and it receives the argument max-pause which specifies the maximum pause time in milliseconds that is acceptable and the `balanced' mode which is a general purpose optimal mode.

soft-heap-limit=size

Once the heap size gets larger than this size, ignore what the default major collection trigger metric says and only allow four nursery size's of major heap growth between major collections.

evacuation-threshold=threshold

Sets the evacuation threshold in percent. This option is only available on the Mark&Sweep major collectors. The value must be an integer in the range 0 to 100. The default is 66. If the sweep phase of the collection finds that the occupancy of a specific heap block type is less than this percentage, it will do a copying collection for that block type in the next major collection, thereby restoring occupancy to close to 100 percent. A value of 0 turns evacuation off.

(no-)lazy-sweep

Enables or disables lazy sweep for the Mark&Sweep collector. If enabled, the sweeping of individual major heap blocks is done piecemeal whenever the need arises, typically during nursery collections. Lazy sweeping is enabled by default.

(no-)concurrent-sweep

Enables or disables concurrent sweep for the Mark&Sweep collector. If enabled, the iteration of all major blocks to determine which ones can be freed and which ones have to be kept and swept, is done concurrently with the running program. Concurrent sweeping is enabled by default.

stack-mark=mark-mode

Specifies how application threads should be scanned. Options are `precise` and `conservative`. Precise marking allow the collector to know what values on stack are references and what are not. Conservative marking threats all values as potentially references and leave them untouched. Precise marking reduces floating garbage and can speed up nursery collection and allocation rate, it has the downside of requiring a significant extra memory per compiled method. The right option, unfortunately, requires experimentation.

save-target-ratio=ratio

Specifies the target save ratio for the major collector. The collector lets a given amount of memory to be promoted from the nursery due to minor collections before it triggers a major collection. This amount is based on how much memory it expects to free. It is represented as a ratio of the size of the heap after a major collection. Valid values are between 0.1 and 2.0. The default is 0.5. Smaller values will keep the major heap size smaller but will trigger more major collections. Likewise, bigger values will use more memory and result in less frequent major collections. This option is EXPERIMENTAL, so it might disappear in later versions of mono.

default-allowance-ratio=ratio

Specifies the default allocation allowance when the calculated size is too small. The allocation allowance is how much memory the collector let be promoted before triggered a major collection. It is a ratio of the nursery size. Valid values are between 1.0 and 10.0. The default is 4.0. Smaller values lead to smaller heaps and more frequent major collections. Likewise, bigger values will allow the heap to grow faster but use more memory when it reaches a stable size. This option is EXPERIMENTAL, so it might disappear in later versions of mono.

minor=minor-collector

Specifies which minor collector to use. Options are `simple' which promotes all objects from the nursery directly to the old generation, `simple-par' which has same promotion behavior as `simple' but using multiple workers and `split' which lets objects stay longer on the nursery before promoting.

alloc-ratio=ratio

Specifies the ratio of memory from the nursery to be use by the alloc space. This only can only be used with the split minor collector. Valid values are integers between 1 and 100. Default is 60.

promotion-age=age

Specifies the required age of an object must reach inside the nursery before been promoted to the old generation. This only can only be used with the split minor collector. Valid values are integers between 1 and 14. Default is 2.

(no-)cementing

Enables or disables cementing. This can dramatically shorten nursery collection times on some benchmarks where pinned objects are referred to from the major heap.

allow-synchronous-major

This forbids the major collector from performing synchronous major collections. The major collector might want to do a synchronous collection due to excessive fragmentation. Disabling this might trigger OutOfMemory error in situations that would otherwise not happen.

number

Sets the debug level to the specified number.

print-allowance

After each major collection prints memory consumption for before and after the collection and the allowance for the minor collector, i.e. how much the heap is allowed to grow from minor collections before the next major collection is triggered.

print-pinning

Gathers statistics on the classes whose objects are pinned in the nursery and for which global remset entries are added. Prints those statistics when shutting down.

collect-before-allocs

check-remset-consistency

This performs a remset consistency check at various opportunities, and also clears the nursery at collection time, instead of the default, when buffers are allocated (clear-at-gc). The consistency check ensures that there are no major to minor references that are not on the remembered sets.

mod-union-consistency-check

Checks that the mod-union cardtable is consistent before each finishing major collection pause. This check is only applicable to concurrent major collectors.

check-mark-bits

Checks that mark bits in the major heap are consistent at the end of each major collection. Consistent mark bits mean that if an object is marked, all objects that it had references to must also be marked.

check-nursery-untag

After garbage collections, check whether all vtable pointers are no longer tagged.

xdomain-checks

Performs a check to make sure that no references are left to an unloaded AppDomain.

clear-at-tlab-creation

Clears the nursery incrementally when the thread local allocation buffers (TLAB) are created. The default setting clears the whole nursery at GC time.

debug-clear-at-tlab-creation

Clears the nursery incrementally when the thread local allocation buffers (TLAB) are created, but at GC time fills it with the byte `0xff`, which should result in a crash more quickly if `clear-at-tlab-creation` doesn't work properly.

clear-at-gc

This clears the nursery at GC time instead of doing it when the thread local allocation buffer (TLAB) is created. The default is to clear the nursery at TLAB creation time.

disable-minor

Don't do minor collections. If the nursery is full, a major collection is triggered instead, unless it, too, is disabled.

disable-major

Don't do major collections.

conservative-stack-mark

Forces the GC to scan the stack conservatively, even if precise scanning is available.

no-managed-allocator

Disables the managed allocator.

check-scan-starts

If set, does a plausibility check on the scan_starts before and after each collection

verify-nursery-at-minor-gc

If set, does a complete object walk of the nursery at the start of each minor collection.

dump-nursery-at-minor-gc

If set, dumps the contents of the nursery at the start of each minor collection. Requires verify-nursery-at-minor-gc to be set.

heap-dump=file

Dumps the heap contents to the specified file. To visualize the information, use the mono-heapviz tool.

binary-protocol=file

Outputs the debugging output to the specified file. For this to work, Mono needs to be compiled with the BINARY_PROTOCOL define on sgen-gc.c. You can then use this command to explore the output

                sgen-grep-binprot 0x1234 0x5678 < file
    

nursery-canaries

If set, objects allocated in the nursery are suffixed with a canary (guard) word, which is checked on each minor collection. Can be used to detect/debug heap corruption issues.

do-not-finalize(=classes)

If enabled, finalizers will not be run. Everything else will be unaffected: finalizable objects will still be put into the finalization queue where they survive until they're scheduled to finalize. Once they're not in the queue anymore they will be collected regularly. If a list of comma-separated class names is given, only objects from those classes will not be finalized.

log-finalizers

Log verbosely around the finalization process to aid debugging.

default

Uses the default TLS stack that the Mono runtime was configured with.
Usually this is configured to use Apple's SSL stack on Apple
platforms, and Boring SSL on other platforms.
    

apple

Forces the use of the Apple SSL stack, only works on Apple platforms.
    

btls

Forces the use of the BoringSSL stack.    See
https://opensource.google.com/projects/boringssl for more information
about this stack.
    

legacy

This is the old Mono stack, which only supports SSL and TLS up to
version 1.0.   It is deprecated and will be removed in the future.
    

align-small-structs

Enables small structs alignment to 4/8 bytes.

arm-use-fallback-tls

When this option is set on ARM, a fallback thread local store will be used instead of the default fast thread local storage primitives.

break-on-unverified

If this variable is set, when the Mono VM runs into a verification problem, instead of throwing an exception it will break into the debugger. This is useful when debugging verifier problems

casts

This option can be used to get more detailed information from InvalidCast exceptions, it will provide information about the types involved.

check-pinvoke-callconv

This option causes the runtime to check for calling convention mismatches when using pinvoke, i.e. mixing cdecl/stdcall. It only works on windows. If a mismatch is detected, an ExecutionEngineException is thrown.

collect-pagefault-stats

Collects information about pagefaults. This is used internally to track the number of page faults produced to load metadata. To display this information you must use this option with "--stats" command line option.

debug-domain-unload

When this option is set, the runtime will invalidate the domain memory pool instead of destroying it.

disable_omit_fp

Disables a compiler optimization where the frame pointer is omitted from the stack. This optimization can interact badly with debuggers.

dont-free-domains

This is an Optimization for multi-AppDomain applications (most commonly ASP.NET applications). Due to internal limitations Mono, Mono by default does not use typed allocations on multi-appDomain applications as they could leak memory when a domain is unloaded. Although this is a fine default, for applications that use more than on AppDomain heavily (for example, ASP.NET applications) it is worth trading off the small leaks for the increased performance (additionally, since ASP.NET applications are not likely going to unload the application domains on production systems, it is worth using this feature).

dyn-runtime-invoke

Instructs the runtime to try to use a generic runtime-invoke wrapper instead of creating one invoke wrapper.

explicit-null-checks

Makes the JIT generate an explicit NULL check on variable dereferences instead of depending on the operating system to raise a SIGSEGV or another form of trap event when an invalid memory location is accessed.

gdb

Equivalent to setting the MONO_XDEBUG variable, this emits symbols into a shared library as the code is JITed that can be loaded into GDB to inspect symbols.

gen-seq-points

Automatically generates sequence points where the IL stack is empty. These are places where the debugger can set a breakpoint.

no-compact-seq-points

Unless the option is used, the runtime generates sequence points data that maps native offsets to IL offsets. Sequence point data is used to display IL offset in stacktraces. Stacktraces with IL offsets can be symbolicated using mono-symbolicate tool.

handle-sigint

Captures the interrupt signal (Control-C) and displays a stack trace when pressed. Useful to find out where the program is executing at a given point. This only displays the stack trace of a single thread.

init-stacks

Instructs the runtime to initialize the stack with some known values (0x2a on x86-64) at the start of a method to assist in debuggin the JIT engine.

keep-delegates

This option will leak delegate trampolines that are no longer referenced as to present the user with more information about a delegate misuse. Basically a delegate instance might be created, passed to unmanaged code, and no references kept in managed code, which will garbage collect the code. With this option it is possible to track down the source of the problems.

no-gdb-backtrace

This option will disable the GDB backtrace emitted by the runtime after a SIGSEGV or SIGABRT in unmanaged code.

partial-sharing

When this option is set, the runtime can share generated code between generic types effectively reducing the amount of code generated.

reverse-pinvoke-exceptions

This option will cause mono to abort with a descriptive message when during stack unwinding after an exception it reaches a native stack frame. This happens when a managed delegate is passed to native code, and the managed delegate throws an exception. Mono will normally try to unwind the stack to the first (managed) exception handler, and it will skip any native stack frames in the process. This leads to undefined behaviour (since mono doesn't know how to process native frames), leaks, and possibly crashes too.

single-imm-size

This guarantees that each time managed code is compiled the same instructions and registers are used, regardless of the size of used values.

soft-breakpoints

This option allows using single-steps and breakpoints in hardware where we cannot do it with signals.

suspend-on-native-crash

This option will suspend the program when a native crash occurs (SIGSEGV, SIGILL, ...). This is useful for debugging crashes which do not happen under gdb, since a live process contains more information than a core file.

suspend-on-sigsegv

Same as suspend-on-native-crash.

suspend-on-exception

This option will suspend the program when an exception occurs.

suspend-on-unhandled

This option will suspend the program when an unhandled exception occurs.

thread-dump-dir=DIR

Use DIR for storage thread dumps created by SIGQUIT.

weak-memory-model

Don't enforce the CLR memory model on platforms with weak memory models. This can introduce random crashes in some rare cases, for multithreaded environments. This can be used for a performance boost on applications that are single threaded.

verbose-gdb

Make gdb output on native crashes more verbose.