// Copyright 2013 Xamarin Inc. All rights reserved.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Xml.Linq;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

using MonoTouch.Tuner;

using Mono.Cecil;
using Mono.Tuner;
using Xamarin.Linker;

using Xamarin.Utils;
using Xamarin.MacDev;

namespace Xamarin.Bundler {

	public enum BitCodeMode {
		None = 0,
		ASMOnly = 1,
		LLVMOnly = 2,
		MarkerOnly = 3,
	}

	[Flags]
	public enum Abi {
		None   =   0,
		i386   =   1,
		ARMv6  =   2,
		ARMv7  =   4,
		ARMv7s =   8,
		ARM64 =   16,
		x86_64 =  32,
		Thumb  =  64,
		LLVM   = 128,
		ARMv7k = 256,
		SimulatorArchMask = i386 | x86_64,
		DeviceArchMask = ARMv6 | ARMv7 | ARMv7s | ARMv7k | ARM64,
		ArchMask = SimulatorArchMask | DeviceArchMask,
		Arch64Mask = x86_64 | ARM64,
		Arch32Mask = i386 | ARMv6 | ARMv7 | ARMv7s | ARMv7k,
	}

	public static class AbiExtensions {
		public static string AsString (this Abi self)
		{
			var rv = (self & Abi.ArchMask).ToString ();
			if ((self & Abi.LLVM) == Abi.LLVM)
				rv += "+LLVM";
			if ((self & Abi.Thumb) == Abi.Thumb)
				rv += "+Thumb";
			return rv;
		}

		public static string AsArchString (this Abi self)
		{
			return (self & Abi.ArchMask).ToString ().ToLowerInvariant ();
		}
	}

	public enum RegistrarMode {
		Default,
		Legacy,
		Dynamic,
		Static,
		LegacyStatic,
		LegacyDynamic,
	}

	public enum BuildTarget {
		Simulator,
		Device,
	}

	public enum DlsymOptions
	{
		Default,
		All,
		None,
		Custom,
	}

	public partial class Application
	{
		public string ExecutableName;
		public string RootAssembly;
		public BuildTarget BuildTarget;

		public Version DeploymentTarget;
		public bool EnableCxx;
		public bool EnableProfiling;
		bool? package_mdb;
		public bool PackageMdb {
			get { return package_mdb.Value; }
			set { package_mdb = value; }
		}
		bool? enable_msym;
		public bool EnableMSym {
			get { return enable_msym.Value; }
			set { enable_msym = value; }
		}
		public bool EnableRepl;

		public bool IsExtension;
		public List<string> Extensions = new List<string> (); // A list of the extensions this app contains.

		public bool FastDev;
		public string RegistrarOutputLibrary;

		public bool? EnablePie;
		public bool NativeStrip = true;
		public string SymbolList;
		public bool ManagedStrip = true;
		public List<string> NoSymbolStrip = new List<string> ();
		
		public bool? ThreadCheck;
		public DlsymOptions DlsymOptions;
		public List<Tuple<string, bool>> DlsymAssemblies;
		public bool? UseMonoFramework;
		public bool? PackageMonoFramework;

		//
		// Linker config
		//

		public bool LinkAway = true;
		public bool LinkerDumpDependencies { get; set; }
		public List<string> References = new List<string> ();
		
		public bool? BuildDSym;
		bool? generate_manifests;
		public bool GenerateManifests {
			get { return generate_manifests.Value; }
			set { generate_manifests = value; }
		}
		bool? sign;
		public bool Sign {
			get { return sign.Value; }
			set { sign = value; }
		}
		public bool Is32Build { get { return IsArchEnabled (Abi.Arch32Mask); } } // If we're targetting a 32 bit arch.
		public bool Is64Build { get { return IsArchEnabled (Abi.Arch64Mask); } } // If we're targetting a 64 bit arch.
		public bool IsDualBuild { get { return Is32Build && Is64Build; } } // if we're building both a 32 and a 64 bit version.
		public bool IsUnified { get { return !IsClassic; } } // this is true for watch
		public bool IsClassic { get { return Driver.TargetFramework.Identifier == "MonoTouch"; } }
		public bool IsLLVM { get { return IsArchEnabled (Abi.LLVM); } }

		public List<Target> Targets = new List<Target> ();

		//
		// Bundle config
		//
		public string BundleDisplayName;
		public string BundleId = "com.yourcompany.sample";
		public string MainNib = "MainWindow";
		public string Icon;
		public string CertificateName;

		public string UserGccFlags;

		// If we didn't link the final executable because the existing binary is up-to-date.
		bool cached_executable; 

		List<Abi> abis;
		HashSet<Abi> all_architectures; // all Abis used in the app, including extensions.

		public void ParseDlsymOptions (string options)
		{
			bool dlsym;
			if (Driver.TryParseBool (options, out dlsym)) {
				DlsymOptions = dlsym ? DlsymOptions.All : DlsymOptions.None;
			} else {
				DlsymAssemblies = new List<Tuple<string, bool>> ();

				var assemblies = options.Split (',');
				foreach (var assembly in assemblies) {
					var asm = assembly;
					if (assembly.StartsWith ("+")) {
						dlsym = true;
						asm = assembly.Substring (1);
					} else if (assembly.StartsWith ("-")) {
						dlsym = false;
						asm = assembly.Substring (1);
					} else {
						dlsym = true;
					}
					DlsymAssemblies.Add (new Tuple<string, bool> (Path.GetFileNameWithoutExtension (asm), dlsym));
				}

				DlsymOptions = DlsymOptions.Custom;
			}
		}

		public bool UseDlsym (string assembly)
		{
			string asm;

			switch (DlsymOptions) {
			case DlsymOptions.All:
				return true;
			case DlsymOptions.None:
				return false;
			}

			if (DlsymAssemblies != null) {
				asm = Path.GetFileNameWithoutExtension (assembly);
				foreach (var tuple in DlsymAssemblies) {
					if (string.Equals (tuple.Item1, asm, StringComparison.Ordinal))
						return tuple.Item2;
				}
			}

			if (EnableLLVMOnlyBitCode)
				return false;

			switch (Platform) {
			case ApplePlatform.iOS:
				return !Profile.IsSdkAssembly (Path.GetFileNameWithoutExtension (assembly));
			case ApplePlatform.TVOS:
			case ApplePlatform.WatchOS:
				return false;
			default:
				throw ErrorHelper.CreateError (71, "Unknown platform: {0}. This usually indicates a bug in Xamarin.iOS; please file a bug report at http://bugzilla.xamarin.com with a test case.", Platform);
			}
		}

		public string MonoGCParams {
			get {
				// Configure sgen to use a small nursery
				if (IsTodayExtension) {
					return "nursery-size=512k,soft-heap-limit=8m";
				} else if (Platform == ApplePlatform.WatchOS) {
					// A bit test shows different behavior
					// Sometimes apps are killed with ~100mb allocated,
					// but I've seen apps allocate up to 240+mb as well
					return "nursery-size=512k,soft-heap-limit=8m";
				} else {
					return "nursery-size=512k";
				}
			}
		}

		public bool IsDeviceBuild { 
			get { return BuildTarget == BuildTarget.Device; } 
		}

		public bool IsSimulatorBuild { 
			get { return BuildTarget == BuildTarget.Simulator; } 
		}

		public IEnumerable<Abi> Abis {
			get { return abis; }
		}

		public BitCodeMode BitCodeMode { get; set; }

		public bool EnableAsmOnlyBitCode { get { return BitCodeMode == BitCodeMode.ASMOnly; } }
		public bool EnableLLVMOnlyBitCode { get { return BitCodeMode == BitCodeMode.LLVMOnly; } }
		public bool EnableMarkerOnlyBitCode { get { return BitCodeMode == BitCodeMode.MarkerOnly; } }
		public bool EnableBitCode { get { return BitCodeMode != BitCodeMode.None; } }

		public ICollection<Abi> AllArchitectures {
			get {
				if (all_architectures == null) {
					all_architectures = new HashSet<Abi> ();
					foreach (var abi in abis)
						all_architectures.Add (abi & Abi.ArchMask);
					foreach (var ext in Extensions) {
						var executable = GetStringFromInfoPList (ext, "CFBundleExecutable");
						if (string.IsNullOrEmpty (executable))
							throw ErrorHelper.CreateError (63, "Cannot find the executable in the extension {0} (no CFBundleExecutable entry in its Info.plist)", ext);
						foreach (var abi in Xamarin.MachO.GetArchitectures (Path.Combine (ext, executable)))
							all_architectures.Add (abi);
					}
				}
				return all_architectures;
			}
		}

		public bool IsTodayExtension {
			get {
				return ExtensionIdentifier == "com.apple.widget-extension";
			}
		}

		public bool IsWatchExtension {
			get {
				return ExtensionIdentifier == "com.apple.watchkit";
			}
		}

		public bool IsTVExtension {
			get {
				return ExtensionIdentifier == "com.apple.tv-services";
			}
		}

		public string ExtensionIdentifier {
			get {
				if (!IsExtension)
					return null;

				var info_plist = Path.Combine (AppDirectory, "Info.plist");
				var plist = Driver.FromPList (info_plist);
				var dict = plist.Get<PDictionary> ("NSExtension");
				if (dict == null)
					return null;
				return dict.GetString ("NSExtensionPointIdentifier");
			}
		}

		string GetStringFromInfoPList (string key)
		{
			return GetStringFromInfoPList (AppDirectory, "Info.plist");
		}

		string GetStringFromInfoPList (string directory, string key)
		{
			var info_plist = Path.Combine (directory, "Info.plist");
			if (!File.Exists (info_plist))
				return null;

			var plist = Driver.FromPList (info_plist);
			if (!plist.ContainsKey (key))
				return null;
			return plist.GetString (key);
		}

