monolinker

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  com-
       piler targeting the Mono platform like mcs, gmcs, vbnc, booc or others.
       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 assem-
       blies 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 spe-
              cific:
                   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
              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 for-
              mat:

              <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" />
                        </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  tak-
              ing 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.

              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

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