[mono-runtimes] Build AOT+LLVM cross-compilers (#125)

The commit implements building of LLVM and cross-compilers to support
Xamarin.Android/Mono AOT. LLVM and cross-compilers can be built for
both the host platform (Linux and OS/X at the moment) as well as
cross-compiled for 32-bit and 64-bit Windows platforms.

Windows builds are done with MXE toolchain on OS/X and with the packaged
mingw-w64 toolchain on Linux (tested on Ubuntu 16.04 ONLY).

Also introducing a new set of MSBuild properties that contain information
about the host system. Some of those properties (HostOS, HostCC, HostCXX
for instance) have been moved from Configuration.props to better support
auto-detection. A new script, build-tools/scripts/generate-os-info, is
invoked as part of `make prepare` to generate file that contains the
new properties. The generated file is required for the build to work and
is also host-specific (it mustn't be moved between different machines)

Cross compiler builds require access to a configured Mono build tree, in
order to generate C structure offsets header file that is used by the AOT
compilers to properly generate AOT-ed binaries. Therefore, even if a JIT
target is not enabled in the configuration, enabling a cross-compiler for
some target will configure Mono for that JIT target but it will NOT build
it, to save time. To facilitate this, the _MonoRuntimes items defined in
build-tools/mono-runtimes/mono-runtimes.projitems gain an additional metadata
item called `DoBuild` which will be set to `true` if the runtime actually needs
to be built, as opposed to just configured.

MXE builds are disabled on Linux as mingw-w64 works just fine.

A `make prepare` warning is issued for Linux hosts which have the binfmt_misc
module enabled and either Wine of Mono (cli) registered as PE32/PE32+ binary
interpreters. In such instance building of the Windows cross-compilers will
fail because Autotools determine whether software is being cross compiled by
building a test program and attempting to execute it. In normal circumstances
such an attempt will fail, but with Windows cross-compilation and either Wine
or Mono registered to handle the PE32 executables this attempt will succeed
thus causing the cross compilation detection to fail.

Currently to build cross compilers on Linux you need to generate the C structure
offsets header file on OS/X and copy the resulting headers to appropriate places
on Linux. The header files should be placed in

  build-tools/mono-runtimes/obj/Debug/cross-*/

directories. The header files are:

   {cross-arm,cross-arm-win}/aarch64-v8a-linux-android.h
   {cross-arm64,cross-arm64-win}/armv5-none-linux-androideabi.h
   {cross-x86,cross-x86-win}/i686-none-linux-android.h
   {cross-x86_64,cross-x86_64-win}/x86_64-none-linux-android.h

Offsets header generation doesn't work on Linux atm because of missing support
for it in the Mono utility used to generate the offsets. Hopefully this limitation
will be removed in the near future and a start-to-end build of everything will be
possible on Linux.

It is now mandatory to run at least `make prepare-props` before Xamarin.Android
can be built. The target generates the OS-specific props file which is required
by the build. `make prepare` depends on the target.

.gitignore

@@ -1,6 +1,7 @@
 *.userprefs
 bin
 Configuration.Override.props
+Configuration.OperatingSystem.props
 msfinal.pub
 obj
 packages

.gitmodules

@@ -25,3 +25,7 @@
 	path = external/LibZipSharp
 	url = https://github.com/grendello/LibZipSharp.git
 	branch = master
+[submodule "external/llvm"]
+	path = external/llvm
+	url = https://github.com/mono/llvm.git
+	branch = master

Configuration.Override.props.in

@@ -18,6 +18,23 @@
       -->
     <AndroidSupportedTargetJitAbis>armeabi:armeabi-v7a:arm64-v8a:x86:x86_64</AndroidSupportedTargetJitAbis>
 
+    <!--
+        Colon-separated list of ABIs to build AOT cross-compilers for. Note that there is no configuration
+        to build the armeabi-v7a cross-compiler. This is intentional as the ARMv6 cross-compiler takes care
+        of that target as well.
+        There doesn't need to be any parity between the AOT targets and the JIT ABIs above.
+        Supported targets are:
+
+          - armeabi
+          - win-armeabi
+          - arm64
+          - win-arm64
+          - x86
+          - win-x86
+          - x86_64
+          - win-x86_64
+    -->
+    <AndroidSupportedTargetAotAbis>armeabi:win-armeabi:arm64:win-arm64:x86:win-x86:x86_64:win-x86_64</AndroidSupportedTargetAotAbis>
     <!--
       Colon-separated list of ABIs to build a "host" mono JIT for.
       The host JIT is used for the Xamarin Studio Designer, among other things.

Configuration.props

@@ -7,25 +7,38 @@
       Project="$(MSBuildThisFileDirectory)Configuration.Override.props"
       Condition="Exists('$(MSBuildThisFileDirectory)Configuration.Override.props')"
   />
+
+  <!--
+      Note: this file *must* be imported *after* Configuration.Override.props
+  -->
+  <Import Project="$(MSBuildThisFileDirectory)Configuration.OperatingSystem.props" />
   <PropertyGroup>
     <HostOS Condition=" '$(HostOS)' == '' And '$(OS)' == 'Windows_NT' ">Windows</HostOS>
-    <HostOS Condition=" '$(HostOS)' == '' And '$(OS)' == 'Unix' And Exists ('/Applications') ">Darwin</HostOS>
-    <HostOS Condition=" '$(HostOS)' == '' And '$(OS)' == 'Unix' ">Linux</HostOS>
+    <HostCc Condition=" '$(HostCc)' == '' ">$(HostCc64)</HostCc>
+    <HostCxx Condition=" '$(HostCxx)' == '' ">$(HostCxx64)</HostCxx>
+    <HostCc Condition=" '$(HostCc)' == '' ">$(HostCc32)</HostCc>
+    <HostCxx Condition=" '$(HostCxx)' == '' ">$(HostCxx32)</HostCxx>
     <HostCc Condition=" '$(HostCc)' == '' ">cc</HostCc>
     <HostCxx Condition=" '$(HostCxx)' == '' ">c++</HostCxx>
+    <HostCcName Condition=" '$(HostCcName)' == '' ">cc</HostCcName>
+    <HostCxxName Condition=" '$(HostCxxName)' == '' ">c++</HostCxxName>
+    <NeedMxe Condition=" '$(HostOS)' == 'Darwin' ">true</NeedMxe>
+    <MakeConcurrency Condition=" '$(MakeConcurrency)' == '' And '$(HostCpuCount)' != '' ">-j$(HostCpuCount)</MakeConcurrency>
     <ManagedRuntime Condition=" '$(ManagedRuntime)' == '' And '$(OS)' != 'Windows_NT' ">mono</ManagedRuntime>
     <TargetFrameworkRootPath>$(MSBuildThisFileDirectory)bin\$(Configuration)\lib\xbuild-frameworks</TargetFrameworkRootPath>
     <HOME Condition=" '$(HOME)' == '' ">$(HOMEDRIVE)$(HOMEPATH)</HOME>
     <AndroidApiLevel Condition=" '$(AndroidApiLevel)' == '' ">23</AndroidApiLevel>
     <AndroidFrameworkVersion Condition=" '$(AndroidFrameworkVersion)' == '' ">v6.0</AndroidFrameworkVersion>
     <AndroidToolchainCacheDirectory Condition=" '$(AndroidToolchainCacheDirectory)' == '' ">$(HOME)\android-archives</AndroidToolchainCacheDirectory>
     <AndroidToolchainDirectory Condition=" '$(AndroidToolchainDirectory)' == '' ">$(HOME)\android-toolchain</AndroidToolchainDirectory>
-    <AndroidMxeInstallPrefix Condition=" '$(AndroidMxeInstallPrefix)' == '' ">$(AndroidToolchainDirectory)\mxe</AndroidMxeInstallPrefix>
+    <AndroidMxeInstallPrefix Condition=" '$(AndroidMxeInstallPrefix)' == '' And '$(NeedMxe)' == 'true' ">$(AndroidToolchainDirectory)\mxe</AndroidMxeInstallPrefix>
+    <AndroidMxeInstallPrefix Condition=" '$(HostOS)' == 'Linux' ">\usr</AndroidMxeInstallPrefix>
     <AndroidSdkDirectory>$(AndroidToolchainDirectory)\sdk</AndroidSdkDirectory>
     <AndroidNdkDirectory>$(AndroidToolchainDirectory)\ndk</AndroidNdkDirectory>
     <AndroidSupportedHostJitAbis Condition=" '$(AndroidSupportedHostJitAbis)' == '' ">$(HostOS)</AndroidSupportedHostJitAbis>
     <AndroidSupportedTargetJitAbis Condition=" '$(AndroidSupportedTargetJitAbis)' == '' ">armeabi-v7a</AndroidSupportedTargetJitAbis>
     <JavaInteropSourceDirectory Condition=" '$(JavaInteropSourceDirectory)' == '' ">$(MSBuildThisFileDirectory)external\Java.Interop</JavaInteropSourceDirectory>
+    <LlvmSourceDirectory Condition=" '$(LlvmSourceDirectory)' == '' ">$(MSBuildThisFileDirectory)external\llvm</LlvmSourceDirectory>
     <MonoSourceDirectory>$(MSBuildThisFileDirectory)external\mono</MonoSourceDirectory>
     <OpenTKSourceDirectory>$(MSBuildThisFileDirectory)external\opentk</OpenTKSourceDirectory>
     <LibZipSourceDirectory Condition=" '$(LibZipSourceDirectory)' == '' ">$(MSBuildThisFileDirectory)external\libzip</LibZipSourceDirectory>
@@ -36,11 +49,17 @@
     <AllSupported64BitTargetAndroidAbis>arm64-v8a;x86_64</AllSupported64BitTargetAndroidAbis>
     <AllSupportedTargetAndroidAbis>$(AllSupported32BitTargetAndroidAbis);$(AllSupported64BitTargetAndroidAbis)</AllSupportedTargetAndroidAbis>
   </PropertyGroup>
+  <PropertyGroup>
+    <_MingwPrefixTail Condition=" '$(HostOS)' == 'Darwin' ">.static</_MingwPrefixTail>
+    <MingwCommandPrefix32>i686-w64-mingw32$(_MingwPrefixTail)</MingwCommandPrefix32>
+    <MingwCommandPrefix64>x86_64-w64-mingw32$(_MingwPrefixTail)</MingwCommandPrefix64>
+  </PropertyGroup>
   <PropertyGroup>
     <AndroidMxeFullPath>$([System.IO.Path]::GetFullPath ('$(AndroidMxeInstallPrefix)'))</AndroidMxeFullPath>
     <AndroidNdkFullPath>$([System.IO.Path]::GetFullPath ('$(AndroidNdkDirectory)'))</AndroidNdkFullPath>
     <AndroidSdkFullPath>$([System.IO.Path]::GetFullPath ('$(AndroidSdkDirectory)'))</AndroidSdkFullPath>
     <JavaInteropFullPath>$([System.IO.Path]::GetFullPath ('$(JavaInteropSourceDirectory)'))</JavaInteropFullPath>
+    <LlvmSourceFullPath>$([System.IO.Path]::GetFullPath ('$(LlvmSourceDirectory)'))</LlvmSourceFullPath>
     <MonoSourceFullPath>$([System.IO.Path]::GetFullPath ('$(MonoSourceDirectory)'))</MonoSourceFullPath>
     <SqliteSourceFullPath>$([System.IO.Path]::GetFullPath ('$(SqliteSourceDirectory)'))</SqliteSourceFullPath>
     <OpenTKSourceFullPath>$([System.IO.Path]::GetFullPath ('$(OpenTKSourceDirectory)'))</OpenTKSourceFullPath>
@@ -73,4 +92,11 @@
   <ItemGroup>
     <AndroidSupportedTargetJitAbi Include="$(AndroidSupportedTargetJitAbisSplit)" />
   </ItemGroup>
+
+  <PropertyGroup>
+    <AndroidSupportedTargetAotAbisForConditionalChecks>$(AndroidSupportedTargetAotAbis)</AndroidSupportedTargetAotAbisForConditionalChecks>
+    <AndroidSupportedTargetAotAbisForConditionalChecks Condition=" !$(AndroidSupportedTargetAotAbisForConditionalChecks.EndsWith (':')) "   >$(AndroidSupportedTargetAotAbisForConditionalChecks):</AndroidSupportedTargetAotAbisForConditionalChecks>
+    <AndroidSupportedTargetAotAbisForConditionalChecks Condition=" !$(AndroidSupportedTargetAotAbisForConditionalChecks.StartsWith (':')) " >:$(AndroidSupportedTargetAotAbisForConditionalChecks)</AndroidSupportedTargetAotAbisForConditionalChecks>
+    <AndroidSupportedTargetAotAbisSplit>$(AndroidSupportedTargetAotAbis.Split(':'))</AndroidSupportedTargetAotAbisSplit>
+  </PropertyGroup>
 </Project>

Documentation/binfmt_misc-warning-Linux.txt

@@ -0,0 +1,23 @@
+*************** WARNING ***************
+
+Your Linux appears to have support for binfmt_misc kernel module enabled.
+The module makes it possible to execute non-Linux binaries if the appropriate
+interpreter for the given format is available.
+Your machine is configured to handle Windows PE executables either via Mono or
+Wine. It will make the Xamarin.Android build fail IF you choose to build the
+Windows cross-compilers by enabling the 'mxe-Win32' or 'mxe-Win64' host targets.
+
+You can disable the binfmt_misc module by issuing the following command as root
+before building Xamarin.Android:
+
+   echo 0 > /proc/sys/fs/binfmt_misc/status
+
+and re-enable it after building wiht the following command:
+
+   echo 1 > /proc/sys/fs/binfmt_misc/status
+
+If you are on Ubuntu then you can disable just the CLI (Mono) and Wine interpreters
+by issuing the following commands as root:
+
+   update-binfmts --disable cli
+   update-binfmts --disable wine

Makefile

@@ -1,4 +1,5 @@
 OS            := $(shell uname)
+OS_ARCH       := $(shell uname -m)
 V             ?= 0
 CONFIGURATION = Debug
 MSBUILD       = xbuild /p:Configuration=$(CONFIGURATION) $(MSBUILD_ARGS)
@@ -21,21 +22,59 @@ endif
 all:
 	$(MSBUILD)
 
-prepare::
+prepare:: prepare-props
 	git submodule update --init --recursive
 	nuget restore
 	(cd external/Java.Interop && nuget restore)
+
+prepare-props:
 	cp Configuration.Java.Interop.Override.props external/Java.Interop/Configuration.Override.props
+	./build-tools/scripts/generate-os-info Configuration.OperatingSystem.props
 	cp `$(MSBUILD) /nologo /v:minimal /t:GetMonoSourceFullPath build-tools/scripts/Paths.targets`/mcs/class/msfinal.pub .
 
 include build-tools/scripts/BuildEverything.mk
 
+# Please keep the package names sorted
 ifeq ($(OS),Linux)
-UBUNTU_DEPS          = libzip4 curl openjdk-8-jdk git make automake autoconf libtool unzip vim-common clang lib32stdc++6 lib32z1
+UBUNTU_DEPS          = \
+	autoconf \
+	autotools-dev \
+	automake \
+	clang \
+	curl \
+	g++-mingw-w64 \
+	gcc-mingw-w64 \
+	git \
+	libtool \
+	libzip4 \
+	linux-libc-dev \
+	make \
+	openjdk-8-jdk \
+	unzip \
+	vim-common
+
+ifeq ($(OS_ARCH),x86_64)
+UBUNTU_DEPS          += \
+	lib32stdc++6 \
+	lib32z1 \
+	libx32tinfo-dev \
+	linux-libc-dev:i386 \
+	zlib1g-dev:i386
+endif
 LINUX_DISTRO         := $(shell lsb_release -i -s || true)
 LINUX_DISTRO_RELEASE := $(shell lsb_release -r -s || true)
+BINFMT_MISC_TROUBLE  := cli win
 
 prepare:: linux-prepare-$(LINUX_DISTRO) linux-prepare-$(LINUX_DISTRO)-$(LINUX_DISTRO_RELEASE)
+	@BINFMT_WARN=no ; \
+	for m in $(BINFMT_MISC_TROUBLE); do \
+		if [ -f /proc/sys/fs/binfmt_misc/$$m ]; then \
+			BINFMT_WARN=yes ; \
+		fi ; \
+	done ; \
+	if [ "x$$BINFMT_WARN" = "xyes" ]; then \
+		cat Documentation/binfmt_misc-warning-Linux.txt ; \
+	fi
 
 linux-prepare-Ubuntu::
 	@echo Installing build depedencies for $(LINUX_DISTRO)

README.md

@@ -155,6 +155,23 @@ Then, you may do one of the following:
     because it generates sources, and those sources won't exist on the
     initial project load. Rebuild the project should this happen.
 
+## Linux build notes
+
+If you have the `binfmt_misc` module enabled with any of Mono or Wine installed and
+you plan to cross-build the Windows compilers and tools (by enabling the `mxe-Win32`
+or `mxe-Win64` host targets) as well as LLVM+AOT targets, you will need to disable 
+`binfmt_misc` for the duration of the build or the Mono/LLVM configure scripts will
+fail to detect they are cross-compiling and they will produce Windows PE executables
+for tools required by the build.
+
+To disable `binfmt_misc` you need to issue the following command as root:
+
+        echo 0 > /proc/sys/fs/binfmt_misc/status
+
+and to enable it again, issue the following command:
+
+        echo 1 > /proc/sys/fs/binfmt_misc/status
+
 # Build Output Directory Structure
 
 There are two configurations, `Debug` and `Release`, controlled by the

build-tools/android-toolchain/android-toolchain.projitems

@@ -80,58 +80,58 @@
     </AndroidSdkItem>
   </ItemGroup>
   <ItemGroup>
-    <_NdkToolchain Include="arm-linux-androideabi-clang" Condition="$(AndroidSupportedTargetJitAbisForConditionalChecks.Contains(':armeabi:')) Or $(AndroidSupportedTargetJitAbisForConditionalChecks.Contains(':armeabi-v7a:'))">
+    <_NdkToolchain Include="arm-linux-androideabi-clang" Condition="$(AndroidSupportedTargetJitAbisForConditionalChecks.Contains(':armeabi:')) Or $(AndroidSupportedTargetJitAbisForConditionalChecks.Contains(':armeabi-v7a:')) Or $(AndroidSupportedTargetAotAbisForConditionalChecks.Contains (':win-armeabi:'))">
       <Platform>android-4</Platform>
       <Arch>arm</Arch>
     </_NdkToolchain>
-    <_NdkToolchain Include="aarch64-linux-android-clang" Condition="$(AndroidSupportedTargetJitAbisForConditionalChecks.Contains(':arm64-v8a:'))">
+    <_NdkToolchain Include="aarch64-linux-android-clang" Condition="$(AndroidSupportedTargetJitAbisForConditionalChecks.Contains(':arm64-v8a:')) Or $(AndroidSupportedTargetAotAbisForConditionalChecks.Contains (':win-arm64:'))">
       <Platform>android-21</Platform>
       <Arch>arm64</Arch>
     </_NdkToolchain>
-    <_NdkToolchain Include="x86-clang" Condition="$(AndroidSupportedTargetJitAbisForConditionalChecks.Contains(':x86:'))">
+    <_NdkToolchain Include="x86-clang" Condition="$(AndroidSupportedTargetJitAbisForConditionalChecks.Contains(':x86:')) Or $(AndroidSupportedTargetAotAbisForConditionalChecks.Contains (':win-x86:'))">
       <Platform>android-9</Platform>
       <Arch>x86</Arch>
     </_NdkToolchain>
-    <_NdkToolchain Include="x86_64-clang" Condition="$(AndroidSupportedTargetJitAbisForConditionalChecks.Contains(':x86_64:'))">
+    <_NdkToolchain Include="x86_64-clang" Condition="$(AndroidSupportedTargetJitAbisForConditionalChecks.Contains(':x86_64:')) Or $(AndroidSupportedTargetAotAbisForConditionalChecks.Contains (':win-x86_64:'))">
       <Platform>android-21</Platform>
       <Arch>x86_64</Arch>
     </_NdkToolchain>
   </ItemGroup>
   <ItemGroup>
     <RequiredProgram Include="$(ManagedRuntime)"    Condition=" '$(ManagedRuntime)' != '' " />
-    <RequiredProgram Include="$(HostCc)" />
-    <RequiredProgram Include="$(HostCxx)" />
-    <RequiredProgram Include="7za"                  Condition="$(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
+    <RequiredProgram Include="$(HostCcName)" />
+    <RequiredProgram Include="$(HostCxxName)" />
+    <RequiredProgram Include="7za"                  Condition=" '$(NeedMxe)' == 'true' And $(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
       <Homebrew>p7zip</Homebrew>
     </RequiredProgram>
     <RequiredProgram Include="autoconf" />
     <RequiredProgram Include="automake" />
-    <RequiredProgram Include="cmake"                Condition="$(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))" />
-    <RequiredProgram Include="gdk-pixbuf-csource"   Condition="$(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
+    <RequiredProgram Include="cmake"                Condition=" '$(NeedMxe)' == 'true' And $(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))" />
+    <RequiredProgram Include="gdk-pixbuf-csource"   Condition=" '$(NeedMxe)' == 'true' And $(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
       <Homebrew>gdk-pixbuf</Homebrew>
     </RequiredProgram>
-    <RequiredProgram Include="gettext"              Condition="$(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))" />
-    <RequiredProgram Include="glibtool"             Condition="$(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
+    <RequiredProgram Include="gettext"              Condition=" '$(NeedMxe)' == 'true' And $(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))" />
+    <RequiredProgram Include="glibtool"             Condition=" '$(NeedMxe)' == 'true' And $(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
       <Homebrew>libtool</Homebrew>
     </RequiredProgram>
-    <RequiredProgram Include="gsed"                 Condition="$(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
+    <RequiredProgram Include="gsed"                 Condition=" '$(NeedMxe)' == 'true' And $(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
       <Homebrew>gnu-sed</Homebrew>
     </RequiredProgram>
-    <RequiredProgram Include="intltoolize"          Condition="$(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
+    <RequiredProgram Include="intltoolize"          Condition=" '$(NeedMxe)' == 'true' And $(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
       <Homebrew>intltool</Homebrew>
     </RequiredProgram>
     <RequiredProgram Include="make" />
-    <RequiredProgram Include="pkg-config"           Condition="$(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
+    <RequiredProgram Include="pkg-config"           Condition=" '$(NeedMxe)' == 'true' And $(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
       <Homebrew>pkg-config</Homebrew>
     </RequiredProgram>
-    <RequiredProgram Include="ruby"                 Condition="$(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))" />
-    <RequiredProgram Include="scons"                Condition="$(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
+    <RequiredProgram Include="ruby"                 Condition=" '$(NeedMxe)' == 'true' And $(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))" />
+    <RequiredProgram Include="scons"                Condition=" '$(NeedMxe)' == 'true' And $(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
       <Homebrew>scons</Homebrew>
     </RequiredProgram>
-    <RequiredProgram Include="wget"                 Condition="$(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
+    <RequiredProgram Include="wget"                 Condition=" '$(NeedMxe)' == 'true' And $(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
       <Homebrew>wget</Homebrew>
     </RequiredProgram>
-    <RequiredProgram Include="xz"                   Condition="$(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
+    <RequiredProgram Include="xz"                   Condition=" '$(NeedMxe)' == 'true' And $(AndroidSupportedHostJitAbisForConditionalChecks.Contains (':mxe-Win64:'))">
       <Homebrew>xz</Homebrew>
     </RequiredProgram>
   </ItemGroup>