		public void SetDefaultAbi ()
		{
			if (abis == null)
				abis = new List<Abi> ();
			
			switch (Platform) {
			case ApplePlatform.iOS:
				if (abis.Count == 0) {
					abis.Add (IsDeviceBuild ? Abi.ARMv7 : Abi.i386);
				}
				break;
			case ApplePlatform.WatchOS:
				if (abis.Count == 0)
					throw ErrorHelper.CreateError (76, "No architecture specified (using the --abi argument). An architecture is required for {0} projects.", "Xamarin.WatchOS");
				break;
			case ApplePlatform.TVOS:
				if (abis.Count == 0)
					throw ErrorHelper.CreateError (76, "No architecture specified (using the --abi argument). An architecture is required for {0} projects.", "Xamarin.TVOS");
				break;
			default:
				throw ErrorHelper.CreateError (71, "Unknown platform: {0}. This usually indicates a bug in Xamarin.iOS; please file a bug report at http://bugzilla.xamarin.com with a test case.", Platform);
			}
		}

		public void ValidateAbi ()
		{
			var validAbis = new List<Abi> ();
			switch (Platform) {
			case ApplePlatform.iOS:
				if (IsDeviceBuild) {
					validAbis.Add (Abi.ARMv7);
					validAbis.Add (Abi.ARMv7 | Abi.Thumb);
					validAbis.Add (Abi.ARMv7 | Abi.LLVM);
					validAbis.Add (Abi.ARMv7 | Abi.LLVM | Abi.Thumb);
					validAbis.Add (Abi.ARMv7s);
					validAbis.Add (Abi.ARMv7s | Abi.Thumb);
					validAbis.Add (Abi.ARMv7s | Abi.LLVM);
					validAbis.Add (Abi.ARMv7s | Abi.LLVM | Abi.Thumb);
				} else {
					validAbis.Add (Abi.i386);
				}
				if (IsUnified) {
					if (IsDeviceBuild) {
						validAbis.Add (Abi.ARM64);
						validAbis.Add (Abi.ARM64 | Abi.LLVM);
					} else {
						validAbis.Add (Abi.x86_64);
					}
				}
				break;
			case ApplePlatform.WatchOS:
				if (IsDeviceBuild) {
					validAbis.Add (Abi.ARMv7k);
					validAbis.Add (Abi.ARMv7k | Abi.LLVM);
				} else {
					validAbis.Add (Abi.i386);
				}
				break;
			case ApplePlatform.TVOS:
				if (IsDeviceBuild) {
					validAbis.Add (Abi.ARM64);
					validAbis.Add (Abi.ARM64 | Abi.LLVM);
				} else {
					validAbis.Add (Abi.x86_64);
				}
				break;
			default:
				throw ErrorHelper.CreateError (71, "Unknown platform: {0}. This usually indicates a bug in Xamarin.iOS; please file a bug report at http://bugzilla.xamarin.com with a test case.", Platform);
			}

			foreach (var abi in abis) {
				if (!validAbis.Contains (abi))
					throw ErrorHelper.CreateError (75, "Invalid architecture '{0}' for {1} projects. Valid architectures are: {2}", abi, Platform, string.Join (", ", validAbis.Select ((v) => v.AsString ()).ToArray ()));
			}
		}

		public void ClearAbi ()
		{
			abis = null;
		}

		// This is to load the symbols for all assemblies, so that we can give better error messages
		// (with file name / line number information).
		public void LoadSymbols ()
		{
			foreach (var t in Targets)
				t.LoadSymbols ();
		}

		public void ParseAbi (string abi)
		{
			var res = new List<Abi> ();
			foreach (var str in abi.Split (new char [] { ',' }, StringSplitOptions.RemoveEmptyEntries)) {
				Abi value;
				switch (str) {
				case "i386":
					value = Abi.i386;
					break;
				case "x86_64":
					value = Abi.x86_64;
					break;
				case "armv7":
					value = Abi.ARMv7;
					break;
				case "armv7+llvm":
					value = Abi.ARMv7 | Abi.LLVM;
					break;
				case "armv7+llvm+thumb2":
					value = Abi.ARMv7 | Abi.LLVM | Abi.Thumb;
					break;
				case "armv7s":
					value = Abi.ARMv7s;
					break;
				case "armv7s+llvm":
					value = Abi.ARMv7s | Abi.LLVM;
					break;
				case "armv7s+llvm+thumb2":
					value = Abi.ARMv7s | Abi.LLVM | Abi.Thumb;
					break;
				case "arm64":
					value = Abi.ARM64;
					break;
				case "arm64+llvm":
					value = Abi.ARM64 | Abi.LLVM;
					break;
				case "armv7k":
					value = Abi.ARMv7k;
					break;
				case "armv7k+llvm":
					value = Abi.ARMv7k | Abi.LLVM;
					break;
				default:
					throw new MonoTouchException (15, true, "Invalid ABI: {0}. Supported ABIs are: i386, x86_64, armv7, armv7+llvm, armv7+llvm+thumb2, armv7s, armv7s+llvm, armv7s+llvm+thumb2, armv7k, armv7k+llvm, arm64 and arm64+llvm.", str);
				}

				// merge this value with any existing ARMv? already specified.
				// this is so that things like '--armv7 --thumb' work correctly.
				if (abis != null) {
					for (int i = 0; i < abis.Count; i++) {
						if ((abis [i] & Abi.ArchMask) == (value & Abi.ArchMask)) {
							value |= abis [i];
							break;
						}
					}
				}

				res.Add (value);
			}

			// We replace any existing abis, to keep the old behavior where '--armv6 --armv7' would 
			// enable only the last abi specified and disable the rest.
			abis = res;
		}

		public static string GetArchitectures (IEnumerable<Abi> abis)
		{
			var res = new List<string> ();

			foreach (var abi in abis)
				res.Add (abi.AsArchString ());

			return string.Join (", ", res.ToArray ());
		}

		public bool IsArchEnabled (Abi arch)
		{
			return IsArchEnabled (abis, arch);
		}

		public static bool IsArchEnabled (IEnumerable<Abi> abis, Abi arch)
		{
			foreach (var abi in abis) {
				if ((abi & arch) != 0)
					return true;
			}
			return false;
		}

		public void RunRegistrar ()
		{
			// The static registrar.
			if (Registrar != RegistrarMode.Static)
				throw new MonoTouchException (67, "Invalid registrar: {0}", Registrar); // this is only called during our own build

			var registrar_m = RegistrarOutputLibrary;

			var resolvedAssemblies = new List<AssemblyDefinition> ();
			var ps = new ReaderParameters ();
			ps.AssemblyResolver = new MonoTouchResolver () {
				FrameworkDirectory = Driver.PlatformFrameworkDirectory,
				RootDirectory = Path.GetDirectoryName (RootAssembly),
			};
			resolvedAssemblies.Add (ps.AssemblyResolver.Resolve ("mscorlib"));

			var rootName = Path.GetFileNameWithoutExtension (RootAssembly);
			switch (rootName) {
			// MonoTouch.NUnitLite doesn't quite work yet, because its generated registrar code uses types
			// from the generated registrar code for MonoTouch.Dialog-1 (and there is no header file (yet)
			// for those types).
//			case "MonoTouch.NUnitLite":
//				resolvedAssemblies.Add (ps.AssemblyResolver.Resolve (rootName));
//				goto case "MonoTouch.Dialog-1";
			case "MonoTouch.Dialog-1":
				resolvedAssemblies.Add (ps.AssemblyResolver.Resolve (rootName));
				resolvedAssemblies.Add (ps.AssemblyResolver.Resolve (Driver.ProductAssembly));
				break;
			default:
				if (rootName == Driver.ProductAssembly) {
					resolvedAssemblies.Add (ps.AssemblyResolver.Resolve (rootName));
				} else {
					throw new MonoTouchException (66, "Invalid build registrar assembly: {0}", RootAssembly);
				}
				break;
			}

			BuildTarget = BuildTarget.Simulator;

			var registrar = new XamCore.Registrar.StaticRegistrar (this);
			registrar.GenerateSingleAssembly (resolvedAssemblies, Path.ChangeExtension (registrar_m, "h"), registrar_m, Path.GetFileNameWithoutExtension (RootAssembly));
		}

		public void Build ()
		{
			if (Driver.Force) {
				Driver.Log (3, "A full rebuild has been forced by the command line argument -f.");
				Cache.Clean ();
			} else if (!Cache.VerifyCache ()) {
				Driver.Force = true;
			}

			Initialize ();
			ValidateAbi ();
			SelectRegistrar ();
			ExtractNativeLinkInfo ();
			SelectNativeCompiler ();
			BuildApp ();
			WriteNotice ();
			BuildFatSharedLibraries ();
			CopyAotData ();
			BuildFinalExecutable ();
			BuildDsymDirectory ();
			BuildMSymDirectory ();
			StripNativeCode ();
			StripManagedCode ();
			GenerateAppManifests ();
			GenerateRuntimeOptions ();
			SignBundle ();

			if (Cache.IsCacheTemporary) {
				// If we used a temporary directory we created ourselves for the cache
				// (in which case it's more a temporary location where we store the 
				// temporary build products than a cache), it will not be used again,
				// so just delete it.
				try {
					Directory.Delete (Cache.Location, true);
				} catch {
					// Don't care.
				}
			} else {
				// Write the cache data as the last step, so there is no half-done/incomplete (but yet detected as valid) cache.
				Cache.ValidateCache ();
			}

			Console.WriteLine ("{0} built successfully.", AppDirectory);
		}

