.\"
-.\" mini manual page.
+.\" mono manual page.
.\" (C) 2003 Ximian, Inc.
+.\" (C) 2004-2005 Novell, Inc.
.\" Author:
.\" Miguel de Icaza (miguel@gnu.org)
.\"
+.de Sp \" Vertical space (when we can't use .PP)
+.if t .sp .5v
+.if n .sp
+..
.TH Mono "Mono 1.0"
.SH NAME
-mini \- Mono new's code ECMA-CLI code generator (Just-in-Time and Ahead-of-Time)
+mono \- Mono's ECMA-CLI native code generator (Just-in-Time and Ahead-of-Time)
.SH SYNOPSIS
.PP
-.B mini
-[\-\-aot]
-[\-\-break METHOD]
-[\-\-breakonex]
-[\-\-compile name]
-[\-\-compileall]
-[\-\-config filename]
-[\-\-coverage]
-[\-\-debug]
-[\-\-graph[=TYPE] METHOD]
-[\-\-help]
-[\-\-trace]
-[\-\-ncompile num]
-[\-\-optimize=MODE]
-[\-O=mode]
-[\-\-profile]
-[\-\-regression]
-[\-\-statfile FILE]
-[\-v]
-[\-\-verbose]
-file [arguments...]
+.B mono [options] file [arguments...]
.SH DESCRIPTION
-The \fImini\fP program is a runtime implementation of the ECMA Common
-Language Infrastructure. The runtime contains a native code generator
-that transforms the Common Intermediate Language into native code.
+\fImono\fP is a runtime implementation of the ECMA Common Language
+Infrastructure. This can be used to run ECMA and .NET applications.
+.PP
+The runtime contains a native code generator that transforms the
+Common Intermediate Language into native code.
.PP
The code generator can operate in two modes: just in time compilation
(JIT) or ahead of time compilation (AOT). Since code can be
dynamically loaded, the runtime environment and the JIT are always
-present, even if code is compiled ahead of time.
+present, even if code is compiled ahead of time.
.PP
The runtime loads ths specified
.I file
applications, for developping and debugging, and for testing and
debugging the runtime itself.
.SH RUNTIME OPTIONS
+The following options are available:
.TP
.I "--aot"
This option is used to precompile the CIL code in the specified
assembly to native code. The generated code is stored in a file with
the extension .so. This file will be automatically picked up by the
runtime when the assembly is executed.
-.TP
+.Sp
+Ahead-of-Time compilation is most useful if you use it in combination
+with the -O=all,-shared flag which enables all of the optimizations in
+the code generator to be performed. Some of those optimizations are
+not practical for Just-in-Time compilation since they might be very
+time consuming.
+.Sp
+Unlike the .NET Framework, Ahead-of-Time compilation will not generate
+domain independent code: it generates the same code that the
+Just-in-Time compiler would produce. Since most applications use a
+single domain, this is fine. If you want to optimize the generated
+code for use in multi-domain applications, consider using the
+-O=shared flag.
+.Sp
This pre-compiles the methods, but the original assembly is still
required to execute as this one contains the metadata and exception
information which is not availble on the generated file. When
precompiling code, you might want to compile with all optimizations
(-O=all). Pre-compiled code is position independent code.
-.TP
+.Sp
Pre compilation is just a mechanism to reduce startup time, and avoid
just-in-time compilation costs. The original assembly must still be
present, as the metadata is contained there.
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.
-.TP
+.Sp
The following optimizations are implemented:
.nf
+ all Turn on all optimizations
peephole Peephole postpass
branch Branch optimizations
inline Inline method calls
cmov Conditional moves
shared Emit per-domain code
sched Instruction scheduling
- instrins Intrinsic method implementations
+ intrins Intrinsic method implementations
tailc Tail recursion and tail calls
loop Loop related optimizations
+ fcmov Fast x86 FP compares
+ leaf Leaf procedures optimizations
+ aot Usage of Ahead Of Time compiled code
+ precomp Precompile all methods before executing Main
+ abcrem Array bound checks removal
+ ssapre SSA based Partial Redundancy Elimination
.fi
-.TP
+.Sp
For example, to enable all the optimization but dead code
elimination and inlining, you can use:
.nf
-O=all,-deadce,-inline
.fi
-
-.SH DEVELOPMENT OPTIONS
-.I "--break method"
-Inserts a breakpoint before the method whose name is `method'
-(namespace.class:methodname). Use `Main' as method name to insert a
-breakpoint on the application's main method.
-.TP
-.I "--breakonex"
-Inserts a breakpoint on exceptions. This allows you to debug your
-application with a native debugger when an exception is thrown.
.TP
-.I "--coverage"
-Performs coverage analysis on the underlying IL code.
+.I "--security"
+Activate the security manager (experimental feature in 1.1). This allows
+mono to support declarative security attributes (e.g. execution of, CAS
+or non-CAS, security demands). The security manager is OFF by default
+(experimental).
.TP
-.I "--trace"
-Shows method names as they are invoked.
-
+.I "-V", "--version"
+Prints JIT version information.
.SH DEVELOPMENT OPTIONS
-The following options are used to debug a JITed application. They're
-only useful when running the JIT in a debugger:
+The following options are used to help when developing a JITed application.
.TP
.I "--debug"
Turns on the debugging mode in the runtime. If an assembly was
compiled with debugging information, it will produce line number
information for stack traces.
.TP
-.I "--profile"
+.I "--profile[=profiler[:profiler_args]]"
Instructs the runtime to collect profiling information about execution
times and memory allocation, and dump it at the end of the execution.
-
-
-
-.SH MAINTAINER OPTIONS
+If a profiler is not specified, the default profiler is used.
+.Sp
+Mono has a built-in profiler called `default' (and is also the default
+if no arguments are specified), but developers can write custom
+profilers as shared libraries. The shared library must be called
+`mono-profiler-NAME.so' where `NAME' is the name of your profiler.
+.Sp
+For a sample of the custom profilers look in the Mono source tree for
+in the samples/profiler.c.
+.Sp
+The
+.I profiler_args
+is a profiler-specific string of options for the profiler itself.
+.Sp
+The default profiler is called `default' and it accepts `alloc' to
+profile memory consumption by the application; `time' to profile the
+time spent on each routine and `stat' to perform sample statistical
+profiling. If no options are provided the default is `alloc,time'.
+.Sp
+For example:
+.nf
+ mono --profile program.exe
+.fi
+.Sp
+That will run the program with the default profiler and will do time
+and allocation profiling.
+.Sp
+.nf
+ mono --profile=default:stat,alloc program.exe
+.fi
+Will do sample statistical profiling and allocation profiling on
+program.exe.
+.TP
+.nf
+ mono --profile=custom program.exe
+.fi
+.Sp
+In the above sample Mono will load the user defined profiler from the
+shared library `mono-profiler-custom.so'.
+.SH JIT MAINTAINER OPTIONS
The maintainer options are only used by those developing the runtime
itself, and not typically of interest to runtime users or developers.
.TP
the specified method (namespace.name:methodname). This requires `dot'
and ghostview to be installed (it expects Ghostview to be called
"gv").
-.TP
+.Sp
The following graphs are available:
.nf
cfg Control Flow Graph (CFG)
ssa CFG showing code after SSA translation
optcode CFG showing code after IR optimizations
.fi
+.Sp
Some graphs will only be available if certain optimizations are turned
on.
.TP
.TP
.I "-v", "--verbose"
Increases the verbosity level, each time it is listed, increases the
-verbosity level to include more information.
+verbosity level to include more information (including, for example,
+a disassembly of the native code produced, code selector info etc.).
+.TP
+.I "--break method"
+Inserts a breakpoint before the method whose name is `method'
+(namespace.class:methodname). Use `Main' as method name to insert a
+breakpoint on the application's main method.
+.TP
+.I "--breakonex"
+Inserts a breakpoint on exceptions. This allows you to debug your
+application with a native debugger when an exception is thrown.
+.TP
+.I "--trace[=expression]"
+Shows method names as they are invoked. By default all methods are
+traced.
+.Sp
+The trace can be customized to include or exclude methods, classes or
+assemblies. A trace expression is a comma separated list of targets,
+each target can be prefixed with a minus sign to turn off a particular
+target. The words `program' and `all' have special meaning.
+`program' refers to the main program being executed, and `all' means
+all the method calls.
+.Sp
+Assemblies are specified by their name, for example, to trace all
+calls in the System assembly, use:
+.nf
+
+ mono --trace=System app.exe
+
+.fi
+Classes are specified with the T: prefix. For example, to trace all
+calls to the System.String class, use:
+.nf
+ mono --trace=T:System.String app.exe
+.fi
+And individual methods are referenced with the M: prefix, and the
+standar method notation:
+.nf
+
+ mono --trace=M:System.Console:WriteLine app.exe
+
+.fi
+As previously noted, various rules can be specified at once:
+.nf
+
+ mono --trace=T:System.String,T:System.Random app.exe
+
+.fi
+You can exclude pieces, the next example traces calls to
+System.String except for the System.String:Concat method.
+.nf
+
+ mono --trace=T:System.String,-M:System.String:Concat
+
+.fi
+Finally, namespaces can be specified using the N: prefix:
+.nf
+
+ mono --trace=N:System.Xml
+
+.fi
+.SH DEBUGGING
+.PP
+You can use the MONO_LOG_LEVEL and MONO_LOG_MASK environment variables
+to get verbose debugging output about the execution of your
+application within Mono.
+.PP
+The
+.I MONO_LOG_LEVEL
+environment variable if set, the logging level is changed to the set
+value. Possible values are "error", "critical", "warning", "message",
+"info", "debug". The default value is "error". Messages with a logging
+level greater then or equal to the log level will be printed to
+stdout/stderr.
+.PP
+Use "info" to track the dynamic loading of assemblies.
+.PP
+.PP
+Use the
+.I MONO_LOG_MASK
+environment variable to limit the extent of the messages you get:
+If set, the log mask is changed to the set value. Possible values are
+"asm" (assembly loader), "type", "dll" (native library loader), "gc"
+(garbage collector), "cfg" (config file loader), "aot" (precompiler) and "all".
+The default value is "all". Changing the mask value allows you to display only
+messages for a certain component. You can use multiple masks by comma
+separating them. For example to see config file messages and assembly loader
+messages set you mask to "asm,cfg".
+.PP
+The following is a common use to track down problems with P/Invoke:
+.nf
+ $ MONO_LOG_LEVEL="debug" MONO_LOG_MASK="dll" mono glue.exe
+.fi
+.PP
+.SH SERIALIZATION
+Mono's XML serialization engine by default will use a reflection-based
+approach to serialize which might be slow for continous processing
+(web service applications). The serialization engine will determine
+when a class must use a hand-tuned serializer based on a few
+parameters and if needed it will produce a customized C# serializer
+for your types at runtime. This customized serializer then gets
+dynamically loaded into your application.
+.PP
+You can control this with the MONO_XMLSERIALIZER_THS environment
+variable.
+.PP
+The possible values are
+.B `no'
+to disable the use of a C# customized
+serializer, or an integer that is the minimum number of uses before
+the runtime will produce a custom serializer (0 will produce a
+custom serializer on the first access, 50 will produce a serializer on
+the 50th use).
.SH ENVIRONMENT VARIABLES
.TP
.I "GC_DONT_GC"
Turns off the garbage collection in Mono. This should be only used
for debugging purposes
.TP
-.I "MONO_PATH"
-Provides a search path to mono and mint where to look for library files.
-Directories are separated by the platform path separator (colons on unix). Example:
-.B /home/username/lib:/usr/local/mono/lib
+.I "MONO_AOT_CACHE"
+If set, this variable will instruct Mono to ahead-of-time compile new
+assemblies on demand and store the result into a cache in
+~/.mono/aot-cache.
.TP
-.I "MONO_DISABLE_SHM"
-If this variable is set, it disables the Windows I/O Emulation layer,
-and handles (files, events, mutexes, pipes) will not be shared across
-processes. This option is only available on Unix.
+.I "MONO_ASPNET_NODELETE"
+If set to any value, temporary source files generated by ASP.NET support
+classes will not be removed. They will be kept in the user's temporary
+directory.
.TP
.I "MONO_CFG_DIR"
If set, this variable overrides the default system configuration directory
If set, this variable overrides the default runtime configuration file
($PREFIX/etc/mono/config). The --config command line options overrides the
environment variable.
+.TP
+.I "MONO_DEBUG"
+If set, enables some features of the runtime useful for debugging.
+Currently this enables two features: stack traces when interrupting
+the process from the shell; Visible error messages on assembly
+loading and also to track problems with delegates that are released,
+but a reference is kept in unmanaged code.
+.TP
+The stack tracing option makes the runtime display the stack traces
+for all the threads running and exit when mono is interrupted (Ctrl-C)
+and print some additional messages on error conditions. It may not
+exit cleanly. Use at your own risk.
+.TP
+Also, this option will leak delegate trampolines that are no longer
+referenced as to present the user with more information about a
+delegate missuse. 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.
+.TP
+.I "MONO_DISABLE_AIO"
+If set, tells mono NOT to attempt using native asynchronous I/O services. In
+that case, a default select/poll implementation is used. Currently only epoll()
+is supported.
+.TP
+.I "MONO_EGD_SOCKET"
+For platforms that do not otherwise have a way of obtaining random bytes
+this can be set to the name of a file system socket on which an egd or
+prngd daemon is listening.
+.TP
+.I "MONO_EXTERNAL_ENCODINGS"
+If set, contains a colon-separated list of text encodings to try when
+turning externally-generated text (e.g. command-line arguments or
+filenames) into Unicode. The encoding names come from the list
+provided by iconv, and the special case "default_locale" which refers
+to the current locale's default encoding.
+.IP
+When reading externally-generated text strings UTF-8 is tried first,
+and then this list is tried in order with the first successful
+conversion ending the search. When writing external text (e.g. new
+filenames or arguments to new processes) the first item in this list
+is used, or UTF-8 if the environment variable is not set.
+.TP
+.I "MONO_GAC_PREFIX"
+Provides a prefix the runtime uses to look for Global Assembly Caches.
+Directories are separated by the platform path separator (colons on
+unix). MONO_GAC_PREFIX should point to the top directory of a prefixed
+install. Or to the directory provided in the gacutil /gacdir command. Example:
+.B /home/username/.mono:/usr/local/mono/
+.TP
+.I "MONO_LOG_LEVEL"
+The logging level, possible values are `error', `critical', `warning',
+`message', `info' and `debug'. See the DEBUGGING section for more
+details.
+.TP
+.I "MONO_LOG_MASK"
+Controls the domain of the Mono runtime that logging will apply to.
+If set, the log mask is changed to the set value. Possible values are
+"asm" (assembly loader), "type", "dll" (native library loader), "gc"
+(garbage collector), "cfg" (config file loader), "aot" (precompiler) and "all".
+The default value is "all". Changing the mask value allows you to display only
+messages for a certain component. You can use multiple masks by comma
+separating them. For example to see config file messages and assembly loader
+messages set you mask to "asm,cfg".
+.TP
+.I "MONO_MANAGED_WATCHER"
+If set to any value, System.IO.FileSystemWatcher will use the default
+managed implementation (slow). If unset, mono will try to use FAM under
+Unix systems and native API calls on Windows, falling back to the
+managed implementation on error.
+.TP
+.I "MONO_PATH"
+Provides a search path to the runtime where to look for library files.
+Directories are separated by the platform path separator (colons on unix). Example:
+.B /home/username/lib:/usr/local/mono/lib
+.TP
+.I "MONO_RTC"
+Experimental RTC support in the statistical profiler: if the user has
+the permission, more accurate statistics are gathered. The MONO_RTC
+value must be restricted to what the linux rtc allows: power of two
+from 64 to 8192 Hz. To enable higher frequencies like 4096 Hz, run as root:
+.nf
+ echo 4096 > /proc/sys/dev/rtc/max-user-freq
+.fi
+.Sp
+For example:
+.nf
+ MONO_RTC=4096 mono --profiler=default:stat program.exe
+.fi
+.TP
+.I "MONO_NO_TLS"
+Disable inlining of thread local accesses. Try setting this if you get a segfault
+early on in the execution of mono.
+.TP
+.I "MONO_SHARED_DIR"
+If set its the directory where the ".wapi" handle state is stored.
+This is the directory where the Windows I/O Emulation layer stores its
+shared state data (files, events, mutexes, pipes). By default Mono
+will store the ".wapi" directory in the users's home directory.
+.TP
+.I "MONO_THREADS_PER_CPU"
+The maximum number of threads in the general threadpool will be
+20 + (MONO_THREADS_PER_CPU * number of CPUs). The default value for this
+variable is 5.
+.TP
+.I "MONO_TRACE"
+If set, enables the System.Diagnostics.DefaultTraceListener, which will
+print the output of the System.Diagnostics Trace and Debug classes.
+It can be set to a filename, and to Console.Out or Console.Error to display
+output to standard output or standard error, respectively.
+See the System.Diagnostics.DefaultTraceListener documentation for more
+information.
+.TP
+.I "MONO_XMLSERIALIZER_THS"
+Controls the threshold for the XmlSerializer to produce a custom
+serializer for a given class instead of using the Reflection-based
+interpreter. The possible values are `no' to disable the use of a
+custom serializer or a number to indicate when the XmlSerializer
+should start serializing. The default value is 50, which means that
+the a custom serializer will be produced on the 50th use.
.SH FILES
On Unix assemblies are loaded from the installation lib directory. If you set
`prefix' to /usr, the assemblies will be located in /usr/lib. On
Windows, the assemblies are loaded from the directory where mono and
mint live.
.PP
+~/.mono/aot-cache
+.PP
+The directory for the ahead-of-time compiler demand creation
+assemblies are located.
+.PP
/etc/mono/config, ~/.mono/config
-.IP
+.PP
Mono runtime configuration file. See the mono-config(5) manual page
for more information.
+.PP
+~/.config/.mono/certs, /usr/share/.mono/certs
+.PP
+Contains Mono certificate stores for users / machine. See the certmgr(1)
+manual page for more information on managing certificate stores.
+.PP
+~/.config/.mono/keypairs, /usr/share/.mono/keypairs
+.PP
+Contains Mono cryptographic keypairs for users / machine. They can be
+accessed by using a CspParameters object with DSACryptoServiceProvider
+and RSACryptoServiceProvider classes.
+.PP
+~/.config/.isolatedstorage, ~/.local/share/.isolatedstorage, /usr/share/.isolatedstorage
+.PP
+Contains Mono isolated storage for non-roaming users, roaming users and
+local machine. Isolated storage can be accessed using the classes from
+the System.IO.IsolatedStorage namespace.
.SH MAILING LISTS
-Visit http://mail.ximian.com/mailman/mono-list for details.
+Visit http://lists.ximian.com/mailman/listinfo/mono-list for details.
.SH WEB SITE
-Visit: http://www.go-mono.com for details
+Visit: http://www.mono-project.com for details
.SH SEE ALSO
-.BR mcs(1), mint(1), monodis(1), mono-config(5)
-
-
+.BR mcs(1), mint(1), monodis(1), mono-config(5), certmgr(1).
+.PP
+For ASP.NET-related documentation, see the xsp(1) manual page
projects / mono.git / blobdiff