xamarin
/
xamarin-android
зеркало из https://github.com/xamarin/xamarin-android.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
xamarin-android/build-tools/mono-runtimes/mono-runtimes.targets

100 строки
5.9 KiB
Plaintext
Исходник Обычный вид История

[mono-runtimes] Build required mono runtimes. Add a new build-tools/mono-runtimes project to build the required Mono runtimes for Xamarin.Android app execution on Android devices. Xamarin.Android 6.0 ("cycle 6") includes Mono runtimes compiled for five architectures: * armeabi (armv5) * armeabi-v7a (armv7) * arm64-v8a (aarch64) * x86 * x86_64 An additional "host" architecture is also built to build the "monodroid" profile assemblies such as mscorlib.dll. In the interest of expediency and not requiring that *six* different runtimes be built -- which can greatly increase build times and storage requirements -- the initial xamarin-android open-source build will only build the armeabi-v7a (armv7) and "host" architectures. Additionally, the <UnzipDirectoryChildren/> task needed to be altered to use unzip(1) on OS X instead of using System.IO.Compression.ZipFile, because the ZipFile implementation included with Mono 4.4 doesn't respect file attributes such as the +x, causing all files to be extracted as 644 (rw-r--r--), resulting in an NDK toolchain which wouldn't work. To resolve this issue, execution on OS X and Linux now uses unzip(1). ~~ Adding new architectures ~~ To build Mono for a new architecture, edit build-tools/mono-runtimes/mono-runtimes.projitems and add a new @(_MonoRuntime) entry for the desired architecture. TODO: Figure out if there's a reasonable way to "opt-in" or "opt-out" of CPU architectures so that it isn't an "all or nothing" prospect.
2016-04-20 04:30:00 +03:00
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="..\..\Configuration.props" />
<Import Project="mono-runtimes.props" />
<Import Project="mono-runtimes.projitems" />
<PropertyGroup>
<_MonoPath>..\..\external\mono</_MonoPath>
</PropertyGroup>
<Target Name="_Autogen"
Inputs="$(_MonoPath)\autogen.sh"
Outputs="$(_MonoPath)\configure">
<Exec
Command="NOCONFIGURE=1 ./autogen.sh"
WorkingDirectory="$(_MonoPath)"
/>
</Target>
<Target Name="_ConfigureRuntimes"
Inputs="$(_MonoPath)\configure"
[mono-runtimes] Use $(IntermediateOutputPath), not `obj`. One of the "cute" things in mono-runtimes.props is that $(_CommonCFlags) changes based on $(Configuration): for Debug builds, `-O0 -fno-omit-frame-pointer` is used (no optimizations and make stack traces easier for gdb), while for Release builds `-O2` is used. The natural result of this is that Debug and Release builds *are not the same*, and that's a *good* thing. ...except that previously, both Debug and Release builds used the same `obj\%(Identity)` directories, which meant there weren't separate Debug and Release outputs, there were instead "whatever was built first" outputs, which is *madness*. Fix mono-runtimes.targets so that $(IntermediateOutputPath) is used instead instead of `obj`. $(IntermediateOutputPath) should be `obj\$(Configuration)`, so Debug and Release build artifacts will be kept properly separate. Additionally, fix the `Clean` target, so that the $(IntermediateOutputPath) subdirectories are properly removed.
2016-04-22 21:30:39 +03:00
Outputs="@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)\.stamp')">
<MakeDir Directories="@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)')" />
[mono-runtimes] Build required mono runtimes. Add a new build-tools/mono-runtimes project to build the required Mono runtimes for Xamarin.Android app execution on Android devices. Xamarin.Android 6.0 ("cycle 6") includes Mono runtimes compiled for five architectures: * armeabi (armv5) * armeabi-v7a (armv7) * arm64-v8a (aarch64) * x86 * x86_64 An additional "host" architecture is also built to build the "monodroid" profile assemblies such as mscorlib.dll. In the interest of expediency and not requiring that *six* different runtimes be built -- which can greatly increase build times and storage requirements -- the initial xamarin-android open-source build will only build the armeabi-v7a (armv7) and "host" architectures. Additionally, the <UnzipDirectoryChildren/> task needed to be altered to use unzip(1) on OS X instead of using System.IO.Compression.ZipFile, because the ZipFile implementation included with Mono 4.4 doesn't respect file attributes such as the +x, causing all files to be extracted as 644 (rw-r--r--), resulting in an NDK toolchain which wouldn't work. To resolve this issue, execution on OS X and Linux now uses unzip(1). ~~ Adding new architectures ~~ To build Mono for a new architecture, edit build-tools/mono-runtimes/mono-runtimes.projitems and add a new @(_MonoRuntime) entry for the desired architecture. TODO: Figure out if there's a reasonable way to "opt-in" or "opt-out" of CPU architectures so that it isn't an "all or nothing" prospect.
2016-04-20 04:30:00 +03:00
<Exec
[mono-runtimes] Use $(IntermediateOutputPath), not `obj`. One of the "cute" things in mono-runtimes.props is that $(_CommonCFlags) changes based on $(Configuration): for Debug builds, `-O0 -fno-omit-frame-pointer` is used (no optimizations and make stack traces easier for gdb), while for Release builds `-O2` is used. The natural result of this is that Debug and Release builds *are not the same*, and that's a *good* thing. ...except that previously, both Debug and Release builds used the same `obj\%(Identity)` directories, which meant there weren't separate Debug and Release outputs, there were instead "whatever was built first" outputs, which is *madness*. Fix mono-runtimes.targets so that $(IntermediateOutputPath) is used instead instead of `obj`. $(IntermediateOutputPath) should be `obj\$(Configuration)`, so Debug and Release build artifacts will be kept properly separate. Additionally, fix the `Clean` target, so that the $(IntermediateOutputPath) subdirectories are properly removed.
2016-04-22 21:30:39 +03:00
Command="..\..\..\$(_MonoPath)\configure LDFLAGS=&quot;%(_MonoRuntime.LdFlags)&quot; CFLAGS=&quot;%(_MonoRuntime.CFlags)&quot; CXXFLAGS=&quot;%(_MonoRuntime.CxxFlags)&quot; CC=&quot;%(_MonoRuntime.Cc)&quot; CXX=&quot;%(_MonoRuntime.Cxx)&quot; CPP=&quot;%(_MonoRuntime.Cpp)&quot; CXXCPP=&quot;%(_MonoRuntime.CxxCpp)&quot; LD=&quot;%(_MonoRuntime.Ld)&quot; AR=&quot;%(_MonoRuntime.Ar)&quot; AS=&quot;%(_MonoRuntime.As)&quot; RANLIB=&quot;%(_MonoRuntime.RanLib)&quot; STRIP=&quot;%(_MonoRuntime.Strip)&quot; --cache-file=..\%(_MonoRuntime.Identity).config.cache %(_MonoRuntime.ConfigureFlags)"
WorkingDirectory="@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)')"
[mono-runtimes] Build required mono runtimes. Add a new build-tools/mono-runtimes project to build the required Mono runtimes for Xamarin.Android app execution on Android devices. Xamarin.Android 6.0 ("cycle 6") includes Mono runtimes compiled for five architectures: * armeabi (armv5) * armeabi-v7a (armv7) * arm64-v8a (aarch64) * x86 * x86_64 An additional "host" architecture is also built to build the "monodroid" profile assemblies such as mscorlib.dll. In the interest of expediency and not requiring that *six* different runtimes be built -- which can greatly increase build times and storage requirements -- the initial xamarin-android open-source build will only build the armeabi-v7a (armv7) and "host" architectures. Additionally, the <UnzipDirectoryChildren/> task needed to be altered to use unzip(1) on OS X instead of using System.IO.Compression.ZipFile, because the ZipFile implementation included with Mono 4.4 doesn't respect file attributes such as the +x, causing all files to be extracted as 644 (rw-r--r--), resulting in an NDK toolchain which wouldn't work. To resolve this issue, execution on OS X and Linux now uses unzip(1). ~~ Adding new architectures ~~ To build Mono for a new architecture, edit build-tools/mono-runtimes/mono-runtimes.projitems and add a new @(_MonoRuntime) entry for the desired architecture. TODO: Figure out if there's a reasonable way to "opt-in" or "opt-out" of CPU architectures so that it isn't an "all or nothing" prospect.
2016-04-20 04:30:00 +03:00
/>
<Touch
[mono-runtimes] Use $(IntermediateOutputPath), not `obj`. One of the "cute" things in mono-runtimes.props is that $(_CommonCFlags) changes based on $(Configuration): for Debug builds, `-O0 -fno-omit-frame-pointer` is used (no optimizations and make stack traces easier for gdb), while for Release builds `-O2` is used. The natural result of this is that Debug and Release builds *are not the same*, and that's a *good* thing. ...except that previously, both Debug and Release builds used the same `obj\%(Identity)` directories, which meant there weren't separate Debug and Release outputs, there were instead "whatever was built first" outputs, which is *madness*. Fix mono-runtimes.targets so that $(IntermediateOutputPath) is used instead instead of `obj`. $(IntermediateOutputPath) should be `obj\$(Configuration)`, so Debug and Release build artifacts will be kept properly separate. Additionally, fix the `Clean` target, so that the $(IntermediateOutputPath) subdirectories are properly removed.
2016-04-22 21:30:39 +03:00
Files="@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)\.stamp')"
[mono-runtimes] Build required mono runtimes. Add a new build-tools/mono-runtimes project to build the required Mono runtimes for Xamarin.Android app execution on Android devices. Xamarin.Android 6.0 ("cycle 6") includes Mono runtimes compiled for five architectures: * armeabi (armv5) * armeabi-v7a (armv7) * arm64-v8a (aarch64) * x86 * x86_64 An additional "host" architecture is also built to build the "monodroid" profile assemblies such as mscorlib.dll. In the interest of expediency and not requiring that *six* different runtimes be built -- which can greatly increase build times and storage requirements -- the initial xamarin-android open-source build will only build the armeabi-v7a (armv7) and "host" architectures. Additionally, the <UnzipDirectoryChildren/> task needed to be altered to use unzip(1) on OS X instead of using System.IO.Compression.ZipFile, because the ZipFile implementation included with Mono 4.4 doesn't respect file attributes such as the +x, causing all files to be extracted as 644 (rw-r--r--), resulting in an NDK toolchain which wouldn't work. To resolve this issue, execution on OS X and Linux now uses unzip(1). ~~ Adding new architectures ~~ To build Mono for a new architecture, edit build-tools/mono-runtimes/mono-runtimes.projitems and add a new @(_MonoRuntime) entry for the desired architecture. TODO: Figure out if there's a reasonable way to "opt-in" or "opt-out" of CPU architectures so that it isn't an "all or nothing" prospect.
2016-04-20 04:30:00 +03:00
AlwaysCreate="True"
/>
</Target>
<Target Name="_BuildRuntimes"
[mono-runtimes] Fix _BuildRuntimes @Outputs paths. The `_BuildRuntimes` target would constantly re-run, because the //Build/@Outputs files were wrong, and thus never existed. Fix the Outputs references so that the `_BuildRuntimes` target doesn't need to constantly execute.
2016-04-25 22:14:34 +03:00
Inputs="@(_MonoRuntime->'$(IntermediateOutputPath)%(Identity)\.stamp')"
Outputs="@(_MonoRuntime->'$(IntermediateOutputPath)%(Identity)\mono\mini\.libs\%(OutputRuntime)');@(_MonoRuntime->'$(IntermediateOutputPath)%(Identity)\mono\profiler\.libs\%(OutputProfiler)');@(_MonoRuntime->'$(IntermediateOutputPath)%(Identity)\support\.libs\%(OutputMonoPosixHelper)')">
[mono-runtimes] Build required mono runtimes. Add a new build-tools/mono-runtimes project to build the required Mono runtimes for Xamarin.Android app execution on Android devices. Xamarin.Android 6.0 ("cycle 6") includes Mono runtimes compiled for five architectures: * armeabi (armv5) * armeabi-v7a (armv7) * arm64-v8a (aarch64) * x86 * x86_64 An additional "host" architecture is also built to build the "monodroid" profile assemblies such as mscorlib.dll. In the interest of expediency and not requiring that *six* different runtimes be built -- which can greatly increase build times and storage requirements -- the initial xamarin-android open-source build will only build the armeabi-v7a (armv7) and "host" architectures. Additionally, the <UnzipDirectoryChildren/> task needed to be altered to use unzip(1) on OS X instead of using System.IO.Compression.ZipFile, because the ZipFile implementation included with Mono 4.4 doesn't respect file attributes such as the +x, causing all files to be extracted as 644 (rw-r--r--), resulting in an NDK toolchain which wouldn't work. To resolve this issue, execution on OS X and Linux now uses unzip(1). ~~ Adding new architectures ~~ To build Mono for a new architecture, edit build-tools/mono-runtimes/mono-runtimes.projitems and add a new @(_MonoRuntime) entry for the desired architecture. TODO: Figure out if there's a reasonable way to "opt-in" or "opt-out" of CPU architectures so that it isn't an "all or nothing" prospect.
2016-04-20 04:30:00 +03:00
<Exec
Command="make $(MAKEFLAGS) # %(_MonoRuntime.Identity)"
[mono-runtimes] Use $(IntermediateOutputPath), not `obj`. One of the "cute" things in mono-runtimes.props is that $(_CommonCFlags) changes based on $(Configuration): for Debug builds, `-O0 -fno-omit-frame-pointer` is used (no optimizations and make stack traces easier for gdb), while for Release builds `-O2` is used. The natural result of this is that Debug and Release builds *are not the same*, and that's a *good* thing. ...except that previously, both Debug and Release builds used the same `obj\%(Identity)` directories, which meant there weren't separate Debug and Release outputs, there were instead "whatever was built first" outputs, which is *madness*. Fix mono-runtimes.targets so that $(IntermediateOutputPath) is used instead instead of `obj`. $(IntermediateOutputPath) should be `obj\$(Configuration)`, so Debug and Release build artifacts will be kept properly separate. Additionally, fix the `Clean` target, so that the $(IntermediateOutputPath) subdirectories are properly removed.
2016-04-22 21:30:39 +03:00
WorkingDirectory="@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)')"
[mono-runtimes] Build required mono runtimes. Add a new build-tools/mono-runtimes project to build the required Mono runtimes for Xamarin.Android app execution on Android devices. Xamarin.Android 6.0 ("cycle 6") includes Mono runtimes compiled for five architectures: * armeabi (armv5) * armeabi-v7a (armv7) * arm64-v8a (aarch64) * x86 * x86_64 An additional "host" architecture is also built to build the "monodroid" profile assemblies such as mscorlib.dll. In the interest of expediency and not requiring that *six* different runtimes be built -- which can greatly increase build times and storage requirements -- the initial xamarin-android open-source build will only build the armeabi-v7a (armv7) and "host" architectures. Additionally, the <UnzipDirectoryChildren/> task needed to be altered to use unzip(1) on OS X instead of using System.IO.Compression.ZipFile, because the ZipFile implementation included with Mono 4.4 doesn't respect file attributes such as the +x, causing all files to be extracted as 644 (rw-r--r--), resulting in an NDK toolchain which wouldn't work. To resolve this issue, execution on OS X and Linux now uses unzip(1). ~~ Adding new architectures ~~ To build Mono for a new architecture, edit build-tools/mono-runtimes/mono-runtimes.projitems and add a new @(_MonoRuntime) entry for the desired architecture. TODO: Figure out if there's a reasonable way to "opt-in" or "opt-out" of CPU architectures so that it isn't an "all or nothing" prospect.
2016-04-20 04:30:00 +03:00
/>
[mono-runtimes] Fix _BuildRuntimes @Outputs checking. The _BuildRuntimes target was executing unnecessarily: Target _BuildRuntimes needs to be built as input file 'obj/Debug//armeabi-v7a/.stamp' is newer than output file 'obj/host/mono/profiler/.libs/libmono-profiler-log.dylib This would *always* be true, because the output files were never touched once they were built, so e.g. when copying a build tree from one machine to another (Dropbox!), the dependency check would be "wrong". Improve the _BuildRuntimes target to explicitly <Touch/> the output files so that -- short of timezone changes (!) -- the outputs will be forced to be newer than the inputs.
2016-04-23 14:54:47 +03:00
<Touch
[mono-runtimes] Fix _BuildRuntimes @Outputs paths. The `_BuildRuntimes` target would constantly re-run, because the //Build/@Outputs files were wrong, and thus never existed. Fix the Outputs references so that the `_BuildRuntimes` target doesn't need to constantly execute.
2016-04-25 22:14:34 +03:00
Files="@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)\mono\mini\.libs\%(OutputRuntime)');@(_MonoRuntime->'$(IntermediateOutputPath)%(Identity)\mono\profiler\.libs\%(OutputProfiler)');@(_MonoRuntime->'$(IntermediateOutputPath)%(Identity)\support\.libs\%(OutputMonoPosixHelper)')"
[mono-runtimes] Fix _BuildRuntimes @Outputs checking. The _BuildRuntimes target was executing unnecessarily: Target _BuildRuntimes needs to be built as input file 'obj/Debug//armeabi-v7a/.stamp' is newer than output file 'obj/host/mono/profiler/.libs/libmono-profiler-log.dylib This would *always* be true, because the output files were never touched once they were built, so e.g. when copying a build tree from one machine to another (Dropbox!), the dependency check would be "wrong". Improve the _BuildRuntimes target to explicitly <Touch/> the output files so that -- short of timezone changes (!) -- the outputs will be forced to be newer than the inputs.
2016-04-23 14:54:47 +03:00
/>
[mono-runtimes] Build required mono runtimes. Add a new build-tools/mono-runtimes project to build the required Mono runtimes for Xamarin.Android app execution on Android devices. Xamarin.Android 6.0 ("cycle 6") includes Mono runtimes compiled for five architectures: * armeabi (armv5) * armeabi-v7a (armv7) * arm64-v8a (aarch64) * x86 * x86_64 An additional "host" architecture is also built to build the "monodroid" profile assemblies such as mscorlib.dll. In the interest of expediency and not requiring that *six* different runtimes be built -- which can greatly increase build times and storage requirements -- the initial xamarin-android open-source build will only build the armeabi-v7a (armv7) and "host" architectures. Additionally, the <UnzipDirectoryChildren/> task needed to be altered to use unzip(1) on OS X instead of using System.IO.Compression.ZipFile, because the ZipFile implementation included with Mono 4.4 doesn't respect file attributes such as the +x, causing all files to be extracted as 644 (rw-r--r--), resulting in an NDK toolchain which wouldn't work. To resolve this issue, execution on OS X and Linux now uses unzip(1). ~~ Adding new architectures ~~ To build Mono for a new architecture, edit build-tools/mono-runtimes/mono-runtimes.projitems and add a new @(_MonoRuntime) entry for the desired architecture. TODO: Figure out if there's a reasonable way to "opt-in" or "opt-out" of CPU architectures so that it isn't an "all or nothing" prospect.
2016-04-20 04:30:00 +03:00
</Target>
<Target Name="_InstallRuntimes"
[mono-runtimes] Use $(IntermediateOutputPath), not `obj`. One of the "cute" things in mono-runtimes.props is that $(_CommonCFlags) changes based on $(Configuration): for Debug builds, `-O0 -fno-omit-frame-pointer` is used (no optimizations and make stack traces easier for gdb), while for Release builds `-O2` is used. The natural result of this is that Debug and Release builds *are not the same*, and that's a *good* thing. ...except that previously, both Debug and Release builds used the same `obj\%(Identity)` directories, which meant there weren't separate Debug and Release outputs, there were instead "whatever was built first" outputs, which is *madness*. Fix mono-runtimes.targets so that $(IntermediateOutputPath) is used instead instead of `obj`. $(IntermediateOutputPath) should be `obj\$(Configuration)`, so Debug and Release build artifacts will be kept properly separate. Additionally, fix the `Clean` target, so that the $(IntermediateOutputPath) subdirectories are properly removed.
2016-04-22 21:30:39 +03:00
Inputs="@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)\mono\mini\.libs\%(OutputRuntime)');@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)\mono\profiler\.libs\%(OutputProfiler)');@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)\support\.libs\%(OutputMonoPosixHelper)')"
[mono-runtimes] Build required mono runtimes. Add a new build-tools/mono-runtimes project to build the required Mono runtimes for Xamarin.Android app execution on Android devices. Xamarin.Android 6.0 ("cycle 6") includes Mono runtimes compiled for five architectures: * armeabi (armv5) * armeabi-v7a (armv7) * arm64-v8a (aarch64) * x86 * x86_64 An additional "host" architecture is also built to build the "monodroid" profile assemblies such as mscorlib.dll. In the interest of expediency and not requiring that *six* different runtimes be built -- which can greatly increase build times and storage requirements -- the initial xamarin-android open-source build will only build the armeabi-v7a (armv7) and "host" architectures. Additionally, the <UnzipDirectoryChildren/> task needed to be altered to use unzip(1) on OS X instead of using System.IO.Compression.ZipFile, because the ZipFile implementation included with Mono 4.4 doesn't respect file attributes such as the +x, causing all files to be extracted as 644 (rw-r--r--), resulting in an NDK toolchain which wouldn't work. To resolve this issue, execution on OS X and Linux now uses unzip(1). ~~ Adding new architectures ~~ To build Mono for a new architecture, edit build-tools/mono-runtimes/mono-runtimes.projitems and add a new @(_MonoRuntime) entry for the desired architecture. TODO: Figure out if there's a reasonable way to "opt-in" or "opt-out" of CPU architectures so that it isn't an "all or nothing" prospect.
2016-04-20 04:30:00 +03:00
Outputs="@(_MonoRuntime->'$(OutputPath)\lib\xbuild\Xamarin\Android\lib\%(Identity)\%(OutputRuntime)');@(_MonoRuntime->'$(OutputPath)\lib\xbuild\Xamarin\Android\lib\%(Identity)\%(OutputProfiler)');@(_MonoRuntime->'$(OutputPath)\lib\xbuild\Xamarin\Android\lib\%(Identity)\%(OutputMonoPosixHelper)')">
<MakeDir Directories="@(_MonoRuntime->'$(OutputPath)\lib\xbuild\Xamarin\Android\lib\%(Identity)')" />
<Copy
[mono-runtimes] Use $(IntermediateOutputPath), not `obj`. One of the "cute" things in mono-runtimes.props is that $(_CommonCFlags) changes based on $(Configuration): for Debug builds, `-O0 -fno-omit-frame-pointer` is used (no optimizations and make stack traces easier for gdb), while for Release builds `-O2` is used. The natural result of this is that Debug and Release builds *are not the same*, and that's a *good* thing. ...except that previously, both Debug and Release builds used the same `obj\%(Identity)` directories, which meant there weren't separate Debug and Release outputs, there were instead "whatever was built first" outputs, which is *madness*. Fix mono-runtimes.targets so that $(IntermediateOutputPath) is used instead instead of `obj`. $(IntermediateOutputPath) should be `obj\$(Configuration)`, so Debug and Release build artifacts will be kept properly separate. Additionally, fix the `Clean` target, so that the $(IntermediateOutputPath) subdirectories are properly removed.
2016-04-22 21:30:39 +03:00
SourceFiles="@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)\mono\mini\.libs\%(OutputRuntime)')"
[mono-runtimes] Build required mono runtimes. Add a new build-tools/mono-runtimes project to build the required Mono runtimes for Xamarin.Android app execution on Android devices. Xamarin.Android 6.0 ("cycle 6") includes Mono runtimes compiled for five architectures: * armeabi (armv5) * armeabi-v7a (armv7) * arm64-v8a (aarch64) * x86 * x86_64 An additional "host" architecture is also built to build the "monodroid" profile assemblies such as mscorlib.dll. In the interest of expediency and not requiring that *six* different runtimes be built -- which can greatly increase build times and storage requirements -- the initial xamarin-android open-source build will only build the armeabi-v7a (armv7) and "host" architectures. Additionally, the <UnzipDirectoryChildren/> task needed to be altered to use unzip(1) on OS X instead of using System.IO.Compression.ZipFile, because the ZipFile implementation included with Mono 4.4 doesn't respect file attributes such as the +x, causing all files to be extracted as 644 (rw-r--r--), resulting in an NDK toolchain which wouldn't work. To resolve this issue, execution on OS X and Linux now uses unzip(1). ~~ Adding new architectures ~~ To build Mono for a new architecture, edit build-tools/mono-runtimes/mono-runtimes.projitems and add a new @(_MonoRuntime) entry for the desired architecture. TODO: Figure out if there's a reasonable way to "opt-in" or "opt-out" of CPU architectures so that it isn't an "all or nothing" prospect.
2016-04-20 04:30:00 +03:00
DestinationFiles="@(_MonoRuntime->'$(OutputPath)\lib\xbuild\Xamarin\Android\lib\%(Identity)\%(OutputRuntime)')"
/>
<Touch
Files="@(_MonoRuntime->'$(OutputPath)\lib\xbuild\Xamarin\Android\lib\%(Identity)\%(OutputRuntime)')"
/>
<Copy
[mono-runtimes] Use $(IntermediateOutputPath), not `obj`. One of the "cute" things in mono-runtimes.props is that $(_CommonCFlags) changes based on $(Configuration): for Debug builds, `-O0 -fno-omit-frame-pointer` is used (no optimizations and make stack traces easier for gdb), while for Release builds `-O2` is used. The natural result of this is that Debug and Release builds *are not the same*, and that's a *good* thing. ...except that previously, both Debug and Release builds used the same `obj\%(Identity)` directories, which meant there weren't separate Debug and Release outputs, there were instead "whatever was built first" outputs, which is *madness*. Fix mono-runtimes.targets so that $(IntermediateOutputPath) is used instead instead of `obj`. $(IntermediateOutputPath) should be `obj\$(Configuration)`, so Debug and Release build artifacts will be kept properly separate. Additionally, fix the `Clean` target, so that the $(IntermediateOutputPath) subdirectories are properly removed.
2016-04-22 21:30:39 +03:00
SourceFiles="@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)\mono\mini\.libs\%(OutputRuntime)')"
[mono-runtimes] Build required mono runtimes. Add a new build-tools/mono-runtimes project to build the required Mono runtimes for Xamarin.Android app execution on Android devices. Xamarin.Android 6.0 ("cycle 6") includes Mono runtimes compiled for five architectures: * armeabi (armv5) * armeabi-v7a (armv7) * arm64-v8a (aarch64) * x86 * x86_64 An additional "host" architecture is also built to build the "monodroid" profile assemblies such as mscorlib.dll. In the interest of expediency and not requiring that *six* different runtimes be built -- which can greatly increase build times and storage requirements -- the initial xamarin-android open-source build will only build the armeabi-v7a (armv7) and "host" architectures. Additionally, the <UnzipDirectoryChildren/> task needed to be altered to use unzip(1) on OS X instead of using System.IO.Compression.ZipFile, because the ZipFile implementation included with Mono 4.4 doesn't respect file attributes such as the +x, causing all files to be extracted as 644 (rw-r--r--), resulting in an NDK toolchain which wouldn't work. To resolve this issue, execution on OS X and Linux now uses unzip(1). ~~ Adding new architectures ~~ To build Mono for a new architecture, edit build-tools/mono-runtimes/mono-runtimes.projitems and add a new @(_MonoRuntime) entry for the desired architecture. TODO: Figure out if there's a reasonable way to "opt-in" or "opt-out" of CPU architectures so that it isn't an "all or nothing" prospect.
2016-04-20 04:30:00 +03:00
DestinationFiles="@(_MonoRuntime->'$(OutputPath)\lib\xbuild\Xamarin\Android\lib\%(Identity)\%(OutputRuntime)-unstripped')"
/>
<Exec
Command="%(_MonoRuntime.Strip) &quot;@(_MonoRuntime->'$(OutputPath)\lib\xbuild\Xamarin\Android\lib\%(Identity)\%(OutputRuntime)')&quot;"
/>
<Copy
[mono-runtimes] Use $(IntermediateOutputPath), not `obj`. One of the "cute" things in mono-runtimes.props is that $(_CommonCFlags) changes based on $(Configuration): for Debug builds, `-O0 -fno-omit-frame-pointer` is used (no optimizations and make stack traces easier for gdb), while for Release builds `-O2` is used. The natural result of this is that Debug and Release builds *are not the same*, and that's a *good* thing. ...except that previously, both Debug and Release builds used the same `obj\%(Identity)` directories, which meant there weren't separate Debug and Release outputs, there were instead "whatever was built first" outputs, which is *madness*. Fix mono-runtimes.targets so that $(IntermediateOutputPath) is used instead instead of `obj`. $(IntermediateOutputPath) should be `obj\$(Configuration)`, so Debug and Release build artifacts will be kept properly separate. Additionally, fix the `Clean` target, so that the $(IntermediateOutputPath) subdirectories are properly removed.
2016-04-22 21:30:39 +03:00
SourceFiles="@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)\mono\profiler\.libs\%(OutputProfiler)')"
[mono-runtimes] Build required mono runtimes. Add a new build-tools/mono-runtimes project to build the required Mono runtimes for Xamarin.Android app execution on Android devices. Xamarin.Android 6.0 ("cycle 6") includes Mono runtimes compiled for five architectures: * armeabi (armv5) * armeabi-v7a (armv7) * arm64-v8a (aarch64) * x86 * x86_64 An additional "host" architecture is also built to build the "monodroid" profile assemblies such as mscorlib.dll. In the interest of expediency and not requiring that *six* different runtimes be built -- which can greatly increase build times and storage requirements -- the initial xamarin-android open-source build will only build the armeabi-v7a (armv7) and "host" architectures. Additionally, the <UnzipDirectoryChildren/> task needed to be altered to use unzip(1) on OS X instead of using System.IO.Compression.ZipFile, because the ZipFile implementation included with Mono 4.4 doesn't respect file attributes such as the +x, causing all files to be extracted as 644 (rw-r--r--), resulting in an NDK toolchain which wouldn't work. To resolve this issue, execution on OS X and Linux now uses unzip(1). ~~ Adding new architectures ~~ To build Mono for a new architecture, edit build-tools/mono-runtimes/mono-runtimes.projitems and add a new @(_MonoRuntime) entry for the desired architecture. TODO: Figure out if there's a reasonable way to "opt-in" or "opt-out" of CPU architectures so that it isn't an "all or nothing" prospect.
2016-04-20 04:30:00 +03:00
DestinationFiles="@(_MonoRuntime->'$(OutputPath)\lib\xbuild\Xamarin\Android\lib\%(Identity)\%(OutputProfiler)')"
/>
<Touch
Files="@(_MonoRuntime->'$(OutputPath)\lib\xbuild\Xamarin\Android\lib\%(Identity)\%(OutputProfiler)')"
/>
<Copy
[mono-runtimes] Use $(IntermediateOutputPath), not `obj`. One of the "cute" things in mono-runtimes.props is that $(_CommonCFlags) changes based on $(Configuration): for Debug builds, `-O0 -fno-omit-frame-pointer` is used (no optimizations and make stack traces easier for gdb), while for Release builds `-O2` is used. The natural result of this is that Debug and Release builds *are not the same*, and that's a *good* thing. ...except that previously, both Debug and Release builds used the same `obj\%(Identity)` directories, which meant there weren't separate Debug and Release outputs, there were instead "whatever was built first" outputs, which is *madness*. Fix mono-runtimes.targets so that $(IntermediateOutputPath) is used instead instead of `obj`. $(IntermediateOutputPath) should be `obj\$(Configuration)`, so Debug and Release build artifacts will be kept properly separate. Additionally, fix the `Clean` target, so that the $(IntermediateOutputPath) subdirectories are properly removed.
2016-04-22 21:30:39 +03:00
SourceFiles="@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)\support\.libs\%(OutputMonoPosixHelper)')"
[mono-runtimes] Build required mono runtimes. Add a new build-tools/mono-runtimes project to build the required Mono runtimes for Xamarin.Android app execution on Android devices. Xamarin.Android 6.0 ("cycle 6") includes Mono runtimes compiled for five architectures: * armeabi (armv5) * armeabi-v7a (armv7) * arm64-v8a (aarch64) * x86 * x86_64 An additional "host" architecture is also built to build the "monodroid" profile assemblies such as mscorlib.dll. In the interest of expediency and not requiring that *six* different runtimes be built -- which can greatly increase build times and storage requirements -- the initial xamarin-android open-source build will only build the armeabi-v7a (armv7) and "host" architectures. Additionally, the <UnzipDirectoryChildren/> task needed to be altered to use unzip(1) on OS X instead of using System.IO.Compression.ZipFile, because the ZipFile implementation included with Mono 4.4 doesn't respect file attributes such as the +x, causing all files to be extracted as 644 (rw-r--r--), resulting in an NDK toolchain which wouldn't work. To resolve this issue, execution on OS X and Linux now uses unzip(1). ~~ Adding new architectures ~~ To build Mono for a new architecture, edit build-tools/mono-runtimes/mono-runtimes.projitems and add a new @(_MonoRuntime) entry for the desired architecture. TODO: Figure out if there's a reasonable way to "opt-in" or "opt-out" of CPU architectures so that it isn't an "all or nothing" prospect.
2016-04-20 04:30:00 +03:00
DestinationFiles="@(_MonoRuntime->'$(OutputPath)\lib\xbuild\Xamarin\Android\lib\%(Identity)\%(OutputMonoPosixHelper)')"
/>
<Touch
Files="@(_MonoRuntime->'$(OutputPath)\lib\xbuild\Xamarin\Android\lib\%(Identity)\%(OutputMonoPosixHelper)')"
/>
</Target>
<Target Name="_InstallBcl"
Inputs="$(_MonoPath)\mcs\class\lib\monodroid\mscorlib.dll"
Outputs="$(OutputPath)\lib\xbuild-frameworks\MonoAndroid\v1.0\mscorlib.dll">
<MakeDir Directories="$(OutputPath)\lib\xbuild-frameworks\MonoAndroid\v1.0" />
<MakeDir Directories="$(OutputPath)\lib\xbuild-frameworks\MonoAndroid\v1.0\Facades" />
<ItemGroup>
<_Assemblies Include="$(_MonoPath)\mcs\class\lib\monodroid\*.dll" />
<_Facades Include="$(_MonoPath)\mcs\class\lib\monodroid\Facades\*.dll" />
</ItemGroup>
<Copy
SourceFiles="@(_Assemblies)"
DestinationFolder="$(OutputPath)\lib\xbuild-frameworks\MonoAndroid\v1.0"
/>
<Copy
SourceFiles="@(_Facades)"
DestinationFolder="$(OutputPath)\lib\xbuild-frameworks\MonoAndroid\v1.0\Facades"
/>
<Touch
Files="$(OutputPath)\lib\xbuild-frameworks\MonoAndroid\v1.0\mscorlib.dll"
/>
</Target>
[mono-runtimes] Use $(IntermediateOutputPath), not `obj`. One of the "cute" things in mono-runtimes.props is that $(_CommonCFlags) changes based on $(Configuration): for Debug builds, `-O0 -fno-omit-frame-pointer` is used (no optimizations and make stack traces easier for gdb), while for Release builds `-O2` is used. The natural result of this is that Debug and Release builds *are not the same*, and that's a *good* thing. ...except that previously, both Debug and Release builds used the same `obj\%(Identity)` directories, which meant there weren't separate Debug and Release outputs, there were instead "whatever was built first" outputs, which is *madness*. Fix mono-runtimes.targets so that $(IntermediateOutputPath) is used instead instead of `obj`. $(IntermediateOutputPath) should be `obj\$(Configuration)`, so Debug and Release build artifacts will be kept properly separate. Additionally, fix the `Clean` target, so that the $(IntermediateOutputPath) subdirectories are properly removed.
2016-04-22 21:30:39 +03:00
<Target Name="_CleanRuntimes"
AfterTargets="Clean">
<RemoveDir Directories="@(_MonoRuntime->'$(IntermediateOutputPath)\%(Identity)')" />
</Target>
[mono-runtimes] Build required mono runtimes. Add a new build-tools/mono-runtimes project to build the required Mono runtimes for Xamarin.Android app execution on Android devices. Xamarin.Android 6.0 ("cycle 6") includes Mono runtimes compiled for five architectures: * armeabi (armv5) * armeabi-v7a (armv7) * arm64-v8a (aarch64) * x86 * x86_64 An additional "host" architecture is also built to build the "monodroid" profile assemblies such as mscorlib.dll. In the interest of expediency and not requiring that *six* different runtimes be built -- which can greatly increase build times and storage requirements -- the initial xamarin-android open-source build will only build the armeabi-v7a (armv7) and "host" architectures. Additionally, the <UnzipDirectoryChildren/> task needed to be altered to use unzip(1) on OS X instead of using System.IO.Compression.ZipFile, because the ZipFile implementation included with Mono 4.4 doesn't respect file attributes such as the +x, causing all files to be extracted as 644 (rw-r--r--), resulting in an NDK toolchain which wouldn't work. To resolve this issue, execution on OS X and Linux now uses unzip(1). ~~ Adding new architectures ~~ To build Mono for a new architecture, edit build-tools/mono-runtimes/mono-runtimes.projitems and add a new @(_MonoRuntime) entry for the desired architecture. TODO: Figure out if there's a reasonable way to "opt-in" or "opt-out" of CPU architectures so that it isn't an "all or nothing" prospect.
2016-04-20 04:30:00 +03:00
</Project>