		bool implicit_monotouch_reference;
		public void SetDefaultFramework ()
		{
			// If no target framework was specified, check if we're referencing Xamarin.iOS.dll or monotouch.dll,
			// and then deduce the target framework.
			if (!Driver.HasTargetFramework) {
				foreach (var reference in References) {
					var name = Path.GetFileName (reference);
					switch (name) {
					case "monotouch.dll":
						Driver.TargetFramework = TargetFramework.MonoTouch_1_0;
						break;
					case "Xamarin.iOS.dll":
						Driver.TargetFramework = TargetFramework.Xamarin_iOS_1_0;
						break;
					case "Xamarin.TVOS.dll":
					case "Xamarin.WatchOS.dll":
						throw ErrorHelper.CreateError (86, "A target framework (--target-framework) must be specified when building for TVOS or WatchOS.");
					}

					if (Driver.HasTargetFramework)
						break;
				}
			}

			// Still nothing. Default to monotouch.dll.
			if (!Driver.HasTargetFramework) {
				implicit_monotouch_reference = true;
				Driver.TargetFramework = TargetFramework.MonoTouch_1_0;
				References.Add (Path.Combine (Driver.PlatformFrameworkDirectory, "monotouch.dll"));
			}
		}

		void Initialize ()
		{
			if (!File.Exists (RootAssembly))
				throw new MonoTouchException (7, true, "The root assembly '{0}' does not exist", RootAssembly);

			if (implicit_monotouch_reference)
				ErrorHelper.Warning (42, "No reference to either monotouch.dll or Xamarin.iOS.dll was found. A reference to monotouch.dll will be added.");
			
			// Add a reference to the platform assembly if none has been added, and check that we're not referencing
			// any platform assemblies from another platform.
			var platformAssemblyReference = false;
			foreach (var reference in References) {
				var name = Path.GetFileNameWithoutExtension (reference);
				if (name == Driver.ProductAssembly) {
					platformAssemblyReference = true;
				} else {
					switch (name) {
					case "monotouch":
					case "Xamarin.iOS":
					case "Xamarin.TVOS":
					case "Xamarin.WatchOS":
						throw ErrorHelper.CreateError (41, "Cannot reference '{0}' in a {1} app.", Path.GetFileName (reference), Driver.TargetFramework.Identifier);
					}
				}
			}
			if (!platformAssemblyReference) {
				ErrorHelper.Warning (85, "No reference to '{0}' was found. It will be added automatically.", Driver.ProductAssembly + ".dll");
				References.Add (Path.Combine (Driver.PlatformFrameworkDirectory, Driver.ProductAssembly + ".dll"));
			}

			var FrameworkDirectory = Driver.PlatformFrameworkDirectory;
			var RootDirectory = Path.GetDirectoryName (Path.GetFullPath (RootAssembly));

			((MonoTouchProfile) Profile.Current).SetProductAssembly (Driver.ProductAssembly);

			string root_wo_ext = Path.GetFileNameWithoutExtension (RootAssembly);
			if (Profile.IsSdkAssembly (root_wo_ext) || Profile.IsProductAssembly (root_wo_ext))
				throw new MonoTouchException (3, true, "Application name '{0}.exe' conflicts with an SDK or product assembly (.dll) name.", root_wo_ext);

			if (IsDualBuild) {
				var target32 = new Target (this);
				var target64 = new Target (this);

				target32.ArchDirectory = Path.Combine (Cache.Location, "32");
				target32.TargetDirectory = IsSimulatorBuild ? Path.Combine (AppDirectory, ".monotouch-32") : Path.Combine (target32.ArchDirectory, "Output");
				target32.AppTargetDirectory = Path.Combine (AppDirectory, ".monotouch-32");
				target32.Resolver.ArchDirectory = Path.Combine (Driver.PlatformFrameworkDirectory, "..", "..", "32bits");
				target32.Abis = SelectAbis (abis, Abi.Arch32Mask);

				target64.ArchDirectory = Path.Combine (Cache.Location, "64");
				target64.TargetDirectory = IsSimulatorBuild ? Path.Combine (AppDirectory, ".monotouch-64") : Path.Combine (target64.ArchDirectory, "Output");
				target64.AppTargetDirectory = Path.Combine (AppDirectory, ".monotouch-64");
				target64.Resolver.ArchDirectory = Path.Combine (Driver.PlatformFrameworkDirectory, "..", "..", "64bits");
				target64.Abis = SelectAbis (abis, Abi.Arch64Mask);

				Targets.Add (target64);
				Targets.Add (target32);
			} else {
				var target = new Target (this);

				target.TargetDirectory = AppDirectory;
				target.AppTargetDirectory = (IsSimulatorBuild || IsClassic) ? AppDirectory : Path.Combine (AppDirectory, Is64Build ? ".monotouch-64" : ".monotouch-32");
				target.ArchDirectory = Cache.Location;
				if (IsClassic) {
					target.Resolver.ArchDirectory = Driver.PlatformFrameworkDirectory;
				} else {
					target.Resolver.ArchDirectory = Path.Combine (Driver.PlatformFrameworkDirectory, "..", "..", Is32Build ? "32bits" : "64bits");
				}
				target.Abis = abis;

				Targets.Add (target);

				// Make sure there aren't any lingering .monotouch-* directories.
				if (IsSimulatorBuild) {
					var dir = Path.Combine (AppDirectory, ".monotouch-32");
					if (Directory.Exists (dir))
						Directory.Delete (dir, true);
					dir = Path.Combine (AppDirectory, ".monotouch-64");
					if (Directory.Exists (dir))
						Directory.Delete (dir, true);
				}
			}

			foreach (var target in Targets) {
				target.Resolver.FrameworkDirectory = Driver.PlatformFrameworkDirectory;
				target.Resolver.RootDirectory = RootDirectory;
				target.Resolver.EnableRepl = EnableRepl;
				target.ManifestResolver.EnableRepl = EnableRepl;
				target.ManifestResolver.FrameworkDirectory = target.Resolver.FrameworkDirectory;
				target.ManifestResolver.RootDirectory = target.Resolver.RootDirectory;
				target.ManifestResolver.ArchDirectory = target.Resolver.ArchDirectory;
				target.Initialize (target == Targets [0]);

				if (!Directory.Exists (target.TargetDirectory))
					Directory.CreateDirectory (target.TargetDirectory);
			}

			if (string.IsNullOrEmpty (ExecutableName)) {
				var bundleExecutable = GetStringFromInfoPList ("CFBundleExecutable");
				ExecutableName = bundleExecutable ?? Path.GetFileNameWithoutExtension (RootAssembly);
			}

			if (ExecutableName != Path.GetFileNameWithoutExtension (AppDirectory))
				ErrorHelper.Warning (30, "The executable name ({0}) and the app name ({1}) are different, this may prevent crash logs from getting symbolicated properly.",
					ExecutableName, Path.GetFileName (AppDirectory));
			
			if (Is64Build && IsClassic)
				ErrorHelper.Error (37, "monotouch.dll is not 64-bit compatible. Either reference Xamarin.iOS.dll, or do not build for a 64-bit architecture (ARM64 or x86_64).");

			if (IsExtension && Platform == ApplePlatform.iOS && Driver.SDKVersion < new Version (8, 0))
				throw new MonoTouchException (45, true, "--extension is only supported when using the iOS 8.0 (or later) SDK.");

			if (IsExtension && Platform != ApplePlatform.iOS && Platform != ApplePlatform.WatchOS && Platform != ApplePlatform.TVOS)
				throw new MonoTouchException (72, true, "Extensions are not supported for the platform '{0}'.", Platform);

			if (!IsExtension && Platform == ApplePlatform.WatchOS)
				throw new MonoTouchException (77, true, "WatchOS projects must be extensions.");
		
#if ENABLE_BITCODE_ON_IOS
			if (Platform == ApplePlatform.iOS)
				DeploymentTarget = new Version (9, 0);
#endif

			if (DeploymentTarget == null) {
				DeploymentTarget = Xamarin.SdkVersions.GetVersion (Platform);
			} else if (DeploymentTarget < Xamarin.SdkVersions.GetMinVersion (Platform)) {
				throw new MonoTouchException (73, true, "Xamarin.iOS {0} does not support a deployment target of {1} for {3} (the minimum is {2}). Please select a newer deployment target in your project's Info.plist.", Constants.Version, DeploymentTarget, Xamarin.SdkVersions.GetMinVersion (Platform), PlatformName);
			} else if (DeploymentTarget > Xamarin.SdkVersions.GetVersion (Platform)) {
				throw new MonoTouchException (74, true, "Xamarin.iOS {0} does not support a deployment target of {1} for {3} (the maximum is {2}). Please select an older deployment target in your project's Info.plist or upgrade to a newer version of Xamarin.iOS.", Constants.Version, DeploymentTarget, Xamarin.SdkVersions.GetVersion (Platform), PlatformName);
			}

			if (Platform == ApplePlatform.iOS && FastDev && DeploymentTarget.Major < 8) {
				ErrorHelper.Warning (78, "Incremental builds are enabled with a deployment target < 8.0 (currently {0}). This is not supported (the resulting application will not launch on iOS 9), so the deployment target will be set to 8.0.", DeploymentTarget);
				DeploymentTarget = new Version (8, 0);
			}

			if (Driver.classic_only_arguments.Count > 0) {
				var exceptions = new List<Exception> ();
				foreach (var deprecated in Driver.classic_only_arguments) {
					switch (deprecated) {
					case "--nomanifest":
					case "--nosign":
						// These options default to 'true' (for Classic), so we can't deprecated them (for Classic).
						if (IsClassic)
							continue;
						break;
					}
					exceptions.Add (new MonoTouchException (16, IsUnified, "The option '{0}' has been deprecated.", deprecated));
				}
				ErrorHelper.Show (exceptions);
			}

			if (!generate_manifests.HasValue)
				generate_manifests = IsClassic;

			if (!sign.HasValue)
				sign = IsClassic;

			if (!package_mdb.HasValue) {
				package_mdb = EnableDebug;
			} else if (package_mdb.Value && IsLLVM) {
				ErrorHelper.Warning (3007, "Debug info files (*.mdb) will not be loaded when llvm is enabled.");
			}

			if (!enable_msym.HasValue)
				enable_msym = !EnableDebug && IsDeviceBuild;

			if (!UseMonoFramework.HasValue && DeploymentTarget >= new Version (8, 0)) {
				if (IsExtension) {
					if (IsUnified) {
						UseMonoFramework = true;
						Driver.Log (2, "Automatically linking with Mono.framework because this is an extension");
					}
				} else if (IsUnified) {
					if (Extensions.Count > 0) {
						UseMonoFramework = true;
						Driver.Log (2, "Automatically linking with Mono.framework because this is an app with extensions");
					}
				}
			}

			if (!UseMonoFramework.HasValue)
				UseMonoFramework = false;
			
			if (UseMonoFramework.Value)
				Frameworks.Add (Path.Combine (Driver.ProductFrameworksDirectory, "Mono.framework"));

			if (!PackageMonoFramework.HasValue) {
				if (!IsExtension && Extensions.Count > 0 && !UseMonoFramework.Value) {
					// The main app must package the Mono framework if we have extensions, even if it's not linking with
					// it. This happens when deployment target < 8.0 for the main app.
					PackageMonoFramework = true;
				} else {
					// Package if we're not an extension and we're using the mono framework.
					PackageMonoFramework = UseMonoFramework.Value && !IsExtension;
				}
			}

			if (Frameworks.Count > 0) {
				if (DeploymentTarget < new Version (8, 0))
					throw ErrorHelper.CreateError (65, "Xamarin.iOS only supports embedded frameworks when deployment target is at least 8.0 (current deployment target: '{0}'; embedded frameworks: '{1}')", DeploymentTarget, string.Join (", ", Frameworks.ToArray ()));

				if (IsClassic)
					throw ErrorHelper.CreateError (64, "Xamarin.iOS only supports embedded frameworks with Unified projects.");
			}

			if (IsDeviceBuild) {
				switch (BitCodeMode) {
				case BitCodeMode.ASMOnly:
					if (Platform == ApplePlatform.WatchOS)
						throw ErrorHelper.CreateError (83, "asm-only bitcode is not supported on watchOS. Use either --bitcode:marker or --bitcode:full.");
					break;
				case BitCodeMode.LLVMOnly:
				case BitCodeMode.MarkerOnly:
					break;
				case BitCodeMode.None:
					// If neither llvmonly nor asmonly is enabled, enable markeronly.
					if (Platform == ApplePlatform.TVOS || Platform == ApplePlatform.WatchOS)
						BitCodeMode = BitCodeMode.MarkerOnly;
					break;
				}
			}

			if (EnableBitCode && IsSimulatorBuild)
				throw ErrorHelper.CreateError (84, "Bitcode is not supported in the simulator. Do not pass --bitcode when building for the simulator.");

			if (LinkMode == LinkMode.None && Driver.SDKVersion < SdkVersions.GetVersion (Platform))
				throw ErrorHelper.CreateError (91, "This version of Xamarin.iOS requires the {0} {1} SDK (shipped with Xcode {2}) when the managed linker is disabled. Either upgrade Xcode, or enable the managed linker.", PlatformName, SdkVersions.GetVersion (Platform), SdkVersions.Xcode);

			Namespaces.Initialize ();

			InitializeCommon ();

			Driver.Watch ("Resolve References", 1);
		}
		
