CIL(Linker)															       CIL(Linker)

NAME

       Mono CIL Linker

SYNOPSIS

       monolinker [-o output_directory][-l i18n_assemblies][-c skip | copy | link] -x descriptor | -a assembly | -i info_file ...

DESCRIPTION

       monolinker  is  a  CIL  Linker.	The linker is a tool one can use to only ship the minimal possible set of functions that a set of programs
       might require to run as opposed to the full libraries.

       The linker analyses the intermediate code (CIL) produced by every compiler targeting the Mono platform like mcs, gmcs, vbnc, booc  or  oth-
       ers.  It  will  walk through all the code that it is given to it, and remove all the unused methods and classes.  This is done using a mark
       and sweep operation on all the code that it is referenced.

       The generated output from the monolinker can be later processed by the mkbundle tool to generate small native self-contained executables.

       Do not confuse this with the Assembly Linker (al) which creates assemblies from manifests, modules and resource files.

OPTIONS

       -d search_directory
	      Specify a directory to the linker where to look for assemblies.

       -o output_directory
	      Specify the output directory, default is 'output'.

	      If you specify the directory `.', please ensure that you won't write over important assemblies of yours.

       -b true | false
	      Specify whether to generate debug symbols or not, default is false.

       -g true | false
	      Specify whether to generate a new guid for each linked module or reuse the existing one, default is true.

       -l i18n_assemblies
	      Specify what to do with the region specific assemblies

	      Mono have a few assemblies which contains everything region specific:
		   I18N.CJK.dll
		   I18N.MidEast.dll
		   I18N.Other.dll
		   I18N.Rare.dll
		   I18N.West.dll

	      By default, they will all be copied to the output directory, but you can specify which one you want using this command.  The  choice
	      can either be: none, all, cjk, mideast, other, rare or west. You can combine the values with a comma.

       -c action
	      Specify the action to apply to the core assemblies.

	      Core  assemblies	are  the  assemblies  that  belongs  to  the  base  class  library,  like  mscorlib.dll, System.dll or System.Win-
	      dows.Forms.dll.

	      The linker supports three operations on these assemblies, you can specify one of the following actions:

	      skip   This instructs the linker to skip them and do nothing with them.

	      copy   This instructs the linker to copy them to the output directory,

	      link   This instructs the linker to apply the linking process and reduce their size.

       -p action assembly
	      Specify per assembly which action to apply.

       -x descriptor
	      Use an XML descriptor as a source for the linker.

	      Here is an example that shows all the possibilities of this format:

	      <linker>
		   <assembly fullname="Library">
			<type fullname="Foo" />
			<type fullname="Bar" preserve="nothing" required="false" />
			<type fullname="Baz" preserve="fields" required="false" />
			<type fullname="Gazonk">
			     <method signature="System.Void .ctor(System.String)" />
			     <field signature="System.String _blah" />
			     <field name="someFieldName" />
			</type>
		   </assembly>
	      </linker>

	      In this example, the linker will link the types Foo, Bar, Baz and Gazonk.

	      The preserve attribute ensures that all the fields of the type Baz will be always be linked, not matter if they are used or not, but
	      that  neither the fields or the methods of Bar will be linked if they are not used. Not specifying a preserve attribute implies that
	      we are preserving everything in the specified type.

	      The required attribute specifies that if the type is not marked, during the mark operation, it will not be linked.

	      The type Gazonk will be linked, as well as its constructor taking a string as a parameter, and it's _blah field.

	      You can have multiple assembly nodes.

       -a assemblies
	      use an assembly as a source for the linker.

	      The linker will walk through all the methods of the assembly to generate only what is necessary for this assembly to run.

       -i info_file
	      use a .info xml file as a source for the linker.

	      An info file is a file produced by the tool mono-api-info. The linker will use it to generate an assembly that  contains	only  what
	      the public API defined in the info file needs.

       -s [StepBefore:]StepFullName,StepAssembly[:StepAfter]

	      You can ask the linker to execute custom steps by using the -s command. This command takes the standard TypeFullName,Assembly format
	      to locate the step. You can customize its position in the pipeline by either adding it before a step, or after.

	      Example:

	      using System;

	      using Mono.Linker;
	      using Mono.Linker.Steps;

	      namespace Foo {

		   public class FooStep : IStep {

			public void Process (LinkContext context)
			{
			     foreach (IStep step in context.Pipeline.GetSteps ()) {
				  Console.WriteLine (step.GetType ().Name);
			     }
			}
		   }
	      }

	      If you compile this custom against monolinker to a Foo.dll assembly, you can use the -s switch as follows.   To add the  FooStep	at
	      the end of the pipeline:

		   monolinker -s Foo.FooStep,Foo -a program.exe

	      This commanand will add the FooStep after the MarkStep:

		   monolinker -s MarkStep:Foo.FooStep,Foo -a program.exe

	      This command will add the FooStep before the MarkStep:

		   monolinker -s Foo.FooStep,Foo:MarkStep -a program.exe

	      This command will add the FooStep before the MarkStep

       -m CustomParam ParamValue
	      Specify a parameter for a custom step.

COPYRIGHT

       Copyright (C) 2007 Novell, Inc (http://www.novell.com)

BUGS

       Bugs report are welcome at http://bugzilla.ximian.com

       Product Mono Tools, Component linker.

MAILING LISTS

       Mailing lists are listed at http://www.mono-project.com/Mailing_Lists

WEB SITE

       http://www.mono-project.com/Linker

AUTHORS

       The linker has been written by Jb Evain, and have been partially founded by the Google Summer of Code.

LICENSE

       The linker is licensed under the MIT/X11 license. Please read the accompayning MIT.X11 file for details.

SEE ALSO

       al(1),mkbundle(1),mono(1),mcs(1).

								    monolinker							       CIL(Linker)