Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
illinkanalyzer(1)	    General Commands Manual	     illinkanalyzer(1)

NAME
       illinkanalyzer -	Mono's linker analyzer tool

SYNOPSIS
       illinkanalyzer [options]	<linker-dependency-file.xml.gz>

DESCRIPTION
       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  LinkAssem-
       blies  task is called, it might require cleaning	the project sometimes)
       Usually it is enough to build the project like this:

	      rm -f obj/Release/link.flag
	      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.

OPTIONS
		-a, --alldeps		   show	all dependencies
		    --csvoutput=VALUE	   outputs types and optionally	size analysis to CSV
					     file
		-h, --help		   show	this message and exit.
		-l, --linkedpath=VALUE	   sets	the linked assemblies directory	path. Enables
					     displaying	size estimates.
		-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.

EXAMPLES
       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  be-
       cause  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

SEE ALSO
       msbuild(1)

							     illinkanalyzer(1)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=illinkanalyzer&sektion=1&manpath=FreeBSD+Ports+15.0.quarterly>

home | help