		void SelectRegistrar ()
		{
			if (IsUnified) {
				// The old registrars are not implemented when using Xamarin.iOS.dll.
				if (Registrar == RegistrarMode.LegacyStatic || Registrar == RegistrarMode.LegacyDynamic || Registrar == RegistrarMode.Legacy)
					throw new MonoTouchException (38, true, "The legacy registrars (--registrar:legacy|legacystatic|legacydynamic) are not supported with the Unified API.");
			}

			// If the default values are changed, remember to update CanWeSymlinkTheApplication
			// and main.m (default value for xamarin_use_old_dynamic_registrar must match).
			if (Driver.enable_generic_nsobject && Registrar != RegistrarMode.Default)
				throw new MonoTouchException (22, true, "The options '--unsupported--enable-generics-in-registrar' and '--registrar' are not compatible.");

			if (Registrar == RegistrarMode.Default) {
				if (IsDeviceBuild) {
					Registrar = RegistrarMode.Static;
				} else { /* if (app.IsSimulatorBuild) */
					Registrar = RegistrarMode.Dynamic;
				}
			} else if (Registrar == RegistrarMode.Legacy) {
				if (IsDeviceBuild) {
					Registrar = RegistrarMode.LegacyStatic;
				} else { /* if (app.IsSimulatorBuild) */
					Registrar = RegistrarMode.LegacyDynamic;
				}
			}

			foreach (var target in Targets)
				target.SelectStaticRegistrar ();
		}

		// Select all abi from the list matching the specified mask.
		List<Abi> SelectAbis (IEnumerable<Abi> abis, Abi mask)
		{
			var rv = new List<Abi> ();
			foreach (var abi in abis) {
				if ((abi & mask) != 0)
					rv.Add (abi);
			}
			return rv;
		}

		public string AssemblyName {
			get {
				return Path.GetFileName (RootAssembly);
			}
		}

		public string Executable {
			get {
				return Path.Combine (AppDirectory, ExecutableName);
			}
		}

		void ManagedLink ()
		{
			foreach (var target in Targets)
				target.ManagedLink ();
		}

		void BuildApp ()
		{
			foreach (var target in Targets)	{
				if (target.CanWeSymlinkTheApplication ()) {
					target.Symlink ();
				} else {
					target.ProcessAssemblies ();
				}
			}

			// Deduplicate files from the Build directory. We need to do this before the AOT
			// step, so that we can ignore timestamp/GUID in assemblies (the GUID is
			// burned into the AOT assembly, so after that we'll need the original assembly.
			if (IsDualBuild && IsDeviceBuild && !Sign) {
				// All the assemblies are now in BuildDirectory.
				var t1 = Targets [0];
				var t2 = Targets [1];

				foreach (var f1 in Directory.GetFileSystemEntries (t1.BuildDirectory)) {
					var f2 = Path.Combine (t2.BuildDirectory, Path.GetFileName (f1));
					if (!File.Exists (f2))
						continue;
					var ext = Path.GetExtension (f1).ToUpperInvariant ();
					var is_assembly = ext == ".EXE" || ext == ".DLL";
					if (!is_assembly)
						continue;

					if (!Cache.CompareAssemblies (f1, f2, true))
						continue;
						
					if (Driver.Verbosity > 0)
						Console.WriteLine ("Targets {0} and {1} found to be identical", f1, f2);
					// Don't use symlinks, since it just gets more complicated
					// For instance: on rebuild, when should the symlink be updated and when
					// should the target of the symlink be updated? And all the usages
					// must be audited to ensure the right thing is done...
					Driver.CopyAssembly (f1, f2);
				}
			}

			foreach (var target in Targets) {
				if (target.CanWeSymlinkTheApplication ())
					continue;

				target.ComputeLinkerFlags ();
				target.Compile ();
				target.NativeLink ();
			}
		}

		void WriteNotice ()
		{
			if (!IsDeviceBuild)
				return;

			if (Directory.Exists (Path.Combine (AppDirectory, "NOTICE")))
				throw new MonoTouchException (1016, true, "Failed to create the NOTICE file because a directory already exists with the same name.");

			try {
				// write license information inside the .app
				StringBuilder sb = new StringBuilder ();
				sb.Append ("Xamarin built applications contain open source software.  ");
				sb.Append ("For detailed attribution and licensing notices, please visit...");
				sb.AppendLine ().AppendLine ().Append ("http://xamarin.com/mobile-licensing").AppendLine ();
				var filename = Path.Combine (AppDirectory, "NOTICE");
				if (!File.Exists (filename) || File.ReadAllText (filename) != sb.ToString ()) {
					File.WriteAllText (Path.Combine (AppDirectory, "NOTICE"), sb.ToString ());
					Driver.Log (3, "Wrote '{0}'.", filename);
				} else {
					Driver.Log (3, "Target '{0}' is up-to-date.", filename);
				}
			} catch (Exception ex) {
				throw new MonoTouchException (1017, true, ex, "Failed to create the NOTICE file: {0}", ex.Message);
			}
		}

		void BuildFatSharedLibraries ()
		{
			// Create shared fat libraries.
			if (!FastDev)
				return;

			var hash = new Dictionary<string, List<string>> ();
			foreach (var target in Targets) {
				foreach (var a in target.Assemblies) {
					List<string> dylibs;

					if (a.Dylibs == null || a.Dylibs.Count () == 0)
						continue;

					if (!hash.TryGetValue (a.Dylib, out dylibs)) {
						dylibs = new List<string> ();
						hash [a.Dylib] = dylibs;
					}
					dylibs.AddRange (a.Dylibs);

					target.LinkWith (a.Dylib);
				}
			}

			foreach (var kvp in hash) {
				var dylib = kvp.Key;
				var dylibs = kvp.Value;
				if (!Application.IsUptodate (dylibs, new string [] { dylib })) {
					var cmd = new StringBuilder ();
					foreach (var lib in dylibs) {
						cmd.Append (Driver.Quote (lib));
						cmd.Append (' ');
					}
					cmd.Append ("-create -output ");
					cmd.Append (Driver.Quote (dylib));
					Driver.RunLipo (cmd.ToString ());
				} else {
					Driver.Log (3, "Target '{0}' is up-to-date.", dylib);
				}
			}
		}

