127 lines
4.9 KiB
Markdown
127 lines
4.9 KiB
Markdown
Linker analyzer is a command line tool to analyze dependencies, which
|
|
were recorded during linker processing, and led linker to mark an item
|
|
to keep it in the resulting linked assembly.
|
|
|
|
It works on an oriented graph of dependencies, which are collected and
|
|
dumped during the linker run. The vertices of this graph are the items
|
|
of interest like assemblies, types, methods, fields, linker steps,
|
|
etc. The edges represent the dependencies.
|
|
|
|
How to dump dependencies
|
|
------------------------
|
|
|
|
The linker analyzer needs a linker dependencies file as an input. It
|
|
can be retrieved by enabling dependencies dumping during linking of a
|
|
Xamarin.Android or a Xamarin.iOS project.
|
|
|
|
That can be done on the command line by setting
|
|
`LinkerDumpDependencies` property to `true` and building the
|
|
project. (make sure the LinkAssemblies task is called, it might
|
|
require cleaning the project sometimes) Usually it is enough to build
|
|
the project like this:
|
|
|
|
```msbuild /p:LinkerDumpDependencies=true /p:Configuration=Release YourAppProject.csproj```
|
|
|
|
After a successful build, there will be a linker-dependencies.xml.gz
|
|
file created, containing the information for the analyzer.
|
|
|
|
How to use the analyzer
|
|
-----------------------
|
|
|
|
Let say you would like to know, why a type, Android.App.Activity for
|
|
example, was marked by the linker. So run the analyzer like this:
|
|
|
|
```illinkanalyzer -t Android.App.Activity linker-dependencies.xml.gz```
|
|
|
|
Output:
|
|
|
|
```
|
|
Loading dependency tree from: linker-dependencies.xml.gz
|
|
|
|
--- Type dependencies: 'Android.App.Activity' -----------------------
|
|
|
|
--- TypeDef:Android.App.Activity dependencies -----------------------
|
|
Dependency #1
|
|
TypeDef:Android.App.Activity
|
|
| TypeDef:XA.App.MainActivity [2 deps]
|
|
| Assembly:XA.App, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null [3 deps]
|
|
| Other:Mono.Linker.Steps.ResolveFromAssemblyStep
|
|
```
|
|
|
|
The output contains dependencies string(s), starting with the type and
|
|
continuing with the item of interest, which depends on the type. The
|
|
dependency could be result of multiple reasons. For example the type
|
|
was referenced from a method, or the type was listed in the linker xml
|
|
file to be protected.
|
|
|
|
In our example there is only one dependency string called `Dependency
|
|
#1`. It shows us that the type `Android.App.Activity` was marked
|
|
during processing of type `XA.App.MainActivity` by the linker. In this
|
|
case because the `MainActivity` type is based on the `Activity` type
|
|
and thus the linker marked it and kept it in the linked assembly. We
|
|
can also see that there are 2 dependencies for the `MainActivity`
|
|
class. Note that in the string (above) we see only 1st dependency of
|
|
the 2, the dependency on the assembly `XA.App`. And finally the
|
|
assembly vertex depends on the `ResolveFromAssemblyStep` vertex. So we
|
|
see that the assembly was processed in the `ResolveFromAssembly`
|
|
linker step.
|
|
|
|
Now we might want to see the `MainActivity` dependencies. That could
|
|
be done by the following analyzer run:
|
|
|
|
```illinkanalyzer -r TypeDef:XA.App.MainActivity linker-dependencies.xml.gz```
|
|
|
|
Output:
|
|
|
|
```
|
|
Loading dependency tree from: linker-dependencies.xml.gz
|
|
|
|
--- Raw dependencies: 'TypeDef:XA.App.MainActivity' -----------------
|
|
|
|
--- TypeDef:XA.App.MainActivity dependencies ------------------------
|
|
Dependency #1
|
|
TypeDef:XA.App.MainActivity
|
|
| Assembly:XA.App, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null [3 deps]
|
|
| Other:Mono.Linker.Steps.ResolveFromAssemblyStep
|
|
Dependency #2
|
|
TypeDef:XA.App.MainActivity
|
|
| TypeDef:XA.App.MainActivity/<>c__DisplayClass1_0 [2 deps]
|
|
| TypeDef:XA.App.MainActivity [2 deps]
|
|
| Assembly:XA.App, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null [3 deps]
|
|
| Other:Mono.Linker.Steps.ResolveFromAssemblyStep
|
|
```
|
|
|
|
Known issues
|
|
------------
|
|
|
|
Sometimes the linker processing is not straight forward and the
|
|
marking is postponed, like processing of some of the methods. They are
|
|
queued to be processed later. In such case the dependencies are
|
|
"interrupted" and the dependecy string for the method usually shows
|
|
just dependency on the Mark step.
|
|
|
|
Command line help
|
|
-----------------
|
|
```
|
|
Usage:
|
|
|
|
illinkanalyzer [Options] <linker-dependency-file.xml.gz>
|
|
|
|
Options:
|
|
|
|
-a, --alldeps show all dependencies
|
|
-h, --help show this message and exit.
|
|
-r, --rawdeps=VALUE show raw vertex dependencies. Raw vertex VALUE is
|
|
in the raw format written by linker to the
|
|
dependency XML file. VALUE can be regular
|
|
expression
|
|
--roots show root dependencies.
|
|
--stat show statistic of loaded dependencies.
|
|
--tree reduce the dependency graph to the tree.
|
|
--types show all types dependencies.
|
|
-t, --typedeps=VALUE show type dependencies. The VALUE can be regular
|
|
expression
|
|
-f, --flat show all dependencies per vertex and their distance
|
|
-v, --verbose be more verbose. Enables stat and roots options.
|
|
```
|