3 .\" (C) 2003 Ximian, Inc.
5 .\" Miguel de Icaza (miguel@gnu.org)
7 .de Sp \" Vertical space (when we can't use .PP)
13 mono \- Mono's ECMA-CLI native code generator (Just-in-Time and Ahead-of-Time)
16 .B mono [options] file [arguments...]
18 \fImono\fP is a runtime implementation of the ECMA Common Language
19 Infrastructure. This can be used to run ECMA and .NET applications.
21 The runtime contains a native code generator that transforms the
22 Common Intermediate Language into native code.
24 The code generator can operate in two modes: just in time compilation
25 (JIT) or ahead of time compilation (AOT). Since code can be
26 dynamically loaded, the runtime environment and the JIT are always
27 present, even if code is compiled ahead of time.
29 The runtime loads ths specified
36 is an ECMA assembly. They typically have a .exe or .dll extension.
38 The runtime provides a number of configuration options for running
39 applications, for developping and debugging, and for testing and
40 debugging the runtime itself.
42 The following options are available:
45 This option is used to precompile the CIL code in the specified
46 assembly to native code. The generated code is stored in a file with
47 the extension .so. This file will be automatically picked up by the
48 runtime when the assembly is executed.
50 Ahead-of-Time compilation is most useful if you use it in combination
51 with the -O=all,-shared flag which enables all of the optimizations in
52 the code generator to be performed. Some of those optimizations are
53 not practical for Just-in-Time compilation since they might be very
56 Unlike the .NET Framework, Ahead-of-Time compilation will not generate
57 domain independent code: it generates the same code that the
58 Just-in-Time compiler would produce. Since most applications use a
59 single domain, this is fine. If you want to optimize the generated
60 code for use in multi-domain applications, consider using the
63 This pre-compiles the methods, but the original assembly is still
64 required to execute as this one contains the metadata and exception
65 information which is not availble on the generated file. When
66 precompiling code, you might want to compile with all optimizations
67 (-O=all). Pre-compiled code is position independent code.
69 Pre compilation is just a mechanism to reduce startup time, and avoid
70 just-in-time compilation costs. The original assembly must still be
71 present, as the metadata is contained there.
73 .I "--config filename"
74 Load the specified configuration file instead of the default one(s).
75 The default files are /etc/mono/config and ~/.mono/config or the file
76 specified in the MONO_CONFIG environment variable, if set. See the
77 mono-config(5) man page for details on the format of this file.
80 Displays usage instructions.
82 .I "--optimize=MODE", "-O=mode"
83 MODE is a comma separated list of optimizations. They also allow
84 optimizations to be turned off by prefixing the optimization name with
87 The following optimizations are implemented:
89 all Turn on all optimizations
90 peephole Peephole postpass
91 branch Branch optimizations
92 inline Inline method calls
93 cfold Constant folding
94 consprop Constant propagation
95 copyprop Copy propagation
96 deadce Dead code elimination
97 linears Linear scan global reg allocation
98 cmov Conditional moves
99 shared Emit per-domain code
100 sched Instruction scheduling
101 intrins Intrinsic method implementations
102 tailc Tail recursion and tail calls
103 loop Loop related optimizations
104 fcmov Fast x86 FP compares
105 leaf Leaf procedures optimizations
106 aot Usage of Ahead Of Time compiled code
107 precomp Precompile all methods before executing Main
108 abcrem Array bound checks removal
109 ssapre SSA based Partial Redundancy Elimination
112 For example, to enable all the optimization but dead code
113 elimination and inlining, you can use:
115 -O=all,-deadce,-inline
119 Activate the security manager (experimental in 1.1). This allows the
120 support for declarative security attributes (e.g. execution of, CAS or
121 non-CAS, security demands). The security manager is OFF by default
122 (experimental). Note that this options is currently not compatible with
123 AOT. The security manager will be disabled if AOT (--aot) is specified.
126 Prints JIT version information.
129 .SH DEVELOPMENT OPTIONS
130 The following options are used to help when developing a JITed application.
133 Turns on the debugging mode in the runtime. If an assembly was
134 compiled with debugging information, it will produce line number
135 information for stack traces.
137 .I "--profile[=profiler[:profiler_args]]"
138 Instructs the runtime to collect profiling information about execution
139 times and memory allocation, and dump it at the end of the execution.
140 If a profiler is not specified, the default profiler is used.
142 Mono has a built-in profiler called `default' (and is also the default
143 if no arguments are specified), but developers can write custom
144 profilers as shared libraries. The shared library must be called
145 `mono-profiler-NAME.so' where `NAME' is the name of your profiler.
147 For a sample of the custom profilers look in the Mono source tree for
148 in the samples/profiler.c.
152 is a profiler-specific string of options for the profiler itself.
154 The default profiler is called `default' and it accepts `alloc' to
155 profile memory consumption by the application; `time' to profile the
156 time spent on each routine and `stat' to perform sample statistical
157 profiling. If no options are provided the default is `alloc,time'.
161 mono --profile program.exe
164 That will run the program with the default profiler and will do time
165 and allocation profiling.
168 mono --profile=default:stat,alloc program.exe
170 Will do sample statistical profiling and allocation profiling on
174 mono --profile=custom program.exe
177 In the above sample Mono will load the user defined profiler from the
178 shared library `mono-profiler-custom.so'.
179 .SH JIT MAINTAINER OPTIONS
180 The maintainer options are only used by those developing the runtime
181 itself, and not typically of interest to runtime users or developers.
184 This compiles a method (namespace.name:methodname), this is used for
185 testing the compiler performance or to examine the output of the code
189 Compiles all the methods in an assembly. This is used to test the
190 compiler performance or to examine the output of the code generator
192 .I "--graph=TYPE METHOD"
193 This generates a postscript file with a graph with the details about
194 the specified method (namespace.name:methodname). This requires `dot'
195 and ghostview to be installed (it expects Ghostview to be called
198 The following graphs are available:
200 cfg Control Flow Graph (CFG)
202 code CFG showing code
203 ssa CFG showing code after SSA translation
204 optcode CFG showing code after IR optimizations
207 Some graphs will only be available if certain optimizations are turned
211 Instruct the runtime on the number of times that the method specified
212 by --compile (or all the methods if --compileall is used) to be
213 compiled. This is used for testing the code generator performance.
216 Increases the verbosity level, each time it is listed, increases the
217 verbosity level to include more information (including, for example,
218 a disassembly of the native code produced, code selector info etc.).
221 Inserts a breakpoint before the method whose name is `method'
222 (namespace.class:methodname). Use `Main' as method name to insert a
223 breakpoint on the application's main method.
226 Inserts a breakpoint on exceptions. This allows you to debug your
227 application with a native debugger when an exception is thrown.
229 .I "--trace[=expression]"
230 Shows method names as they are invoked. By default all methods are
233 The trace can be customized to include or exclude methods, classes or
234 assemblies. A trace expression is a comma separated list of targets,
235 each target can be prefixed with a minus sign to turn off a particular
236 target. The words `program' and `all' have special meaning.
237 `program' refers to the main program being executed, and `all' means
238 all the method calls.
240 Assemblies are specified by their name, for example, to trace all
241 calls in the System assembly, use:
244 mono --trace=System app.exe
247 Classes are specified with the T: prefix. For example, to trace all
248 calls to the System.String class, use:
251 mono --trace=T:System.String app.exe
254 And individual methods are referenced with the M: prefix, and the
255 standar method notation:
258 mono --trace=M:System.Console:WriteLine app.exe
261 As previously noted, various rules can be specified at once:
264 mono --trace=T:System.String,T:System.Random app.exe
267 You can exclude pieces, the next example traces calls to
268 System.String except for the System.String:Concat method.
271 mono --trace=T:System.String,-M:System.String:Concat
274 Finally, namespaces can be specified using the N: prefix:
277 mono --trace=N:System.Xml
282 You can use the MONO_LOG_LEVEL and MONO_LOG_MASK environment variables
283 to get verbose debugging output about the execution of your
284 application within Mono.
288 environment variable if set, the logging level is changed to the set
289 value. Possible values are "error", "critical", "warning", "message",
290 "info", "debug". The default value is "error". Messages with a logging
291 level greater then or equal to the log level will be printed to
294 Use "info" to track the dynamic loading of assemblies.
299 environment variable to limit the extent of the messages you get:
300 If set, the log mask is changed to the set value. Possible values are
301 "asm" (assembly loader), "type", "dll" (native library loader), "gc"
302 (garbage collector), "cfg" (config file loader), "aot" (precompiler) and "all".
303 The default value is "all". Changing the mask value allows you to display only
304 messages for a certain component. You can use multiple masks by comma
305 separating them. For example to see config file messages and assembly loader
306 messages set you mask to "asm,cfg".
308 The following is a common use to track down problems with P/Invoke:
310 $ MONO_LOG_LEVEL="debug" MONO_LOG_MASK="dll" mono glue.exe
314 Mono's XML serialization engine by default will use a reflection-based
315 approach to serialize which might be slow for continous processing
316 (web service applications). The serialization engine will determine
317 when a class must use a hand-tuned serializer based on a few
318 parameters and if needed it will produce a customized C# serializer
319 for your types at runtime. This customized serializer then gets
320 dynamically loaded into your application.
322 You can control this with the MONO_XMLSERIALIZER_THS environment
325 The possible values are
327 to disable the use of a C# customized
328 serializer, or an integer that is the minimum number of uses before
329 the runtime will produce a custom serializer (0 will produce a
330 custom serializer on the first access, 50 will produce a serializer on
332 .SH ENVIRONMENT VARIABLES
335 Turns off the garbage collection in Mono. This should be only used
336 for debugging purposes
339 If set, this variable will instruct Mono to ahead-of-time compile new
340 assemblies on demand and store the result into a cache in
343 .I "MONO_ASPNET_NODELETE"
344 If set to any value, temporary source files generated by ASP.NET support
345 classes will not be removed. They will be kept in the user's temporary
349 If set, this variable overrides the default system configuration directory
350 ($PREFIX/etc). It's used to locate machine.config file.
353 If set, this variable overrides the default runtime configuration file
354 ($PREFIX/etc/mono/config). The --config command line options overrides the
355 environment variable.
358 If set, enables some features of the runtime useful for debugging.
359 It makes the runtime display the stack traces for all the threads
360 running and exit when mono is interrupted (Ctrl-C) and print some
361 additional messages on error conditions. It may not exit cleanly. Use at
364 .I "MONO_DISABLE_AIO"
365 If set, tells mono NOT to attempt using native asynchronous I/O services. In
366 that case, the threadpool is used for asynchronous I/O on files and sockets.
368 .I "MONO_DISABLE_SHM"
369 If this variable is set, it disables the shared memory part of the
370 Windows I/O Emulation layer, and handles (files, events, mutexes,
371 pipes) will not be shared across processes. Process creation is also
372 disabled. This option is only available on Unix.
375 For platforms that do not otherwise have a way of obtaining random bytes
376 this can be set to the name of a file system socket on which an egd or
377 prngd daemon is listening.
379 .I "MONO_EXTERNAL_ENCODINGS"
380 If set, contains a colon-separated list of text encodings to try when
381 turning externally-generated text (e.g. command-line arguments or
382 filenames) into Unicode. The encoding names come from the list
383 provided by iconv, and the special case "default_locale" which refers
384 to the current locale's default encoding.
386 When reading externally-generated text strings UTF-8 is tried first,
387 and then this list is tried in order with the first successful
388 conversion ending the search. When writing external text (e.g. new
389 filenames or arguments to new processes) the first item in this list
390 is used, or UTF-8 if the environment variable is not set.
393 Provides a prefix the runtime uses to look for Global Assembly Caches.
394 Directories are separated by the platform path separator (colons on
395 unix). MONO_GAC_PREFIX should point to the top directory of a prefixed
396 install. Or to the directory provided in the gacutil /gacdir command. Example:
397 .B /home/username/.mono:/usr/local/mono/
400 The logging level, possible values are `error', `critical', `warning',
401 `message', `info' and `debug'. See the DEBUGGING section for more
405 Controls the domain of the Mono runtime that logging will apply to.
406 If set, the log mask is changed to the set value. Possible values are
407 "asm" (assembly loader), "type", "dll" (native library loader), "gc"
408 (garbage collector), "cfg" (config file loader), "aot" (precompiler) and "all".
409 The default value is "all". Changing the mask value allows you to display only
410 messages for a certain component. You can use multiple masks by comma
411 separating them. For example to see config file messages and assembly loader
412 messages set you mask to "asm,cfg".
414 .I "MONO_MANAGED_WATCHER"
415 If set to any value, System.IO.FileSystemWatcher will use the default
416 managed implementation (slow). If unset, mono will try to use FAM under
417 Unix systems and native API calls on Windows, falling back to the
418 managed implementation on error.
421 Provides a search path to the runtime where to look for library files.
422 Directories are separated by the platform path separator (colons on unix). Example:
423 .B /home/username/lib:/usr/local/mono/lib
426 Experimental RTC support in the statistical profiler: if the user has
427 the permission, more accurate statistics are gathered. The MONO_RTC
428 value must be restricted to what the linux rtc allows: power of two
433 MONO_RTC=4096 mono --profiler=default:stat program.exe
437 If set its the directory where the ".wapi" handle state is stored.
438 This is the directory where the Windows I/O Emulation layer stores its
439 shared state data (files, events, mutexes, pipes). By default Mono
440 will store the ".wapi" directory in the users's home directory.
442 .I "MONO_THREADS_PER_CPU"
443 Sets the maximum number of threads in the threadpool per CPU. The default is
444 50 for non-windows systems and 25 for windows.
447 If set, enables the System.Diagnostics.DefaultTraceListener, which will
448 print the output of the System.Diagnostics Trace and Debug classes.
449 It can be set to a filename, and to Console.Out or Console.Error to display
450 output to standard output or standard error, respectively.
451 See the System.Diagnostics.DefaultTraceListener documentation for more
454 .I "MONO_XMLSERIALIZER_THS"
455 Controls the threshold for the XmlSerializer to produce a custom
456 serializer for a given class instead of using the Reflection-based
457 interpreter. The possible values are `no' to disable the use of a
458 custom serializer or a number to indicate when the XmlSerializer
459 should start serializing. The default value is 50, which means that
460 the a custom serializer will be produced on the 50th use.
462 On Unix assemblies are loaded from the installation lib directory. If you set
463 `prefix' to /usr, the assemblies will be located in /usr/lib. On
464 Windows, the assemblies are loaded from the directory where mono and
469 The directory for the ahead-of-time compiler demand creation
470 assemblies are located.
472 /etc/mono/config, ~/.mono/config
474 Mono runtime configuration file. See the mono-config(5) manual page
475 for more information.
477 ~/.config/.mono/certs
479 Contains Mono certificate stores. See the certmgr(1) manual page for
482 Visit http://lists.ximian.com/mailman/listinfo/mono-list for details.
484 Visit: http://www.mono-project.com for details
486 .BR mcs(1), mint(1), monodis(1), mono-config(5), certmgr(1).
488 For ASP.NET-related documentation, see the xsp(1) manual page