		void CopyAotData ()
		{
			if (!IsDeviceBuild)
				return;

			foreach (var target in Targets) {
				foreach (var a in target.Assemblies) {
					foreach (var data in a.AotDataFiles) {
						Application.UpdateFile (data, Path.Combine (target.AppTargetDirectory, Path.GetFileName (data)));
					}
				}
			}
		}

		public static void CopyMSymData (string src, string dest)
		{
			if (string.IsNullOrEmpty (src) || string.IsNullOrEmpty (dest))
				return;
			if (!Directory.Exists (src)) // got no aot data
				return;

			var p = new Process ();
			p.StartInfo.UseShellExecute = false;
			p.StartInfo.RedirectStandardError = true;
			p.StartInfo.FileName = "mono-symbolicate";
			p.StartInfo.Arguments = $"store-symbols \"{src}\" \"{dest}\"";

			try {
				if (p.Start ()) {
					var error = p.StandardError.ReadToEnd();
					p.WaitForExit ();
					if (p.ExitCode == 0)
						return;
					else {
						ErrorHelper.Warning (95, $"Aot files could not be copied to the destination directory {dest}: {error}"); 
						return;
					}
				}

				ErrorHelper.Warning (95, $"Aot files could not be copied to the destination directory {dest}: Could not start process."); 
				return;
			}
			catch (Exception e) {
				ErrorHelper.Warning (95, e, $"Aot files could not be copied to the destination directory {dest}: Could not start process."); 
				return;
			}
		}

		void BuildFinalExecutable ()
		{
			if (FastDev) {
				var libdir = Path.Combine (Driver.ProductSdkDirectory, "usr", "lib");
				var libmono_name = LibMono;
				if (!UseMonoFramework.Value) {
					var libmono_target = Path.Combine (AppDirectory, libmono_name);
					var libmono_source = Path.Combine (libdir, libmono_name);
					Application.UpdateFile (libmono_source, libmono_target);
				}

				var libprofiler_target = Path.Combine (AppDirectory, "libmono-profiler-log.dylib");
				var libprofiler_source = Path.Combine (libdir, "libmono-profiler-log.dylib");
				if (EnableProfiling)
					Application.UpdateFile (libprofiler_source, libprofiler_target);

				// Copy libXamarin.dylib to the app
				var libxamarin_target = Path.Combine (AppDirectory, LibXamarin);
				Application.UpdateFile (Path.Combine (Driver.MonoTouchLibDirectory, LibXamarin), libxamarin_target);

				if (UseMonoFramework.Value) {
					if (EnableProfiling)
						Driver.XcodeRun ("install_name_tool", "-change @executable_path/libmonosgen-2.0.dylib @rpath/Mono.framework/Mono " + Driver.Quote (libprofiler_target));
					Driver.XcodeRun ("install_name_tool", "-change @executable_path/libmonosgen-2.0.dylib @rpath/Mono.framework/Mono " + Driver.Quote (libxamarin_target));
				}
			}

			// Copy frameworks to the app bundle.
			if (!IsExtension) {
				var all_frameworks = new HashSet<string> ();
				all_frameworks.UnionWith (Frameworks);
				all_frameworks.UnionWith (WeakFrameworks);
				foreach (var t in Targets) {
					all_frameworks.UnionWith (t.Frameworks);
					all_frameworks.UnionWith (t.WeakFrameworks);
					foreach (var a in t.Assemblies) {
						if (a.Frameworks != null)
							all_frameworks.UnionWith (a.Frameworks);
						if (a.WeakFrameworks != null)
							all_frameworks.UnionWith (a.WeakFrameworks);
					}
				}
					
				if (PackageMonoFramework.Value) {
					// We may have to copy the Mono framework to the bundle even if we're not linking with it.
					all_frameworks.Add (Path.Combine (Driver.ProductSdkDirectory, "Frameworks", "Mono.framework"));
				}
				
				foreach (var fw in all_frameworks) {
					if (!fw.EndsWith (".framework"))
						continue;
					if (!Xamarin.MachO.IsDynamicFramework (Path.Combine (fw, Path.GetFileNameWithoutExtension (fw)))) {
						// We can have static libraries camouflaged as frameworks. We don't want those copied to the app.
						Driver.Log (1, "The framework {0} is a framework of static libraries, and will not be copied into the app.", fw);
						continue;
					}

					if (!File.Exists (Path.Combine (fw, "Info.plist")))
						throw ErrorHelper.CreateError (1304, "The embedded framework '{0}' in {1} is invalid: it does not contain an Info.plist.", Path.GetFileNameWithoutExtension (fw), fw);
					
					Application.UpdateDirectory (fw, Path.Combine (AppDirectory, "Frameworks"));
					if (IsDeviceBuild) {
						// Remove architectures we don't care about.
						Xamarin.MachO.SelectArchitectures (Path.Combine (AppDirectory, "Frameworks", Path.GetFileName (fw), Path.GetFileNameWithoutExtension (fw)), AllArchitectures);
					}
				}
			}

			if (IsSimulatorBuild || !IsDualBuild) {
				if (IsDeviceBuild)
					cached_executable = Targets [0].cached_executable;
				return;
			}

			if (IsSimulatorBuild || !IsDualBuild) {
				if (IsDeviceBuild)
					cached_executable = Targets [0].cached_executable;
				return;
			}

			if (IsUptodate (new string [] { Targets [0].Executable, Targets [1].Executable }, new string [] { Executable })) {
				cached_executable = true;
				Driver.Log (3, "Target '{0}' is up-to-date.", Executable);
				return;
			}

			var cmd = new StringBuilder ();
			foreach (var target in Targets) {
				cmd.Append (Driver.Quote (target.Executable));
				cmd.Append (' ');
			}
			cmd.Append ("-create -output ");
			cmd.Append (Driver.Quote (Executable));
			Driver.RunLipo (cmd.ToString ());

		}
			
		public void ExtractNativeLinkInfo ()
		{
			var exceptions = new List<Exception> ();

			foreach (var target in Targets)
				target.ExtractNativeLinkInfo (exceptions);

			if (exceptions.Count > 0)
				throw new AggregateException (exceptions);

			Driver.Watch ("Extracted native link info", 1);
		}

		public void SelectNativeCompiler ()
		{
			foreach (var t in Targets) {
				foreach (var a in t.Assemblies) {
					if (a.EnableCxx) {	
						EnableCxx = true;
						break;
					}
				}
			}

			Driver.CalculateCompilerPath ();
		}

		public string LibMono {
			get {
				if (FastDev) {
					return "libmonosgen-2.0.dylib";
				} else {
					return "libmonosgen-2.0.a";
				}
			}
		}

		public string LibXamarin {
			get {
				if (FastDev) {
					return EnableDebug ? "libxamarin-debug.dylib" : "libxamarin.dylib";
				} else {
					return EnableDebug ? "libxamarin-debug.a" : "libxamarin.a";
				}
			}
		}

		public void NativeLink ()
		{
			foreach (var target in Targets)
				target.NativeLink ();
		}
		
		// this will filter/remove warnings that are not helpful (e.g. complaining about non-matching armv6-6 then armv7-6 on fat binaries)
		// and turn the remaining of the warnings into MT5203 that MonoDevelop will be able to report as real warnings (not just logs)
		// it will also look for symbol-not-found errors and try to provide useful error messages.
		public static void ProcessNativeLinkerOutput (Target target, string output, IList<string> inputs, List<Exception> errors, bool error)
		{
			List<string> lines = new List<string> (output.Split (new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries));

			// filter
			for (int i = 0; i < lines.Count; i++) {
				string line = lines [i];

				if (errors.Count > 100)
					return;

				if (line.Contains ("ld: warning: ignoring file ") && 
					line.Contains ("file was built for") && 
					line.Contains ("which is not the architecture being linked") &&
				// Only ignore warnings related to the object files we've built ourselves (assemblies, main.m, registrar.m)
					inputs.Any ((v) => line.Contains (v))) {
					continue;
				} else if (line.Contains ("ld: symbol(s) not found for architecture") && errors.Count > 0) {
					continue;
				} else if (line.Contains ("clang: error: linker command failed with exit code 1")) {
					continue;
				} else if (line.Contains ("was built for newer iOS version (5.1.1) than being linked (5.1)")) {
					continue;
				}

				if (line.Contains ("Undefined symbols for architecture")) {
					while (++i < lines.Count) {
						line = lines [i];
						if (!line.EndsWith (", referenced from:"))
							break;

						var symbol = line.Replace (", referenced from:", "").Trim ('\"', ' ');
						if (symbol.StartsWith ("_OBJC_CLASS_$_")) {
							errors.Add (new MonoTouchException (5211, error, 
																"Native linking failed, undefined Objective-C class: {0}. The symbol '{1}' could not be found in any of the libraries or frameworks linked with your application.",
							                                    symbol.Replace ("_OBJC_CLASS_$_", ""), symbol));
						} else {
							var member = target.GetMemberForSymbol (symbol.Substring (1));
							if (member != null) {
								// Neither P/Invokes nor fields have IL, so we can't find the source code location.
								errors.Add (new MonoTouchException (5214, error,
									"Native linking failed, undefined symbol: {0}. " +
									"This symbol was referenced by the managed member {1}.{2}. " +
									"Please verify that all the necessary frameworks have been referenced and native libraries linked.",
									symbol, member.DeclaringType.FullName, member.Name));
							} else {
								errors.Add (new MonoTouchException (5210, error, 
							                                    "Native linking failed, undefined symbol: {0}. " +
																"Please verify that all the necessary frameworks have been referenced and native libraries are properly linked in.",
							                                    symbol));
							}
						}

						// skip all subsequent lines related to the same error.
						// we skip all subsequent lines with more indentation than the initial line.
						var indent = GetIndentation (line);
						while (i + 1 < lines.Count) {
							line = lines [i + 1];
							if (GetIndentation (lines [i + 1]) <= indent)
								break;
							i++;
						}
					}
				} else if (line.StartsWith ("duplicate symbol") && line.EndsWith (" in:")) {
					var symbol = line.Replace ("duplicate symbol ", "").Replace (" in:", "").Trim ();
					errors.Add (new MonoTouchException (5212, error, "Native linking failed, duplicate symbol: '{0}'.", symbol));

					var indent = GetIndentation (line);
					while (i + 1 < lines.Count) {
						line = lines [i + 1];
						if (GetIndentation (lines [i + 1]) <= indent)
							break;
						i++;
						errors.Add (new MonoTouchException (5213, error, "Duplicate symbol in: {0} (Location related to previous error)", line.Trim ()));
					}
				} else {
					if (line.StartsWith ("ld: "))
						line = line.Substring (4);

					line = line.Trim ();

					if (error) {
						errors.Add (new MonoTouchException (5209, error, "Native linking error: {0}", line));
					} else {
						errors.Add (new MonoTouchException (5203, error, "Native linking warning: {0}", line));
					}
				}
			}
		}

		static int GetIndentation (string line)
		{
			int rv = 0;
			if (line.Length == 0)
				return 0;

			while (true) {
				switch (line [rv]) {
				case ' ':
				case '\t':
					rv++;
					break;
				default:
					return rv;
				}
			};
		}

		// return the ids found in a macho file
		List<Guid> GetUuids (MachOFile file)
		{
			var result = new List<Guid> ();
			foreach (var cmd in file.load_commands) {
				if (cmd is UuidCommand) {
					var uuidCmd = cmd as UuidCommand;
					result.Add (new Guid (uuidCmd.uuid));
				}
			}
			return result;
		}

		// This method generates the manifest that is required by the symbolication in order to be able to debug the application, 
		// The following is an example of the manifest to be generated:
		// <mono-debug version=”1”>
		//	<app-id>com.foo.bar</app-id>
		//	<build-date>datetime</build-date>
		//	<build-id>build-id</build-id>
		//	<build-id>build-id</build-id>
		// </mono-debug>
		// where:
		// 
		// app-id: iOS/Android/Mac app/package ID. Currently for verification and user info only but in future may be used to find symbols automatically.
		// build-date: Local time in DateTime “O” format. For user info only.
		// build-id: The build UUID. Needed for HockeyApp to find the mSYM folder matching the app build. There may be more than one, as in the case of iOS multi-arch.
		void GenerateMSymManifest (Target target, string target_directory)
		{
			var manifestPath = Path.Combine (target_directory, "manifest.xml");
			if (String.IsNullOrEmpty (target_directory))
				throw new ArgumentNullException (nameof (target_directory));
			var root = new XElement ("mono-debug",
				new XAttribute("version", 1),
				new XElement ("app-id", BundleId),
				new XElement ("build-date", DateTime.Now.ToString ("O")));
				
			var file = MachO.Read (target.Executable);
			
			if (file is MachO) {
				var mfile = file as MachOFile;
				var uuids = GetUuids (mfile);
				foreach (var str in uuids) {
					root.Add (new XElement ("build-id", str));
				}
			} else if (file is IEnumerable<MachOFile>) {
				var ffile = file as IEnumerable<MachOFile>;
				foreach (var fentry in ffile) {
					var uuids = GetUuids (fentry);
					foreach (var str in uuids) {
						root.Add (new XElement ("build-id", str));
					}
				}
				
			} else {
				// do not write a manifest
				return;
			}

			// Write only if we need to update the manifest
			Driver.WriteIfDifferent (manifestPath, root.ToString ());
		}

		void CopyAotData (string src, string dest)
		{
			if (string.IsNullOrEmpty (src) || string.IsNullOrEmpty (dest)) {
				ErrorHelper.Warning (95, $"Aot files could not be copied to the destination directory {dest}"); 
				return;
			}
				
			var dir = new DirectoryInfo (src);
			if (!dir.Exists) {
				ErrorHelper.Warning (95, $"Aot files could not be copied to the destination directory {dest}"); 
				return;
			}

			var dirs = dir.GetDirectories ();
			if (!Directory.Exists (dest))
				Directory.CreateDirectory (dest);
				
			var files = dir.GetFiles ();
			foreach (var file in files) {
				var tmp = Path.Combine (dest, file.Name);
				file.CopyTo (tmp, true);
			}

			foreach (var subdir in dirs) {
				var tmp = Path.Combine (dest, subdir.Name);
				CopyAotData (subdir.FullName, tmp);
			}
		}

		public void BuildMSymDirectory ()
		{
			if (!EnableMSym)
				return;

			var target_directory = string.Format ("{0}.mSYM", AppDirectory);
			if (!Directory.Exists (target_directory))
				Directory.CreateDirectory (target_directory);

			foreach (var target in Targets) {
				GenerateMSymManifest (target, target_directory);
				var msymdir = Path.Combine (target.BuildDirectory, "Msym");
				// copy aot data must be done BEFORE we do copy the msym one
				CopyAotData (msymdir, target_directory);
				
				// copy all assemblies under mvid and with the dll and mdb
				var tmpdir =  Path.Combine (msymdir, "Msym", "tmp");
				if (!Directory.Exists (tmpdir))
					Directory.CreateDirectory (tmpdir);
					
				foreach (var asm in target.Assemblies) {
					asm.CopyToDirectory (tmpdir, reload: false, only_copy: true);
				}
				// mono-symbolicate knows best
				CopyMSymData (target_directory, tmpdir);
			}
		}

		public void BuildDsymDirectory ()
		{
			if (!BuildDSym.HasValue)
				BuildDSym = IsDeviceBuild;

			if (!BuildDSym.Value)
				return;

			string dsym_dir = string.Format ("{0}.dSYM", AppDirectory);
			bool cached_dsym = false;

			if (cached_executable)
				cached_dsym = IsUptodate (new string [] { Executable }, Directory.EnumerateFiles (dsym_dir, "*", SearchOption.AllDirectories));

			if (!cached_dsym) {
				if (Directory.Exists (dsym_dir))
					Directory.Delete (dsym_dir, true);
				
				Driver.CreateDsym (AppDirectory, ExecutableName, dsym_dir);
			} else {
				Driver.Log (3, "Target '{0}' is up-to-date.", dsym_dir);
			}
			Driver.Watch ("Linking DWARF symbols", 1);
		}

		IEnumerable<string> GetRequiredSymbols ()
		{
			foreach (var target in Targets) {
				foreach (var symbol in target.GetRequiredSymbols ())
					yield return symbol;
			}
		}

		bool WriteSymbolList (string filename)
		{
			var required_symbols = GetRequiredSymbols ().ToArray ();
			using (StreamWriter writer = new StreamWriter (filename)) {
				foreach (string symbol in required_symbols)
					writer.WriteLine ("_{0}", symbol);
				foreach (var symbol in NoSymbolStrip)
					writer.WriteLine ("_{0}", symbol);
				writer.Flush ();
				return writer.BaseStream.Position > 0;
			}
		}

		void StripNativeCode (string name)
		{
			if (NativeStrip && IsDeviceBuild && !EnableDebug && string.IsNullOrEmpty (SymbolList)) {
				string symbol_file = Path.Combine (Cache.Location, "symbol-file");
				if (WriteSymbolList (symbol_file)) {
					Driver.RunStrip (String.Format ("-i -s \"{0}\" \"{1}\"", symbol_file, Executable));
				} else {
					Driver.RunStrip (String.Format ("\"{0}\"", Executable));
				}
				Driver.Watch ("Native Strip", 1);
			}

			if (!string.IsNullOrEmpty (SymbolList))
				WriteSymbolList (SymbolList);
		}

		public void StripNativeCode ()
		{
			if (IsDualBuild) {
				bool cached = true;
				foreach (var target in Targets)
					cached &= target.cached_executable;
				if (!cached)
					StripNativeCode (Executable);
			} else {
				foreach (var target in Targets) {
					if (!target.cached_executable)
						StripNativeCode (target.Executable);
				}
			}
		}

		public void StripManagedCode ()
		{
			foreach (var target in Targets)
				target.StripManagedCode ();

			// deduplicate assemblies between the .monotouch-32 and .monotouch-64 directories
			if (IsDualBuild && IsDeviceBuild && !Sign)
				DeduplicateDir ("..", Targets [0].AppTargetDirectory, Targets [1].AppTargetDirectory);
		}

		void DeduplicateDir (string base_dir, string d1, string d2)
		{
			foreach (var f1 in Directory.GetFileSystemEntries (d1)) {
				var f2 = Path.Combine (d2, Path.GetFileName (f1));
				if (Directory.Exists (f1))
					DeduplicateDir (Path.Combine (base_dir, ".."), f1, f2);
				else
					DeduplicateFile (base_dir, f1, f2);
			}
		}

		void DeduplicateFile (string base_dir, string f1, string f2)
		{
			if (!File.Exists (f2))
				return;

			if (Driver.IsSymlink (f2))
				return; // Already determined to be identical from a previous build.

			bool equal;
			var ext = Path.GetExtension (f1).ToUpperInvariant ();
			var is_assembly = ext == ".EXE" || ext == ".DLL";

			if (is_assembly) {
				equal = Cache.CompareAssemblies (f1, f2, true, true);
				if (!equal && Driver.Verbosity > 0)
					Console.WriteLine ("Assemblies {0} and {1} not found to be identical, cannot replace one with a symlink to the other.", f1, f2);
			} else {
				equal = Cache.CompareFiles (f1, f2, true);
				if (!equal && Driver.Verbosity > 0)
					Console.WriteLine ("Targets {0} and {1} not found to be identical, cannot replace one with a symlink to the other.", f1, f2);
			}
			if (!equal)
				return;

			var dest = Path.Combine (base_dir, f1.Substring (AppDirectory.Length + 1));
			Driver.FileDelete (f2);
			if (!Driver.Symlink (dest, f2)) {
				File.Copy (f1, f2);
			} else {
				if (Driver.Verbosity > 0)
					Console.WriteLine ("Targets {0} and {1} found to be identical, the later has been replaced with a symlink to the former.", f1, f2);
			}
		}

		public void SignBundle ()
		{
			if (!IsDeviceBuild || !Sign)
				return;

			var env_vars = new string [] {
				"CODESIGN_ALLOCATE", 
				Path.Combine (Driver.PlatformDirectory, "Developer", "usr", "bin", "codesign_allocate")
			};

			if (Driver.RunCommand ("codesign", String.Format ("-v -s \"{0}\" \"{1}\"", CertificateName, Executable), env_vars) != 0)
				ErrorHelper.Error (5307, "Failed to sign the executable. Please review the build log.");
		}

		public void GenerateRuntimeOptions ()
		{
			// only if the linker is disabled
			if (LinkMode != LinkMode.None)
				return;

			RuntimeOptions.Write (AppDirectory);
		}

		public void GenerateAppManifests ()
		{
			if (!GenerateManifests)
				return;
			
			using (var f = File.OpenWrite (Path.Combine (AppDirectory, "PkgInfo"))){
				f.Write (new byte [] { 0X41, 0X50, 0X50, 0X4C, 0x3f, 0x3f, 0x3f, 0x3f}, 0, 8);
			}

			var executable = Path.GetFileName (Executable);

			var sr = new StreamReader (typeof (Driver).Assembly.GetManifestResourceStream ("Info.plist.tmpl"));
			var all = sr.ReadToEnd ();
			var icon_str = (Icon != null) ? "\t<key>CFBundleIconFile</key>\n\t<string>" + Icon + "</string>\n\t" : "";

			using (var sw = new StreamWriter (Path.Combine (AppDirectory, "Info.plist"))){
				sw.WriteLine (
					all.Replace ("@BUNDLEDISPLAYNAME@", BundleDisplayName ?? executable).
					Replace ("@EXECUTABLE@", executable).
					Replace ("@BUNDLEID@", BundleId).
					Replace ("@BUNDLEICON@", icon_str).
					Replace ("@BUNDLENAME@", executable).
					Replace ("@MAINNIB@", MainNib));

			}
		}

		public void ProcessFrameworksForArguments (StringBuilder args, IEnumerable<string> frameworks, IEnumerable<string> weak_frameworks, IList<string> inputs)
		{
			bool any_user_framework = false;

			if (frameworks != null) {
				foreach (var fw in frameworks)
					ProcessFrameworkForArguments (args, fw, false, inputs, ref any_user_framework);
			}

			if (weak_frameworks != null) {
				foreach (var fw in weak_frameworks)
					ProcessFrameworkForArguments (args, fw, true, inputs, ref any_user_framework);
			}
			
			if (any_user_framework) {
				args.Append (" -Xlinker -rpath -Xlinker @executable_path/Frameworks");
				if (IsExtension)
					args.Append (" -Xlinker -rpath -Xlinker @executable_path/../../Frameworks");
			}

		}

		public static void ProcessFrameworkForArguments (StringBuilder args, string fw, bool is_weak, IList<string> inputs, ref bool any_user_framework)
		{
			var name = Path.GetFileNameWithoutExtension (fw);
			if (fw.EndsWith (".framework")) {
				// user framework, we need to pass -F to the linker so that the linker finds the user framework.
				any_user_framework = true;
				if (inputs != null)
					inputs.Add (Path.Combine (fw, name));
				args.Append (" -F ").Append (Driver.Quote (Path.GetDirectoryName (fw)));
			}
			args.Append (is_weak ? " -weak_framework " : " -framework ").Append (Driver.Quote (name));
		}
	}

	public class BuildTasks : List<BuildTask>
	{
		static void Execute (BuildTask v)
		{
			var next = v.Execute ();
			if (next != null)
				Parallel.ForEach (next, new ParallelOptions () { MaxDegreeOfParallelism = Environment.ProcessorCount }, Execute);
		}

		public void ExecuteInParallel ()
		{
			if (Count == 0)
				return;
			
			Parallel.ForEach (this, new ParallelOptions () { MaxDegreeOfParallelism = Environment.ProcessorCount }, Execute);

			Clear ();
		}
	}

	public abstract class BuildTask
	{
		public IEnumerable<BuildTask> NextTasks;

		protected abstract void Build ();

		public IEnumerable<BuildTask> Execute ()
		{
			Build ();
			return NextTasks;
		}

		public virtual bool IsUptodate ()
		{
			return false;
		}
	}

	public abstract class ProcessTask : BuildTask
	{
		public ProcessStartInfo ProcessStartInfo;
		protected StringBuilder Output;
		
		protected string Command {
			get {
				var result = new StringBuilder ();
				if (ProcessStartInfo.EnvironmentVariables.ContainsKey ("MONO_PATH")) {
					result.Append ("MONO_PATH=");
					result.Append (ProcessStartInfo.EnvironmentVariables ["MONO_PATH"]);
					result.Append (' ');
				}
				result.Append (ProcessStartInfo.FileName);
				result.Append (' ');
				result.Append (ProcessStartInfo.Arguments);
				return result.ToString ();
			}
		}

		protected int Start ()
		{
			if (Driver.Verbosity > 0 || Driver.DryRun)
				Console.WriteLine (Command);
			
			if (Driver.DryRun)
				return 0;
			
			var info = ProcessStartInfo;
			var stdout_completed = new ManualResetEvent (false);
			var stderr_completed = new ManualResetEvent (false);

			Output = new StringBuilder ();

			using (var p = Process.Start (info)) {
				p.OutputDataReceived += (sender, e) => {
					if (e.Data != null) {
						lock (Output)
							Output.AppendLine (e.Data);
					} else {
						stdout_completed.Set ();
					}
				};
				
				p.ErrorDataReceived += (sender, e) => {
					if (e.Data != null) {
						lock (Output)
							Output.AppendLine (e.Data);
					} else {
						stderr_completed.Set ();
					}
				};
				
				p.BeginOutputReadLine ();
				p.BeginErrorReadLine ();
				
				p.WaitForExit ();
				
				stderr_completed.WaitOne (TimeSpan.FromSeconds (1));
				stdout_completed.WaitOne (TimeSpan.FromSeconds (1));

				if (p.ExitCode != 0)
					return p.ExitCode;

				if (Driver.Verbosity >= 2 && Output.Length > 0)
					Console.Error.WriteLine (Output.ToString ());
			}

			return 0;
		}
	}

	internal class MainTask : CompileTask {
		public static void Create (List<BuildTask> tasks, Target target, Abi abi, IEnumerable<Assembly> assemblies, string assemblyName, IList<string> registration_methods)
		{
			var arch = abi.AsArchString ();
			var ofile = Path.Combine (Cache.Location, "main." + arch + ".o");
			var ifile = Path.Combine (Cache.Location, "main." + arch + ".m");

			var files = assemblies.Select (v => v.FullPath);

			if (!Application.IsUptodate (files, new string [] { ifile })) {
				Driver.GenerateMain (assemblies, assemblyName, abi, ifile, registration_methods);
			} else {
				Driver.Log (3, "Target '{0}' is up-to-date.", ifile);
			}
			
			if (!Application.IsUptodate (ifile, ofile)) {
				var main = new MainTask ()
				{
					Target = target,
					Abi = abi,
					AssemblyName = assemblyName,
					InputFile = ifile,
					OutputFile = ofile,
					SharedLibrary = false,
					Language = "objective-c++",
				};
				main.CompilerFlags.AddDefine ("MONOTOUCH");
				tasks.Add (main);
			} else {
				Driver.Log (3, "Target '{0}' is up-to-date.", ofile);
			}
			
			target.LinkWith (ofile);
		}

		protected override void Build ()
		{
			if (Compile () != 0)
				throw new MonoTouchException (5103, true, "Failed to compile the file '{0}'. Please file a bug report at http://bugzilla.xamarin.com", InputFile);
		}
	}

	internal class PinvokesTask : CompileTask
	{
		public static void Create (List<BuildTask> tasks, IEnumerable<Abi> abis, Target target, string ifile)
		{
			foreach (var abi in abis)
				Create (tasks, abi, target, ifile);
		}

		public static void Create (List<BuildTask> tasks, Abi abi, Target target, string ifile)
		{
			var arch = abi.AsArchString ();
			var ext = Driver.App.FastDev ? ".dylib" : ".o";
			var ofile = Path.Combine (Cache.Location, Path.GetFileNameWithoutExtension (ifile) + "." + arch + ext);

			if (!Application.IsUptodate (ifile, ofile)) {
				var task = new PinvokesTask ()
				{
					Target = target,
					Abi = abi,
					InputFile = ifile,
					OutputFile = ofile,
					SharedLibrary = Driver.App.FastDev,
					Language = "objective-c++",
				};
				if (Driver.App.FastDev) {
					task.CompilerFlags.AddFramework ("Foundation");
					task.CompilerFlags.LinkWithXamarin ();
				}
				tasks.Add (task);
			} else {
				Driver.Log (3, "Target '{0}' is up-to-date.", ofile);
			}

			target.LinkWith (ofile);
		}

		protected override void Build ()
		{
			if (Compile () != 0)
				throw new MonoTouchException (4002, true, "Failed to compile the generated code for P/Invoke methods. Please file a bug report at http://bugzilla.xamarin.com");
		}
	}

	internal class RegistrarTask : CompileTask {
		public static void Create (List<BuildTask> tasks, IEnumerable<Abi> abis, Target target, string ifile)
		{
			foreach (var abi in abis)
				Create (tasks, abi, target, ifile);
		}

		public static void Create (List<BuildTask> tasks, Abi abi, Target target, string ifile)
		{
			var arch = abi.AsArchString ();
			var ofile = Path.Combine (Cache.Location, Path.GetFileNameWithoutExtension (ifile) + "." + arch + ".o");

			if (!Application.IsUptodate (ifile, ofile)) {
				tasks.Add (new RegistrarTask ()
				{
					Target = target,
					Abi = abi,
					InputFile = ifile,
					OutputFile = ofile,
					SharedLibrary = false,
					Language = "objective-c++",
				});
			} else {
				Driver.Log (3, "Target '{0}' is up-to-date.", ofile);
			}
			
			target.LinkWith (ofile);
		}

		protected override void Build ()
		{
			if (Driver.IsUsingClang) {
				// This is because iOS has a forward declaration of NSPortMessage, but no actual declaration.
				// They still use NSPortMessage in other API though, so it can't just be removed from our bindings.
				CompilerFlags.AddOtherFlag ("-Wno-receiver-forward-class");
			}

			if (Compile () != 0)
				throw new MonoTouchException (4109, true, "Failed to compile the generated registrar code. Please file a bug report at http://bugzilla.xamarin.com");
		}
	}

	public class AOTTask : ProcessTask {
		public string AssemblyName;

		// executed with Parallel.ForEach
		protected override void Build ()
		{
			var exit_code = base.Start ();

			if (exit_code == 0)
				return;

			Console.Error.WriteLine ("AOT Compilation exited with code {0}, command:\n{1}{2}", exit_code, Command, Output.Length > 0 ? ("\n" + Output.ToString ()) : string.Empty);
			if (Output.Length > 0) {
				List<Exception> exceptions = new List<Exception> ();
				foreach (var line in Output.ToString ().Split ('\n')) {
					if (line.StartsWith ("AOT restriction: Method '") && line.Contains ("must be static since it is decorated with [MonoPInvokeCallback]")) {
						exceptions.Add (new MonoTouchException (3002, true, line));
					}
				}
				if (exceptions.Count > 0)
					throw new AggregateException (exceptions.ToArray ());
			}

			throw new MonoTouchException (3001, true, "Could not AOT the assembly '{0}'", AssemblyName);
		}
	}

	public class LinkTask : CompileTask {
	}

	public class CompileTask : BuildTask {
		public Target Target;
		public Application App { get { return Target.App; } }
		public bool SharedLibrary;
		public string InputFile;
		public string OutputFile;
		public Abi Abi;
		public string AssemblyName;
		public string InstallName;
		public string Language;

		CompilerFlags compiler_flags;
		public CompilerFlags CompilerFlags {
			get { return compiler_flags ?? (compiler_flags = new CompilerFlags () { Target = Target }); }
			set { compiler_flags = value; }
		}

		public static void GetArchFlags (CompilerFlags flags, params Abi [] abis)
		{
			GetArchFlags (flags, (IEnumerable<Abi>) abis);
		}

		public static void GetArchFlags (CompilerFlags flags, IEnumerable<Abi> abis)
		{
			bool enable_thumb = false;

			foreach (var abi in abis) {
				var arch = abi.AsArchString ();
				flags.AddOtherFlag ($"-arch {arch}");

				enable_thumb |= (abi & Abi.Thumb) != 0;
			}

			if (enable_thumb)
				flags.AddOtherFlag ("-mthumb");
		}

		public static void GetCompilerFlags (CompilerFlags flags, string ifile, string language = null)
		{
			if (string.IsNullOrEmpty (ifile) || !ifile.EndsWith (".s"))
				flags.AddOtherFlag ("-gdwarf-2");

			if (!string.IsNullOrEmpty (ifile) && !ifile.EndsWith (".s")) {
				if (string.IsNullOrEmpty (language) || !language.Contains ("++")) {
					// error: invalid argument '-std=c99' not allowed with 'C++/ObjC++'
					flags.AddOtherFlag ("-std=c99");
				}
				flags.AddOtherFlag ($"-I{Driver.Quote (Path.Combine (Driver.ProductSdkDirectory, "usr", "include"))}");
			}
			flags.AddOtherFlag ($"-isysroot {Driver.Quote (Driver.FrameworkDirectory)}");
			flags.AddOtherFlag ("-Qunused-arguments"); // don't complain about unused arguments (clang reports -std=c99 and -Isomething as unused).
		}
		
		public static void GetSimulatorCompilerFlags (CompilerFlags flags, string ifile, Application app, string language = null)
		{
			GetCompilerFlags (flags, ifile, language);

			if (Driver.SDKVersion == new Version ())
				throw new MonoTouchException (25, true, "No SDK version was provided. Please add --sdk=X.Y to specify which iOS SDK should be used to build your application.");

			string sim_platform = Driver.PlatformDirectory;
			string plist = Path.Combine (sim_platform, "Info.plist");

			var dict = Driver.FromPList (plist);
			var dp = dict.Get<PDictionary> ("DefaultProperties");
			if (dp.GetString ("GCC_OBJC_LEGACY_DISPATCH") == "YES")
					flags.AddOtherFlag ("-fobjc-legacy-dispatch");
			string objc_abi = dp.GetString ("OBJC_ABI_VERSION");
			if (!String.IsNullOrWhiteSpace (objc_abi))
				flags.AddOtherFlag ($"-fobjc-abi-version={objc_abi}");
			
			plist = Path.Combine (Driver.FrameworkDirectory, "SDKSettings.plist");
			string min_prefix = Driver.CompilerPath.Contains ("clang") ? Driver.TargetMinSdkName : "iphoneos";
			dict = Driver.FromPList (plist);
			dp = dict.Get<PDictionary> ("DefaultProperties");
			if (app.DeploymentTarget == new Version ()) {
				string target = dp.GetString ("IPHONEOS_DEPLOYMENT_TARGET");
				if (!String.IsNullOrWhiteSpace (target))
					flags.AddOtherFlag ($"-m{min_prefix}-version-min={target}");
			} else {
				flags.AddOtherFlag ($"-m{min_prefix}-version-min={app.DeploymentTarget}");
			}
			string defines = dp.GetString ("GCC_PRODUCT_TYPE_PREPROCESSOR_DEFINITIONS");
			if (!String.IsNullOrWhiteSpace (defines))
				flags.AddDefine (defines.Replace (" ", String.Empty));
		}
		
		void GetDeviceCompilerFlags (CompilerFlags flags, string ifile)
		{
			GetCompilerFlags (flags, ifile, Language);
			
			flags.AddOtherFlag ($"-m{Driver.TargetMinSdkName}-version-min={App.DeploymentTarget.ToString ()}");

			if (App.EnableLLVMOnlyBitCode)
				// The AOT compiler doesn't optimize the bitcode so clang will do it
				flags.AddOtherFlag ("-O2 -fexceptions");
		}
		
		void GetSharedCompilerFlags (CompilerFlags flags, string install_name)
		{
			flags.AddOtherFlag ("-shared");
			if (!App.EnableMarkerOnlyBitCode)
				flags.AddOtherFlag ("-read_only_relocs suppress");
			flags.LinkWithMono ();
			flags.AddOtherFlag ("-install_name " + Driver.Quote ($"@executable_path/{install_name}"));
			flags.AddOtherFlag ("-fapplication-extension"); // fixes this: warning MT5203: Native linking warning: warning: linking against dylib not safe for use in application extensions: [..]/actionextension.dll.arm64.dylib
		}
		
		void GetStaticCompilerFlags (CompilerFlags flags)
		{
			flags.AddOtherFlag ("-c");
		}

		void GetBitcodeCompilerFlags (CompilerFlags flags)
		{
			flags.AddOtherFlag (App.EnableMarkerOnlyBitCode ? "-fembed-bitcode-marker" : "-fembed-bitcode");
		}

		protected override void Build ()
		{
			if (Compile () != 0)
				throw new MonoTouchException (3001, true, "Could not AOT the assembly '{0}'", AssemblyName);
		}

		public int Compile ()
		{
			if (App.IsDeviceBuild) {
				GetDeviceCompilerFlags (CompilerFlags, InputFile);
			} else {
				GetSimulatorCompilerFlags (CompilerFlags, InputFile, App, Language);
			}

			if (App.EnableBitCode)
				GetBitcodeCompilerFlags (CompilerFlags);
			GetArchFlags(CompilerFlags, Abi);

			if (SharedLibrary) {
				GetSharedCompilerFlags (CompilerFlags, InstallName);
			} else {
				GetStaticCompilerFlags (CompilerFlags);
			}

			if (App.EnableDebug)
				CompilerFlags.AddDefine ("DEBUG");

			CompilerFlags.AddOtherFlag ($"-o {Driver.Quote (OutputFile)}");

			if (!string.IsNullOrEmpty (Language))
				CompilerFlags.AddOtherFlag ($"-x {Language}");

			CompilerFlags.AddOtherFlag (Driver.Quote (InputFile));

			var rv = Driver.RunCommand (Driver.CompilerPath, CompilerFlags.ToString (), null, null);
			
			return rv;
		}
	}

	public class BitCodeify : BuildTask {
		public string Input { get; set; }
		public string OutputFile { get; set; }
		public ApplePlatform Platform { get; set; }
		public Abi Abi { get; set; }
		public Version DeploymentTarget { get; set; }

		protected override void Build ()
		{
			new BitcodeConverter (Input, OutputFile, Platform, Abi, DeploymentTarget).Convert ();
		}
	}
}